packetgen 3.3.3 → 4.1.0

data/lib/packetgen/header/dot11.rb

@@ -17,25 +17,24 @@ module PacketGen
     class PPI < Base
       # @!attribute version
       #  @return [Integer] 8-bit PPI version
-      define_field :version, Types::Int8, default: 0
+      define_attr :version, BinStruct::Int8, default: 0
       # @!attribute flags
       #  @return [Integer] 8-bit PPI flags
-      define_field :flags, Types::Int8
+      # @!attribute align
+      #  @return [Boolean] align flag from {#flags} attribute
+      define_bit_attr :flags, reserved: 7, align: 1
       # @!attribute length
       #  @return [Integer] 16-bit PPI header length
-      define_field :length, Types::Int16le, default: 8
+      define_attr :length, BinStruct::Int16le, default: 8
       # @!attribute dlt
       #  @return [Integer] 32-bit PPI data link type
-      define_field :dlt, Types::Int32le
+      define_attr :dlt, BinStruct::Int32le
       # @!attribute ppi_fields
       #  @return [Type::String] concatenation of PPI fields
-      define_field :ppi_fields, Types::String, builder: ->(h, t) { t.new(length_from: -> { h.length - 8 }) }
+      define_attr :ppi_fields, BinStruct::String, builder: ->(h, t) { t.new(length_from: -> { h.length - 8 }) }
       # @!attribute body
       #  @return [Type::String]
-      define_field :body, Types::String
-      # @!attribute align
-      #  @return [Boolean] align flag from {#flags} attribute
-      define_bit_fields_on :flags, :reserved, 7, :align
+      define_attr :body, BinStruct::String
 
       # Check version field
       # @see [Base#parse?]
@@ -65,22 +64,22 @@ module PacketGen
     class RadioTap < Base
       # @!attribute version
       #  @return [Integer] 8-bit version
-      define_field :version, Types::Int8, default: 0
+      define_attr :version, BinStruct::Int8, default: 0
       # @!attribute pad
       #  @return [Integer] 8-bit pad
-      define_field :pad, Types::Int8, default: 0
+      define_attr :pad, BinStruct::Int8, default: 0
       # @!attribute length
       #  @return [Integer] 16-bit RadioTap header length
-      define_field :length, Types::Int16le, default: 8
+      define_attr :length, BinStruct::Int16le, default: 8
       # @!attribute present_flags
       #  @return [Integer] 32-bit integer
-      define_field :present_flags, Types::Int32le
+      define_attr :present_flags, BinStruct::Int32le
       # @!attribute radio_fields
       #  @return [Type::String] concatenation of RadioTap fields
-      define_field :radio_fields, Types::String, builder: ->(h, t) { t.new(length_from: -> { h.length - 8 }) }
+      define_attr :radio_fields, BinStruct::String, builder: ->(h, t) { t.new(length_from: -> { h.length - 8 }) }
       # @!attribute body
       #  @return [Type::String]
-      define_field :body, Types::String
+      define_attr :body, BinStruct::String
 
       # Check version field
       # @see [Base#parse?]
@@ -104,58 +103,54 @@ module PacketGen
     end
     self.add_class RadioTap
 
-    # IEEE 802.11 header
     # @abstract This is a base class to demultiplex different IEEE 802.11 frames when
     #   parsing.
     # A IEEE 802.11 header may consist of at least:
-    # * a {#frame_ctrl} ({Types::Int16}),
-    # * a {#id}/duration ({Types::Int16le}),
+    # * a {#frame_ctrl} (+BinStruct::Int16+),
+    # * a {#id}/duration (+BinStruct::Int16le+),
     # * and a {#mac1} ({Eth::MacAddr}).
     # Depending on frame type and subtype, it may also contains:
     # * a {#mac2} ({Eth::MacAddr}),
     # * a {#mac3} ({Eth::MacAddr}),
-    # * a {#sequence_ctrl} ({Types::Int16}),
+    # * a {#sequence_ctrl} (+BinStruct::Int16+),
     # * a {#mac4} ({Eth::MacAddr}),
-    # * a {#qos_ctrl} ({Types::Int16}),
-    # * a {#ht_ctrl} ({Types::Int32}),
-    # * a {#body} (a {Types::String} or another {Base} class),
-    # * a Frame check sequence ({#fcs}, of type {Types::Int32le})
+    # * a {#qos_ctrl} (+BinStruct::Int16+),
+    # * a {#ht_ctrl} (+BinStruct::Int32+),
+    # * a {#body} (a +BinStruct::String+ or another {Headerable} class),
+    # * a Frame check sequence ({#fcs}, of type +BinStruct::Int32le+)
     #
     # == Header accessors
     # As Dot11 header types are defined under Dot11 namespace, Dot11 header accessors
