packetgen 3.3.3 → 4.1.0

data/lib/packetgen/header/eap/ttls.rb

@@ -13,31 +13,32 @@ module PacketGen
       # {https://tools.ietf.org/html/rfc5281 RFC 5281}
       #
       # {EAP::TTLS} has following fields:
-      # * {#flags} ({Types::Int8}),
-      # * optionally {#message_length} ({Types::Int32}), if +#l?+ is +true+,
-      # * {#body} ({Types::String}).
+      # * {#flags} (+BinStruct::Int8+),
+      # * optionally {#message_length} (+BinStruct::Int32+), if +#l?+ is +true+,
+      # * {#body} (+BinStruct::String+).
       # @author Sylvain Daubert
       # @since 2.1.4
       class TTLS < EAP
-        update_field :type, default: 21
+        update_attr :type, default: 21
         # @!attribute flags
-        #  @return [Integer] 8-bit flags
-        define_field_before :body, :flags, Types::Int8
-
-        # @!attribute l
-        #  Say if length field is included. Defined on {#flags} field.
-        #  @return [Boolean]
-        # @!attribute m
-        #  Say if there are more fragments. Defined on {#flags} field.
-        #  @return [Boolean]
-        # @!attribute s
-        #  If set, this message is a TLS-Start. Defined on {#flags} field.
-        #  @return [Boolean]
+        #  8-bit flags
+        #  @return [Integer]
+        # @!attribute l?
+        #  Say if {#message_length} field is included
+        #  @return [Integer]
+        # @!attribute m?
+        #  Say if there are more fragments
+        #  @return [Integer]
+        # @!attribute s?
+        #  If set, this message is a TLS-Start
+        #  @return [Integer]
         # @!attribute reserved
-        #  @return [Integer] 2-bit reserved integer
+        #   2-bit reserved integer
+        #  @return [Integer]
         # @!attribute version
-        #  @return [Integer] 3-bit version
-        define_bit_fields_on :flags, :l, :m, :s, :reserved, 2, :version, 3
+        #  3-bit version
+        #  @return [Integer]
+        define_bit_attr_before :body, :flags, l: 1, m: 1, s: 1, reserved: 2, version: 3
         alias length_present? l?
         alias more_fragments? m?
         alias tls_start? s?
@@ -47,8 +48,8 @@ module PacketGen
         #  raw data message sequence prior to fragmentation. So, it
         #  cannot be automatically calculated (no +#calc_length+ method).
         #  @return [Integer] 32-bit message length
-        define_field_before :body, :message_length, Types::Int32,
-                            optional: ->(h) { h.l? }
+        define_attr_before :body, :message_length, BinStruct::Int32,
+                           optional: lambda(&:l?)
 
         # @return [String]
         def inspect

data/lib/packetgen/header/eap.rb

@@ -12,34 +12,22 @@ module PacketGen
     # {https://tools.ietf.org/html/rfc3748 RFC 3748}
     #
     # A EAP header has:
-    # * a {#code} field ({Types::Int8Enum}),
-    # * a {#id} field ({Types::Int8}),
-    # * a {#length} field ({Types::Int16}).
+    # * a {#code} field (+BinStruct::Int8Enum+),
+    # * a {#id} field (+BinStruct::Int8+),
+    # * a {#length} field (+BinStruct::Int16+).
     # Request (code 1) and Response (code 2) packets also have:
-    # * a {#type} field (+Types::Int8Enum+).
+    # * a {#type} field (+BinStruct::Int8Enum+).
     # And Expanded Types (type 254) packets also have:
-    # * a {#vendor_id} field ({Types::Int24}),
-    # * a {#vendor_type} field ({Types::Int32}).
-    # Finally, all packets have a {#body} ({Types::String}).
-    #
-    # == Create EAP headers
-    # An EAP header may be created this way:
-    #   # create a request header with default type (1)
-    #   eap = EAP.new(code: 1)   # => PacketGen::Header::EAP
-    #   # the same
-    #   eap = EAP.new(code: 'Request')   # => PacketGen::Header::EAP
-    #   # create a Response header of type Nak
-    #   nak = EAP.new(code: 'Response', type: 'Nak')
+    # * a {#vendor_id} field (+BinStruct::Int24+),
+    # * a {#vendor_type} field (+BinStruct::Int32+).
+    # Finally, all packets have a {#body} (+BinStruct::String+).
     #
     # === Specialized headers
     # Some EAP has a specialized class:
-    # * EAP-MD5,
-    # * EAP-TLS,
-    # * EAP-TTLS,
-    # * EAP-FAST.
-    # Creating such a header is fairly simple:
-    #   # Generate a EAP-TLS Response (type is forced to 13)
-    #   eap = EAP::TLS.new(code: 2)     # => PacketGen::Header::EAP::TLS
+    # * EAP-MD5 ({EAP::MD5}),
+    # * EAP-TLS ({EAP::TLS}),
+    # * EAP-TTLS ({EAP::TTLS}),
+    # * EAP-FAST ({EAP::FAST}).
     #
     # == Header accessors
     # EAP headers may be accessed through +Packet#eap+ accessor.
@@ -54,7 +42,29 @@ module PacketGen
     # So result of parsing a EAP header may be a {EAP}, {EAP::MD5}, {EAP::TLS},
     # {EAP::TTLS} or {EAP::FAST} instance. But this instance is still accessible
     # through +Packet#eap+.
+    #
+    # @example Create EAP headers
+    #   # create a request header with default type (1)
+    #   eap = PacketGen::Header::EAP.new(code: 1)
+    #   eap.human_code   #=> 'Request'
+    #   # the same
+    #   eap = PacketGen::Header::EAP.new(code: 'Request')
+    #   eap.code         #=> 1
+    #   # create a Response header of type Nak
+    #   nak = PacketGen::Header::EAP.new(code: 'Response', type: 'Nak')
+    #   nak.code      #=> 2
+    #   nak.type      #=> 3
+    #
+    # @example Create a specialized EAP header
+    #   eap = PacketGen::Header::EAP::TLS.new(code: 2)
+    #   eap.class    #=> PacketGen::Header::EAP::TLS
+    #
+    # @example Parse a specialized class from a binary string
+    #   pkt = PacketGen.parse("\x01\x00\x00\x0e\x04\x04\x00\x01\x02\x03name", first_header: 'EAP')
+    #   pkt.eap.class   # => PacketGen::Header::EAP::MD5
+    #
     # @author Sylvain Daubert
+    # @author LemonTree55
     # @since 2.1.4
     class EAP < Base
       # EAP known codes
@@ -81,42 +91,49 @@ module PacketGen
       }.freeze
 
       # @!attribute code
-      #  @return [Integer] 8-bit EAP code
-      define_field :code, Types::Int8Enum, enum: CODES
+      #  8-bit EAP code. See {CODES known EAP codes}
+      #  @return [Integer]
+      define_attr :code, BinStruct::Int8Enum, enum: CODES
 
       # @!attribute id
-      #  @return [Integer] 8-bit identifier
-      define_field :id, Types::Int8
+      #  8-bit identifier
+      #  @return [Integer]
+      define_attr :id, BinStruct::Int8
 
       # @!attribute length
-      #  @return [Integer] 16-bit length of EAP packet
-      define_field :length, Types::Int16, default: 4
+      #  16-bit length of EAP packet
+      #  @return [Integer]
+      define_attr :length, BinStruct::Int16, default: 4
 
       # @!attribute type
-      #  This field is present only for Request or Response packets,
-      #  with type different from Expanded Types (254).
-      #  @return [Integer] 8-bit request or response type
-      define_field :type, Types::Int8Enum,
-                   enum: TYPES,
-                   optional: ->(eap) { eap.type? }
+      #  8-bit request or response type.
+      #  This field is present only for Request or Response packets.
+      #  See {TYPES known EAP types}.
+      #  @return [Integer]
+      define_attr :type, BinStruct::Int8Enum,
+                  enum: TYPES,
+                  optional: lambda(&:type?)
 
       # @!attribute vendor_id
+      #  24-bit vendor ID.
       #  This field is present only for Request or Response packets,
       #  with type equal to +Expanded Types+ (254).
-      #  @return [Integer] 24-bit vendor ID
-      define_field :vendor_id, Types::Int24,
-                   optional: ->(eap) { eap.type? && (eap.type == 254) }
+      #  @return [Integer]
+      define_attr :vendor_id, BinStruct::Int24,
+                  optional: ->(eap) { eap.type? && (eap.type == 254) }
 
       # @!attribute vendor_type
+      #  32-bit vendor type.
       #  This field is present only for Request or Response packets,
       #  with type equal to +Expanded Types+ (254).
