packetgen 2.8.4 → 2.8.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd941670ed94baa729f5ee91da53062195f6764b3e75d7e70cbbc09075adfdc2
-  data.tar.gz: 4e5b3082f9ada7a234fc559baf53f8abb0ab374e76391c938505f82235a2a58a
+  metadata.gz: 6763c9433901ae848d2186d92ec47e3894b493b951c048d68e3a01bd52504563
+  data.tar.gz: 68ec7d1ea6a27fa2101d8c7b72800083cdebe80cf8eec93d52255d459fbc5f73
 SHA512:
-  metadata.gz: ebe8bf700763779d708b96bc7731dec2e73b2aa9c23308b9b2f63743c785bc989dfeea01d1b04dba8210f031f6047791151f06a4671b0980bd429becc653403c
-  data.tar.gz: 9243425668eba786664e28a55edb7458b0d51bb27e3ca09ac68573b9d41e0cb5f087fe677f93c5d05aef05ac55adc08220475c643e1da81958259ab07b34407c
+  metadata.gz: d8166a6b1fee9a6d8ed45af7f100368272576cc6242e367e1735b204362e75fe5b76839fb53b75046a42cb7e5e3518705142ee9ef2a4326f44ea080f9f70c35b
+  data.tar.gz: 7079595e88887e39e1bb5b2e6d24689710cc0edcf2399d67fcf20964fa160481654b3e0ce1375739844465d51428b7c3a67f55fa0e008c9e379cbddff8cf5847

data/lib/packetgen/deprecation.rb

@@ -4,15 +4,17 @@ module PacketGen
   # @author Sylvain Daubert
   # @api private
   module Deprecation
-    def self.deprecated(klass, deprecated_method, new_method, klass_method: false, remove_version: '3.0.0')
+    def self.deprecated(klass, deprecated_method, new_method=nil, klass_method: false, remove_version: '3.0.0')
       separator = klass_method ? '.' : '#'
       base_name = klass.to_s + separator
       complete_deprecated_method_name = base_name + deprecated_method.to_s
-      complete_new_method_name = base_name + new_method.to_s
+      complete_new_method_name = base_name + new_method.to_s unless new_method.nil?
 
       file, line = caller(2).first.split(':')[0, 2]
-      warn "#{file}:#{line}: #{complete_deprecated_method_name} is deprecated in favor of #{complete_new_method_name}. " \
-           "It will be remove in PacketGen #{remove_version}."
+      message = +"#{file}:#{line}: #{complete_deprecated_method_name} is deprecated"
+      message << "in favor of #{complete_new_method_name}" unless new_method.nil?
+      message << ". It will be remove in PacketGen #{remove_version}."
+      warn message
     end
   end
 end

data/lib/packetgen/header/dot11/data.rb

@@ -64,6 +64,60 @@ module PacketGen
           self
         end
 
+        # Get destination MAC address
+        # @return [String]
+        def dst
+          ds = frame_ctrl & 3
+          case ds
+          when 0, 2
+            self.mac1
+          when 1, 3
+            self.mac3
+          end
+        end
+
+        # Set destination MAC address
+        # @param [String] mac MAC address to set
+        # @return [String]
+        def dst=(mac)
+          ds = frame_ctrl & 3
+          case ds
+          when 0, 2
+            self.mac1 = mac
+          when 1, 3
+            self.mac3 = mac
+          end
+        end
+
+        # Get source MAC address
+        # @return [String]
+        def src
+          ds = frame_ctrl & 3
+          case ds
+          when 0, 1
+            self.mac2
+          when 2
+            self.mac3
+          when 3
+            self.mac4
+          end
+        end
+
+        # Set source MAC address
+        # @param [String] mac MAC address to set
+        # @return [String]
+        def src=(mac)
+          ds = frame_ctrl & 3
+          case ds
+          when 0, 1
+            self.mac2 = mac
+          when 2
+            self.mac3 = mac
+          when 3
+            self.mac4 = mac
+          end
+        end
+
         private
 
         def define_applicable_fields

