packetgen 1.2.0 → 1.3.0

data/lib/packetgen/pcapng/shb.rb

@@ -17,10 +17,7 @@ module PacketGen
     #   Int64   :section_len
     #   String  :options        Default: ''
     #   Int32   :block_len2
-    class SHB < Struct.new(:type, :block_len, :magic, :ver_major, :ver_minor,
-                           :section_len, :options, :block_len2)
-      include StructFu
-      include Block
+    class SHB < Block
 
       # @return [:little, :big]
       attr_accessor :endian
@@ -43,6 +40,27 @@ module PacketGen
       # +section_len+ value for undefined length
       SECTION_LEN_UNDEFINED = 0xffffffff_ffffffff
 
+      # @!attribute magic
+      #  32-bit magic number
+      #  @return [Integer]
+      define_field_before :block_len2, :magic, Types::Int32, default: MAGIC_INT32
+      # @!attribute ver_major
+      #  16-bit major version number
+      #  @return [Integer]
+      define_field_before :block_len2, :ver_major, Types::Int16, default: 1
+      # @!attribute ver_major
+      #  16-bit minor version number
+      #  @return [Integer]
+      define_field_before :block_len2, :ver_minor, Types::Int16, default: 0
+      # @!attribute section_len
+      #  64-bit section length
+      #  @return [Integer]
+      define_field_before :block_len2, :section_len, Types::Int64,
+                          default: SECTION_LEN_UNDEFINED
+      # @!attribute options
+      #  @return [Types::String]
+      define_field_before :block_len2, :options, Types::String
+
       # @param [Hash] options
       # @option options [:little, :big] :endian set block endianness
       # @option options [Integer] :type
@@ -58,28 +76,12 @@ module PacketGen
       # @option options [::String] :options
       # @option options [Integer] :block_len2 block total length
       def initialize(options={})
-        @endian = set_endianness(options[:endian] || :little)
+        super
         @interfaces = []
         @unknown_blocks = []
-        init_fields(options)
-        super(options[:type], options[:block_len], options[:magic], options[:ver_major],
-              options[:ver_minor], options[:section_len], options[:options], options[:block_len2])
-      end
-
-      # Used by {#initialize} to set the initial fields
-      # @see #initialize possible options
-      # @param [Hash] options
-      # @return [Hash] return +options+
-      def init_fields(options={})
-        options[:type]  = @int32.new(options[:type] || PcapNG::SHB_TYPE.to_i)
-        options[:block_len] = @int32.new(options[:block_len] || MIN_SIZE)
-        options[:magic] = @int32.new(options[:magic] || MAGIC_INT32)
-        options[:ver_major] = @int16.new(options[:ver_major] || 1)
-        options[:ver_minor] = @int16.new(options[:ver_minor] || 0)
-        options[:section_len] = @int64.new(options[:section_len] || SECTION_LEN_UNDEFINED)
-        options[:options] = StructFu::String.new(options[:options] || '')
-        options[:block_len2] = @int32.new(options[:block_len2] || MIN_SIZE)
-        options
+        set_endianness(options[:endian] || :little)
+        recalc_block_len
+        self.type = options[:type] || PcapNG::SHB_TYPE.to_i
       end
 
       # Reads a String or a IO to populate the object
@@ -130,10 +132,7 @@ module PacketGen
         self[:options].read io.read(self[:block_len].to_i - MIN_SIZE)
         self[:block_len2].read io.read(4)
 
-        unless self[:block_len].to_i == self[:block_len2].to_i
-          raise InvalidFileError, 'Incoherency in Section Header Block'
-        end
-
+        check_len_coherency
         self
       end
 
@@ -154,25 +153,22 @@ module PacketGen
         end
         pad_field :options
         recalc_block_len
-        to_a.map(&:to_s).join + body
+        fields.map { |f| @fields[f].to_s }.join + body
       end
 
 
       private
 
       def force_endianness(endian)
-        set_endianness endian
         @endian = endian
