packetgen 3.1.4 → 3.2.0

data/lib/packetgen/pcapng/idb.rb

@@ -60,7 +60,7 @@ module PacketGen
       # @option options [Integer] :block_len2 block total length
       def initialize(options={})
         super
-        set_endianness(options[:endian] || :little)
+        endianness(options[:endian] || :little)
         @packets = []
         @options_decoded = false
         recalc_block_len
@@ -74,15 +74,12 @@ module PacketGen
         io = to_io(str_or_io)
         return self if io.eof?
 
-        self[:type].read io.read(4)
-        self[:block_len].read io.read(4)
-        self[:link_type].read io.read(2)
-        self[:reserved].read io.read(2)
-        self[:snaplen].read io.read(4)
+        %i[type block_len link_type reserved snaplen].each do |attr|
+          self[attr].read io.read(self[attr].sz)
+        end
         self[:options].read io.read(self.block_len - MIN_SIZE)
-        self[:block_len2].read io.read(4)
+        read_blocklen2_and_check(io)
 
-        check_len_coherency
         self
       end
 
@@ -91,6 +88,7 @@ module PacketGen
       # @return [self]
       def <<(xpb)
         @packets << xpb
+        xpb.interface = self
         self
       end
 
@@ -133,7 +131,7 @@ module PacketGen
 
         while idx < options.length
           opt_code, opt_len = options[idx, 4].unpack("#{packstr}2")
-          return options[idx + 4, 1].unpack('C').first if opt_code == OPTION_IF_TSRESOL && opt_len == 1
+          return options[idx + 4, 1].unpack1('C') if opt_code == OPTION_IF_TSRESOL && opt_len == 1
 
           idx += 4 + opt_len
         end

data/lib/packetgen/pcapng/shb.rb

@@ -80,7 +80,7 @@ module PacketGen
         super
         @interfaces = []
         @unknown_blocks = []
-        set_endianness(options[:endian] || :little)
+        endianness(options[:endian] || :little)
         recalc_block_len
         self.type = options[:type] || PcapNG::SHB_TYPE.to_i
       end
@@ -92,29 +92,15 @@ module PacketGen
         io = to_io(str_or_io)
         return self if io.eof?
 
-        type_str = check_shb(io)
-        block_len_str = io.read(4)
-        magic_str = io.read(4)
-
-        case magic_str
-        when MAGIC_LITTLE
-          force_endianness :little if @endian == :big
-        when MAGIC_BIG
-          force_endianness :big if @endian == :little
-        else
-          raise InvalidFileError, 'Incorrect magic for Section Header Block'
+        self[:type].read check_shb(io)
+        %i[block_len magic ver_major ver_minor section_len].each do |attr|
+          self[attr].read io.read(self[attr].sz)
         end
+        handle_magic_and_check(self[:magic].to_s)
 
-        self[:type].read type_str
-        self[:block_len].read block_len_str
-        self[:magic].read magic_str
-        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 - MIN_SIZE)
-        self[:block_len2].read io.read(4)
+        read_options(io)
+        read_blocklen2_and_check(io)
 
-        check_len_coherency
         self
       end
 
@@ -123,6 +109,7 @@ module PacketGen
       # @return [self]
       def <<(idb)
         @interfaces << idb
+        idb.section = self
         self
       end
 
@@ -137,17 +124,22 @@ module PacketGen
         super + body
       end
 
+      def add_unknown_block(block)
+        self.unknown_blocks << block
+        block.section = self
+      end
+
       private
 
       def force_endianness(endian)
         @endian = endian
-        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)
+        %i[type block_len magic block_len2].each do |attr|
+          self[attr] = Types::Int32.new(0, endian).read(self[attr].to_s)
+        end
+        %i[ver_major ver_minor].each do |attr|
+          self[attr] = Types::Int16.new(0, endian).read(self[attr].to_s)
+        end
+        self[:section_len] = Types::Int64.new(0, endian).read(self[:section_len].to_s)
       end
 
       # Check io contains a SHB