data/lib/packetgen/types/fields.rb

@@ -94,249 +94,258 @@ module PacketGen
     #   offset subfield from +frag+ field.
     # @author Sylvain Daubert
     class Fields
-      # @private
+      # @private field names, ordered as they were declared
       @ordered_fields = []
-      # @private
+      # @private field definitions
       @field_defs = {}
-      # @private
+      # @private bit field definitions
       @bit_fields = {}
 
-      # On inheritage, create +@field_defs+ class variable
-      # @param [Class] klass
-      # @return [void]
-      def self.inherited(klass)
-        field_defs = {}
-        @field_defs.each do |k, v|
-          field_defs[k] = v.clone
-        end
-        ordered = @ordered_fields.clone
-        bf = @bit_fields.clone
-        klass.class_eval do
-          @ordered_fields = ordered
-          @field_defs = field_defs
-          @bit_fields = bf
+      class <<self
+        # On inheritage, create +@field_defs+ class variable
+        # @param [Class] klass
+        # @return [void]
+        def inherited(klass)
+          field_defs = {}
+          @field_defs.each do |k, v|
+            field_defs[k] = v.clone
+          end
+          ordered = @ordered_fields.clone
+          bf = @bit_fields.clone
+          klass.class_eval do
+            @ordered_fields = ordered
+            @field_defs = field_defs
+            @bit_fields = bf
+          end
         end
-      end
 
-      # Define a field in class
-      #   class BinaryStruct < PacketGen::Types::Fields
-      #     # 8-bit value
-      #     define_field :value1, Types::Int8
-      #     # 16-bit value
-      #     define_field :value2, Types::Int16
-      #     # specific class, may use a specific constructor
-      #     define_field :value3, MyClass, builder: ->(obj, type) { type.new(obj) }
-      #   end
-      #
-      #   bs = BinaryStruct.new
-      #   bs[value1]   # => Types::Int8
-      #   bs.value1    # => Integer
-      # @param [Symbol] name field name
-      # @param [Object] type class or instance
-      # @param [Hash] options Unrecognized options are passed to object builder if
-      #   +:builder+ option is not set.
-      # @option options [Object] :default default value. May be a proc. This lambda
-      #   take one argument: the caller object.
-      # @option options [Lambda] :builder lambda to construct this field.
-      #   Parameters to this lambda is the caller object and the field type class.
-      # @option options [Lambda] :optional define this field as optional. Given lambda
-      #   is used to known if this field is present or not. Parameter to this lambda is
-      #   the being defined Field object.
-      # @option options [Hash] :enum mandatory option for an {Enum} type.
-      #   Define enumeration: hash's keys are +String+, and values are +Integer+.
-      # @return [void]
-      def self.define_field(name, type, options={})
-        define = []
-        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"
+        # Get field names
+        # @return [Array<Symbol>]
+        def fields
+          @ordered_fields
         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]
