packetgen 3.3.3 → 4.1.0

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

@@ -11,23 +11,27 @@ module PacketGen
     class IP
       # Class to handle series of IP addresses
       # @author Sylvain Daubert
-      class ArrayOfAddr < Types::Array
+      class ArrayOfAddr < BinStruct::Array
         set_of IP::Addr
 
         # Push a IP address to the array
         # @param [String,Addr] addr
         # @return [self]
+        # @example
+        #   array = PacketGen::Header::IP::ArrayOfAddr.new
+        #   # #<< uses #push internally
         #   array << '192.168.1.12'
+        #   array.push(PacketGen::Header::IP::Addr.new.from_human('192.18.1.13'))
         def push(addr)
           addr = Addr.new.from_human(addr) unless addr.is_a?(Addr)
-          super(addr)
+          super
         end
       end
 
       # Base class for IP options
       # @author Sylvain Daubert
-      class Option < Types::Fields
-        include Types::Fieldable
+      class Option < BinStruct::Struct
+        include BinStruct::Structable
 
         # EOL option type
         EOL_TYPE = 0x00
@@ -46,21 +50,10 @@ module PacketGen
 
         # @!attribute type
         #  8-bit option type
-        # @return [Integer]
-        define_field :type, Types::Int8
-        # @!attribute length
-        #  8-bit option length. If 0, there is no +length+ field in option
-        # @return [Integer]
-        define_field :length, Types::Int8, default: 0, optional: ->(h) { h.type > 1 }
-        # @!attribute data
-        #  option data
-        # @return [String]
-        define_field :data, Types::String, optional: ->(h) { h.length > 2 },
-                                           builder: ->(h, t) { t.new(length_from: -> { h.length - 2 }) }
-
+        #  @return [Integer]
         # @!attribute copied
         #  1-bit copied flag from {#type} field
-        #  @return [Boolean]
+        #  @return [Integer]
         # @!attribute option_class
         #  2-bit option class (0: control, 2: debug and measurement, 1 and 3:
         #  reserved) from {#type} field
@@ -68,15 +61,26 @@ module PacketGen
         # !@attribute number
         #  5-bit option number from {#type} field
         #  @return [Integer]
-        define_bit_fields_on :type, :copied, :option_class, 2, :number, 5
+        define_bit_attr :type, copied: 1, option_class: 2, number: 5
+        # @!attribute length
+        #  8-bit option length. If 0, there is no +length+ field in option
+        #  @return [Integer]
+        define_attr :length, BinStruct::Int8, default: 0, optional: ->(h) { h.type > 1 }
+        # @!attribute data
+        #  option data
+        #  @return [String]
+        define_attr :data, BinStruct::String, optional: ->(h) { h.length > 2 },
+                                              builder: ->(h, t) { t.new(length_from: -> { h.length - 2 }) }
 
-        # @return [Hash]
+        # @private
+        # Return a cached hash associating type name to its value.
+        # @return [Hash{String => Integer}]
         def self.types
           return @types if defined? @types
 
           @types = {}
           Option.constants.each do |cst|
-            next unless cst.to_s.end_with? '_TYPE'
+            next unless cst.to_s.end_with?('_TYPE')
 
             optname = cst.to_s.sub('_TYPE', '')
             @types[optname] = Option.const_get(cst)
@@ -85,6 +89,7 @@ module PacketGen
         end
 
         # Factory to build an option from its type
+        # @param [Hash] options
         # @return [Option]
         def self.build(options={})
           type = options[:type]
@@ -98,6 +103,8 @@ module PacketGen
           klass.new(options)
         end
 
+        # Force type value for subclasses, if not specified
+        # @return [Option]
         def initialize(options={})
           options[:type] = class2type unless options[:type]
 
@@ -109,14 +116,14 @@ module PacketGen
         # Get binary string. Set {#length} field.
         # @return [String]
         def to_s
-          self.length = super.size if respond_to? :length
+          self.length = super.size if respond_to?(:length)
           super
         end
 
         # Get a human readable string
         # @return [String]
         def to_human
-          str = self.instance_of?(Option) ? +"unk-#{type}" : self.class.to_s.sub(/.*::/, '')
+          str = self.instance_of?(Option) ? "unk-#{type}" : self.class.to_s.sub(/.*::/, '')
           str << ":#{self[:data].to_s.inspect}" if respond_to?(:length) && (length > 2) && !self[:data].to_s.empty?
           str
         end
