packetgen 2.8.7 → 3.0.0

data/lib/packetgen/pcapng/block.rb

@@ -37,13 +37,6 @@ module PacketGen
         @fields.key?(:options) && @fields[:options].sz > 0
       end
 
-      # @deprecated Use {#options?} instead.
-      # @return [Boolean]
-      def has_options?
-        Deprecation.deprecated(self.class, __method__, 'options?')
-        options?
-      end
-
       # Calculate block length and update :block_len and block_len2 fields
       # @return [void]
       def recalc_block_len
@@ -56,8 +49,8 @@ module PacketGen
       # @return [void]
       def pad_field(*fields)
         fields.each do |field|
-          unless (@fields[field].size % 4).zero?
-            @fields[field] << "\x00" * (4 - (@fields[field].size % 4))
+          unless (@fields[field].sz % 4).zero?
+            @fields[field] << "\x00" * (4 - (@fields[field].sz % 4))
           end
         end
       end
@@ -72,13 +65,14 @@ module PacketGen
         unless %i[little big].include? endian
           raise ArgumentError, "unknown endianness for #{self.class}"
         end
+
         @endian = endian
         @fields.each { |_f, v| v.endian = endian if v.is_a?(Types::Int) }
         endian
       end
 
       def check_len_coherency
-        unless self[:block_len].to_i == self[:block_len2].to_i
+        unless self.block_len == self.block_len2
           raise InvalidFileError, 'Incoherency in Block length'
         end
       end

data/lib/packetgen/pcapng/epb.rb

@@ -96,10 +96,10 @@ module PacketGen
         self[:tsl].read io.read(4)
         self[:cap_len].read io.read(4)
         self[:orig_len].read io.read(4)
-        self[:data].read io.read(self[:cap_len].to_i)
+        self[:data].read io.read(self.cap_len)
         data_pad_len = (4 - (self[:cap_len].to_i % 4)) % 4
         io.read data_pad_len
-        options_len = self[:block_len].to_i - self[:cap_len].to_i - data_pad_len
+        options_len = self.block_len - self.cap_len - data_pad_len
         options_len -= MIN_SIZE
         self[:options].read io.read(options_len)
         self[:block_len2].read io.read(4)
@@ -111,7 +111,7 @@ module PacketGen
       # Return timestamp as a Time object
       # @return [Time]
       def timestamp
-        Time.at((self[:tsh].to_i << 32 | self[:tsl].to_i) * ts_resol)
+        Time.at((self.tsh << 32 | self.tsl) * ts_resol)
       end
 
       # Return the object as a String
@@ -125,7 +125,7 @@ module PacketGen
       private
 
       def ts_resol
-        if @interface.nil?
+        if !defined?(@interface) || @interface.nil?
           1E-6
         else
           @interface.ts_resol

data/lib/packetgen/pcapng/file.rb

@@ -66,10 +66,14 @@ module PacketGen
         end
 
         return unless blk
+
         count = 0
         @sections.each do |section|
           section.interfaces.each do |intf|
-            intf.packets.each { |pkt| count += 1; yield pkt }
+            intf.packets.each do |pkt|
+              count += 1
+              yield pkt
+            end
           end
         end
         count
@@ -347,8 +351,8 @@ module PacketGen
           shb << block
           block.section = shb
         when EPB
-          shb.interfaces[block.interface_id.to_i] << block
-          block.interface = shb.interfaces[block.interface_id.to_i]
+          shb.interfaces[block.interface_id] << block
+          block.interface = shb.interfaces[block.interface_id]
         when SPB
           shb.interfaces[0] << block
           block.interface = shb.interfaces[0]

data/lib/packetgen/pcapng/idb.rb

@@ -83,7 +83,7 @@ module PacketGen
         self[:link_type].read io.read(2)
         self[:reserved].read io.read(2)
         self[:snaplen].read io.read(4)
-        self[:options].read io.read(self[:block_len].to_i - MIN_SIZE)
+        self[:options].read io.read(self.block_len - MIN_SIZE)
         self[:block_len2].read io.read(4)
 
         check_len_coherency
@@ -105,7 +105,7 @@ module PacketGen
         if @options_decoded && !force
           @ts_resol
         else
-          packstr = @endian == :little ? 'v' : 'n'
+          packstr = endian == :little ? 'v' : 'n'
           idx = 0
           options = self[:options]
 