-        @ordered_fields << name
-      end
-
-      # Define a field, before another one
-      # @param [Symbol,nil] other field name to create a new one before. If +nil+,
-      #    new field is appended.
-      # @param [Symbol] name field name to create
-      # @param [Object] type class or instance
-      # @param [Hash] options See {.define_field}.
-      # @return [void]
-      # @see .define_field
-      def self.define_field_before(other, name, type, options={})
-        define_field name, type, options
-        return if other.nil?
-
-        @ordered_fields.delete name
-        idx = @ordered_fields.index(other)
-        raise ArgumentError, "unknown #{other} field" if idx.nil?
+        # Define a field in class
+        #   class BinaryStruct < PacketGen::Types::Fields
+        #     # 8-bit value
+        #     define_field :value1, Types::Int8
+        #     # 16-bit value
+        #     define_field :value2, Types::Int16
+        #     # specific class, may use a specific constructor
+        #     define_field :value3, MyClass, builder: ->(obj, type) { type.new(obj) }
+        #   end
+        #
+        #   bs = BinaryStruct.new
+        #   bs[value1]   # => Types::Int8
+        #   bs.value1    # => Integer
+        # @param [Symbol] name field name
+        # @param [Object] type class or instance
+        # @param [Hash] options Unrecognized options are passed to object builder if
+        #   +:builder+ option is not set.
+        # @option options [Object] :default default value. May be a proc. This lambda
+        #   take one argument: the caller object.
+        # @option options [Lambda] :builder lambda to construct this field.
+        #   Parameters to this lambda is the caller object and the field type class.
+        # @option options [Lambda] :optional define this field as optional. Given lambda
+        #   is used to known if this field is present or not. Parameter to this lambda is
+        #   the being defined Field object.
+        # @option options [Hash] :enum mandatory option for an {Enum} type.
+        #   Define enumeration: hash's keys are +String+, and values are +Integer+.
+        # @return [void]
+        def define_field(name, type, options={})
+          define = []
+          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"
+          end
 
-        @ordered_fields[idx, 0] = name
-      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]
+          fields << name
+        end
 
-      # Define a field, after another one
-      # @param [Symbol,nil] other field name to create a new one after. If +nil+,
-      #    new field is appended.
-      # @param [Symbol] name field name to create
-      # @param [Object] type class or instance
-      # @param [Hash] options See {.define_field}.
-      # @return [void]
-      # @see .define_field
-      def self.define_field_after(other, name, type, options={})
-        define_field name, type, options
-        return if other.nil?
+        # Define a field, before another one
+        # @param [Symbol,nil] other field name to create a new one before. If +nil+,
+        #    new field is appended.
+        # @param [Symbol] name field name to create
+        # @param [Object] type class or instance
+        # @param [Hash] options See {.define_field}.
+        # @return [void]
+        # @see .define_field
+        def define_field_before(other, name, type, options={})
+          define_field name, type, options
+          return if other.nil?
+
+          fields.delete name
+          idx = fields.index(other)
+          raise ArgumentError, "unknown #{other} field" if idx.nil?
+
+          fields[idx, 0] = name
+        end
 
-        @ordered_fields.delete name
-        idx = @ordered_fields.index(other)
-        raise ArgumentError, "unknown #{other} field" if idx.nil?
+        # Define a field, after another one
+        # @param [Symbol,nil] other field name to create a new one after. If +nil+,
+        #    new field is appended.
+        # @param [Symbol] name field name to create
+        # @param [Object] type class or instance
+        # @param [Hash] options See {.define_field}.
+        # @return [void]
+        # @see .define_field
+        def define_field_after(other, name, type, options={})
+          define_field name, type, options
+          return if other.nil?
+
+          fields.delete name
+          idx = fields.index(other)
+          raise ArgumentError, "unknown #{other} field" if idx.nil?
+
+          fields[idx + 1, 0] = name
+        end
 
-        @ordered_fields[idx + 1, 0] = name
-      end
+        # Remove a previously defined field
+        # @param [Symbol] name
+        # @return [void]
+        # @since 2.8.4
+        def remove_field(name)
+          fields.delete name
+          @field_defs.delete name
+          undef_method name
+          undef_method "#{name}="
+        end
 
-      # Remove a previously defined field
-      # @param [Symbol] name
-      # @return [void]
-      # @since 2.8.4
-      def self.remove_field(name)
-        @ordered_fields.delete name
-        @field_defs.delete name
-        undef_method name
-        undef_method "#{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
 
-      # Delete a previously defined field
-      # @param [Symbol] name
-      # @return [void]
-      # @deprecated Use {.remove_field} instead.
-      # @since 2.8.4 deprecated
-      def self.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}.
-      # @return [void]
-      # @see .define_field
-      # @raise [ArgumentError] unknown +field+
-      # @since 2.8.4
-      def self.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)
-      end
+        # Update a previously defined field
+        # @param [Symbol] field field name to create
+        # @param [Hash] options See {.define_field}.
+        # @return [void]
+        # @see .define_field
+        # @raise [ArgumentError] unknown +field+
+        # @since 2.8.4
+        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)
+        end
 