@@ -124,8 +131,8 @@ module PacketGen
         private
 
         def class2type
-          opt_name = self.class.to_s.gsub(/.*::/, '')
-          Option.const_get(:"#{opt_name}_TYPE") if Option.const_defined? :"#{opt_name}_TYPE"
+          opt_sym = :"#{self.class.to_s.gsub(/.*::/, '')}_TYPE"
+          Option.const_get(opt_sym) if Option.const_defined?(opt_sym)
         end
 
         def initialize_length_if_needed(options)
@@ -133,7 +140,7 @@ module PacketGen
         end
 
         def initialize_data_if_needed(options)
-          return unless fields.include?(:data) && self[:data].respond_to?(:from_human) && options.key?(:data)
+          return unless attributes.include?(:data) && self[:data].respond_to?(:from_human) && options.key?(:data)
 
           # Force data if data is set in options but not length
           self.length += options[:data].size
@@ -143,8 +150,8 @@ module PacketGen
 
       # End-of-option-List IP option
       class EOL < Option
-        remove_field :length
-        remove_field :data
+        remove_attr :length
+        remove_attr :data
       end
 
       # No OPeration IP option
@@ -152,16 +159,16 @@ module PacketGen
 
       # Loose Source and Record Route IP option
       class LSRR < Option
-        remove_field :data
+        remove_attr :data
 
         # @!attribute pointer
-        #  8-bit pointer on next address
+        #  8-bit po+++inter on next address
         #  @return [Integer]
-        define_field :pointer, Types::Int8, default: 4
+        define_attr :pointer, BinStruct::Int8, default: 4
         # @!attribute data
         #  Array of IP addresses
-        #  @return [Types::Array<IP::Addr>]
-        define_field :data, ArrayOfAddr, builder: ->(h, t) { t.new(length_from: -> { h.length - 3 }) }
+        #  @return [BinStruct::Array<IP::Addr>]
+        define_attr :data, ArrayOfAddr, builder: ->(h, t) { t.new(length_from: -> { h.length - 3 }) }
 
         # Get IP address pointer by {#pointer}
         # @return [Addr]
@@ -185,13 +192,15 @@ module PacketGen
 
       # Stream Identifier IP option
       class SI < Option
-        remove_field :data
+        remove_attr :data
 
         # @!attribute id
         #  16-bit stream ID
         #  @return [Integer]
-        define_field :id, Types::Int16
+        define_attr :id, BinStruct::Int16
 
+        # Return a human-readable string
+        # @return [String]
         def to_human
           super << ":#{self.id}"
         end
@@ -199,13 +208,15 @@ module PacketGen
 
       # Router Alert IP option
       class RA < Option
-        remove_field :data
+        remove_attr :data
 
         # @!attribute value
         #  16-bit value. Should be 0.
         #  @return [Integer]
-        define_field :value, Types::Int16, default: 0
+        define_attr :value, BinStruct::Int16, default: 0
 
+        # Return a human-readable string
+        # @return [String]
         def to_human
           super << ":#{self.value}"
         end

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

@@ -11,7 +11,7 @@ module PacketGen
     class IP
       # Class to handle IP options
       # @author Sylvain Daubert
-      class Options < Types::Array
+      class Options < BinStruct::Array
         set_of Option
 
         HUMAN_SEPARATOR = ';'

data/lib/packetgen/header/ip.rb

@@ -27,32 +27,33 @@ module PacketGen
     #   |                    Options                    |    Padding    |
     #   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     # A IP header consists of:
-    # * a first byte ({#u8} of {Types::Int8} type) composed of:
+    # * a first byte ({#u8} of +BinStruct::Int8+ type) composed of:
     #   * a 4-bit {#version} field,
     #   * a 4-bit IP header length ({#ihl}) field,
-    # * a Type of Service field ({#tos}, {Types::Int8} type),
-    # * a total length ({#length}, {Types::Int16} type),
-    # * a ID ({#id}, +Int16+ type),
-    # * a {#frag} worg (+Int16+) composed of:
+    # * a Type of Service field ({#tos}, +BinStruct::Int8+ type),
+    # * a total length ({#length}, +BinStruct::Int16+ type),
+    # * a ID ({#id}, +BinStruct::Int16+ type),
+    # * a {#frag} worg (+BinStruct::Int16+) composed of:
     #   * 3 1-bit flags ({#flag_rsv}, {#flag_df} and {#flag_mf}),
     #   * a 13-bit {#fragment_offset} field,
     # * a Time-to-Live ({#ttl}) field (+Int8+),