data/lib/packetgen/pcapng/shb.rb

@@ -130,7 +130,7 @@ module PacketGen
         self[:ver_major].read io.read(2)
         self[:ver_minor].read io.read(2)
         self[:section_len].read io.read(8)
-        self[:options].read io.read(self[:block_len].to_i - MIN_SIZE)
+        self[:options].read io.read(self.block_len - MIN_SIZE)
         self[:block_len2].read io.read(4)
 
         check_len_coherency
@@ -149,8 +149,8 @@ module PacketGen
       # @return [String]
       def to_s
         body = @interfaces.map(&:to_s).join
-        unless self[:section_len].to_i == SECTION_LEN_UNDEFINED
-          self.section_len.value = body.size
+        unless self.section_len == SECTION_LEN_UNDEFINED
+          self.section_len = body.size
         end
         pad_field :options
         recalc_block_len

data/lib/packetgen/pcapng/spb.rb

@@ -56,13 +56,6 @@ module PacketGen
         false
       end
 
-      # @deprecated Use {#options?} instead.
-      # @return [false]
-      def has_options?
-        Deprecation.deprecated(self.class, __method__, 'options?')
-        options?
-      end
-
       # Reads a String or a IO to populate the object
       # @param [::String,IO] str_or_io
       # @return [self]
@@ -90,7 +83,7 @@ module PacketGen
         self[:block_len2].read io.read(4)
 
         check_len_coherency
-        self.type = self[:type] || PcapNG::IDB_TYPE.to_i
+        self.type ||= PcapNG::IDB_TYPE.to_i
         self
       end
 

data/lib/packetgen/pcapng/unknown_block.rb

@@ -40,13 +40,6 @@ module PacketGen
         false
       end
 
-      # @deprecated Use {#options?} instead.
-      # @return [false]
-      def has_options?
-        Deprecation.deprecated(self.class, __method__, 'options?')
-        options?
-      end
-
       # Reads a String or a IO to populate the object
       # @param [::String,IO] str_or_io
       # @return [self]

data/lib/packetgen/types.rb

@@ -9,6 +9,7 @@ module PacketGen
   end
 end
 
+require_relative 'types/length_from'
 require_relative 'types/int'
 require_relative 'types/enum'
 require_relative 'types/string'

data/lib/packetgen/types/array.rb

@@ -5,6 +5,8 @@
 
 # frozen_string_literal: true
 
+require 'forwardable'
+
 module PacketGen
   module Types
     # @abstract Base class to define set of {Fields} subclasses.
@@ -14,20 +16,66 @@ module PacketGen
     #
     # A default method is defined by {Array}: it calls constructor of class defined
     # by {.set_of}.
+    #
+    # == #real_type
+    # Subclasses should define private method +#real_type+ is {.set_of} type
+    # may be subclassed. This method should return real class to use. It
+    # takes an only argument, which is of type given by {.set_of}.
+    #
+    # Default behaviour of this method is to argument's class.
+    #
     # @author Sylvain Daubert
     class Array
+      extend Forwardable
+
+      # @!method [](index)
+      #   Return the element at +index+.
+      #   @param [integer] index
+      #   @return [Object]
+      # @!method clear
+      #   Clear array.
+      #   @return [void]
+      # @!method each
+      #   Calls the given block once for each element in self, passing that
+      #   element as a parameter. Returns the array itself.
+      #   @return [Array]
+      # @method empty?
+      #   Return +true+ if contains no element.
+      #   @return [Booelan]
+      # @!method first
+      #   Return first element
+      #   @return [Object]
+      # @!method last
+      #   Return last element.
+      #   @return [Object]
+      # @!method size
+      #   Get number of element in array
+      #   @return [Integer]
+      def_delegators :@array, :[], :clear, :each, :empty?, :first, :last, :size
+      alias length size
+
       include Enumerable
+      include LengthFrom
 
       # Separator used in {#to_human}.
       # May be ovverriden by subclasses
       HUMAN_SEPARATOR = ','
 
-      # Define type of objects in set. Used by {#read} and {#push}.
-      # @param [Class] klass
-      # @return [void]
       # rubocop:disable Naming/AccessorMethodName
