packetgen 3.3.3 → 4.1.0

data/lib/packetgen/header/tcp/option.rb

@@ -11,8 +11,8 @@ module PacketGen
     class TCP
       # Base class to describe a TCP option
       # @author Sylvain Daubert
-      class Option < Types::Fields
-        include Types::Fieldable
+      class Option < BinStruct::Struct
+        include BinStruct::Structable
 
         # EOL option value
         EOL_KIND       = 0
@@ -36,15 +36,15 @@ module PacketGen
         # @!attribute kind
         #  Option kind
         #  @return [Integer] 8-bit option kind
-        define_field :kind, Types::Int8
+        define_attr :kind, BinStruct::Int8
         # @!attribute length
         #  Option length
         #  @return [Integer] 8-bit option length
-        define_field :length, Types::Int8, optional: ->(h) { h.length? }
+        define_attr :length, BinStruct::Int8, optional: lambda(&:length?)
         # @!attribute value
         #  @return [Integer,String] option value
-        define_field :value, Types::String, optional: ->(h) { h.length? && h.length > 2 },
-                                            builder: ->(h, t) { t.new(length_from: -> { h.length - 2 }) }
+        define_attr :value, BinStruct::String, optional: ->(h) { h.length? && h.length > 2 },
+                                               builder: ->(h, t) { t.new(length_from: -> { h.length - 2 }) }
 
         # @param [hash] options
         # @option options [Integer] :kind
@@ -55,18 +55,18 @@ module PacketGen
           case options[:value]
           when Integer
             klass = case self[:length].to_i
-                    when 3 then Types::Int8
-                    when 4 then Types::Int16
-                    when 6 then Types::Int32
+                    when 3 then BinStruct::Int8
+                    when 4 then BinStruct::Int16
+                    when 6 then BinStruct::Int32
                     else
                       raise ArgumentError, 'impossible length'
                     end
-            self[:value] = klass.new(options[:value])
+            self[:value] = klass.new(value: options[:value])
           when NilClass
             # Nothing to do
           else
-            self[:value] = Types::String.new.read(options[:value])
-            self[:length].read(self[:value].sz + 2) unless options[:length]
+            self[:value] = BinStruct::String.new.read(options[:value])
+            self[:length].from_human(self[:value].sz + 2) unless options[:length]
           end
         end
 
@@ -83,25 +83,33 @@ module PacketGen
         # @return [String, Integer]
         def value
           case self[:value]
-          when Types::Int
+          when BinStruct::Int
             self[:value].to_i
           else
             self[:value].to_s
           end
         end
 
+        # @private
         alias old_set_value value=
+
         # Setter for value attribute
-        # @param[String,Integer]
+        # @param[String,Integer] val
         # @return [String, Integer]
         def value=(val)
           case self[:value]
-          when Types::Int
+          when BinStruct::Int
             self.length = 2 + self[:value].sz
-          when Types::String
-            self.length = 2 + Types::String.new.read(val).sz
+          when BinStruct::String
+            self.length = 2 + BinStruct::String.new.read(val).sz
+          end
+
+          case val
+          when Integer
+            self[:value].from_human(val)
+          else
+            self[:value].read(val)
           end
-          self[:value].read val
           val
         end
 
@@ -115,14 +123,14 @@ module PacketGen
         # Get option as a human readable string
         # @return [String]
         def to_human
-          str = self.instance_of?(Option) ? +"unk-#{kind}" : self.class.to_s.sub(/.*::/, '')
+          str = self.instance_of?(Option) ? "unk-#{kind}" : self.class.to_s.sub(/.*::/, '')
           str << ":#{self[:value].to_s.inspect}" if (length > 2) && !self[:value].to_s.empty?
           str
         end
 
         # @return [String]
         def inspect
-          str = +"#<#{self.class} kind=#{self[:kind].value.inspect} "
+          str = "#<#{self.class} kind=#{self[:kind].value.inspect} "
           str << "length=#{self[:length].value.inspect} " if self[:length].value
           str << "value=#{self[:value].inspect}>"
         end
@@ -131,28 +139,29 @@ module PacketGen
       # End Of Option TCP option
       # @author Sylvain Daubert
       class EOL < Option
-        update_field :kind, default: EOL_KIND
+        update_attr :kind, default: EOL_KIND
       end
 
       # No OPeration TCP option
       # @author Sylvain Daubert
       class NOP < Option
         # @see Option#initialize