-    # have a specific name. By example, to access to a {Dot11::Beacon} header,
+    # have a specific name. For example, to access to a {Dot11::Beacon} header,
     # accessor is +#dot11_beacon+.
     #
     # == Create Dot11 packets
     # As {Dot11} is an abstract class, you have to use one of its subclasses to
-    # instanciate a IEEE802.11 header.
+    # instanciate a IEEE802.11 header (see examples below).
     #
-    # === IEEE802.11 control frames
-    # Control frames may be created this way:
+    # @example Create IEEE802.11 control frames
     #   pkt = PacketGen.gen('Dot11::Control', subtype: 13) # Ack control frame
-    #   pkt.dot11_control     # => PacketGen::Header::Dot11::Control
+    #   pkt.dot11_control.class   # => PacketGen::Header::Dot11::Control
     #   # #dot11 is a shortcut for #dot11_control
-    #   pkt.dot11             # => PacketGen::Header::Dot11::Control
+    #   pkt.dot11.class           # => PacketGen::Header::Dot11::Control
     #
-    # === IEEE802.11 management frames
-    # Management frames may be created this way:
+    # @example Create IEEE802.11 management frames
     #   pkt = PacketGen.gen('Dot11::Management')
-    #   pkt.dot11_management     # => PacketGen::Header::Dot11::Management
+    #   pkt.dot11_management.class   # => PacketGen::Header::Dot11::Management
     #   # #dot11 is a shortcut for #dot11_management
-    #   pkt.dot11                # => PacketGen::Header::Dot11::Management
-    # Management frames are usually specialized, AssociationRequest by example:
+    #   pkt.dot11.class              # => PacketGen::Header::Dot11::Management
+    #   # Management frames are usually specialized, AssociationRequest by example
     #   pkt.add('Dot11::AssoReq')
-    #   pkt.dot11_assoreq        # => PacketGen::Header::Dot11::AssoReq
-    # Management frames also may contain some elements (see IEEE 802.11 standard):
-    #   pkt.dot11_assoreq.add_elements(type: 'SSID', value: "My SSID")
-    #   pkt.dot11_assoreq.add_elements(type: 'Rates', value: supported_rates)
+    #   pkt.dot11_assoreq .class     # => PacketGen::Header::Dot11::AssoReq
+    #   # Management frames also may contain some elements (see IEEE 802.11 standard)
+    #   pkt.dot11_assoreq.elements << { type: 'SSID', value: "My SSID" }
+    #   pkt.dot11_assoreq.elements << { type: 'Rates', value: "\x8c\x12\x98\x24\xb0" }
     #
-    # === IEEE802.11 data frames
-    # Data frames may be created this way:
+    # @example Create IEEE802.11 data frames
     #   pkt = PacketGen.gen('Dot11::Data')
-    #   pkt.dot11_data     # => PacketGen::Header::Dot11::Data
+    #   pkt.dot11_data.class   # => PacketGen::Header::Dot11::Data
     #   # #dot11 is a shortcut for #dot11_data
-    #   pkt.dot11          # => PacketGen::Header::Dot11::Data
+    #   pkt.dot11.class        # => PacketGen::Header::Dot11::Data
     #
     # == Parse Dot11 packets
     # When parsing a Dot11 packet, Dot11 subclass is created from +type+ value.
@@ -164,13 +159,12 @@ module PacketGen
     # for a control frame, +Packet#dot11_control+ may also be used.
     #
     # == Send Dot11 packets
-    # To send a Dot11 packet, a RadioTap header is needed:
+    # To send a Dot11 packet, a RadioTap or PPI header is needed (depending on your hardware):
     #   pkt = PacketGen.gen('RadioTap')
     #   pkt.add('Dot11::Management', mac1: client, mac2: bssid, mac3: bssid)
     #   pkt.add('Dot11::Beacon')
-    #   pkt.dot11_beacon.add_element(type: 'SSID', value: 'My SSID')
-    #   pkt.dot11_beacon.add_element(type: 'Rates', value: "\x85\x0c")
-    #   pkt.calc
+    #   pkt.dot11_management.add_element(type: 'SSID', value: 'My SSID')
+    #   pkt.dot11_management.add_element(type: 'Rates', value: "\x85\x0c")
     #   pkt.to_w('wlan0')
     # @author Sylvain Daubert
     # @since 1.4.0