@@ -160,6 +152,21 @@ module PacketGen
         type = type_str.unpack('H*').join
         raise InvalidFileError, "Incorrect type (#{type})for Section Header Block"
       end
+
+      def handle_magic_and_check(magic_str)
+        case magic_str
+        when MAGIC_LITTLE
+          force_endianness :little if endian == :big
+        when MAGIC_BIG
+          force_endianness :big if endian == :little
+        else
+          raise InvalidFileError, 'Incorrect magic for Section Header Block'
+        end
+      end
+
+      def read_options(io)
+        self[:options].read io.read(self.block_len - MIN_SIZE)
+      end
     end
   end
 end

data/lib/packetgen/pcapng/spb.rb

@@ -44,7 +44,7 @@ module PacketGen
       # @option options [Integer] :block_len2 block total length
       def initialize(options={})
         super
-        set_endianness(options[:endian] || :little)
+        endianness(options[:endian] || :little)
         recalc_block_len
         self.type = options[:type] || PcapNG::SPB_TYPE.to_i
       end
@@ -66,19 +66,11 @@ module PacketGen
         self[:type].read io.read(4)
         self[:block_len].read io.read(4)
         self[:orig_len].read io.read(4)
-        # Take care of IDB snaplen
-        # CAUTION: snaplen == 0 -> no capture limit
-        data_len = if interface && interface.snaplen.to_i.positive?
-                     [self[:orig_len].to_i, interface.snaplen.to_i].min
-                   else
-                     self[:orig_len].to_i
-                   end
-        data_pad_len = (4 - (data_len % 4)) % 4
+        data_len = compute_data_len
         self[:data].read io.read(data_len)
-        io.read data_pad_len
-        self[:block_len2].read io.read(4)
+        remove_padding(io, data_len)
+        read_blocklen2_and_check(io)
 
-        check_len_coherency
         self.type ||= PcapNG::IDB_TYPE.to_i
         self
       end
@@ -90,6 +82,18 @@ module PacketGen
         recalc_block_len
         super
       end
+
+      private
+
+      # Take care of IDB snaplen
+      # CAUTION: snaplen == 0 -> no capture limit
+      def compute_data_len
+        if interface && interface.snaplen.to_i.positive?
+          [self[:orig_len].to_i, interface.snaplen.to_i].min
+        else
+          self[:orig_len].to_i
+        end
+      end
     end
   end
 end

data/lib/packetgen/pcapng/unknown_block.rb

@@ -29,7 +29,7 @@ module PacketGen
       # @option options [Integer] :block_len2 block total length
       def initialize(options={})
         super
-        set_endianness(options[:endian] || :little)
+        endianness(options[:endian] || :little)
         recalc_block_len
       end
 
@@ -44,21 +44,13 @@ module PacketGen
       # @param [::String,IO] str_or_io
       # @return [self]
       def read(str_or_io)
-        io = if str_or_io.respond_to? :read
-               str_or_io
-             else
-               StringIO.new(force_binary(str_or_io.to_s))
-             end
+        io = to_io(str_or_io)
         return self if io.eof?
 
         self[:type].read io.read(4)
         self[:block_len].read io.read(4)
         self[:body].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 Header Block'
-        end
+        read_blocklen2_and_check(io)
 
         self
       end

data/lib/packetgen/pcaprub_wrapper.rb

@@ -23,26 +23,42 @@ module PacketGen
     # @param [String] iface interface name
     # @param [Integer] snaplen
     # @param [Boolean] promisc
+    # @param [Boolean] monitor
     # @return [PCAPRUB::Pcap]