-        update_field :kind, default: NOP_KIND
+        update_attr :kind, default: NOP_KIND
       end
 
       # Maximum Segment Size TCP option
       # @author Sylvain Daubert
       class MSS < Option
-        update_field :kind, default: MSS_KIND
-        update_field :length, default: 4
+        update_attr :kind, default: MSS_KIND
+        update_attr :length, default: 4
 
         # @see Option#initialize
         def initialize(options={})
           super
-          self[:value] = Types::Int16.new(options[:value])
+          self[:value] = BinStruct::Int16.new(value: options[:value])
         end
 
+        # Get human-readable description
         # @return [String]
         def to_human
           "MSS:#{value}"
@@ -162,15 +171,16 @@ module PacketGen
       # Window Size TCP option
       # @author Sylvain Daubert
       class WS < Option
-        update_field :kind, default: WS_KIND
-        update_field :length, default: 3
+        update_attr :kind, default: WS_KIND
+        update_attr :length, default: 3
 
         # @see Option#initialize
         def initialize(options={})
           super
-          self[:value] = Types::Int8.new(options[:value])
+          self[:value] = BinStruct::Int8.new(value: options[:value])
         end
 
+        # Get human-readable description
         # @return [String]
         def to_human
           "WS:#{value}"
@@ -180,28 +190,29 @@ module PacketGen
       # Selective Acknowledgment OK TCP option
       # @author Sylvain Daubert
       class SACKOK < Option
-        update_field :kind, default: SACKOK_KIND
-        update_field :length, default: 2
+        update_attr :kind, default: SACKOK_KIND
+        update_attr :length, default: 2
       end
 
       # Selective Acknowledgment TCP option
       # @author Sylvain Daubert
       class SACK < Option
-        update_field :kind, default: SACK_KIND
+        update_attr :kind, default: SACK_KIND
       end
 
       # Echo TCP option
       # @author Sylvain Daubert
       class ECHO < Option
-        update_field :kind, default: ECHO_KIND
-        update_field :length, default: 6
+        update_attr :kind, default: ECHO_KIND
+        update_attr :length, default: 6
 
         # @see Option#initialize
         def initialize(options={})
           super
-          self[:value] = Types::Int32.new(options[:value])
+          self[:value] = BinStruct::Int32.new(value: options[:value])
         end
 
+        # Get human-readable description
         # @return [String]
         def to_human
           "WS:#{value}"
@@ -211,15 +222,16 @@ module PacketGen
       # Echo Reply TCP option
       # @author Sylvain Daubert
       class ECHOREPLY < Option
-        update_field :kind, default: ECHOREPLY_KIND
-        update_field :length, default: 6
+        update_attr :kind, default: ECHOREPLY_KIND
+        update_attr :length, default: 6
 
         # @see Option#initialize
         def initialize(options={})
           super
-          self[:value] = Types::Int32.new(options[:value])
+          self[:value] = BinStruct::Int32.new(value: options[:value])
         end
 
+        # Get human-readable description
         # @return [String]
         def to_human
           "WS:#{value}"
@@ -229,8 +241,8 @@ module PacketGen
       # Timestamp TCP option
       # @author Sylvain Daubert
       class TS < Option
-        update_field :kind, default: TS_KIND
-        update_field :length, default: 10
+        update_attr :kind, default: TS_KIND
+        update_attr :length, default: 10
 
         # @see Option#initialize
         def initialize(options={})
@@ -238,6 +250,7 @@ module PacketGen
           self[:value].read(options[:value] || "\0" * 8)
         end
 
+        # Get human-readable description
         # @return [String]
         def to_human
           value, echo_reply = self[:value].unpack('NN')

data/lib/packetgen/header/tcp/options.rb

@@ -11,9 +11,17 @@ require_relative 'option'
 module PacketGen
   module Header
     class TCP
-      # Container for TCP options in {TCP TCP header}.
+      # Container for TCP {Option options} in {TCP TCP header}.
       # @author Sylvain Daubert