-        self[:type]  = @int32.new(self[:type].to_i)
-        self[:block_len] = @int32.new(self[:block_len].to_i)
-        self[:magic] = @int32.new(self[:magic].to_i)
-        self[:ver_major] = @int16.new(self[:ver_major].to_i)
-        self[:ver_minor] = @int16.new(self[:ver_minor].to_i)
-        self[:section_len] = @int64.new(self[:section_len].to_i)
-        self[:block_len2] = @int32.new(self[:block_len2].to_i)
+        self[:type]  = Types::Int32.new(self[:type].to_i, endian)
+        self[:block_len] = Types::Int32.new(self[:block_len].to_i, endian)
+        self[:magic] = Types::Int32.new(self[:magic].to_i, endian)
+        self[:ver_major] = Types::Int16.new(self[:ver_major].to_i, endian)
+        self[:ver_minor] = Types::Int16.new(self[:ver_minor].to_i, endian)
+        self[:section_len] = Types::Int64.new(self[:section_len].to_i, endian)
+        self[:block_len2] = Types::Int32.new(self[:block_len2].to_i, endian)
       end
-
     end
-
   end
 end

data/lib/packetgen/pcapng/spb.rb

@@ -14,17 +14,23 @@ module PacketGen
     #   Int32   :orig_len
     #   String  :data
     #   Int32   :block_len2
-    class SPB < Struct.new(:type, :block_len, :orig_len, :data, :block_len2)
-      include StructFu
-      include Block
+    class SPB < Block
+
+      # Minimum SPB size
+      MIN_SIZE     = 4*4
 
       # @return [:little, :big]
       attr_accessor :endian
       # @return [IPB]
       attr_accessor :interface
 
-      # Minimum SPB size
-      MIN_SIZE     = 4*4
+      # @!attribute orig_len
+      #  32-bit original length
+      #  @return [Integer]
+      define_field_before :block_len2, :orig_len, Types::Int32, default: 0
+      # @!attribute data
+      #  @return [Types::String]
+      define_field_before :block_len2, :data, Types::String
 
       # @param [Hash] options
       # @option options [:little, :big] :endian set block endianness
@@ -36,23 +42,10 @@ module PacketGen
       # @option options [::String] :options
       # @option options [Integer] :block_len2 block total length
       def initialize(options={})
-        @endian = set_endianness(options[:endian] || :little)
-        init_fields(options)
-        super(options[:type], options[:block_len], options[:orig_len], options[:data],
-              options[:block_len2])
-      end
-
-      # Used by {#initialize} to set the initial fields
-      # @param [Hash] options
-      # @see #initialize possible options
-      # @return [Hash] return +options+
-      def init_fields(options={})
-        options[:type]  = @int32.new(options[:type] || PcapNG::SPB_TYPE.to_i)
-        options[:block_len] = @int32.new(options[:block_len] || MIN_SIZE)
-        options[:orig_len] = @int32.new(options[:orig_len] || 0)
-        options[:data] = StructFu::String.new(options[:data] || '')
-        options[:block_len2] = @int32.new(options[:block_len2] || MIN_SIZE)
-        options
+        super
+        set_endianness(options[:endian] || :little)
+        recalc_block_len
+        self.type = options[:type] || PcapNG::SPB_TYPE.to_i
       end
 
       # Has this block option?
@@ -87,10 +80,8 @@ module PacketGen
         io.read data_pad_len
         self[:block_len2].read io.read(4)
 
-        unless self[:block_len].to_i == self[:block_len2].to_i
-          raise InvalidFileError, 'Incoherency in Simple Packet Block'
-        end
-
+        check_len_coherency
+        self.type = self[:type] || PcapNG::IDB_TYPE.to_i
         self
       end
 
@@ -99,7 +90,7 @@ module PacketGen
       def to_s
         pad_field :data
         recalc_block_len
-        to_a.map(&:to_s).join
+        fields.map { |f| @fields[f].to_s }.join
       end
 
     end

data/lib/packetgen/pcapng/unknown_block.rb

@@ -7,17 +7,19 @@ module PacketGen
   module PcapNG
 
     # {UnknownBlock} is used to handle unsupported blocks of a pcapng file.
-    class UnknownBlock < Struct.new(:type, :block_len, :body, :block_len2)
-      include StructFu
-      include Block
+    class UnknownBlock < Block
+
+      # Minimum Iblock size
+      MIN_SIZE     = 12
 
       # @return [:little, :big]
       attr_accessor :endian
       # @return [SHB]
       attr_accessor :section
 
-      # Minimum Iblock size
-      MIN_SIZE     = 12
+      # @!attribute body
+      #  @return [Types::String]
+      define_field_before :block_len2, :body, Types::String
 
       # @option options [:little, :big] :endian set block endianness
       # @option options [Integer] :type