-    def self.open_iface(iface:, snaplen: DEFAULT_SNAPLEN, promisc: DEFAULT_PROMISC)
-      PCAPRUB::Pcap.open_live(iface, snaplen, promisc, TIMEOUT)
+    # @author Sylvain Daubert
+    # @author optix2000 - add support for setting monitor mode
+    # @since 3.1.5 add monitor argument
+    def self.open_iface(iface:, snaplen: DEFAULT_SNAPLEN, promisc: DEFAULT_PROMISC, monitor: nil)
+      pcap = PCAPRUB::Pcap.create(iface)
+      pcap.setsnaplen(snaplen)
+      pcap.setpromisc(promisc)
+      pcap.settimeout(TIMEOUT)
+      # Monitor MUST be set before pcap is activated
+      pcap.setmonitor monitor unless monitor.nil?
+      pcap.activate
     end
 
+    # rubocop:disable Metrics/ParameterLists
+
     # Capture packets from a network interface
     # @param [String] iface interface name
     # @param [Integer] snaplen
     # @param [Boolean] promisc
     # @param [String] filter BPF filter
+    # @param [Boolean] monitor
     # @yieldparam [String] packet_data binary packet data
     # @return [void]
-    def self.capture(iface:, snaplen: DEFAULT_SNAPLEN, promisc: DEFAULT_PROMISC, filter: nil)
-      pcap = self.open_iface(iface: iface, snaplen: snaplen, promisc: promisc)
+    # @author Sylvain Daubert
+    # @author optix2000 - add support for setting monitor mode
+    # @since 3.1.5 add monitor argument
+    def self.capture(iface:, snaplen: DEFAULT_SNAPLEN, promisc: DEFAULT_PROMISC, filter: nil, monitor: nil, &block)
+      pcap = self.open_iface(iface: iface, snaplen: snaplen, promisc: promisc, monitor: monitor)
       pcap.setfilter filter unless filter.nil?
-      pcap.each do |packet_data|
-        yield packet_data
-      end
+      pcap.each(&block)
     end
 
+    # rubocop:enable Metrics/ParameterLists
+
     # Inject given data onto wire
     # @param [String] iface interface name
     # @param [String] data to inject
@@ -58,10 +74,8 @@ module PacketGen
     # @yieldparam [String] data binary packet data
     # @return [void]
     # @author Kent Gruber
-    def self.read_pcap(filename:)
-      PCAPRUB::Pcap.open_offline(filename).each_packet do |packet|
-        yield packet
-      end
+    def self.read_pcap(filename:, &block)
+      PCAPRUB::Pcap.open_offline(filename).each_packet(&block)
     end
   end
 end

data/lib/packetgen/types.rb

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

data/lib/packetgen/types/abstract_tlv.rb

@@ -58,6 +58,8 @@ module PacketGen
     # @since 3.1.0
     # @since 3.1.1 add +:aliases+ keyword to {#initialize}
     class AbstractTLV < Types::Fields
+      include Fieldable
+
       class <<self
         # @return [Hash]
         attr_accessor :aliases
@@ -169,7 +171,7 @@ module PacketGen
       # @return [String]
       def to_human
         my_value = self[:value].is_a?(String) ? self[:value].inspect : self[:value].to_human
-        "type:%s,length:%u,value:#{my_value}" % [human_type, length]
+        'type:%s,length:%u,value:%s' % [human_type, length, my_value]
       end
 
       private

data/lib/packetgen/types/array.rb

@@ -27,6 +27,9 @@ module PacketGen
     # @author Sylvain Daubert
     class Array
       extend Forwardable
+      include Enumerable
+      include Fieldable
+      include LengthFrom
 
       # @!method [](index)
       #   Return the element at +index+.
@@ -54,9 +57,6 @@ module PacketGen
       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 = ','
@@ -163,11 +163,8 @@ module PacketGen
         return self if @counter&.to_i&.zero?
 
         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
+          obj = create_object_from_str(str)
           @array << obj
           str.slice!(0, obj.sz)
           break if @counter && self.size == @counter.to_i