-      class Options < Types::Array
+      # @since 1.0.0
+      # @since 4.1.0 +#<<+ accepts +:kind+ parameter in hash
+      # @example Add an option from a hash
+      #   opts = PacketGen::Header::TCP::Options.new
+      #   # Option kind may be set using :opt
+      #   opts << { opt: 'MSS', value: 1250 }
+      #   # It may aldo be set using :kind
+      #   opts << { kind: 'EOL' }
+      class Options < BinStruct::Array
         set_of Option
 
         # Get {Option} subclasses
@@ -23,7 +31,7 @@ module PacketGen
 
           @klasses = []
           Option.constants.each do |cst|
-            next unless cst.to_s.end_with? '_KIND'
+            next unless cst.to_s.end_with?('_KIND')
 
             optname = cst.to_s.sub('_KIND', '')
             @klasses[Option.const_get(cst)] = TCP.const_get(optname)
@@ -34,8 +42,8 @@ module PacketGen
         private
 
         def record_from_hash(hsh)
-          if hsh.key? :opt
-            klassname = hsh.delete(:opt)
+          if hsh.key?(:opt) || hsh.key?(:kind)
+            klassname = hsh.delete(:opt) || hsh.delete(:kind)
             raise ArgumentError, 'opt should be a TCP::Option subclass' unless TCP.const_defined?(klassname)
 
             klass = TCP.const_get(klassname)

data/lib/packetgen/header/tcp.rb

@@ -29,56 +29,62 @@ module PacketGen
     #   |                             data                              |
     #   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     # A TCP header consists of:
-    # * a source port ({#sport}, {Types::Int16} type),
-    # * a destination port ({#dport}, +Int16+ type),
-    # * a sequence number ({#seqnum}, {Types::Int32} type),
-    # * an acknownledge number ({#acknum}, +Int32+ type),
-    # * a 16-bit field ({#u16}, +Int16+ type) composed of:
-    #   * a 4-bit {#data_offset} self[attr],
+    # * a source port ({#sport}, +BinStruct::Int16+ type),
+    # * a destination port ({#dport}, +BinStruct::Int16+ type),
+    # * a sequence number ({#seqnum}, +BinStruct::Int32+ type),
+    # * an acknownledge number ({#acknum}, +BinStruct::Int32+ type),
+    # * a 16-bit field ({#u16}, +BinStruct::Int16+ type) composed of:
+    #   * a 4-bit {#data_offset},
     #   * a 3-bit {#reserved} field,
     #   * a 9-bit {#flags} field,
-    # * a {#window} field (+Int16+ type),
-    # * a {#checksum} field (+Int16+ type),
-    # * a urgent pointer ({#urg_pointer}, +Int16+ type),
+    # * a {#window} field (+BinStruct::Int16+ type),
+    # * a {#checksum} field (+BinStruct::Int16+ type),
+    # * a urgent pointer ({#urg_pointer}, +BinStruct::Int16+ type),
     # * an optional {#options} field ({Options} type),
-    # * and a {#body} ({Types::String} type).
+    # * and a {#body} (+BinStruct::String+ type).
     #
-    # == Create a TCP header
+    # @example Create a TCP header
     #  # standalone
     #  tcph = PacketGen::Header::TCP.new
     #  # in a IP packet
     #  pkt = PacketGen.gen('IP').add('TCP')
     #  # access to TCP header
-    #  pkt.tcp   # => PacketGen::Header::TCP
+    #  pkt.tcp.class   # => PacketGen::Header::TCP
     #
-    # == TCP attributes
+    # @example TCP attributes
+    #  tcph = PacketGen::Header::TCP.new
     #  tcph.sport = 4500
     #  tcph.dport = 80
     #  tcph.seqnum = 43
     #  tcph.acknum = 0x45678925
     #  tcph.wsize = 0x240
     #  tcph.urg_pointer = 0x40
-    #  tcph.body.read 'this is a body'
+    #  tcph.body = 'this is a body'
     #
-    # == Flags
-    # TCP flags may be accesed as a 9-bit integer:
+    # @example TCP Flags
+    #  tcph = PacketGen::Header::TCP.new
+    #  # TCP flags may be accesed as a 9-bit integer:
     #  tcph.flags = 0x1002
-    # Each flag may be accessed independently:
-    #  tcph.flag_syn?    # => Boolean
+    #  # Each flag may be accessed independently:
+    #  tcph.flag_syn?    # => true
     #  tcph.flag_rst = true
     #
