packetgen 3.1.5 → 3.1.6

data/lib/packetgen/types/fieldable.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+# This file is part of PacketGen
+# See https://github.com/sdaubert/packetgen for more informations
+# Copyright (C) 2016 Sylvain Daubert <sylvain.daubert@laposte.net>
+# This program is published under MIT license.
+
+module PacketGen
+  module Types
+    # Mixin to define minimal API for a class to be embbeded as a field in
+    # {Fields} type.
+    #
+    # == Optional methods
+    # These methods may, optionally, be defined by fieldable types:
+    # * +from_human+ to load data from a human-readable string.
+    # @author Sylvain Daubert
+    # @since 3.1.6
+    module Fieldable
+      # Get type name
+      # @return [String]
+      def type_name
+        self.class.to_s.split('::').last
+      end
+
+      # rubocop:disable Lint/UselessMethodDefinition
+      # These methods are defined for documentation.
+
+      # Populate object from a binary string
+      # @param [String] str
+      # @return [Fields] self
+      # @abstract subclass should overload it.
+      def read(str)
+        super
+      end
+
+      # Return object as a binary string
+      # @return [String]
+      # @abstract subclass should overload it.
+      def to_s
+        super
+      end
+
+      # Size of object as binary string
+      # @return [Integer]
+      def sz
+        to_s.size
+      end
+
+      # Return a human-readbale string
+      # @return [String]
+      # @abstract subclass should overload it.
+      def to_human
+        super
+      end
+
+      # rubocop:enable Lint/UselessMethodDefinition
+
+      # Format object when inspecting a {Field} object
+      # @return [String]
+      def format_inspect
+        to_human
+      end
+    end
+  end
+end

data/lib/packetgen/types/fields.rb

@@ -5,6 +5,8 @@
 # Copyright (C) 2016 Sylvain Daubert <sylvain.daubert@laposte.net>
 # This program is published under MIT license.
 
+# rubocop:disable Metrics/ClassLength
+
 module PacketGen
   module Types
     # @abstract Set of fields
@@ -13,8 +15,7 @@ module PacketGen
     #
     # == Basics
     # A {Fields} subclass is generaly composed of multiple binary fields. These fields
-    # have each a given type. All types from {Types} module are supported, and all
-    # {Fields} subclasses may also be used as field type.
+    # have each a given type. All {Fieldable} types are supported.
     #
     # To define a new subclass, it has to inherit from {Fields}. And some class
     # methods have to be used to declare attributes/fields:
@@ -128,6 +129,8 @@ module PacketGen
         # @param [Class] klass
         # @return [void]
         def inherited(klass)
+          super
+
           field_defs = {}
           @field_defs.each do |k, v|
             field_defs[k] = v.clone
@@ -162,7 +165,7 @@ module PacketGen
         #   bs[value1]   # => Types::Int8
         #   bs.value1    # => Integer
         # @param [Symbol] name field name
-        # @param [Object] type class or instance
+        # @param [Fieldable] 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
@@ -191,7 +194,7 @@ module PacketGen
         # @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 [Fieldable] type class or instance
         # @param [Hash] options See {.define_field}.
         # @return [void]
         # @see .define_field
@@ -210,7 +213,7 @@ module PacketGen
         # @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 [Fieldable] type class or instance
         # @param [Hash] options See {.define_field}.
         # @return [void]
         # @see .define_field
@@ -244,12 +247,12 @@ module PacketGen
         # @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)
+          check_existence_of field
+
+          %i[default builder optional enum].each do |property|
+            field_defs_property_from(field, property, options)
+          end
 
-          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
 
@@ -271,12 +274,12 @@ module PacketGen
         #   subclass)
         # @param [Array] args list of bitfield names. Name may be followed
         #   by bitfield size. If no size is given, 1 bit is assumed.
+        # @raise [ArgumentError] unknown +attr+
         # @return [void]
         def define_bit_fields_on(attr, *args)
-          attr_def = field_defs[attr]
-          raise ArgumentError, "unknown #{attr} field" if attr_def.nil?
+          check_existence_of attr
 
-          type = attr_def.type
+          type = field_defs[attr].type
           raise TypeError, "#{attr} is not a PacketGen::Types::Int" unless type < Types::Int
 
           total_size = type.new.width * 8
@@ -286,11 +289,7 @@ module PacketGen
             field = args.shift
             next unless field.is_a? Symbol
 
-            size = if args.first.is_a? Integer
-                     args.shift
-                   else
-                     1
-                   end
+            size = size_from(args)
 
             unless field == :_
               add_bit_methods(attr, field, size, total_size, idx)
@@ -338,38 +337,74 @@ module PacketGen
 
         def add_bit_methods(attr, name, size, total_size, idx)
           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 #{name}?