@@ -203,9 +200,7 @@ module PacketGen
 
       def record_from_hash(hsh)
         obj_klass = self.class.set_of_klass
-        unless obj_klass
-          raise NotImplementedError, 'class should define #record_from_hash or declare type of elements in set with .set_of'
-        end
+        raise NotImplementedError, 'class should define #record_from_hash or declare type of elements in set with .set_of' unless obj_klass
 
         obj = obj_klass.new(hsh) if obj_klass
         klass = real_type(obj)
@@ -215,6 +210,18 @@ module PacketGen
       def real_type(obj)
         obj.class
       end
+
+      def create_object_from_str(str)
+        klass = self.class.set_of_klass
+        obj = klass.new.read(str)
+        real_klass = real_type(obj)
+
+        if real_klass == klass
+          obj
+        else
+          real_klass.new.read(str)
+        end
+      end
     end
 
     # Specialized array to handle serie of {Int8}.

data/lib/packetgen/types/cstring.rb

@@ -6,15 +6,30 @@
 # Copyright (C) 2016 Sylvain Daubert <sylvain.daubert@laposte.net>
 # This program is published under MIT license.
 
+require 'forwardable'
+
 module PacketGen
   module Types
     # This class handles null-terminated strings (aka C strings).
     # @author Sylvain Daubert
-    class CString < ::String
+    # @since 3.1.6 no more a subclass or regular String
+    class CString
+      extend Forwardable
+      include Fieldable
+
+      def_delegators :@string, :[], :length, :size, :inspect, :==,
+                     :unpack, :force_encoding, :encoding, :index, :empty?,
+                     :encode, :slice, :slice!
+
+      # @return [::String]
+      attr_reader :string
+      # @return [Integer]
+      attr_reader :static_length
+
       # @param [Hash] options
       # @option options [Integer] :static_length set a static length for this string
       def initialize(options={})
-        super()
+        register_internal_string(+'')
         @static_length = options[:static_length]
       end
 
@@ -22,38 +37,49 @@ module PacketGen
       # @return [String] self
       def read(str)
         s = str.to_s
-        s = s[0, @static_length] if @static_length.is_a? Integer
-        idx = s.index(0.chr)
-        s = s[0, idx] unless idx.nil?
-        self.replace s
+        s = s[0, static_length] if static_length?
+        register_internal_string s
+        remove_null_character
         self
       end
 
       # get null-terminated string
       # @return [String]
       def to_s
-        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)
-            PacketGen.force_binary s
-          else
-            PacketGen.force_binary(self + "\0" * (@static_length - self.length))
-          end
+        if static_length?
+          s = string[0, static_length - 1]
+          s << "\x00" * (static_length - s.length)
         else
-          PacketGen.force_binary(self + +"\x00".encode(self.encoding))
+          s = "#{string}\x00"
         end
+        PacketGen.force_binary(s)
+      end
+
+      # Append the given string to CString
+      # @param [#to_s] str
+      # @return [self]
+      def <<(str)
+        @string << str.to_s
+        remove_null_character
+        self
       end
 
       # @return [Integer]
       def sz
-        if @static_length.is_a? Integer
-          @static_length
+        if static_length?
+          static_length
         else
           to_s.size
         end
       end
 
+      # Say if a static length is defined
+      # @return [Boolean]
+      # @since 3.1.6
+      def static_length?
+        !static_length.nil?
+      end
+
       # Populate CString from a human readable string
       # @param [String] str
       # @return [self]
@@ -63,8 +89,19 @@ module PacketGen
 
       # @return [String]
       def to_human
-        idx = self.index(+"\x00".encode(self.encoding)) || self.sz
-        self[0, idx]
+        string
+      end
+
+      private
+
+      def register_internal_string(str)
+        @string = str
+        PacketGen.force_binary(@string)
+      end
+
+      def remove_null_character
+        idx = string.index(0.chr)
+        register_internal_string(string[0, idx]) unless idx.nil?
       end
     end
   end