@@ -25,21 +27,9 @@ module PacketGen
       # @option options [::String] :body
       # @option options [Integer] :block_len2 block total length
       def initialize(options={})
-        @endian = set_endianness(options[:endian] || :little)
-        init_fields(options)
-        super(options[:type], options[:block_len], options[:body], options[:block_len2])
-      end
-
-      # Used by {#initialize} to set the initial fields
-      # @see #initialize possible options
-      # @param [Hash] options
-      # @return [Hash] return +options+
-      def init_fields(options={})
-        options[:type]  = @int32.new(options[:type] || 0)
-        options[:block_len] = @int32.new(options[:block_len] || MIN_SIZE)
-        options[:body] = StructFu::String.new(options[:body] || '')
-        options[:block_len2] = @int32.new(options[:block_len2] || MIN_SIZE)
-        options
+        super
+        set_endianness(options[:endian] || :little)
+        recalc_block_len
       end
 
       # Has this block option?
@@ -76,7 +66,7 @@ module PacketGen
       def to_s
         pad_field :body
         recalc_block_len
-        to_a.map(&:to_s).join
+        @fields.values.map(&:to_s).join
       end
 
     end

data/lib/packetgen/pcapng.rb

@@ -11,18 +11,20 @@ module PacketGen
   module PcapNG
 
     # Section Header Block type number
-    SHB_TYPE = StructFu::Int32.new(0x0A0D0D0A, :little)
+    SHB_TYPE = Types::Int32.new(0x0A0D0D0A, :little)
     # Interface Description Block type number
-    IDB_TYPE = StructFu::Int32.new(1, :little)
+    IDB_TYPE = Types::Int32.new(1, :little)
     # Simple Packet Block type number
-    SPB_TYPE = StructFu::Int32.new(3, :little)
+    SPB_TYPE = Types::Int32.new(3, :little)
     # Enhanced Packet Block type number
-    EPB_TYPE = StructFu::Int32.new(6, :little)
+    EPB_TYPE = Types::Int32.new(6, :little)
 
-    # Various LINKTYPE values from http://www.tcpdump.org/linktypes.html
-    # FIXME: only ETHERNET type is defined as this is the only link layer
-    # type supported by PacketGen
+    # IEEE 802.3 Ethernet (10Mb, 100Mb, 1000Mb, and up)
     LINKTYPE_ETHERNET = 1
+    # Raw IPv4; the packet begins with an IPv4 header.
+    LINKTYPE_IPV4 = 228
+    # Raw IPv6; the packet begins with an IPv6 header.
+    LINKTYPE_IPV6 = 229
 
     # Base error class for PcapNG
     class Error < PacketGen::Error; end

data/lib/packetgen/types/array.rb

@@ -0,0 +1,56 @@
+# 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
+
+    # @abstract
+    # Array supporting some fields methods
+    # @author Sylvain Daubert
+    class Array < ::Array
+
+      # @abstract depend on private method +#record_from_hash+ which should be
+      #   declared by subclasses.
+      # Add an object to this array
+      # @param [Object] obj type depends on subclass
+      # @return [Array] self
+      def push(obj)
+        obj = case obj
+              when Hash
+                record_from_hash obj
+              else
+                obj
+              end
+        super(obj)
+      end
+      alias :<< :push
+
+      # Get binary string
+      # @return [String]
+      def to_s
+        map(&:to_s).join
+      end
+
+      # Get a human readable string
+      # @return [String]
+      def to_human
+        map(&:to_human).join(',')
+      end
+
+      # Get size in bytes
+      # @return [Integer]
+      def sz
+        to_s.size
+      end
+
+      # Force binary encoding for +str+
+      # @param [String] str
+      # @return [String] binary encoded string
+      def force_binary(str)
+        PacketGen.force_binary str
+      end
+    end
+  end
+end

data/lib/packetgen/types/fields.rb