@@ -189,38 +183,6 @@ module PacketGen
 
       # @!attribute frame_ctrl
       #  @return [Integer] 16-bit frame control word
-      define_field :frame_ctrl, Types::Int16, default: 0
-      # @!attribute id
-      #  @return [Integer] 16-bit ID/Duration word
-      define_field :id, Types::Int16le, default: 0
-      # @!attribute mac1
-      #  @return [Eth::MacAddr]
-      define_field :mac1, Eth::MacAddr
-      # @!attribute mac2
-      #  @return [Eth::MacAddr]
-      define_field :mac2, Eth::MacAddr
-      # @!attribute mac3
-      #  @return [Eth::MacAddr]
-      define_field :mac3, Eth::MacAddr
-      # @!attribute sequence_ctrl
-      #  @return [Integer] 16-bit sequence control word
-      define_field :sequence_ctrl, Types::Int16le, default: 0
-      # @!attribute mac4
-      #  @return [Eth::MacAddr]
-      define_field :mac4, Eth::MacAddr
-      # @!attribute qos_ctrl
-      #  @return [Integer] 16-bit QoS control word
-      define_field :qos_ctrl, Types::Int16
-      # @!attribute ht_ctrl
-      #  @return [Integer] 16-bit HT control word
-      define_field :ht_ctrl, Types::Int32
-      # @!attribute body
-      #  @return [Types::String]
-      define_field :body, Types::String
-      # @!attribute fcs
-      #  @return [Types::Int32le]
-      define_field :fcs, Types::Int32le
-
       # @!attribute subtype
       #  @return [Integer] 4-bit frame subtype from {#frame_ctrl}
       # @!attribute type
@@ -243,32 +205,64 @@ module PacketGen
       #  @return [Boolean] from_ds flag from {#frame_ctrl}
       # @!attribute to_ds
       #  @return [Boolean] to_ds flag from {#frame_ctrl}
-      define_bit_fields_on :frame_ctrl, :subtype, 4, :type, 2, :proto_version, 2,
-                           :order, :wep, :md, :pwmngt, :retry, :mf, :from_ds, :to_ds
-
-      # @!attribute sequence_number (12-bit field from {#sequence_ctrl})
+      define_bit_attr :frame_ctrl, subtype: 4, type: 2, proto_version: 2, order: 1,
+                                   wep: 1, md: 1, pwmngt: 1, retry: 1, mf: 1, from_ds: 1, to_ds: 1
+      # @!attribute id
+      #  @return [Integer] 16-bit ID/Duration word
+      define_attr :id, BinStruct::Int16le, default: 0
+      # @!attribute mac1
+      #  @return [Eth::MacAddr]
+      define_attr :mac1, Eth::MacAddr
+      # @!attribute mac2
+      #  @return [Eth::MacAddr]
+      define_attr :mac2, Eth::MacAddr
+      # @!attribute mac3
+      #  @return [Eth::MacAddr]
+      define_attr :mac3, Eth::MacAddr
+      # @!attribute sequence_ctrl
+      #  @return [Integer] 16-bit sequence control word
+      # @!attribute sequence_number
+      #  12-bit field from {#sequence_ctrl}
       #  @return [Integer]
       #  @since 2.1.3
-      # @!attribute fragment_number (4-bit field from {#sequence_ctrl})
+      # @!attribute fragment_number
+      #  4-bit attribute from {#sequence_ctrl}
       #  @return [Integer]
       #  @since 2.1.3
-      define_bit_fields_on :sequence_ctrl, :sequence_number, 12, :fragment_number, 4
+      define_bit_attr :sequence_ctrl, sequence_number: 12, fragment_number: 4
+      # @!attribute mac4
+      #  @return [Eth::MacAddr]
+      define_attr :mac4, Eth::MacAddr
+      # @!attribute qos_ctrl
+      #  @return [Integer] 16-bit QoS control word
+      define_attr :qos_ctrl, BinStruct::Int16
+      # @!attribute ht_ctrl
+      #  @return [Integer] 16-bit HT control word
+      define_attr :ht_ctrl, BinStruct::Int32
+      # @!attribute body
+      #  Dot11 body, if any
+      #  @return [BinStruct::String]
+      define_attr :body, BinStruct::String
+      # @!attribute fcs
+      #  Checksum of the Dot11 frame.
+      #  @return [BinStruct::Int32le]
+      define_attr :fcs, BinStruct::Int32le
 
       alias duration id
       # @private
