packetgen 3.1.4 → 3.2.0

data/lib/packetgen/packet.rb

@@ -6,6 +6,8 @@
 # Copyright (C) 2016 Sylvain Daubert <sylvain.daubert@laposte.net>
 # This program is published under MIT license.
 
+# rubocop:disable Metrics/ClassLength
+
 module PacketGen
   # An object of type {Packet} handles a network packet. This packet may contain
   # multiple protocol headers, starting from MAC layer or from Network (OSI) layer.
@@ -77,10 +79,10 @@ module PacketGen
     # @yieldparam [Packet,String] packet if a block is given, yield each
     #    captured packet (Packet or raw data String, depending on +:parse+ option)
     # @return [Array<Packet>] captured packet
-    def self.capture(**kwargs)
-      capture = Capture.new(kwargs)
-      if block_given?
-        capture.start { |packet| yield packet }
+    def self.capture(**kwargs, &block)
+      capture = Capture.new(**kwargs)
+      if block
+        capture.start(&block)
       else
         capture.start
       end
@@ -214,7 +216,7 @@ module PacketGen
     # @return [Array] see return from {PcapNG::File#to_file}
     # @see File
     def to_f(filename)
-      PcapNG::File.new.array_to_file(file: filename, array: [self])
+      PcapNG::File.new.read_array([self]).to_f(filename)
     end
     alias write to_f
 
@@ -285,7 +287,7 @@ module PacketGen
       if first_header.nil?
         # No decoding forced for first header. Have to guess it!
         first_header = guess_first_header(binary_str)
-        raise ParseError, 'cannot identify first header in string' if first_header.nil?
+        raise ParseError, "cannot identify first header in string: #{binary_str.inspect}" if first_header.nil?
       end
 
       add first_header
@@ -522,5 +524,7 @@ module PacketGen
   end
 end
 
+# rubocop:enable Metrics/ClassLength
+
 require_relative 'headerable'
 require_relative 'header'

data/lib/packetgen/pcapng.rb

@@ -13,13 +13,13 @@ module PacketGen
   # @author Sylvain Daubert
   module PcapNG
     # Section Header Block type number
-    SHB_TYPE = Types::Int32.new(0x0A0D0D0A, :little)
+    SHB_TYPE = Types::Int32.new(0x0A0D0D0A, :little).freeze
     # Interface Description Block type number
-    IDB_TYPE = Types::Int32.new(1, :little)
+    IDB_TYPE = Types::Int32.new(1, :little).freeze
     # Simple Packet Block type number
-    SPB_TYPE = Types::Int32.new(3, :little)
+    SPB_TYPE = Types::Int32.new(3, :little).freeze
     # Enhanced Packet Block type number
-    EPB_TYPE = Types::Int32.new(6, :little)
+    EPB_TYPE = Types::Int32.new(6, :little).freeze
 
     # IEEE 802.3 Ethernet (10Mb, 100Mb, 1000Mb, and up)
     LINKTYPE_ETHERNET = 1
@@ -46,10 +46,10 @@ module PacketGen
   end
 end
 
-require_relative 'pcapng/block.rb'
-require_relative 'pcapng/unknown_block.rb'
-require_relative 'pcapng/shb.rb'
-require_relative 'pcapng/idb.rb'
-require_relative 'pcapng/epb.rb'
-require_relative 'pcapng/spb.rb'
-require_relative 'pcapng/file.rb'
+require_relative 'pcapng/block'
+require_relative 'pcapng/unknown_block'
+require_relative 'pcapng/shb'
+require_relative 'pcapng/idb'
+require_relative 'pcapng/epb'
+require_relative 'pcapng/spb'
+require_relative 'pcapng/file'

data/lib/packetgen/pcapng/block.rb

@@ -49,7 +49,9 @@ module PacketGen
       # @return [void]
       def pad_field(*fields)
         fields.each do |field|
-          @fields[field] << "\x00" * (4 - (@fields[field].sz % 4)) unless (@fields[field].sz % 4).zero?
+          obj = @fields[field]
+          pad_size = (obj.sz % 4).zero? ? 0 : (4 - (obj.sz % 4))
+          obj << "\x00" * pad_size
         end
       end
 