-      #  @return [Integer] 32-bit vendor type
-      define_field :vendor_type, Types::Int32,
-                   optional: ->(eap) { eap.type? && (eap.type == 254) }
+      #  @return [Integer]
+      define_attr :vendor_type, BinStruct::Int32,
+                  optional: ->(eap) { eap.type? && (eap.type == 254) }
 
       # @!attribute body
-      #  @return [Types::String, Header::Base]
-      define_field :body, Types::String
+      #  EAP packet body
+      #  @return [BinStruct::String, Headerable]
+      define_attr :body, BinStruct::String
 
       # @return [EAP]
       def initialize(options={})
@@ -129,10 +146,10 @@ module PacketGen
 
       # Populate object from a binary string
       # @param [String] str
-      # @return [Dot11] may return a subclass object if a more specific class
+      # @return [EAP] may return a subclass object if a more specific class
       #   may be determined
       def read(str)
-        super(str)
+        super
         return self unless self.instance_of?(EAP)
         return self unless type?
 
@@ -189,11 +206,19 @@ module PacketGen
         code == CODES['Failure']
       end
 
+      # Is packet a NAK?
+      # @return [Boolean]
+      # @since 4.1.0
+      # @author LemonTree55
+      def nak?
+        (code == 2) && (type == 3)
+      end
+
       # Return an array of desired authentication types from a Nak packet
       # @return [Array<Integer>]
       # @raise [ParseError] not a Nak packet
       def desired_auth_type
-        raise ParseError, 'not a Nak response' if (code != 2) && (type != 3)
+        raise ParseError, 'not a Nak response' unless nak?
 
         body.to_s.unpack('C*')
       end
@@ -201,7 +226,7 @@ module PacketGen
       # Calculate length field from content
       # @return [Integer]
       def calc_length
-        Base.calculate_and_set_length self
+        Base.calculate_and_set_length(self)
       end
 
       # Say is this EAP header has {#type} field
@@ -217,7 +242,7 @@ module PacketGen
       # @param [Packet] packet
       # @return [void]
       def added_to_packet(packet)
-        return if packet.respond_to? :eap
+        return if packet.respond_to?(:eap)
 
         packet.instance_eval("def eap(arg=nil); header(#{self.class}, arg); end") # def eap(arg=nil); header(EAP, arg); end
       end

data/lib/packetgen/header/eth.rb

@@ -10,54 +10,64 @@ module PacketGen
   module Header
     # An Ethernet header consists of:
     # * a destination MAC address ({MacAddr}),
-    # * a source MAC address (MacAddr),
-    # * a {#ethertype} ({Types::Int16}),
-    # * and a body (a {Types::String} or another Header class).
+    # * a source MAC address ({MacAddr}),
+    # * a {#ethertype} (+BinStruct::Int16+),
+    # * and a body (a +BinStruct::String+ or another {Headerable} class).
     #
-    # == Create a Ethernet header
+    # @example Create a Ethernet header
     #  # standalone
     #  eth = PacketGen::Header::Eth.new
     #  # in a packet
     #  pkt = PacketGen.gen('Eth')
     #  # access to Ethernet header
-    #  pkt.eth   # => PacketGen::Header::Eth
+    #  pkt.eth.class   # => PacketGen::Header::Eth
     #
-    # == Ethernet attributes
+    # @example Access to Ethernet attributes
+    #  eth = PacketGen::Header::Eth.new(src: '00:01:01:01:01:01', ethertype: 0x1234)
+    #  # Set destination MAC address
     #  eth.dst = "00:01:02:03:04:05"
-    #  eth.src        # => "00:01:01:01:01:01"
-    #  eth[:src]      # => PacketGen::Header::Eth::MacAddr
-    #  eth.ethertype  # => 16-bit Integer
+    #  # Access source MAC address, human-redable
+    #  eth.src            # => "00:01:01:01:01:01"
+    #  # Access to MacAddr object
+    #  eth[:src].class    # => PacketGen::Header::Eth::MacAddr
+    #  eth.ethertype      # => 0x1234
+    #  # Set Ethernet body
     #  eth.body = "This is a body"
     #
     # @author Sylvain Daubert
+    # @author LemonTree55
     class Eth < Base
       # Ethernet MAC address, as a group of 6 bytes
       # @author Sylvain Daubert