-      # Define a bitfield on given attribute
-      #   class MyHeader < PacketGen::Types::Fields
-      #     define_field :flags, Types::Int16
-      #     # define a bit field on :flag attribute:
-      #     # flag1, flag2 and flag3 are 1-bit fields
-      #     # type and stype are 3-bit fields. reserved is a 6-bit field
-      #     define_bit_fields_on :flags, :flag1, :flag2, :flag3, :type, 3, :stype, 3, :reserved, 7
-      #   end
-      # A bitfield of size 1 bit defines 2 methods:
-      # * +#field?+ which returns a Boolean,
-      # * +#field=+ which takes and returns a Boolean.
-      # A bitfield of more bits defines 2 methods:
-      # * +#field+ which returns an Integer,
-      # * +#field=+ which takes and returns an Integer.
-      # @param [Symbol] attr attribute name (attribute should be a {Types::Int}
-      #   subclass)
-      # @param [Array] args list of bitfield names. Name may be followed
-      #   by bitfield size. If no size is given, 1 bit is assumed.
-      # @return [void]
-      def self.define_bit_fields_on(attr, *args)
-        attr_def = @field_defs[attr]
-        raise ArgumentError, "unknown #{attr} field" if attr_def.nil?
+        # Define a bitfield on given attribute
+        #   class MyHeader < PacketGen::Types::Fields
+        #     define_field :flags, Types::Int16
+        #     # define a bit field on :flag attribute:
+        #     # flag1, flag2 and flag3 are 1-bit fields
+        #     # type and stype are 3-bit fields. reserved is a 6-bit field
+        #     define_bit_fields_on :flags, :flag1, :flag2, :flag3, :type, 3, :stype, 3, :reserved, 7
+        #   end
+        # A bitfield of size 1 bit defines 2 methods:
+        # * +#field?+ which returns a Boolean,
+        # * +#field=+ which takes and returns a Boolean.
+        # A bitfield of more bits defines 2 methods:
+        # * +#field+ which returns an Integer,
+        # * +#field=+ which takes and returns an Integer.
+        # @param [Symbol] attr attribute name (attribute should be a {Types::Int}
+        #   subclass)
+        # @param [Array] args list of bitfield names. Name may be followed
+        #   by bitfield size. If no size is given, 1 bit is assumed.
+        # @return [void]
+        def define_bit_fields_on(attr, *args)
+          attr_def = @field_defs[attr]
+          raise ArgumentError, "unknown #{attr} field" if attr_def.nil?
+
+          type = attr_def.first
+          unless type < Types::Int
+            raise TypeError, "#{attr} is not a PacketGen::Types::Int"
+          end
 
-        type = attr_def.first
-        unless type < Types::Int
-          raise TypeError, "#{attr} is not a PacketGen::Types::Int"
-        end
+          total_size = type.new.width * 8
+          idx = total_size - 1
 