-      alias old_fields fields
+      alias old_attributes attributes
 
       # @param [Hash] options
       # @see Base#initialize
       def initialize(options={})
         super
-        @applicable_fields = old_fields
+        @applicable_attributes = old_attributes
       end
 
-      # Get all used field names
+      # Get all used attribute names
       # @return [Array<Symbol>]
-      def fields
-        @applicable_fields
+      def attributes
+        @applicable_attributes
       end
 
       # @private
@@ -281,24 +275,24 @@ module PacketGen
       def read(str)
         fcs = Dot11.fcs?
 
-        if self.instance_of? Dot11
+        if self.instance_of?(Dot11)
           return self if str.nil?
 
-          force_binary str
-          self[:frame_ctrl].read str[0, 2]
+          str = str.b unless str.encoding == Encoding::BINARY
+          self[:frame_ctrl].read(str[0, 2])
 
           case type
           when 0
-            Dot11::Management.new.read str
+            Dot11::Management.new.read(str)
           when 1
-            Dot11::Control.new.read str
+            Dot11::Control.new.read(str)
           when 2
-            Dot11::Data.new.read str
+            Dot11::Data.new.read(str)
           else
-            private_read str, fcs
+            private_read(str, fcs)
           end
         else
-          private_read str, fcs
+          private_read(str, fcs)
         end
       end
 
@@ -310,10 +304,11 @@ module PacketGen
         fcs
       end
 
+      # Generate binary string
       # @return [String]
       def to_s
-        define_applicable_fields
-        @applicable_fields.map { |f| force_binary @fields[f].to_s }.join
+        define_applicable_attributes
+        @applicable_attributes.map { |f| @attributes[f].to_s.b }.join
       end
 
       # Get human readable type
@@ -324,19 +319,19 @@ module PacketGen
 
       # @return [String]
       def inspect
-        str = if self.instance_of? Dot11
+        str = if self.instance_of?(Dot11)
                 Inspect.dashed_line("#{self.class} #{human_type}", 1)
-              elsif self.respond_to? :human_subtype
+              elsif self.respond_to?(:human_subtype)
                 Inspect.dashed_line("#{self.class} #{human_subtype}", 1)
               else
                 Inspect.dashed_line(self.class.to_s, 1)
               end
 
-        define_applicable_fields
-        @applicable_fields.each do |attr|
+        define_applicable_attributes
+        @applicable_attributes.each do |attr|
           next if attr == :body
 
-          str << Inspect.inspect_attribute(attr, @fields[attr], 1)
+          str << Inspect.inspect_attribute(attr, @attributes[attr], 1)
         end
         str
       end
@@ -348,52 +343,52 @@ module PacketGen
         Inject.inject(iface: iface, data: self)
       end
 
-      # Callback called when a Dot11 header is added to a packet
+      # Callback called when a Dot11 header is added to a packet.
       # Here, add +#dot11+ method as a shortcut to existing
       # +#dot11_(control|management|data)+.
       # @param [Packet] packet
       # @return [void]
       def added_to_packet(packet)
-        return if packet.respond_to? :dot11
+        return if packet.respond_to?(:dot11)
 
         packet.instance_eval("def dot11(arg=nil); header(#{self.class}, arg); end") # def dot11(arg=nil); header(Dot11, arg); end
       end
 
       private
 
-      def remove_from_applicable_fields(fields)
-        fields = [fields] unless fields.is_a? Array
-        @applicable_fields -= fields
+      def remove_from_applicable_attributes(attributes)
+        attributes = [attributes] unless attributes.is_a?(Array)
+        @applicable_attributes -= attributes
       end
 
       def handle_mac4
         if to_ds? && from_ds?
-          @applicable_fields[6, 0] = :mac4 unless @applicable_fields.include? :mac4
+          @applicable_attributes[6, 0] = :mac4 unless @applicable_attributes.include?(:mac4)
         else
-          remove_from_applicable_fields :mac4
+          remove_from_applicable_attributes(:mac4)
         end
       end
 
       def handle_ht_ctrl
         if order?
-          unless @applicable_fields.include? :ht_ctrl
-            idx = @applicable_fields.index(:body)
-            @applicable_fields[idx, 0] = :ht_ctrl
+          unless @applicable_attributes.include?(:ht_ctrl)
+            idx = @applicable_attributes.index(:body)
+            @applicable_attributes[idx, 0] = :ht_ctrl
           end
         else