@@ -59,7 +61,7 @@ module PacketGen
       # Must be called by all subclass #initialize method.
       # @param [:little, :big] endian
       # @return [:little, :big] returns endian
-      def set_endianness(endian)
+      def endianness(endian)
         raise ArgumentError, "unknown endianness for #{self.class}" unless %i[little big].include?(endian)
 
         @endian = endian
@@ -76,6 +78,17 @@ module PacketGen
 
         StringIO.new(force_binary(str_or_io.to_s))
       end
+
+      def remove_padding(io, data_len)
+        data_pad_len = (4 - (data_len % 4)) % 4
+        io.read data_pad_len
+        data_pad_len
+      end
+
+      def read_blocklen2_and_check(io)
+        self[:block_len2].read io.read(4)
+        check_len_coherency
+      end
     end
   end
 end

data/lib/packetgen/pcapng/epb.rb

@@ -73,7 +73,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::EPB_TYPE.to_i
       end
@@ -85,22 +85,13 @@ 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[:interface_id].read io.read(4)
-        self[:tsh].read io.read(4)
-        self[:tsl].read io.read(4)
-        self[:cap_len].read io.read(4)
-        self[:orig_len].read io.read(4)
+        %i[type block_len interface_id tsh tsl cap_len orig_len].each do |attr|
+          self[attr].read io.read(self[attr].sz)
+        end
         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 - self.cap_len - data_pad_len
-        options_len -= MIN_SIZE
-        self[:options].read io.read(options_len)
-        self[:block_len2].read io.read(4)
+        read_options(io)
+        read_blocklen2_and_check(io)
 
-        check_len_coherency
         self
       end
 
@@ -110,6 +101,16 @@ module PacketGen
         Time.at((self.tsh << 32 | self.tsl) * ts_resol)
       end
 
+      # Set timestamp from a Time object
+      # @param [Time] time
+      # @return [Time] time
+      def timestamp=(time)
+        tstamp = (time.to_r / ts_resol).to_i
+        self.tsh = (tstamp & 0xffffffff00000000) >> 32
+        self.tsl = tstamp & 0xffffffff
+        time
+      end
+
       # Return the object as a String
       # @return [String]
       def to_s
@@ -127,6 +128,12 @@ module PacketGen
           @interface.ts_resol
         end
       end
+
+      def read_options(io)
+        data_pad_len = remove_padding(io, self.cap_len)
+        options_len = self.block_len - self.cap_len - data_pad_len - MIN_SIZE
+        self[:options].read io.read(options_len)
+      end
     end
   end
 end

data/lib/packetgen/pcapng/file.rb

@@ -22,9 +22,9 @@ module PacketGen
 
       # @private
       BLOCK_TYPES = Hash[
-        PcapNG.constants(false).select { |c| c.to_s =~ /_TYPE/ }.map do |c|
+        PcapNG.constants(false).select { |c| c.to_s.include?('_TYPE') }.map do |c|
           type_value = PcapNG.const_get(c).to_i
-          klass = PcapNG.const_get(c.to_s[0..-6]) # use delete_suffix('_TYPE') when support for Ruby 2.4 will stop
+          klass = PcapNG.const_get(c.to_s[0..-6]) # @todo use delete_suffix('_TYPE') when support for Ruby 2.4 will stop
           [type_value, klass]
         end
       ].freeze
@@ -68,20 +68,13 @@ module PacketGen
       def readfile(fname, &blk)
         raise ArgumentError, "cannot read file #{fname}" unless ::File.readable?(fname)
 
-        ::File.open(fname, 'rb') do |f|
-          parse_section(f) until f.eof?
-        end
-
+        ::File.open(fname, 'rb') { |f| parse_section(f) until f.eof? }
         return unless blk
 
         count = 0
-        @sections.each do |section|
-          section.interfaces.each do |intf|
-            intf.packets.each do |pkt|
-              count += 1
-              yield pkt
-            end
-          end
+        each_packet_with_interface do |pkt, _itf|
+          count += 1
+          yield pkt
         end
         count
       end