-    # * a {#protocol} field (+Int8+),
-    # * a {#checksum} field (+Int16+),
+    # * a {#protocol} field (+BinStruct::Int8+),
+    # * a {#checksum} field (+BinStruct::Int16+),
     # * a source IP address ({#src}, {Addr} type),
-    # * a destination IP address ({#dst}, +Addr+ type),
+    # * a destination IP address ({#dst}, {Addr} type),
     # * an optional {#options} field ({Options} type),
-    # * and a {#body} ({Types::String} type).
+    # * and a {#body} (+BinStruct::String+ type).
     #
-    # == Create a IP header
+    # @example Create a IP header
     #  # standalone
     #  ip = PacketGen::Header::IP.new
     #  # in a packet
     #  pkt = PacketGen.gen('IP')
     #  # access to IP header
-    #  pkt.ip   # => PacketGen::Header::IP
+    #  pkt.ip.class   # => PacketGen::Header::IP
     #
-    # == IP attributes
+    # @example IP attributes
+    #  ip = PacketGen::Header::IP.new
     #  ip.u8 = 0x45
     #  # the same as
     #  ip.version = 4
@@ -66,21 +67,20 @@ module PacketGen
     #  ip.flag_mf = true
     #  ip.fragment_offset = 0x31
     #
-    #  ip.flag_rsv?  # => Boolean
-    #  ip.flag_df?   # => Boolean
-    #  ip.flag_mf?   # => Boolean
+    #  ip.flag_rsv?  # => false
+    #  ip.flag_df?   # => false
+    #  ip.flag_mf?   # => true
     #
     #  ip.ttl = 0x40
     #  ip.protocol = 6
     #  ip.checksum = 0xffff
     #  ip.src = '127.0.0.1'
     #  ip.src                # => "127.0.0.1"
-    #  ip[:src]              # => PacketGen::Header::IP::Addr
+    #  ip[:src].class        # => PacketGen::Header::IP::Addr
     #  ip.dst = '127.0.0.2'
-    #  ip.body.read 'this is a body'
+    #  ip.body = 'this is a body'
     #
-    # == Add IP options
-    # IP has an {#options} attribute used to store datagram options.
+    # @example Add IP options
     #  pkt = PacketGen.gen('IP')
     #  # add option from class
     #  pkt.ip.options << PacketGen::Header::IP::RA.new
@@ -100,58 +100,70 @@ module PacketGen
       # @!attribute u8
       #  First byte of IP header. May be accessed through {#version} and {#ihl}.
       #  @return [Integer] first byte of IP header.
-      define_field :u8, Types::Int8, default: 0x45
+      # @!attribute version
+      #   4-bit version attribute
+      #   @return [Integer]
+      # @!attribute ihl
+      #   4-bit IP header length attribute, as 32-bit word count.
+      #   Default to 5 (IP header without option).
+      #   @return [Integer]
+      define_bit_attr :u8, default: 0x45, version: 4, ihl: 4
       # @!attribute tos
       #   @return [Integer] 8-bit Type of Service self[attr]
-      define_field :tos, Types::Int8, default: 0
+      define_attr :tos, BinStruct::Int8, default: 0
       # @!attribute length
-      #   @return [Integer] 16-bit IP total length
-      define_field :length, Types::Int16, default: 20
+      #   16-bit IP total length, including this header.
+      #   @return [Integer]
+      define_attr :length, BinStruct::Int16, default: 20
       # @!attribute id
       #   @return [Integer] 16-bit ID
-      define_field :id, Types::Int16, default: ->(_) { rand(65_535) }
+      define_attr :id, BinStruct::Int16, default: ->(_) { rand(65_535) }
       # @!attribute frag
-      #   @return [Integer] 16-bit frag word
-      define_field :frag, Types::Int16, default: 0
+      #   16-bit frag word
+      #   @return [Integer]
+      # @!attribute flag_rsv
+      #   reserved bit from flags
+      #   @return [Boolean]
+      # @!attribute flag_df
+      #   Don't Fragment flag
+      #   @return [Boolean]
+      # @!attribute flag_mf
+      #   More Fragment flags
+      #   @return [Boolean]
+      # @!attribute fragment_offset
+      #   13-bit fragment offset
+      #   @return [Integer]
+      define_bit_attr :frag, flag_rsv: 1, flag_df: 1, flag_mf: 1, fragment_offset: 13
       # @!attribute ttl