-        total_size = type.new.width * 8
-        idx = total_size - 1
-
-        field = args.shift
-        while field
-          next unless field.is_a? Symbol
-
-          size = if args.first.is_a? Integer
-                   args.shift
-                 else
-                   1
-                 end
-          unless field == :_
-            shift = idx - (size - 1)
-            field_mask = (2**size - 1) << shift
-            clear_mask = (2**total_size - 1) & (~field_mask & (2**total_size - 1))
-
-            if size == 1
-              class_eval <<-METHODS
-              def #{field}?
-                val = (self[:#{attr}].to_i & #{field_mask}) >> #{shift}
-                val != 0
-              end
-              def #{field}=(v)
-                val = v ? 1 : 0
-                self[:#{attr}].value = self[:#{attr}].to_i & #{clear_mask}
-                self[:#{attr}].value |= val << #{shift}
-              end
-              METHODS
-            else
-              class_eval <<-METHODS
-              def #{field}
-                (self[:#{attr}].to_i & #{field_mask}) >> #{shift}
-              end
-              def #{field}=(v)
-                self[:#{attr}].value = self[:#{attr}].to_i & #{clear_mask}
-                self[:#{attr}].value |= (v & #{2**size - 1}) << #{shift}
+          field = args.shift
+          while field
+            next unless field.is_a? Symbol
+
+            size = if args.first.is_a? Integer
+                     args.shift
+                   else
+                     1
+                   end
+            unless field == :_
+              shift = idx - (size - 1)
+              field_mask = (2**size - 1) << shift
+              clear_mask = (2**total_size - 1) & (~field_mask & (2**total_size - 1))
+
+              if size == 1
+                class_eval <<-METHODS
+                def #{field}?
+                  val = (self[:#{attr}].to_i & #{field_mask}) >> #{shift}
+                  val != 0
+                end
+                def #{field}=(v)
+                  val = v ? 1 : 0
+                  self[:#{attr}].value = self[:#{attr}].to_i & #{clear_mask}
+                  self[:#{attr}].value |= val << #{shift}
+                end
+                METHODS
+              else
+                class_eval <<-METHODS
+                def #{field}
+                  (self[:#{attr}].to_i & #{field_mask}) >> #{shift}
+                end
+                def #{field}=(v)
+                  self[:#{attr}].value = self[:#{attr}].to_i & #{clear_mask}
+                  self[:#{attr}].value |= (v & #{2**size - 1}) << #{shift}
+                end
+                METHODS
               end
-              METHODS
+
+              @bit_fields[attr] = {} if @bit_fields[attr].nil?
+              @bit_fields[attr][field] = size
             end
 
-            @bit_fields[attr] = {} if @bit_fields[attr].nil?
-            @bit_fields[attr][field] = size
+            idx -= size
+            field = args.shift
           end
-
-          idx -= size
-          field = args.shift
         end
-      end
 
-      # Remove all bit fields defined on +attr+
-      # @param [Symbol] attr attribute defining bit fields
-      # @return [void]
-      # @since 2.8.4
-      def self.remove_bit_fields_on(attr)
-        fields = @bit_fields.delete(attr)
-        return if fields.nil?
-
-        fields.each do |field, size|
-          undef_method "#{field}="
-          undef_method(size == 1 ? "#{field}?" : "#{field}")
+        # Remove all bit fields defined on +attr+
+        # @param [Symbol] attr attribute defining bit fields
+        # @return [void]
+        # @since 2.8.4
+        def remove_bit_fields_on(attr)
+          fields = @bit_fields.delete(attr)
+          return if fields.nil?
+
+          fields.each do |field, size|
+            undef_method "#{field}="
+            undef_method(size == 1 ? "#{field}?" : "#{field}")
+          end
         end
       end
 
@@ -405,7 +414,7 @@ module PacketGen
       # Get all field names
       # @return [Array<Symbol>]
       def fields
-        @ordered_fields ||= self.class.class_eval { @ordered_fields }
+        self.class.fields
       end
 
       # Get all optional field name
@@ -435,6 +444,7 @@ module PacketGen
 
       # 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
@@ -507,7 +517,9 @@ module PacketGen
       # @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
@@ -525,6 +537,7 @@ module PacketGen
       # 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

data/lib/packetgen/version.rb

@@ -10,5 +10,5 @@
 # @author Sylvain Daubert
 module PacketGen
   # PacketGen version
-  VERSION = '2.8.4'
+  VERSION = '2.8.5'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: packetgen
 version: !ruby/object:Gem::Version
-  version: 2.8.4
+  version: 2.8.5
 platform: ruby
 authors:
 - Sylvain Daubert
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-02 00:00:00.000000000 Z
+date: 2018-10-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: interfacez