@@ -98,12 +91,10 @@ module PacketGen
       #  @return [Integer] number of packets
       # @raise [ArgumentError] cannot read +fname+
       def read_packet_bytes(fname, &blk)
-        count = 0
         packets = [] unless blk
 
-        readfile(fname) do |packet|
+        count = readfile(fname) do |packet|
           if blk
-            count += 1
             yield packet.data.to_s, packet.interface.link_type
           else
             packets << packet.data.to_s
@@ -124,19 +115,11 @@ module PacketGen
       #  @return [Integer] number of packets
       # @raise [ArgumentError] cannot read +fname+
       def read_packets(fname, &blk)
-        count = 0
         packets = [] unless blk
 
-        read_packet_bytes(fname) do |packet, link_type|
-          first_header = KNOWN_LINK_TYPES[link_type]
-          parsed_pkt = if first_header.nil?
-                         # unknown link type, try to guess
-                         Packet.parse(packet)
-                       else
-                         Packet.parse(packet, first_header: first_header)
-                       end
+        count = read_packet_bytes(fname) do |packet, link_type|
+          parsed_pkt = parse_packet(packet, link_type)
           if blk
-            count += 1
             yield parsed_pkt
           else
             packets << parsed_pkt
@@ -158,6 +141,8 @@ module PacketGen
         @sections.clear
       end
 
+      # @deprecated
+      #  Prefer use of {#to_a} or {#to_h}.
       # Translates a {File} into an array of packets.
       # @param [Hash] options
       # @option options [String] :file if given, object is cleared and filename
@@ -167,37 +152,59 @@ module PacketGen
       #   as value. There is one hash per packet.
       # @return [Array<Packet>,Array<Hash>]
       def file_to_array(options={})
-        Deprecation.deprecated_option(self.class, __method__, :filename) if options[:filename]
-        Deprecation.deprecated_option(self.class, __method__, :keep_ts) if options[:keep_ts]
+        Deprecation.deprecated(self.class, __method__)
 
-        filename = options[:filename] || options[:file]
-        reread filename
+        file = options[:file] || options[:filename]
+        reread file
 
         ary = []
-        @sections.each do |section|
-          section.interfaces.each do |itf|
-            blk = if options[:keep_timestamps] || options[:keep_ts]
-                    proc { |pkt| { pkt.timestamp => pkt.data.to_s } }
-                  else
-                    proc { |pkt| pkt.data.to_s }
-                  end
-            ary.concat(itf.packets.map(&blk))
-          end
+        blk = if options[:keep_timestamps] || options[:keep_ts]
+                proc { |pkt| { pkt.timestamp => pkt.data.to_s } }
+              else
+                proc { |pkt| pkt.data.to_s }
+              end
+        each_packet_with_interface do |pkt, _itf|
+          ary << blk.call(pkt)
         end
+
+        ary
+      end
+
+      # Translates a {File} into an array of packets.
+      # @return [Array<Packet>]
+      # @since 3.1.6
+      def to_a
+        ary = []
+        each_packet_with_interface do |pkt, itf|
+          ary << parse_packet(pkt.data.to_s, itf.link_type)
+        end
+
         ary
       end
 
+      # Translates a {File} into a hash with timestamps as keys.
+      # @note Only packets from {EPB} sections are extracted, as {SPB} ones do not have timestamp.
+      # @return [Hash{Time => Packet}]
+      # @since 3.1.6
+      def to_h
+        hsh = {}
+        each_packet_with_interface do |pkt, itf|
+          next if pkt.is_a?(SPB)
+
+          hsh[pkt.timestamp] = parse_packet(pkt.data.to_s, itf.link_type)
+        end
+
+        hsh
+      end
+
       # Writes the {File} to a file.
       # @param [Hash] options
       # @option options [Boolean] :append (default: +false+) if set to +true+,
       #   the packets are appended to the file, rather than overwriting it
       # @return [Array] array of 2 elements: filename and size written
+      # @todo for 4.0, replace +options+ by +append+ kwarg
       def to_file(filename, options={})
-        mode = if options[:append] && ::File.exist?(filename)
-                 'ab'
-               else
-                 'wb'
-               end
+        mode = (options[:append] && ::File.exist?(filename)) ? 'ab' : 'wb'
         ::File.open(filename, mode) { |f| f.write(self.to_s) }
         [filename, self.to_s.size]
       end