-      #   @return [Integer] 8-bit Time To Live self[attr]
-      define_field :ttl, Types::Int8, default: 64
+      #   8-bit Time To Live
+      #   @return [Integer]
+      define_attr :ttl, BinStruct::Int8, default: 64
       # @!attribute protocol
-      #   @return [Integer] 8-bit upper protocol self[attr]
-      define_field :protocol, Types::Int8
+      #   8-bit upper protocol
+      #   @return [Integer]
+      define_attr :protocol, BinStruct::Int8
       # @!attribute checksum
-      #   @return [Integer] 16-bit IP header checksum
-      define_field :checksum, Types::Int16, default: 0
+      #   16-bit IP header checksum
+      #   @return [Integer]
+      define_attr :checksum, BinStruct::Int16, default: 0
       # @!attribute src
-      #   @return [Addr] source IP address
-      define_field :src, Addr, default: '127.0.0.1'
+      #   source IP address
+      #   @return [Addr]
+      define_attr :src, Addr, default: '127.0.0.1'
       # @!attribute dst
-      #   @return [Addr] destination IP address
-      define_field :dst, Addr, default: '127.0.0.1'
+      #   destination IP address
+      #   @return [Addr]
+      define_attr :dst, Addr, default: '127.0.0.1'
       # @!attribute options
+      #  IP options
       #  @since 2.2.0
-      #  @return [Types::String]
-      define_field :options, Options, optional: ->(h) { h.ihl > 5 },
-                                      builder: ->(h, t) { t.new(length_from: -> { (h.ihl - 5) * 4 }) }
+      #  @return [Options]
+      define_attr :options, Options, optional: ->(h) { h.ihl > 5 },
+                                     builder: ->(h, t) { t.new(length_from: -> { (h.ihl - 5) * 4 }) }
       # @!attribute body
-      #  @return [Types::String,Header::Base]
-      define_field :body, Types::String
-
-      # @!attribute version
-      #   @return [Integer] 4-bit version attribute
-      # @!attribute ihl
-      #   @return [Integer] 4-bit IP header length attribute
-      define_bit_fields_on :u8, :version, 4, :ihl, 4
-
-      # @!attribute flag_rsv
-      #   @return [Boolean] reserved bit from flags
-      # @!attribute flag_df
-      #   @return [Boolean] Don't Fragment flag
-      # @!attribute flag_mf
-      #   @return [Boolean] More Fragment flags
-      # @!attribute fragment_offset
-      #   @return [Integer] 13-bit fragment offset
-      define_bit_fields_on :frag, :flag_rsv, :flag_df, :flag_mf, :fragment_offset, 13
+      #  IP body
+      #  @return [BinStruct::String,Headerable]
+      define_attr :body, BinStruct::String
 
       # Helper method to compute sum of 16-bit words. Used to compute IP-style
       # checksums.
@@ -160,7 +172,7 @@ module PacketGen
       # @return [Integer]
       def self.sum16(hdr)
         old_checksum = nil
-        if hdr.respond_to? :checksum=
+        if hdr.respond_to?(:checksum)
           old_checksum = hdr.checksum
           hdr.checksum = 0
         end
@@ -178,8 +190,8 @@ module PacketGen
       # This method:
       # * checks a checksum is not greater than 0xffff. If it is,
       #   reduces it.
-      # * inverts reduced self[attr].
-      # * forces self[attr] to 0xffff if computed self[attr] is 0.
+      # * inverts reduced checksum.
+      # * forces checksum to 0xffff if computed checksum is 0.
       # @param [Integer] checksum checksum to reduce
       # @return [Integer] reduced checksum
       def self.reduce_checksum(checksum)
@@ -203,7 +215,7 @@ module PacketGen
       # @return [Integer]
       # @since 3.0.0 add +ihl+ calculation
       def calc_length
-        Base.calculate_and_set_length self
+        Base.calculate_and_set_length(self)
         self.ihl = 5 + self[:options].sz / 4
       end
 
@@ -216,31 +228,20 @@ module PacketGen
 
       # Send IP packet on wire.
       #