-          remove_from_applicable_fields %i[ht_ctrl]
+          remove_from_applicable_attributes %i[ht_ctrl]
         end
       end
 
       def handle_fcs
         if Dot11.fcs?
-          @applicable_fields << :fcs unless @applicable_fields.include? :fcs
+          @applicable_attributes << :fcs unless @applicable_attributes.include?(:fcs)
         else
-          remove_from_applicable_fields :fcs
+          remove_from_applicable_attributes(:fcs)
         end
       end
 
-      def define_applicable_fields
+      def define_applicable_attributes
         handle_mac4
         handle_ht_ctrl
         handle_fcs
@@ -401,12 +396,12 @@ module PacketGen
 
       def private_read(str, fcs)
         self[:frame_ctrl].read str[0, 2]
-        define_applicable_fields
+        define_applicable_attributes
         if fcs
-          old_read str[0...-4]
-          self[:fcs].read str[-4..]
+          old_read(str[0...-4])
+          self[:fcs].read(str[-4..])
         else
-          old_read str
+          old_read(str)
         end
         self
       end

data/lib/packetgen/header/dot1q.rb

@@ -11,33 +11,32 @@ module PacketGen
     # IEEE 802.1Q VLAN tagging
     #
     # A VLAN tag consists of:
-    # * a {#tci Tag Control Information} ({Types::Int16}),
-    # * a {#ethertype} ({Types::Int16}),
-    # * and a body (a {Types::String} or another Header class).
+    # * a {#tci Tag Control Information} (+BinStruct::Int16+),
+    # * a {#ethertype} (+BinStruct::Int16+),
+    # * and a body (a +BinStruct::String+ or another {Headerable} class).
     #
-    # == Create a Dot1q header
+    # @example Create a Dot1q header
     #   # Create a IP packet in VLAN #43
     #   pkt = PacketGen.gen('Eth').add('Dot1q', vid: 43).add('IP')
+    #   pkt.is?('Dot1q')   #=> true
     # @author Sylvain Daubert
     # @since 1.4.0
     class Dot1q < Base
       # @!attribute tci
       #  @return [Integer] 16-bit Tag Control Information
-      define_field :tci, Types::Int16
-      # @!attribute ethertype
-      #  @return [Integer] 16-bit EtherType
-      define_field :ethertype, Types::Int16
-      # @!attribute body
-      #  @return [Types::String,Header::Base]
-      define_field :body, Types::String
-
       # @!attribute pcp
       #  @return [Integer] 3-bit Priority Code Point from {#tci}
       # @!attribute dei
       #  @return [Boolean] Drop Eligible Indicator from {#tci}
       # @!attribute vid
       #  @return [Integer] 12-bit VLAN ID from {#tci}
-      define_bit_fields_on :tci, :pcp, 3, :dei, :vid, 12
+      define_bit_attr :tci, pcp: 3, dei: 1, vid: 12
+      # @!attribute ethertype
+      #  @return [Integer] 16-bit EtherType
+      define_attr :ethertype, BinStruct::Int16
+      # @!attribute body
+      #  @return [BinStruct::String,Header::Base]
+      define_attr :body, BinStruct::String
     end
 
     Eth.bind Dot1q, ethertype: 0x8100

data/lib/packetgen/header/dot1x.rb

@@ -11,15 +11,15 @@ module PacketGen
     # IEEE 802.1X / EAPOL
     #
     # A IEEE 802.1X header consists of:
-    # * a {#version} ({Types::Int8}),
-    # * a packet {#type} ({Types::Int8}),
-    # * a {#length} ({Types::Int16}),
-    # * and a body (a {Types::String} or another Header class).
-    # == Create a Dot1x header
+    # * a {#version} (+BinStruct::Int8+),
+    # * a packet {#type} (+BinStruct::Int8+),
+    # * a {#length} (+BinStruct::Int16+),
+    # * and a body (a +BinStruct::String+ or another {Headerable} class).
+    # @example Create a Dot1x header
+    #   # Create with integer type
     #   pkt1 = PacketGen.gen('Eth').add('Dot1x', type: 1)
-    #   pkt2 = PacketGen.gen('Eth').add('Dot1x')
-    #   pkt2.dot1x.type = 'EAP Packet'
-    #   pkt2.dot1x.body.read 'body'
+    #   # Create with human-readable type
+    #   pkt2 = PacketGen.gen('Eth').add('Dot1x', type: 'EAP Packet')
     # @author Sylvain Daubert
     # @since 1.4.0
     class Dot1x < Base