@@ -217,6 +224,7 @@ module PacketGen
         self.to_file(filename.to_s, append: true)
       end
 
+      # @deprecated Prefer use of {#read_array} or {#read_hash}.
       # @overload array_to_file(ary)
       #  Update {File} object with packets.
       #  @param [Array] ary as generated by {#file_to_array} or Array of Packet objects.
@@ -238,12 +246,10 @@ module PacketGen
         filename, ary, ts, ts_inc, append = array_to_file_options(options)
 
         section = create_new_shb_section
-        ts_resol = section.interfaces.last.ts_resol
 
-        ts_add_val = 0 # value to add to ts in Array case
         ary.each do |pkt|
-          classify_block(section, epb_from_pkt(pkt, section.endian, ts, ts_resol, ts_add_val))
-          ts_add_val += ts_inc
+          classify_block(section, epb_from_pkt(pkt, section, ts))
+          ts += ts_inc
         end
 
         if filename
@@ -253,6 +259,54 @@ module PacketGen
         end
       end
 
+      # Update current object from an array of packets
+      # @param [Array<Packet>] packets
+      # @param [Time, nil] timestamp initial timestamp, used for first packet
+      # @param [Numeric, nil] ts_inc timestamp increment, in seconds, to increment
+      #                       initial timestamp for each packet
+      # @return [self]
+      # @note if +timestamp+ and/or +ts_inc+ are nil, {SPB} sections are created
+      #  for each packet, else {EPB} ones are used
+      # @since 3.1.6
+      def read_array(packets, timestamp: nil, ts_inc: nil)
+        ts = timestamp
+        section = create_new_shb_section
+        packets.each do |pkt|
+          block = create_block_from_pkt(pkt, section, ts, ts_inc)
+          classify_block(section, block)
+          ts = update_ts(ts, ts_inc)
+        end
+        self
+      end
+
+      # Update current object from a hash of packets and timestamps
+      # @param [Hash{Time => Packet}] hsh
+      # @return [self]
+      # @since 3.1.6
+      def read_hash(hsh)
+        section = create_new_shb_section
+        hsh.each do |ts, pkt|
+          block = create_block_from_pkt(pkt, section, ts, 0)
+          classify_block(section, block)
+        end
+        self
+      end
+
+      # @return [String]
+      # @since 3.1.6
+      def inspect
+        str = +''
+        sections.each do |section|
+          str << section.inspect
+          section.interfaces.each do |itf|
+            str << itf.inspect
+            itf.packets.each { |block| str << block.inspect }
+          end
+        end
+
+        str
+      end
+
       private
 
       # Parse a section. A section is made of at least a SHB. It than may contain
@@ -260,8 +314,7 @@ module PacketGen
       # @param [IO] io
       # @return [void]
       def parse_section(io)
-        shb = SHB.new
-        shb = parse_shb(shb, io)
+        shb = parse_shb(SHB.new, io)
         raise InvalidFileError, 'no Section header found' unless shb.is_a?(SHB)
 
         to_parse = if shb.section_len.to_i != 0xffffffffffffffff
@@ -294,17 +347,18 @@ module PacketGen
       # @param [SHB] shb header of current section
       # @return [Block]
       def parse(type, io, shb)
-        klass = if BLOCK_TYPES.key?(type.to_i)
-                  BLOCK_TYPES[type.to_i]
-                else
-                  UnknownBlock
-                end
-
-        block = klass.new(endian: shb.endian)
+        block = guess_block_type(type).new(endian: shb.endian)
         classify_block shb, block
         block.read(io)
       end
 
+      # Guess class to use from type
+      # @param [Types::Int] type
+      # @return [Block]
+      def guess_block_type(type)
+        BLOCK_TYPES.key?(type.to_i) ? BLOCK_TYPES[type.to_i] : UnknownBlock
+      end
+
       # Classify block from its type
       # @param [SHB] shb header of current section
       # @param [Block] block block to classify
@@ -315,16 +369,11 @@ module PacketGen
           @sections << block
         when IDB
           shb << block