-      # When sending packet at IP level, +checksum+ and +length+ fields are set by
+      # When sending packet at IP level, +checksum+ and +length+ attributes are set by
       # kernel, so bad IP packets cannot be sent this way. To do so, use {Eth#to_w}.
       # @param [String,nil] _iface interface name. Not used
       # @return [void]
       def to_w(_iface=nil)
         sock = Socket.new(Socket::AF_INET, Socket::SOCK_RAW, Socket::IPPROTO_RAW)
         sockaddrin = Socket.sockaddr_in(0, dst)
-        sock.send to_s, 0, sockaddrin
+        sock.send(to_s, 0, sockaddrin)
         sock.close
       end
 
-      # @return [String]
-      def inspect
-        super do |attr|
-          case attr
-          when :u8
-            inspect_u8
-          when :frag
-            inspect_frag
-          end
-        end
-      end
-
       # Check version field
-      # @see [Base#parse?]
+      # @see Base#parse?
+      # @return [Boolean]
       def parse?
         (version == 4) && (ihl >= 5)
       end
@@ -259,25 +260,6 @@ module PacketGen
         self[:src], self[:dst] = self[:dst], self[:src]
         self
       end
-
-      private
-
-      def inspect_u8
-        shift = Inspect.shift_level
-        str = Inspect.inspect_attribute(:u8, self[:u8])
-        str << shift << Inspect::FMT_ATTR % ['', 'version', version]
-        str << shift << Inspect::FMT_ATTR % ['', 'ihl', ihl]
-      end
-
-      def inspect_frag
-        shift = Inspect.shift_level
-        str = Inspect.inspect_attribute(:frag, self[:frag])
-        flags = %i[rsv df mf].select { |flag| send(:"flag_#{flag}?") }.map(&:upcase)
-        flags_str = flags.empty? ? 'none' : flags.join(',')
-        str << shift << Inspect::FMT_ATTR % ['', 'flags', flags_str]
-        foff = Inspect.int_dec_hex(fragment_offset, 4)
-        str << shift << Inspect::FMT_ATTR % ['', 'frag_offset', foff]
-      end
     end
 
     self.add_class IP

data/lib/packetgen/header/ipv6/addr.rb

@@ -14,47 +14,47 @@ module PacketGen
     class IPv6
       # IPv6 address, as a group of 8 2-byte words
       # @author Sylvain Daubert
-      class Addr < Types::Fields
-        include Types::Fieldable
+      # @author LemonTree55
+      class Addr < BinStruct::Struct
+        include BinStruct::Structable
 
         # @!attribute a1
         #  1st 2-byte word of IPv6 address
         #  @return [Integer]
-        define_field :a1, Types::Int16
+        define_attr :a1, BinStruct::Int16
         # @!attribute a2
         #  2nd 2-byte word of IPv6 address
         #  @return [Integer]
-        define_field :a2, Types::Int16
+        define_attr :a2, BinStruct::Int16
         # @!attribute a3
         #  3rd 2-byte word of IPv6 address
         #  @return [Integer]
-        define_field :a3, Types::Int16
+        define_attr :a3, BinStruct::Int16
         # @!attribute a4
         #  4th 2-byte word of IPv6 address
         #  @return [Integer]
-        define_field :a4, Types::Int16
+        define_attr :a4, BinStruct::Int16
         # @!attribute a5
         #  5th 2-byte word of IPv6 address
         #  @return [Integer]
-        define_field :a5, Types::Int16
+        define_attr :a5, BinStruct::Int16
         # @!attribute a6
         #  6th 2-byte word of IPv6 address
         #  @return [Integer]
-        define_field :a6, Types::Int16
+        define_attr :a6, BinStruct::Int16
         # @!attribute a7
         #  7th 2-byte word of IPv6 address
         #  @return [Integer]
-        define_field :a7, Types::Int16
+        define_attr :a7, BinStruct::Int16
         # @!attribute a8
         #  8th 2-byte word of IPv6 address
         #  @return [Integer]
-        define_field :a8, Types::Int16
-
-        # rubocop:disable Metrics/AbcSize
+        define_attr :a8, BinStruct::Int16
 
         # Read a colon-delimited address
         # @param [String] str
         # @return [self]
+        # @raise [ArgumentError] not a colon-delimited IPv6 address
         def from_human(str)
           return self if str.nil?
 
@@ -62,19 +62,13 @@ module PacketGen
           raise ArgumentError, 'string is not a IPv6 address' unless addr.ipv6?
 
           addri = addr.to_i