-    # == Options
-    # {#options} TCP attribute is a {Options}. {Option} may added to it:
-    #  tcph.options << PacketGen::Header::TCP::MSS.new(1250)
-    # or:
-    #  tcph.options << { opt: 'MSS', self[attr]: 1250 }
+    # @example TCP Options
+    #  tcph = PacketGen::Header::TCP.new
+    #  # options TCP attribute is a PacketGen::Header::TCP::Options.
+    #  # PacketGen::Header::TCP::Option may added to it:
+    #  tcph.options << PacketGen::Header::TCP::MSS.new(value: 1250)
+    #  # or
+    #  tcph.options << { kind: 'MSS', value: 1250 }
+    #  tcph.options.last.class #=> PacketGen::Header::TCP::MSS
     # @author Sylvain Daubert
+    # @author LemonTree55
     class TCP < Base
     end
   end
 end
 
-# Need to load Options now, as this is used through define_bit_fields_on,
+# Need to load Options now, as this is used through define_bit_attr,
 # which make a call to TCP.new, which needs Options
 require_relative 'tcp/options'
 
@@ -91,41 +97,69 @@ module PacketGen
       # @!attribute sport
       #  16-bit TCP source port
       #  @return [Integer]
-      define_field :sport, Types::Int16
+      define_attr :sport, BinStruct::Int16
       # @!attribute dport
       #  16-bit TCP destination port
       #  @return [Integer]
-      define_field :dport, Types::Int16
+      define_attr :dport, BinStruct::Int16
       # @!attribute seqnum
       #  32-bit TCP sequence number
       #  @return [Integer]
-      define_field :seqnum, Types::Int32, default: ->(_) { rand(2**32) }
+      define_attr :seqnum, BinStruct::Int32, default: ->(_) { rand(2**32) }
       # @!attribute acknum
       #  32-bit TCP acknowledgement number
       #  @return [Integer]
-      define_field :acknum, Types::Int32
+      define_attr :acknum, BinStruct::Int32
       # @!attribute u16
       #  @return [Integer] 16-bit word used by flags and bit fields
-      define_field :u16, Types::Int16
+      # @!attribute data_offset
+      #  @return [Integer] 4-bit data offset from {#u16}
+      # @!attribute reserved
+      #  @return [Integer] 3-bit reserved from {#u16}
+      # @!attribute flags
+      #  @return [Integer] 9-bit flags from {#u16}
+      # @!attribute flag_ns
+      #  @return [Integer] 1-bit NS flag
+      # @!attribute flag_cwr
+      #  @return [Integer] 1-bit CWR flag
+      # @!attribute flag_ece
+      #  @return [Integer] 1-bit ECE flag
+      # @!attribute flag_urg
+      #  @return [Integer] 1-bit URG flag
+      # @!attribute flag_ack
+      #  @return [Integer] 1-bit ACK flag
+      # @!attribute flag_psh
+      #  @return [Integer] 1-bit PSH flag
+      # @!attribute flag_rst
+      #  @return [Integer] 1-bit RST flag
+      # @!attribute flag_syn
+      #  @return [Integer] 1-bit SYN flag
+      # @!attribute flag_fin
+      #  @return [Integer] 1-bit FIN flag
+      define_bit_attr :u16, data_offset: 4, reserved: 3, flag_ns: 1, flag_cwr: 1, flag_ece: 1, flag_urg: 1, flag_ack: 1, flag_psh: 1,
+                            flag_rst: 1, flag_syn: 1, flag_fin: 1
+      alias hlen data_offset
+      alias hlen= data_offset=
       # @!attribute window
       #  16-bit TCP window size
       #  @return [Integer]
-      define_field :window, Types::Int16
+      define_attr :window, BinStruct::Int16
       # @!attribute checksum
       #  16-bit TCP checksum
       #  @return [Integer]
-      define_field :checksum, Types::Int16
+      define_attr :checksum, BinStruct::Int16
       # @!attribute urg_pointer
       #  16-bit TCP urgent data pointer
       #  @return [Integer]
-      define_field :urg_pointer, Types::Int16
+      define_attr :urg_pointer, BinStruct::Int16
       # @!attribute options
       #  TCP options
       #  @return [Options]