-          block.section = shb
-        when EPB
-          shb.interfaces[block.interface_id] << block
-          block.interface = shb.interfaces[block.interface_id]
-        when SPB
-          shb.interfaces[0] << block
-          block.interface = shb.interfaces[0]
+        when SPB, EPB
+          ifid = block.is_a?(EPB) ? block.interface_id : 0
+          shb.interfaces[ifid] << block
         else
-          shb.unknown_blocks << block
-          block.section = shb
+          shb.add_unknown_block(block)
         end
       end
 
@@ -341,9 +390,9 @@ module PacketGen
 
       # Extract and check options for #array_to_file
       def array_to_file_options_from_hash(options)
-        Deprecation.deprecated_option(self.class, :array_to_file, :filename) if options[:filename]
-        Deprecation.deprecated_option(self.class, :array_to_file, :arr) if options[:arr]
-        Deprecation.deprecated_option(self.class, :array_to_file, :ts) if options[:ts]
+        %i[filename arr ts].each do |deprecated_opt|
+          Deprecation.deprecated_option(self.class, :array_to_file, deprecated_opt) if options[deprecated_opt]
+        end
 
         filename = options[:filename] || options[:file]
         ary = options[:array] || options[:arr]
@@ -368,10 +417,8 @@ module PacketGen
       # Compute tsh and tsl from ts
       def calc_ts(timeslot, ts_resol)
         this_ts = (timeslot / ts_resol).to_i
-        this_tsh = this_ts >> 32
-        this_tsl = this_ts & 0xffffffff
 
-        [this_tsh, this_tsl]
+        [this_ts >> 32, this_ts & 0xffffffff]
       end
 
       def reread(filename)
@@ -381,18 +428,34 @@ module PacketGen
         readfile filename
       end
 
-      def epb_from_pkt(pkt, endian, ts, ts_resol, ts_add_val)
-        case pkt
-        when Hash
-          this_ts = pkt.keys.first.to_i
-          this_data = pkt.values.first.to_s
+      def create_block_from_pkt(pkt, section, timestamp, ts_inc)
+        if timestamp.nil? || ts_inc.nil?
+          spb_from_pkt(pkt, section)
         else
-          this_ts = (ts + ts_add_val).to_i
-          this_data = pkt.to_s
+          epb_from_pkt(pkt, section, timestamp)
         end
+      end
+
+      def spb_from_pkt(pkt, section)
+        pkt_s = pkt.to_s
+        size = pkt_s.size
+        SPB.new(endian: section.endian,
+                block_len: size,
+                orig_len: size,
+                data: pkt_s)
+      end
+
+      # @todo remove hash case when #array_to_file will be removed
+      def epb_from_pkt(pkt, section, timestamp)
+        this_ts, this_data = case pkt
+                             when Hash
+                               [pkt.keys.first.to_i, pkt.values.first.to_s]
+                             else
+                               [timestamp.to_r, pkt.to_s]
+                             end
         this_cap_len = this_data.size
-        this_tsh, this_tsl = calc_ts(this_ts, ts_resol)
-        EPB.new(endian: endian,
+        this_tsh, this_tsl = calc_ts(this_ts, section.interfaces.last.ts_resol)
+        EPB.new(endian: section.endian,
                 interface_id: 0,
                 tsh: this_tsh,
                 tsl: this_tsl,
@@ -400,6 +463,28 @@ module PacketGen
                 orig_len: this_cap_len,
                 data: this_data)
       end
+
+      def update_ts(timestamp, ts_inc)
+        return nil if timestamp.nil? || ts_inc.nil?
+
+        timestamp + ts_inc
+      end
+
+      # Iterate over each xPB with its associated interface
+      # @return [void]
+      # @yieldparam [String] xpb
+      # @yieldparam [IDB] itf
+      def each_packet_with_interface
+        sections.each do |section|
+          section.interfaces.each do |itf|
+            itf.packets.each { |xpb| yield xpb, itf }
+          end
+        end
+      end
+
+      def parse_packet(data, link_type)
+        Packet.parse(data, first_header: KNOWN_LINK_TYPES[link_type])
+      end
     end
   end
 end