-          self.a1 = addri >> 112
-          self.a2 = addri >> 96 & 0xffff
-          self.a3 = addri >> 80 & 0xffff
-          self.a4 = addri >> 64 & 0xffff
-          self.a5 = addri >> 48 & 0xffff
-          self.a6 = addri >> 32 & 0xffff
-          self.a7 = addri >> 16 & 0xffff
-          self.a8 = addri & 0xffff
+          8.times do |i|
+            self.send(:"a#{i + 1}=", addri >> (16 * (7 - i)) & 0xffff)
+          end
           self
         end
-        # rubocop:enable Metrics/AbcSize
 
-        # Addr6 in human readable form (colon-delimited hex string)
+        # Return IPv6 address in human readable form (colon-delimited hex string)
         # @return [String]
         def to_human
           IPAddr.new(to_a.map { |a| a.to_i.to_s(16) }.join(':')).to_s
@@ -83,7 +77,7 @@ module PacketGen
         # Return an array of address 16-bit words
         # @return [Array<Integer>]
         def to_a
-          @fields.values
+          @attributes.values
         end
 
         # Return true if this address is a multicast one
@@ -92,24 +86,31 @@ module PacketGen
           self.a1 & 0xff00 == 0xff00
         end
 
+        # Check equaliy to +other+.
+        # Equal if other has the same class, and all attributes are equal
+        # @return [Boolean]
         def ==(other)
           other.is_a?(self.class) &&
-            fields.all? { |attr| self[attr].value == other[attr].value }
+            attributes.all? { |attr| self[attr].value == other[attr].value }
         end
       end
 
       # Class to handle series of IPv6 addresses
       # @author Sylvain Daubert
-      class ArrayOfAddr < Types::Array
+      class ArrayOfAddr < BinStruct::Array
         set_of IPv6::Addr
 
         # Push a IPv6 address to the array
         # @param [String,Addr] addr
         # @return [self]
-        #   array << '2001:1234::125'
+        # @example
+        #   array = PacketGen::Header::IPv6::ArrayOfAddr.new
+        #   # #<< uses #push internally
+        #   array << '2001::1'
+        #   array.push(PacketGen::Header::IPv6::Addr.new.from_human('1:2:3:abcd::1'))
         def push(addr)
           addr = Addr.new.from_human(addr) unless addr.is_a?(Addr)
-          super(addr)
+          super
         end
       end
     end

data/lib/packetgen/header/ipv6/extension.rb

@@ -9,7 +9,7 @@
 module PacketGen
   module Header
     class IPv6
-      # Base class to handle IPv6 extensions
+      # Base class to handle IPv6 extensions.
       # @abstract You should not use this class but its subclasses.
       # A IPv6 extension header has the following format:
       #   0                   1                   2                   3
@@ -25,29 +25,31 @@ module PacketGen
       #  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
       #
       # Such a header consists of:
-      # * a {#next} header field ({Types::Int8}),
-      # * a {#length} field ({Types::Int8}),
-      # * an {#options} field ({Types::String}),
+      # * a {#next} header field (+BinStruct::Int8+),
+      # * a {#length} field (+BinStruct::Int8+),
+      # * an {#options} field (+BinStruct::String+),
       # * and a {#body}, containing next header.
       # @author Sylvain Daubert
+      # @since 2.4.0
       class Extension < Base
         # @!attribute next
         #  8-bit Next header field
         #  @return [Integer]
-        define_field :next, Types::Int8
+        define_attr :next, BinStruct::Int8
         # @!attribute length
         #  8-bit extension length, in 8-octets units, not including the
         #  first 8 octets.
         #  @return [Integer]
-        define_field :length, Types::Int8
+        define_attr :length, BinStruct::Int8
         # @!attribute options
         #  Specific options of extension header
         #  @return [String]
-        define_field :options, Types::String,
-                     builder: ->(h, t) { t.new(length_from: -> { h.real_length }) }
+        define_attr :options, BinStruct::String,
+                    builder: ->(h, t) { t.new(length_from: -> { h.real_length - 2}) }
         # @!attribute body
-        #  @return [String,Base]
-        define_field :body, Types::String
+        #  Next header in IPv6 packet
+        #  @return [String,Headerable]
+        define_attr :body, BinStruct::String
 
         # Get real extension header length
         # @return [Integer]
@@ -55,7 +57,7 @@ module PacketGen
           (length + 1) * 8
         end
 
-        # Compute length and set +len+ field
+        # Compute length and set {#length}+ attribute
         # @return [Integer]
         def calc_length
           self.length = (options.sz + 2) / 8 - 1