-              val = (self[:#{attr}].to_i & #{field_mask}) >> #{shift}
-              val != 0
-            end
-            def #{name}=(v)
-              val = v ? 1 : 0
-              self[:#{attr}].value = self[:#{attr}].to_i & #{clear_mask}
-              self[:#{attr}].value |= val << #{shift}
-            end
-            METHODS
+            add_single_bit_methods(attr, name, size, total_size, shift)
           else
-            class_eval <<-METHODS
-            def #{name}
-              (self[:#{attr}].to_i & #{field_mask}) >> #{shift}
-            end
-            def #{name}=(v)
-              self[:#{attr}].value = self[:#{attr}].to_i & #{clear_mask}
-              self[:#{attr}].value |= (v & #{2**size - 1}) << #{shift}
-            end
-            METHODS
+            add_multibit_methods(attr, name, size, total_size, shift)
+          end
+        end
+
+        def compute_field_mask(size, shift)
+          (2**size - 1) << shift
+        end
+
+        def compute_clear_mask(total_size, field_mask)
+          (2**total_size - 1) & (~field_mask & (2**total_size - 1))
+        end
+
+        def add_single_bit_methods(attr, name, size, total_size, shift)
+          field_mask = compute_field_mask(size, shift)
+          clear_mask = compute_clear_mask(total_size, field_mask)
+
+          class_eval <<-METHODS
+          def #{name}?
+            val = (self[:#{attr}].to_i & #{field_mask}) >> #{shift}
+            val != 0
           end
+          def #{name}=(v)
+            val = v ? 1 : 0
+            self[:#{attr}].value = self[:#{attr}].to_i & #{clear_mask}
+            self[:#{attr}].value |= val << #{shift}
+          end
+          METHODS
+        end
+
+        def add_multibit_methods(attr, name, size, total_size, shift)
+          field_mask = compute_field_mask(size, shift)
+          clear_mask = compute_clear_mask(total_size, field_mask)
+
+          class_eval <<-METHODS
+          def #{name}
+            (self[:#{attr}].to_i & #{field_mask}) >> #{shift}
+          end
+          def #{name}=(v)
+            self[:#{attr}].value = self[:#{attr}].to_i & #{clear_mask}
+            self[:#{attr}].value |= (v & #{2**size - 1}) << #{shift}
+          end
+          METHODS
         end
 
         def register_bit_field_size(attr, field, size)
           bit_fields[attr] = {} if bit_fields[attr].nil?
           bit_fields[attr][field] = size
         end
+
+        def field_defs_property_from(field, property, options)
+          field_defs[field].send("#{property}=", options.delete(property)) if options.key?(property)
+        end
+
+        def size_from(args)
+          if args.first.is_a? Integer
+            args.shift
+          else
+            1
+          end
+        end
+
+        def check_existence_of(field)
+          raise ArgumentError, "unknown #{field} field for #{self}" unless field_defs.key?(field)
+        end
       end
 
       # Create a new fields object
@@ -394,7 +429,7 @@ module PacketGen
 
       # Get field object
       # @param [Symbol] field
-      # @return [Object]
+      # @return [Fieldable]
       def [](field)
         @fields[field]
       end
@@ -414,6 +449,7 @@ module PacketGen
       end
 
       # Get all optional field name
+      # @return[Array<Symbol>,nil]
       def optional_fields
         @optional_fields.keys
       end
@@ -444,11 +480,7 @@ module PacketGen
           next unless present?(field)
 
           obj = self[field].read str[start..-1]
-          if self[field].respond_to? :sz
-            start += self[field].sz
-          else
-            start = str.size
-          end
+          start += self[field].sz
           self[field] = obj unless obj == self[field]
         end
 
@@ -545,22 +577,21 @@ module PacketGen
         self.class.field_defs
       end
 
+      # rubocop:disable Metrics/AbcSize
       def build_field(field)
         type = field_defs[field].type
-        builder = field_defs[field].builder
-        enum = field_defs[field].enum
-        field_options = field_defs[field].options
-
-        @fields[field] = if builder
-                           builder.call(self, type)
-                         elsif enum
-                           type.new(enum)
-                         elsif !field_options.empty?
-                           type.new(field_options)
+
+        @fields[field] = if field_defs[field].builder
+                           field_defs[field].builder.call(self, type)
+                         elsif field_defs[field].enum
+                           type.new(field_defs[field].enum)
+                         elsif !field_defs[field].options.empty?
+                           type.new(field_defs[field].options)
                          else
                            type.new
                          end
       end
+      # rubocop:enable Metrics/AbcSize
 
       def initialize_value(field, val)
         type = field_defs[field].type
@@ -572,6 +603,8 @@ module PacketGen
           @fields[field] = value
         elsif @fields[field].respond_to? :from_human
           @fields[field].from_human(value)
+        else
+          @fields[field].read(value)
         end
       end
 
@@ -582,3 +615,5 @@ module PacketGen
     end
   end
 end
+
+# rubocop:enable Metrics/ClassLength

data/lib/packetgen/types/int.rb

@@ -12,7 +12,7 @@ module PacketGen
     # @abstract
     # @author Sylvain Daubert
     class Int
-      include Inspectable
+      include Fieldable
 
       # Integer value
       # @return [Integer]
@@ -47,7 +47,7 @@ module PacketGen
         @value = if value.is_a?(Integer)
                    value.to_i
                  elsif defined? @packstr
-                   value.to_s.unpack(@packstr[@endian]).first
+                   value.to_s.unpack1(@packstr[@endian])
                  else
                    raise ParseError, 'Int#read is abstract and cannot read'
                  end

data/lib/packetgen/types/int_string.rb

@@ -12,7 +12,7 @@ module PacketGen
     # By default, a null string will have one byte length (length byte set to 0).
     # @author Sylvain Daubert
     class IntString
-      include Inspectable
+      include Fieldable
 
       # internal string
       # @return [String]
@@ -78,7 +78,6 @@ module PacketGen
       def to_human
         @string
       end
-      alias format_inspect to_human
 
       # Set length from internal string length
       # @return [Integer]
@@ -91,6 +90,12 @@ module PacketGen
       def sz
         to_s.size
       end
+
+      # Say if IntString is empty
+      # @return [Boolean]
+      def empty?
+        length.zero?
+      end
     end
   end
 end

data/lib/packetgen/types/length_from.rb

@@ -14,6 +14,9 @@ module PacketGen
     # @author Sylvain Daubert
     # @since 3.0.0
     module LengthFrom
+      # Max value returned by {#sz_to_read}.
+      MAX_SZ_TO_READ = 65_535
+
       # Initialize +length from+ capacity.
       # Should be call by extensed object's initialize.
       # @param [Hash] options
@@ -29,16 +32,21 @@ module PacketGen
       # @return [String]
       def read_with_length_from(str)
         s = PacketGen.force_binary(str.to_s)
-        str_end = case @length_from
-                  when Types::Int
-                    @length_from.to_i
-                  when Proc
-                    @length_from.call
-                  else
-                    s.size
-                  end
-        str_end = 0 if str_end.negative?
-        s[0, str_end]
+        s[0, sz_to_read]
+      end
+
+      # Size to read, from length_from
+      # @return [Integer]
+      def sz_to_read
+        len = case @length_from
+              when Types::Int
+                @length_from.to_i
+              when Proc
+                @length_from.call
+              else
+                MAX_SZ_TO_READ
+              end
+        [0, len].max
       end
     end
   end

data/lib/packetgen/types/oui.rb

@@ -14,7 +14,7 @@ module PacketGen
     #  oui.to_human   # => "00:01:02"
     # @author Sylvain Daubert
     class OUI < Types::Fields
-      include Inspectable
+      include Fieldable
 
       # @attribute b2
       #  @return [Integer] left-most byte
@@ -46,7 +46,6 @@ module PacketGen
       def to_human
         fields.map { |m| '%02x' % self[m] }.join(':')
       end
-      alias format_inspect to_human
     end
   end
 end

data/lib/packetgen/types/string.rb

@@ -6,16 +6,23 @@
 # Copyright (C) 2016 Sylvain Daubert <sylvain.daubert@laposte.net>
 # This program is published under MIT license.
 
+require 'forwardable'
+
 module PacketGen
   module Types
-    # This class is just like regular String. It only adds {#read}, {#sz},
-    # #{to_human} and {#from_human} methods
-    # to be compatible with others {Types}.
+    # This class mimics regular String, but it is {Fieldable}.
     # @author Sylvain Daubert
-    class String < ::String
+    # @since 3.1.6 no more a subclass or regular String
+    class String
+      extend Forwardable
+      include Fieldable
       include LengthFrom
-      include Inspectable
 
+      def_delegators :@string, :[], :to_s, :length, :size, :inspect, :==, :<<,
+                     :unpack, :force_encoding, :encoding, :index, :empty?
+
+      # @return [::String]
+      attr_reader :string
       # @return [Integer]
       attr_reader :static_length
 
@@ -24,7 +31,7 @@ module PacketGen
       #   takes length when reading
       # @option options [Integer] :static_length set a static length for this string
       def initialize(options={})
-        super()
+        register_internal_string ''
         initialize_length_from(options)
         @static_length = options[:static_length]
       end
@@ -33,14 +40,44 @@ module PacketGen
       # @return [String] self
       def read(str)
         s = read_with_length_from(str)
-        s = s[0, static_length] if static_length
-        self.replace(s)
+        register_internal_string s
         self
       end
 
+      alias old_sz_to_read sz_to_read
+      private :old_sz_to_read
+
+      # Size to read.
+      # Computed from static_length or length_from, if defined.
+      # @return [Integer]
+      # @since 3.1.6
+      def sz_to_read
+        return static_length if static_length?
+
+        old_sz_to_read
+      end
+
+      # Say if a static length is defined
+      # @return [Boolean]
+      # @since 3.1.6
+      def static_length?
+        !static_length.nil?
+      end
+
+      def format_inspect
+        inspect
+      end
+
       alias sz length
       alias to_human to_s
       alias from_human read
+
+      private
+
+      def register_internal_string(str)
+        @string = str
+        PacketGen.force_binary(@string)
+      end
     end
   end
 end