-      def self.set_of(klass)
-        @klass = klass
+      class <<self
+        # Get class set with {.set_of}.
+        # @return [Class]
+        # @since 3.0.0
+        def set_of_klass
+          @klass
+        end
+
+        # Define type of objects in set. Used by {#read} and {#push}.
+        # @param [Class] klass
+        # @return [void]
+        def set_of(klass)
+          @klass = klass
+        end
       end
       # rubocop:enable Naming/AccessorMethodName
 
@@ -36,6 +84,7 @@ module PacketGen
       def initialize(options={})
         @counter = options[:counter]
         @array = []
+        initialize_length_from(options)
       end
 
       # Initialize array for copy:
@@ -44,26 +93,13 @@ module PacketGen
         @array = @array.dup
       end
 
-      # Return the element at +index+.
-      # @param [integer] index
-      # @return [Object]
-      def [](index)
-        @array[index]
-      end
-
       def ==(other)
-        case other
-        when Array
-          @array == other.to_a
-        else
-          @array == other
-        end
-      end
-
-      # Clear array.
-      # @return [void]
-      def clear
-        @array.clear
+        @array == case other
+                  when Array
+                    other.to_a
+                  else
+                    other
+                  end
       end
 
       # Clear array. Reset associated counter, if any.
@@ -91,31 +127,6 @@ module PacketGen
         deleted
       end
 
-      # Calls the given block once for each element in self, passing that
-      # element as a parameter. Returns the array itself.
-      # @return [Array]
-      def each
-        @array.each { |el| yield el }
-      end
-
-      # Return +true+ if contains no element.
-      # @return [Booelan]
-      def empty?
-        @array.empty?
-      end
-
-      # Return first element
-      # @return [Object]
-      def first
-        @array.first
-      end
-
-      # Return last element.
-      # @return [Object]
-      def last
-        @array.last
-      end
-
       # @abstract depend on private method +#record_from_hash+ which should be
       #   declared by subclasses.
       # Add an object to this array
@@ -150,10 +161,13 @@ module PacketGen
         clear
         return self if str.nil?
         return self if @counter && @counter.to_i.zero?
-        force_binary str
-        klass = self.class.class_eval { @klass }
+
+        str = read_with_length_from(str)
+        klass = self.class.set_of_klass
         until str.empty?
           obj = klass.new.read(str)
+          real_klass = real_type(obj)
+          obj = real_klass.new.read(str) unless real_klass == klass
           @array << obj
           str.slice!(0, obj.sz)
           break if @counter && self.size == @counter.to_i
@@ -161,13 +175,6 @@ module PacketGen
         self
       end
 
-      # Get number of element in array
-      # @return [Integer]
-      def size
-        @array.size
-      end
-      alias length size
-
       # Get size in bytes
       # @return [Integer]
       def sz
@@ -192,22 +199,17 @@ module PacketGen
         @array.map(&:to_human).join(self.class::HUMAN_SEPARATOR)
       end
 
-      # Force binary encoding for +str+
-      # @param [String] str
-      # @return [String] binary encoded string
-      def force_binary(str)
-        PacketGen.force_binary str
-      end
-
       private
 
       def record_from_hash(obj)
-        obj_klass = self.class.class_eval { @klass }
-        if obj_klass
-          obj_klass.new(obj)
-        else
-          raise NotImplementedError, 'class should define #record_from_hash or declare type of elements in set with .set_of'
-        end
+        obj_klass = self.class.set_of_klass
+        return obj_klass.new(obj) if obj_klass
+
+        raise NotImplementedError, 'class should define #record_from_hash or declare type of elements in set with .set_of'
+      end
+
+      def real_type(obj)
+        obj.class
       end
     end
 

data/lib/packetgen/types/cstring.rb

@@ -32,7 +32,7 @@ module PacketGen
       # get null-terminated string
       # @return [String]
       def to_s
-        if @static_length.is_a? Integer
+        if defined?(@static_length) && @static_length.is_a?(Integer)
           if self.size >= @static_length
             s = self[0, @static_length]
             s[-1] = "\x00".encode(s.encoding)

data/lib/packetgen/types/enum.rb

@@ -45,9 +45,10 @@ module PacketGen
       end
 
       # Setter for value attribute
-      # @param [Integer, String,nil] value value as an Integer or as a String
+      # @param [#to_i, String,nil] value value as an Integer or as a String
       #   from enumration
       # @return [Integer]