-      class MacAddr < Types::Fields
-        include Types::Fieldable
+      class MacAddr < BinStruct::Struct
+        include BinStruct::Structable
 
         # @!attribute a0
         #  @return [Integer] first byte from MacAddr
-        define_field :a0, Types::Int8
+        define_attr :a0, BinStruct::Int8
         # @!attribute a1
         #  @return [Integer] second byte from MacAddr
-        define_field :a1, Types::Int8
+        define_attr :a1, BinStruct::Int8
         # @!attribute a2
         #  @return [Integer] third byte from MacAddr
-        define_field :a2, Types::Int8
+        define_attr :a2, BinStruct::Int8
         # @!attribute a3
         #  @return [Integer] fourth byte from MacAddr
-        define_field :a3, Types::Int8
+        define_attr :a3, BinStruct::Int8
         # @!attribute a4
         #  @return [Integer] fifth byte from MacAddr
-        define_field :a4, Types::Int8
+        define_attr :a4, BinStruct::Int8
         # @!attribute a5
         #  @return [Integer] sixth byte from MacAddr
-        define_field :a5, Types::Int8
+        define_attr :a5, BinStruct::Int8
 
         # Read a human-readable string to populate +MacAddr+
         # @param [String] str
         # @return [self]
+        # @example
+        #   mac = PacketGen::Header::Eth::MacAddr.new
+        #   mac.from_human('01:02:03:04:05:06')
+        #   mac.a5  # => 6
         def from_human(str)
           return self if str.nil?
 
@@ -65,7 +75,7 @@ module PacketGen
           raise ArgumentError, 'not a MAC address' unless bytes.size == 6
 
           6.times do |i|
-            self[:"a#{i}"].read(bytes[i].to_i(16))
+            self[:"a#{i}"].from_human(bytes[i].to_i(16))
           end
           self
         end
@@ -73,27 +83,31 @@ module PacketGen
         # +MacAddr+ in human readable form (colon format)
         # @return [String]
         def to_human
-          fields.map { |m| '%02x' % self[m] }.join(':')
+          attributes.map { |m| '%02x' % self[m] }.join(':')
         end
 
+        # Equality check. +true+ only if +other+ is a MacAddr, and each address byte is the same.
+        # @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
 
       # @!attribute dst
-      #  @return [MacAddr] Destination MAC address
-      define_field :dst, MacAddr, default: '00:00:00:00:00:00'
+      #  Destination MAC address
+      #  @return [::String]
+      define_attr :dst, MacAddr, default: '00:00:00:00:00:00'
       # @!attribute src
-      #  @return [MacAddr] Source MAC address
-      define_field :src, MacAddr, default: '00:00:00:00:00:00'
+      #  Source MAC address
+      #  @return [::String]
+      define_attr :src, MacAddr, default: '00:00:00:00:00:00'
       # @!attribute ethertype
       #  @return [Integer] 16-bit integer to determine payload type
-      define_field :ethertype, Types::Int16, default: 0
+      define_attr :ethertype, BinStruct::Int16, default: 0
       # @!attribute body
-      #  @return [Types::String,Header::Base]
-      define_field :body, Types::String
+      #  @return [BinStruct::String,Headerable]
+      define_attr :body, BinStruct::String
 
       # send Eth packet on wire.
       # @param [String] iface interface name

data/lib/packetgen/header/gre.rb

@@ -20,44 +20,66 @@ module PacketGen
     #  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     #  |                 Sequence Number (Optional)                    |
     #  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+    #
+    # A GRE header is composed of:
+    # * A first 16-bit attribute containing given flags:
+    #   * {#c} indicates if {#checksum} and {#reserved1} attributes are present.
+    #   * {#k} indicates if {#key} attribute is present.
+    #   * {#s} indicatesid {#sequence_number} attribute is present.
+    #   * {#ver} 3-bit version number.
+    # * {#protocol_type} (+BinStruct::Int16+).
+    # * optional {#checksum} and {#reserved1} attribute (both +BinStruct::Int16+).
+    # * optional {#key} attribute (+BinStruct::Int32+).
+    # * optional {#sequence_number} attribute (+BinStruct::Int32+).
+    # * and a {#body} (+BinStruct::String or {Headerable}).
+    #
+    # Current implementation supports tunneling {IP} and {IPv6} packets in GRE.
     # @author Sylvain Daubert
+    # @author LemonTree55
     # @since 2.1.0
     class GRE < Base
       # IP protocol number for GRE
       IP_PROTOCOL = 47
 