@@ -37,16 +37,16 @@ module PacketGen
 
       # @!attribute version
       #  @return [Integer] 8-bit Protocol Version
-      define_field :version, Types::Int8, default: 1
+      define_attr :version, BinStruct::Int8, default: 1
       # @!attribute type
       #  @return [Integer] 8-bit Packet Type
-      define_field :type, Types::Int8Enum, enum: TYPES
+      define_attr :type, BinStruct::Int8Enum, enum: TYPES
       # @!attribute length
       #  @return [Integer] 16-bit body length
-      define_field :length, Types::Int16
+      define_attr :length, BinStruct::Int16
       # @!attribute body
-      #  @return [Types::String,Header::Base]
-      define_field :body, Types::String, builder: ->(h, t) { t.new(length_from: h[:length]) }
+      #  @return [BinStruct::String,Header::Base]
+      define_attr :body, BinStruct::String, builder: ->(h, t) { t.new(length_from: h[:length]) }
 
       # Get human readable type
       # @return [String]

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

@@ -13,13 +13,13 @@ module PacketGen
       # Secure Tunneling, {https://tools.ietf.org/html/rfc4851 RFC 4851}
       #
       # {EAP::FAST} 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 FAST < TTLS
-        update_field :type, default: 43
+        update_attr :type, default: 43
       end
     end
   end

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

@@ -14,19 +14,27 @@ module PacketGen
       # @author Sylvain Daubert
       # @since 2.1.4
       class MD5 < EAP
-        update_field :type, default: 4
-        remove_field :body
+        update_attr :type, default: 4
+        remove_attr :body
 
         # @!attribute value_size
-        #  @return [Integer] 8-bit value size
-        define_field :value_size, Types::Int8
+        #  8-bit size of the {#value} attribute.
+        #  @return [Integer]
+        define_attr :value_size, BinStruct::Int8
         # @!attribute value
+        #  MD5 challenge value, as an octet stream, as per {https://datatracker.ietf.org/doc/html/rfc1994#section-4 RFC1994}
         #  @return [::String]
-        define_field :value, Types::String,
-                     builder: ->(h, t) { t.new(length_from: h[:value_size]) }
-        # @!attribute optional_name
+        define_attr :value, BinStruct::String,
+                    builder: ->(h, t) { t.new(length_from: h[:value_size]) }
+        # @!attribute name
+        #  Name identifying the system sending the packet. It is or or more octets. Its size is
+        #  determined from the {#length} attribute.
         #  @return [::String]
-        define_field :optional_name, Types::String
+        # @since 4.1.0 Attribute renamed from +optioanl_name+ to +name+
+        define_attr :name, BinStruct::String
+
+        # @deprecated
+        alias optional_name name
       end
     end
   end

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

@@ -13,27 +13,26 @@ module PacketGen
       # {https://tools.ietf.org/html/rfc5216 RFC 5216}
       #
       # {EAP::TLS} has following fields:
-      # * {#flags} ({Types::Int8}),
-      # * optionally {#tls_length} ({Types::Int32}), if +#l?+ is +true+,
-      # * {#body} ({Types::String}).
+      # * {#flags} (+BinStruct::Int8+),
+      # * optionally {#tls_length} (+BinStruct::Int32+), if +#l?+ is +true+,
+      # * {#body} (+BinStruct::String+).
       # @author Sylvain Daubert
       # @since 2.1.4
       class TLS < EAP
-        update_field :type, default: 13
+        update_attr :type, default: 13
         # @!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]
-        define_bit_fields_on :flags, :l, :m, :s, :reserved, 5
+        #  8-bit flags
+        #  @return [Integer]
+        # @!attribute l?
+        #  Say if {#tls_length 32-bit TLS length attribute} 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]
+        define_bit_attr_before :body, :flags, l: 1, m: 1, s: 1, reserved: 5
         alias length_present? l?
         alias more_fragments? m?
         alias tls_start? s?
@@ -43,8 +42,8 @@ module PacketGen
         #  TLS message or set of messages that is being fragmented. So, it
         #  cannot be automatically calculated (no +#calc_length+ method).
         #  @return [Integer] 32-bit TLS length
-        define_field_before :body, :tls_length, Types::Int32,
-                            optional: ->(h) { h.l? }
+        define_attr_before :body, :tls_length, BinStruct::Int32,
+                           optional: lambda(&:l?)
 
         # @return [String]
         def inspect