+      # @raise [ArgumentError] String value is unknown
       def value=(value)
         ival = case value
                when NilClass
@@ -56,8 +57,7 @@ module PacketGen
                  raise ArgumentError, "#{value.inspect} not in enumeration" unless @enum.key? value
                  @enum[value]
                else
-                 raise ArgumentError, "#{value.inspect} not in enumeration" unless @enum.value? value
-                 value
+                 value.to_i
                end
         @value = ival
       end

data/lib/packetgen/types/fields.rb

@@ -49,7 +49,7 @@ module PacketGen
     #   define_field :type, PacketGen::Types::Int16le
     #   # define a string field
     #   define_field :body, PacketGen::Types::String
-    #   # define afield using a complex type (Fields subclass)
+    #   # define a field using a complex type (Fields subclass)
     #   define_field :mac_addr, PacketGen::Eth::MacAddr
     #
     # This example creates six methods on our Fields subclass: +#type+, +#type=+,
@@ -59,20 +59,22 @@ module PacketGen
     # * +:default+ gives default field value. It may be a simple value (an Integer
     #   for an Int field, for example) or a lambda,
     # * +:builder+ to give a builder/constructor lambda to create field. The lambda
-    #   takes one argument: {Fields} subclass object owning field,
+    #   takes 2 argument: {Fields} subclass object owning field, and type class as passes
+    #   as second argument to .define_field,
     # * +:optional+ to define this field as optional. This option takes a lambda
-    #   parameter used to say if this field is present or not,
+    #   parameter used to say if this field is present or not. The lambda takes an argument
+    #   ({Fields} subclass object owning field),
     # * +:enum+ to define Hash enumeration for an {Enum} type.
     # For example:
     #   # 32-bit integer field defaulting to 1
     #   define_field :type, PacketGen::Types::Int32, default: 1
     #   # 16-bit integer field, created with a random value. Each instance of this
     #   # object will have a different value.
-    #   define_field :id, PacketGen::Types::Int16, default: ->{ rand(65535) }
+    #   define_field :id, PacketGen::Types::Int16, default: ->(obj) { rand(65535) }
     #   # a size field
     #   define_field :body_size, PacketGen::Types::Int16
     #   # String field which length is taken from body_size field
-    #   define_field :body, PacketGen::Types::String, builder: ->(obj, type) { type.new('', length_from: obj[:body_size]) }
+    #   define_field :body, PacketGen::Types::String, builder: ->(obj, type) { type.new(length_from: obj[:body_size]) }
     #   # 16-bit enumeration type. As :default not specified, default to first value of enum
     #   define_field :type_class, PacketGen::Types::Int16Enum, enum: { 'class1' => 1, 'class2' => 2}
     #   # optional field. Only present if another field has a certain value
@@ -92,8 +94,19 @@ module PacketGen
     #   to access Boolean RSV, MF and DF flags from +frag+ field,
     # * +#fragment_offset+ and +#fragment_offset=+ to access 13-bit integer fragment
     #   offset subfield from +frag+ field.
+    #
+    # == Creating a new field class from another one
+    # Some methods may help in this case:
+    # * {.define_field_before} to define a new field before an existing one,
+    # * {.define_field_after} to define a new field after an existing onr,
+    # * {.remove_field} to remove an existing field,
+    # * {.uptade_fied} to change options of a field (but not its type),
+    # * {.remove_bit_fields_on} to remove a bit fields definition.
+    #
     # @author Sylvain Daubert
     class Fields
+      # @private
+      FieldDef = Struct.new(:type, :default, :builder, :optional, :enum, :options)
       # @private field names, ordered as they were declared
       @ordered_fields = []
       # @private field definitions
@@ -112,6 +125,7 @@ module PacketGen
           end
           ordered = @ordered_fields.clone
           bf = @bit_fields.clone
+
           klass.class_eval do
             @ordered_fields = ordered
             @field_defs = field_defs
@@ -157,26 +171,32 @@ module PacketGen
           if type < Types::Enum
             define << "def #{name}; self[:#{name}].to_i; end"
             define << "def #{name}=(val) self[:#{name}].value = val; end"