-      define_field :options, TCP::Options, builder: ->(h, t) { t.new(length_from: -> { h.data_offset > 5 ? (h.data_offset - 5) * 4 : 0 }) }
+      define_attr :options, TCP::Options, builder: ->(h, t) { t.new(length_from: -> { h.data_offset > 5 ? (h.data_offset - 5) * 4 : 0 }) }
       # @!attribute body
-      #  @return [Types::String,Header::Base]
-      define_field :body, Types::String
+      #  TCP body
+      #  @return [BinStruct::String,Headerable]
+      define_attr :body, BinStruct::String
 
       alias source_port sport
       alias source_port= sport=
@@ -154,42 +188,26 @@ module PacketGen
       # @option options [Integer] :window
       # @option options [Integer] :checksum
       # @option options [Integer] :urg_pointer
-      # @option options [String] :body
+      # @option options [String, Headerable] :body
       def initialize(options={})
         opts = { data_offset: 5 }.merge!(options)
         super(opts)
+        self.flags = opts[:flags] if opts.key?(:flags)
       end
 
-      # @!attribute data_offset
-      #  @return [Integer] 4-bit data offset from {#u16}
-      # @!attribute reserved
-      #  @return [Integer] 3-bit reserved from {#u16}
-      # @!attribute flags
-      #  @return [Integer] 9-bit flags from {#u16}
-      define_bit_fields_on :u16, :data_offset, 4, :reserved, 3, :flags, 9
-      alias hlen data_offset
-      alias hlen= data_offset=
+      # Get all flags value from [#u16]
+      # @return [Integer]
+      def flags
+        self.u16 & 0x1ff
+      end
 
-      # @!attribute flag_ns
-      #  @return [Boolean] 1-bit NS flag
-      # @!attribute flag_cwr
-      #  @return [Boolean] 1-bit CWR flag
-      # @!attribute flag_ece
-      #  @return [Boolean] 1-bit ECE flag
-      # @!attribute flag_urg
-      #  @return [Boolean] 1-bit URG flag
-      # @!attribute flag_ack
-      #  @return [Boolean] 1-bit ACK flag
-      # @!attribute flag_psh
-      #  @return [Boolean] 1-bit PSH flag
-      # @!attribute flag_rst
-      #  @return [Boolean] 1-bit RST flag
-      # @!attribute flag_syn
-      #  @return [Boolean] 1-bit SYN flag
-      # @!attribute flag_fin
-      #  @return [Boolean] 1-bit FIN flag
-      define_bit_fields_on :u16, :_, 7, :flag_ns, :flag_cwr, :flag_ece, :flag_urg,
-                           :flag_ack, :flag_psh, :flag_rst, :flag_syn, :flag_fin
+      # Set all flags at once
+      # @param [Integer] value
+      # @return [Integer]
+      def flags=(value)
+        new_u16 = (self.u16 & 0xfe00) | (value & 0x1ff)
+        self[:u16].from_human(new_u16)
+      end
 
       # Compute checksum and set +checksum+ field
       # @return [Integer]

data/lib/packetgen/header/tftp.rb

@@ -10,25 +10,26 @@ module PacketGen
   module Header
     # A TFTP (Trivial File Transfer Protocol,
     # {https://tools.ietf.org/html/rfc1350 RFC 1350}) header consists of:
-    # * a {#opcode} ({Types::Int16Enum}),
+    # * an {#opcode} (+BinStruct::Int16Enum+),
     # * and a body. Its content depends on opcode.
     #
     # Specialized subclasses exists to handle {TFTP::RRQ Read Request},
     # {TFTP::WRQ Write Request}, {TFTP::DATA DATA}, {TFTP::ACK ACK} and
     # {TFTP::ERROR ERROR} packets.
     #
-    # == Create a TFTP header
+    # @example Create a TFTP header
     #  # standalone
     #  tftp = PacketGen::Header::TFTP.new
     #  # in a packet
     #  pkt = PacketGen.gen('IP').add('UDP').add('TFTP')
     #  # access to TFTP header
-    #  pkt.tftp   # => PacketGen::Header::TFTP
+    #  pkt.tftp.class   # => PacketGen::Header::TFTP
     #
-    # == TFTP attributes
+    # @example TFTP attributes
+    #  tftp = PacketGen::Header::TFTP.new
     #  tftp.opcode = 'RRQ'
     #  tftp.opcode = 1