@@ -0,0 +1,325 @@
+# 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
+
+    # @abstract
+    # Set of fields
+    # @author Sylvain Daubert
+    class Fields
+
+      # @private
+      @ordered_fields = []
+      # @private
+      @field_defs = {}
+      # @private
+      @bit_fields = []
+
+      # On inheritage, create +@field_defs+ class variable
+      # @param [Class] klass
+      # @return [void]
+      def self.inherited(klass)
+        ordered = @ordered_fields.clone
+        field_defs = @field_defs.clone
+        bf = @bit_fields.clone
+        klass.class_eval do
+          @ordered_fields = ordered
+          @field_defs = field_defs
+          @bit_fields = bf
+        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) { Myclass.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
+      # @option options [Lambda] :builder lambda to construct this field.
+      #   Parameter to this lambda is the caller object.
+      # @return [void]
+      def self.define_field(name, type, options={})
+        define = []
+        if 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 and
+             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
+
+        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]
+        @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
+        unless other.nil?
+          @ordered_fields.delete name
+          idx = @ordered_fields.index(other)
+          raise ArgumentError, "unknown #{other} field" if idx.nil?
+          @ordered_fields[idx, 0] = name
+        end
+      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
+        unless other.nil?
+          @ordered_fields.delete name
+          idx = @ordered_fields.index(other)
+          raise ArgumentError, "unknown #{other} field" if idx.nil?
+          @ordered_fields[idx+1, 0] = name
+        end
+      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?
+        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
+
+        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 <<-EOM
+              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
+              EOM
+            else
+                class_eval <<-EOM
+              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
+              EOM
+            end
+
+            @bit_fields << field
+          end
+
+          idx -= size
+          field = args.shift
+        end
+      end
+
+      # Create a new header object
+      # @param [Hash] options Keys are symbols. They should have name of object
+      #   attributes, as defined by {.define_field} and by {.define_bit_field}.
+      def initialize(options={})
+        @fields = {}
+        self.class.class_eval { @field_defs }.each do |field, ary|
+          default = ary[1].is_a?(Proc) ? ary[1].call : ary[1]
+          @fields[field] = if ary[2]
+                             ary[2].call(self)
+                           elsif !ary[3].empty?
+                             ary[0].new(ary[3])
+                           else
+                             ary[0].new
+                           end
+
+          value = options[field] || default
+          if ary[0] < Types::Int
+            @fields[field].read(value)
+          elsif ary[0] <= Types::String
+            @fields[field].read(value)
+          else
+            @fields[field].from_human(value) if @fields[field].respond_to? :from_human
+          end
+        end
+        self.class.class_eval { @bit_fields }.each do |bit_field|
+          self.send "#{bit_field}=", options[bit_field] if options[bit_field]
+        end
+      end
+
+      # Get field object
+      # @param [Symbol] field
+      # @return [Object]
+      def [](field)
+        @fields[field]
+      end
+
+      # Set field object
+      # @param [Symbol] field
+      # @param [Object] obj
+      # @return [Object]
+      def []=(field, obj)
+        @fields[field] = obj
+      end
+
+      # Get all field names
+      # @return [Array<Symbol>]
+      def fields
+        @ordered_fields ||= self.class.class_eval { @ordered_fields }
+      end
+
+      # Return header protocol name
+      # @return [String]
+      def protocol_name
+        self.class.to_s.sub(/.*::/, '')
+      end
+
+      # Populate object from a binary string
+      # @param [String] str
+      # @return [Fields] self
+      def read(str)
+        return self if str.nil?
+        force_binary str
+        start = 0
+        fields.each do |field|
+          if self[field].respond_to? :width
+            width = self[field].width
+            self[field].read str[start, width]
+            start += width
+          elsif self[field].respond_to? :sz
+            self[field].read str[start..-1]
+            size = self[field].sz
+            start += size
+          else
+            self[field].read str[start..-1]
+            start = str.size
+          end
+        end
+
+        self
+      end
+
+      # Common inspect method for headers
+      # @return [String]
+      def inspect
+        str = Inspect.dashed_line(self.class, 2)
+        @fields.each do |attr, value|
+          next if attr == :body
+          str << Inspect.inspect_attribute(attr, value, 2)
+        end
+        str
+      end
+
+      # Return object as a binary string
+      # @return [String]
+      def to_s
+        fields.map { |f| force_binary @fields[f].to_s }.join
+      end
+
+      # Size of object as binary strinf
+      # @return [nteger]
+      def sz
+        to_s.size
+      end
+
+      # Return object as a hash
+      # @return [Hash] keys: attributes, values: attribute values
+      def to_h
+        Hash[fields.map { |f| [f, @fields[f]] }]
+      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
+      def body=(value)
+        raise BodyError, 'no body field'  unless @fields.has_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]
+      def force_binary(str)
+        PacketGen.force_binary(str)
+      end
+    end
+  end
+end