-          elsif type < Types::Int
-            define << "def #{name}; self[:#{name}].to_i; end"
-            define << "def #{name}=(val) self[:#{name}].read val; end"
-          elsif type.instance_methods.include?(:to_human) &&
-                type.instance_methods.include?(:from_human)
-            define << "def #{name}; self[:#{name}].to_human; end"
-            define << "def #{name}=(val) self[:#{name}].from_human val; end"
           else
-            define << "def #{name}; self[:#{name}]; end\n"
-            define << "def #{name}=(val) self[:#{name}].read val; end"
+            define << "def #{name}\n" \
+                      "  if self[:#{name}].respond_to?(:to_human) && self[:#{name}].respond_to?(:from_human)\n" \
+                      "    self[:#{name}].to_human\n" \
+                      "  else\n" \
+                      "    self[:#{name}]\n" \
+                      "  end\n" \
+                      "end"
+            define << "def #{name}=(val)\n" \
+                      "  if self[:#{name}].respond_to?(:to_human) && self[:#{name}].respond_to?(:from_human)\n" \
+                      "    self[:#{name}].from_human val\n" \
+                      "  else\n" \
+                      "    self[:#{name}].read val\n" \
+                      "  end\n" \
+                      "end"
           end
 
           define.delete(1) if type.instance_methods.include? "#{name}=".to_sym
           define.delete(0) if type.instance_methods.include? name
           class_eval define.join("\n")
-          @field_defs[name] = [type, options.delete(:default),
-                               options.delete(:builder),
-                               options.delete(:optional),
-                               options.delete(:enum),
-                               options]
+          @field_defs[name] = FieldDef.new(type,
+                                           options.delete(:default),
+                                           options.delete(:builder),
+                                           options.delete(:optional),
+                                           options.delete(:enum),
+                                           options)
           fields << name
         end
 
@@ -229,16 +249,6 @@ module PacketGen
           undef_method "#{name}=" if method_defined?("#{name}=")
         end
 
-        # Delete a previously defined field
-        # @param [Symbol] name
-        # @return [void]
-        # @deprecated Use {.remove_field} instead.
-        # @since 2.8.4 deprecated
-        def delete_field(name)
-          Deprecation.deprecated(self, __method__, 'remove_field', klass_method: true)
-          remove_field name
-        end
-
         # Update a previously defined field
         # @param [Symbol] field field name to create
         # @param [Hash] options See {.define_field}.
@@ -249,11 +259,11 @@ module PacketGen
         def update_field(field, options)
           raise ArgumentError, "unkown #{field} field for #{self}" unless @field_defs.key?(field)
 
-          @field_defs[field][1] = options.delete(:default) if options.key?(:default)
-          @field_defs[field][2] = options.delete(:builder) if options.key?(:builder)
-          @field_defs[field][3] = options.delete(:optional) if options.key?(:optional)
-          @field_defs[field][4] = options.delete(:enum) if options.key?(:enum)
-          @field_defs[field][5].merge!(options)
+          @field_defs[field].default = options.delete(:default) if options.key?(:default)
+          @field_defs[field].builder = options.delete(:builder) if options.key?(:builder)
+          @field_defs[field].optional = options.delete(:optional) if options.key?(:optional)
+          @field_defs[field].enum = options.delete(:enum) if options.key?(:enum)
+          @field_defs[field].options.merge!(options)
         end
 
         # Define a bitfield on given attribute
@@ -279,7 +289,7 @@ module PacketGen
           attr_def = @field_defs[attr]
           raise ArgumentError, "unknown #{attr} field" if attr_def.nil?
 
-          type = attr_def.first
+          type = attr_def.type
           unless type < Types::Int
             raise TypeError, "#{attr} is not a PacketGen::Types::Int"
           end
@@ -344,12 +354,12 @@ module PacketGen
 
           fields.each do |field, size|
             undef_method "#{field}="
-            undef_method(size == 1 ? "#{field}?" : "#{field}")
+            undef_method(size == 1 ? "#{field}?" : field)
           end
         end
       end
 
-      # Create a new header object
+      # Create a new fields object
       # @param [Hash] options Keys are symbols. They should have name of object
       #   attributes, as defined by {.define_field} and by {.define_bit_fields_on}.
       def initialize(options={})
@@ -358,9 +368,14 @@ module PacketGen
 
         field_defs = self.class.class_eval { @field_defs }
         self.class.fields.each do |field|