-      define_field :u16, Types::Int16
-
       # @!attribute c
+      #   Say if {#checksum} and {#reserved1} attributes are present
       #   @return [Boolean]
       # @!attribute k
+      #   Say if {#key} attribute is present
       #   @return [Boolean]
       # @!attribute s
+      #   Say if {#sequence_number} attribute is present
       #   @return [Boolean]
       # @!attribute reserved0
       #   @return [Integer]
       # @!attribute ver
+      #   3-bit GRE protocol version.
       #   @return [Integer]
-      define_bit_fields_on :u16, :c, :r, :k, :s, :reserved0, 9, :ver, 3
+      define_bit_attr :u16, c: 1, r: 1, k: 1, s: 1, reserved0: 9, ver: 3
 
       # @!attribute protocol_type
       #   @return [Integer]
-      define_field :protocol_type, Types::Int16
+      define_attr :protocol_type, BinStruct::Int16
       # @!attribute checksum
+      #   IP checksum over all 16-bit words in GRE header and its body. Present only if {#c} is set.
       #   @return [Integer]
-      define_field :checksum, Types::Int16, default: 0, optional: ->(gre) { gre.c? }
+      define_attr :checksum, BinStruct::Int16, default: 0, optional: lambda(&:c?)
       # @!attribute reserved1
+      #   Reserved field, present only if {#c} is set.
       #   @return [Integer]
-      define_field :reserved1, Types::Int16, default: 0, optional: ->(gre) { gre.c? }
+      define_attr :reserved1, BinStruct::Int16, default: 0, optional: lambda(&:c?)
       # @!attribute key
+      #   32-bit integer used to identify an individual traffic flow within a tunnel.
+      #   Present only if {#k} is set.
       #   @return [Integer]
-      define_field :key, Types::Int32, optional: ->(gre) { gre.k? }
+      define_attr :key, BinStruct::Int32, optional: lambda(&:k?)
       # @!attribute sequence_number
+      #   32-bit integer. Present only if {#s} is set.
       #   @return [Integer]
-      define_field :sequence_number, Types::Int32, optional: ->(gre) { gre.s? }
+      define_attr :sequence_number, BinStruct::Int32, optional: lambda(&:s?)
       # @!attribute body
-      #  @return [Types::String,Header::Base]
-      define_field :body, Types::String
+      #   @return [BinStruct::String,Headerable]
+      define_attr :body, BinStruct::String
 
       alias seqnum sequence_number
       alias seqnum= sequence_number=
@@ -67,7 +89,7 @@ module PacketGen
         super(opts)
       end
 
-      # Compute checksum and set +checksum+ field
+      # Compute checksum and set +checksum+ attribute.
       # @return [Integer]
       def calc_checksum
         sum = IP.sum16(self)

data/lib/packetgen/header/http/headers.rb

@@ -9,14 +9,15 @@
 module PacketGen
   module Header
     # @since 2.2.0
+    # @author Kent 'picat' Gruber
     module HTTP
       # @abstract Base class for HTTP headers.
       # @author Kent 'picat' Gruber
       class Headers
-        include Types::Fieldable
+        include BinStruct::Structable
 
-        # Underlying Headers data (or nil).
-        # @return [Hash, nil]
+        # Underlying Headers data.
+        # @return [Hash{String => String}, nil]
         attr_reader :data
         alias to_h data
 
@@ -25,7 +26,7 @@ module PacketGen
         end
 
         # Populate object from a string or directly from a hash.
-        # @param [String, Hash] s_or_h
+        # @param [String, Hash{String=>String}] s_or_h
         # @return [self]
         def read(s_or_h)
           case s_or_h
@@ -69,14 +70,14 @@ module PacketGen
           d.join("\r\n") << "\r\n\r\n"
         end
 
-        # Get a human readable string.
+        # Get a human readable hash.
         # @return [Hash]
         def to_human
           @data
         end
 
         # Read human-readable data to populate header data.
-        # @param [String, Hash] data
+        # @param [Hash{String=>String}] data
         # @return [self]
         def from_human(data)
           read(data)

data/lib/packetgen/header/http/request.rb

@@ -10,50 +10,57 @@ module PacketGen
   module Header
     module HTTP
       # An HTTP/1.1 Request packet consists of:
-      # * the http verb ({Types::String}).
-      # * the path ({Types::String}).
-      # * the version ({Types::String}).
+      # * the http verb (+BinStruct::String+).
+      # * the path (+BinStruct::String+).
+      # * the version (+BinStruct::String+).
       # * associated http headers ({HTTP::Headers}).
+      # * and a {#body} (+BinStruct::String+).
       #
-      # == Create a HTTP Request header
+      # Note: When creating a HTTP Request packet, {TCP#sport} and {TCP#dport}
+      # attributes are not set.
+      #
+      # @example Create a HTTP Request header
       #   # standalone
-      #   http_rqst = PacketGen::Header::HTTP::Request.new
+      #   http_request = PacketGen::Header::HTTP::Request.new
       #   # in a packet
       #   pkt = PacketGen.gen("IP").add("TCP").add("HTTP::Request")
       #   # access to HTTP Request header
-      #   pkt.http_request # => PacketGen::Header::HTTP::Request
-      #
-      # Note: When creating a HTTP Request packet, +sport+ and +dport+
-      # attributes of TCP header are not set.
+      #   pkt.http_request.class # => PacketGen::Header::HTTP::Request
       #
-      # == HTTP Request attributes
-      #   http_rqst.version = "HTTP/1.1"
-      #   http_rqst.verb  = "GET"
-      #   http_rqst.path    = "/meow.html"
-      #   http_rqst.headers = "Host: tcpdump.org"     # string or
-      #   http_rqst.headers = { "Host": "tcpdump.org" } # even a hash
+      # @example HTTP Request attributes
+      #   http_request = PacketGen::Header::HTTP::Request.new
+      #   http_request.version #=> "HTTP/1.1"
+      #   http_request.verb  = "GET"
+      #   http_request.path    = "/meow.html"
+      #   http_request.headers = "Host: tcpdump.org"     # string or
+      #   http_request.headers = { "Host": "tcpdump.org" } # even a hash
       #
       # @author Kent 'picat' Gruber
       # @author Sylvain Daubert
+      # @author LemonTree55
       # @since 3.1.0 Rename +#method+ into {#verb} to not mask +Object#method+.
       class Request < Base
         # @!attribute verb
-        #   @return [Types::String]
+        #   HTTP verb (method)
+        #   @return [BinStruct::String]
         #   @since 3.1.0
-        define_field :verb, Types::String
+        define_attr :verb, BinStruct::String
         # @!attribute path
-        #   @return [Types::String]
-        define_field :path,    Types::String
+        #   Requested path
+        #   @return [BinStruct::String]
+        define_attr :path,    BinStruct::String
         # @!attribute version
-        #   @return [Types::String]
-        define_field :version, Types::String, default: 'HTTP/1.1'
+        #   HTTP version
+        #   @return [BinStruct::String]
+        define_attr :version, BinStruct::String, default: 'HTTP/1.1'
         # @!attribute headers
         #   associated http/1.1 headers
         #   @return [HTTP::Headers]
-        define_field :headers, HTTP::Headers
+        define_attr :headers, HTTP::Headers
         # @!attribute body
-        #   @return [Types::String]
-        define_field :body, Types::String
+        #   HTTP request body, if any
+        #   @return [BinStruct::String]
+        define_attr :body, BinStruct::String
 
         # @param [Hash] options
         # @option options [String] :verb
@@ -61,18 +68,18 @@ module PacketGen
         # @option options [String] :version
         # @option options [Hash]   :headers
         def initialize(options={})
-          super(options)
+          super
           self.headers ||= options[:headers]
         end
 
         # Read in the HTTP portion of the packet, and parse it.
-        # @return [PacketGen::HTTP::Request]
+        # @return [self]
         def read(str)
           lines = lines(str)
           first_line_words = lines.shift.split
-          self[:verb].read first_line_words[0]
-          self[:path].read first_line_words[1]
-          self[:version].read first_line_words[2]
+          self[:verb].read(first_line_words[0])
+          self[:path].read(first_line_words[1])
+          self[:version].read(first_line_words[2])
 
           # requests can sometimes have a payload
           headers, data = headers_and_payload_from_lines(lines)
@@ -82,6 +89,8 @@ module PacketGen
           self
         end
 
+        # May be parsed as a HTTP request if verb is known, and if version is +HTTP/1.x+.
+        # @return [Boolean]
         def parse?
           VERBS.include?(self.verb) && self.version.start_with?('HTTP/1.')
         end