-    #  tftp.body.read 'this is a body'
+    #  tftp.body = 'this is a body'
     #
     # == TFTP parsing
     # When parsing, only first packet (read or write request) should be decoded
@@ -46,6 +47,7 @@ module PacketGen
     #   packets[0].tftp.decode!(packets[1..-1])
     #   packets.map { |pkt| pkt.headers.last.class.to_s }.join(',')  # => TFTP::RRQ,TFTP::DATA,UDP,TFTP::ACK
     # @author Sylvain Daubert
+    # @author LemonTree55
     # @since 2.3.0
     class TFTP < Base
       # Known opcodes
@@ -60,11 +62,12 @@ module PacketGen
       # @!attribute opcode
       #   16-bit operation code
       #   @return [Integer]
-      define_field :opcode, Types::Int16Enum, enum: OPCODES
+      define_attr :opcode, BinStruct::Int16Enum, enum: OPCODES
 
       # @!attribute body
-      #   @return [String]
-      define_field :body, Types::String
+      #   TFTP body, if opcode is unknown
+      #   @return [String,Headerable]
+      define_attr :body, BinStruct::String
 
       def initialize(options={})
         type = protocol_name.sub(/^.*::/, '')
@@ -85,13 +88,13 @@ module PacketGen
       def read(str)
         if self.instance_of? TFTP
           super
-          if OPCODES.value? opcode
-            TFTP.const_get(human_opcode).new.read str
+          if OPCODES.value?(opcode)
+            TFTP.const_get(human_opcode).new.read(str)
           else
             self
           end
         else
-          old_read str
+          old_read(str)
         end
       end
 
@@ -130,7 +133,7 @@ module PacketGen
       # @param [Packet] packet
       # @return [void]
       def added_to_packet(packet)
-        return if packet.respond_to? :tftp
+        return if packet.respond_to?(:tftp)
 
         packet.instance_eval("def tftp(arg=nil); header(#{self.class}, arg); end") # def tftp(arg=nil); header(TFTP, arg); end
       end
@@ -140,24 +143,25 @@ module PacketGen
       def decode_tftp_packet(pkt)
         tftp = Packet.parse(pkt.body, first_header: 'TFTP')
         udp_dport = pkt.udp.dport
-        pkt.encapsulate tftp
+        pkt.encapsulate(tftp)
         # need to fix it as #encapsulate force it to 69
         pkt.udp.dport = udp_dport
       end
 
-      # TFTP Read Request header
+      # TFTP Read Request header.
+      # This header remove {#body} attribute and repalces it with {#filename} and {#mode}.
       class RRQ < TFTP
-        remove_field :body
+        remove_attr :body
 
         # @!attribute filename
         #   Filename to access
         #   @return [String]
-        define_field :filename, Types::CString
+        define_attr :filename, BinStruct::CString
 
         # @!attribute mode
         #   Mode used. Should be +netascii+, +octet+ or +mail+
         #   @return [String]
-        define_field :mode, Types::CString
+        define_attr :mode, BinStruct::CString
       end
 
       # TFTP Write Request header
@@ -168,32 +172,34 @@ module PacketGen
         # @!attribute block_num
         #   16-bit block number
         #   @return [Integer]
-        define_field_before :body, :block_num, Types::Int16
+        define_attr_before :body, :block_num, BinStruct::Int16
       end
 
-      # TFTP ACK header
+      # TFTP ACK header.
+      # This header remove {#body} attribute and repalces it with {#block_num}.
       class ACK < TFTP
-        remove_field :body
+        remove_attr :body
 
         # @!attribute block_num
         #   16-bit block number
         #   @return [Integer]
-        define_field :block_num, Types::Int16
+        define_attr :block_num, BinStruct::Int16
       end
 
-      # TFTP ERROR header
+      # TFTP ERROR header.
+      # This header remove {#body} attribute and repalces it with {#error_code} and {#error_msg}.
       class ERROR < TFTP
-        remove_field :body
+        remove_attr :body
 
         # @!attribute error_code
         #   16-bit error code
         #   @return [Integer]
-        define_field :error_code, Types::Int16
+        define_attr :error_code, BinStruct::Int16
 
         # @!attribute error_msg
         #   Error message
         #   @return [String]
-        define_field :error_msg, Types::CString
+        define_attr :error_msg, BinStruct::CString
         alias error_message error_msg
       end
     end