-          ary = field_defs[field]
-          type, default, builder, optional, enum, field_options = ary
+          type = field_defs[field].type
+          default = field_defs[field].default
           default = default.to_proc.call(self) if default.is_a?(Proc)
+          builder = field_defs[field].builder
+          optional = field_defs[field].optional
+          enum = field_defs[field].enum
+          field_options = field_defs[field].options
+
           @fields[field] = if builder
                              builder.call(self, type)
                            elsif enum
@@ -374,17 +389,6 @@ module PacketGen
           value = options[field] || default
           if value.class <= type
             @fields[field] = value
-          elsif type < Types::Enum
-            case value
-            when ::String
-              @fields[field].value = value
-            else
-              @fields[field].read(value)
-            end
-          elsif type < Types::Int
-            @fields[field].read(value)
-          elsif type <= Types::String
-            @fields[field].read(value)
           elsif @fields[field].respond_to? :from_human
             @fields[field].from_human(value)
           end
@@ -430,12 +434,6 @@ module PacketGen
         @optional_fields.key? field
       end
 
-      # @deprecated Use {#optional?} instead.
-      def is_optional?(field)
-        Deprecation.deprecated(self.class, __method__, 'optional?', klass_method: true)
-        optional? field
-      end
-
       # Say if an optional field is present
       # @return [Boolean]
       def present?(field)
@@ -444,14 +442,6 @@ module PacketGen
         @optional_fields[field].call(self)
       end
 
-      # Say if an optional field is present
-      # @return [Boolean]
-      # @deprecated Use {#present?} instead.
-      def is_present?(field)
-        Deprecation.deprecated(self.class, __method__, 'present?', klass_method: true)
-        present? field
-      end
-
       # Populate object from a binary string
       # @param [String] str
       # @return [Fields] self
@@ -463,17 +453,10 @@ module PacketGen
         fields.each do |field|
           next unless present?(field)
 
-          obj = nil
-          if self[field].respond_to? :width
-            width = self[field].width
-            obj = self[field].read str[start, width]
-            start += width
-          elsif self[field].respond_to? :sz
-            obj = self[field].read str[start..-1]
-            size = self[field].sz
-            start += size
+          obj = self[field].read str[start..-1]
+          if self[field].respond_to? :sz
+            start += self[field].sz
           else
-            obj = self[field].read str[start..-1]
             start = str.size
           end
           self[field] = obj unless obj == self[field]
@@ -496,7 +479,7 @@ module PacketGen
           next if attr == :body
           next unless present?(attr)
 
-          result = yield(attr)if block_given?
+          result = yield(attr) if block_given?
           str << (result || Inspect.inspect_attribute(attr, self[attr], 1))
         end
         str
@@ -521,36 +504,6 @@ module PacketGen
         Hash[fields.map { |f| [f, @fields[f].to_human] }]
       end
 
-      # Used to set body as value of body object.
-      # @param [String,Int,Fields,nil] value
-      # @return [void]
-      # @raise [BodyError] no body on given object
-      # @raise [ArgumentError] cannot cram +body+ in +:body+ field
-      # @deprecated
-      def body=(value)
-        Deprecation.deprecated(self.class, __method__)
-        raise BodyError, 'no body field' unless @fields.key? :body
-
-        case body
-        when ::String
-          self[:body].read value
-        when Int, Fields
-          self[:body] = value
-        when NilClass
-          self[:body] = Types::String.new.read('')
-        else
-          raise ArgumentError, "Can't cram a #{body.class} in a :body field"
-        end
-      end
-
-      # Force str to binary encoding
-      # @param [String] str
-      # @return [String]
-      # @deprecated Will be a private method
-      def force_binary(str)
-        PacketGen.force_binary(str)
-      end
-
       # Get offset of given field in {Fields} structure.
       # @param [Symbol] field
       # @return [Integer]
@@ -581,9 +534,16 @@ module PacketGen
       # @return [void]
       def initialize_copy(_other)
         fields = {}
-        @fields.each { |k,v| fields[k] = v.dup }
+        @fields.each { |k, v| fields[k] = v.dup }
         @fields = fields
       end
+
+      # Force str to binary encoding
+      # @param [String] str
+      # @return [String]
+      def force_binary(str)
+        PacketGen.force_binary(str)
+      end
     end
   end
 end