packetgen 3.1.3 → 3.1.4

data/lib/packetgen/pcap.rb

@@ -0,0 +1,29 @@
+# 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.
+require_relative 'pcaprub_wrapper'
+
+module PacketGen
+  # Module to read PCAP files
+  # @author Sylvain Daubert
+  # @api private
+  # @since 3.1.4
+  module Pcap
+    # Read a PCAP file
+    # @param [String] filename
+    # @return [Array<Packet>]
+    # @author Kent Gruber
+    def self.read(filename)
+      packets = []
+      PCAPRUBWrapper.read_pcap(filename: filename) do |packet|
+        next unless (packet = PacketGen.parse(packet.to_s))
+
+        packets << packet
+      end
+      packets
+    end
+  end
+end

data/lib/packetgen/pcapng.rb

@@ -1,10 +1,10 @@
+# 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.
 
-# frozen_string_literal: true
-
 require 'stringio'
 
 module PacketGen

data/lib/packetgen/pcapng/block.rb

@@ -1,10 +1,10 @@
+# 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.
 
-# frozen_string_literal: true
-
 module PacketGen
   module PcapNG
     # @abstract Base class for all block types
@@ -34,7 +34,7 @@ module PacketGen
       # @return [Boolean]
       # @since 2.7.0
       def options?
-        @fields.key?(:options) && @fields[:options].sz > 0
+        @fields.key?(:options) && @fields[:options].sz.positive?
       end
 
       # Calculate block length and update :block_len and block_len2 fields
@@ -49,9 +49,7 @@ module PacketGen
       # @return [void]
       def pad_field(*fields)
         fields.each do |field|
-          unless (@fields[field].sz % 4).zero?
-            @fields[field] << "\x00" * (4 - (@fields[field].sz % 4))
-          end
+          @fields[field] << "\x00" * (4 - (@fields[field].sz % 4)) unless (@fields[field].sz % 4).zero?
         end
       end
 
@@ -62,9 +60,7 @@ module PacketGen
       # @param [:little, :big] endian
       # @return [:little, :big] returns endian
       def set_endianness(endian)
-        unless %i[little big].include? endian
-          raise ArgumentError, "unknown endianness for #{self.class}"
-        end
+        raise ArgumentError, "unknown endianness for #{self.class}" unless %i[little big].include?(endian)
 
         @endian = endian
         @fields.each { |_f, v| v.endian = endian if v.is_a?(Types::Int) }
@@ -72,9 +68,13 @@ module PacketGen
       end
 
       def check_len_coherency
-        unless self.block_len == self.block_len2
-          raise InvalidFileError, 'Incoherency in Block length'
-        end
+        raise InvalidFileError, 'Incoherency in Block length' unless self.block_len == self.block_len2
+      end
+
+      def to_io(str_or_io)
+        return str_or_io if str_or_io.respond_to? :read
+
+        StringIO.new(force_binary(str_or_io.to_s))
       end
     end
   end

data/lib/packetgen/pcapng/epb.rb

@@ -1,10 +1,10 @@
+# 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.
 
-# frozen_string_literal: true
-
 module PacketGen
   module PcapNG
     # {EPB} represents a Enhanced Packet Block (EPB) of a pcapng file.
@@ -82,11 +82,7 @@ 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)

data/lib/packetgen/pcapng/file.rb

@@ -1,10 +1,10 @@
+# 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.
 
-# frozen_string_literal: true
-
 module PacketGen
   module PcapNG
     # PcapNG::File is a complete Pcap-NG file handler.
@@ -20,6 +20,15 @@ module PacketGen
         LINKTYPE_IPV6 => 'IPv6'
       }.freeze
 
+      # @private
+      BLOCK_TYPES = Hash[
+        PcapNG.constants(false).select { |c| c.to_s =~ /_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
+          [type_value, klass]
+        end
+      ].freeze
+
       # Get file sections
       # @return [Array]
       attr_accessor :sections
@@ -57,9 +66,7 @@ module PacketGen
       # @return [Integer] return number of yielded blocks (only if a block is given)
       # @raise [ArgumentError] cannot read +fname+
       def readfile(fname, &blk)
-        unless ::File.readable?(fname)
-          raise ArgumentError, "cannot read file #{fname}"
-        end
+        raise ArgumentError, "cannot read file #{fname}" unless ::File.readable?(fname)
 
         ::File.open(fname, 'rb') do |f|
           parse_section(f) until f.eof?
@@ -153,29 +160,28 @@ module PacketGen
 
       # Translates a {File} into an array of packets.
       # @param [Hash] options
-      # @option options [String] :filename if given, object is cleared and filename
+      # @option options [String] :file if given, object is cleared and filename
       #   is analyzed before generating array. Else, array is generated from +self+
-      # @option options [String] :file same as +:filename+
       # @option options [Boolean] :keep_timestamps if +true+ (default value: +false+),
       #   generates an array of hashes, each one with timestamp as key and packet
       #   as value. There is one hash per packet.
-      # @option options [Boolean] :keep_ts same as +:keep_timestamp+
       # @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]
+
         filename = options[:filename] || options[:file]
-        if filename
-          clear
-          readfile filename
-        end
+        reread filename
 
         ary = []
         @sections.each do |section|
           section.interfaces.each do |itf|
-            if options[:keep_timestamps] || options[:keep_ts]
-              ary.concat(itf.packets.map { |pkt| { pkt.timestamp => pkt.data.to_s } })
-            else
-              ary.concat(itf.packets.map { |pkt| pkt.data.to_s })
-            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
+            ary.concat(itf.packets.map(&blk))
           end
         end
         ary
@@ -219,7 +225,7 @@ module PacketGen
       # @overload array_to_file(options={})
       #  Update {File} and/or write it to a file
       #  @param [Hash] options
-      #  @option options [String] :filename file written on disk only if given
+      #  @option options [String] :file file written on disk only if given
       #  @option options [Array] :array can either be an array of packet data,
       #                                 or a hash-value pair of timestamp => data.
       #  @option options [Time] :timestamp set an initial timestamp
@@ -229,53 +235,15 @@ module PacketGen
       #                                    the file
       #  @return [Array] see return value from {#to_file}
       def array_to_file(options={})
-        case options
-        when Hash
-          filename = options[:filename] || options[:file]
-          ary = options[:array] || options[:arr]
-          unless ary.is_a? Array
-            raise ArgumentError, ':array parameter needs to be an array'
-          end
-          ts = options[:timestamp] || options[:ts] || Time.now
-          ts_inc = options[:ts_inc] || 1
-          append = !options[:append].nil?
-        when Array
-          ary = options
-          ts = Time.now
-          ts_inc = 1
-          filename = nil
-          append = false
-        else
-          raise ArgumentError, 'unknown argument. Need either a Hash or Array'
-        end
+        filename, ary, ts, ts_inc, append = array_to_file_options(options)
 
-        section = SHB.new
-        @sections << section
-        itf = IDB.new(endian: section.endian)
-        classify_block section, itf
+        section = create_new_shb_section
+        ts_resol = section.interfaces.last.ts_resol
 
-        ary.each_with_index do |pkt, i|
-          case pkt
-          when Hash
-            this_ts = pkt.keys.first.to_i
-            this_cap_len = pkt.values.first.to_s.size
-            this_data = pkt.values.first.to_s
-          else
-            this_ts = (ts + ts_inc * i).to_i
-            this_cap_len = pkt.to_s.size
-            this_data = pkt.to_s
-          end
-          this_ts = (this_ts / itf.ts_resol).to_i
-          this_tsh = this_ts >> 32
-          this_tsl = this_ts & 0xffffffff
-          this_pkt = EPB.new(endian:       section.endian,
-                             interface_id: 0,
-                             tsh:          this_tsh,
-                             tsl:          this_tsl,
-                             cap_len:      this_cap_len,
-                             orig_len:     this_cap_len,
-                             data:         this_data)
-          classify_block section, this_pkt
+        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
         end
 
         if filename
@@ -288,53 +256,51 @@ module PacketGen
       private
 
       # Parse a section. A section is made of at least a SHB. It than may contain
-      # others blocks, such as  IDB, SPB or EPB.
+      # others blocks, such as IDB, SPB or EPB.
       # @param [IO] io
       # @return [void]
       def parse_section(io)
         shb = SHB.new
-        type = Types::Int32.new(0, shb.endian).read(io.read(4))
-        io.seek(-4, IO::SEEK_CUR)
-        shb = parse(type, io, shb)
+        shb = parse_shb(shb, io)
         raise InvalidFileError, 'no Section header found' unless shb.is_a?(SHB)
 
-        if shb.section_len.to_i != 0xffffffffffffffff
-          # Section length is defined
-          section = StringIO.new(io.read(shb.section_len.to_i))
-          until section.eof?
-            shb = @sections.last
-            type = Types::Int32.new(0, shb.endian).read(section.read(4))
-            section.seek(-4, IO::SEEK_CUR)
-            parse(type, section, shb)
-          end
-        else
-          # section length is undefined
-          until io.eof?
-            shb = @sections.last
-            type = Types::Int32.new(0, shb.endian).read(io.read(4))
-            io.seek(-4, IO::SEEK_CUR)
-            parse(type, io, shb)
-          end
+        to_parse = if shb.section_len.to_i != 0xffffffffffffffff
+                     # Section length is defined
+                     StringIO.new(io.read(shb.section_len.to_i))
+                   else
+                     # section length is undefined
+                     io
+                   end
+
+        until to_parse.eof?
+          shb = @sections.last
+          parse_shb shb, to_parse
         end
       end
 
+      # Parse a SHB
+      # @param [SHB] shb SHB to parse
+      # @param [IO] io stream from which parse SHB
+      # @return [SHB]
+      def parse_shb(shb, io)
+        type = Types::Int32.new(0, shb.endian).read(io.read(4))
+        io.seek(-4, IO::SEEK_CUR)
+        parse(type, io, shb)
+      end
+
       # Parse a block from its type
       # @param [Types::Int32] type
       # @param [IO] io stream from which parse block
       # @param [SHB] shb header of current section
-      # @return [void]
+      # @return [Block]
       def parse(type, io, shb)
-        types = PcapNG.constants(false).select { |c| c.to_s =~ /_TYPE/ }
-                      .map { |c| [PcapNG.const_get(c).to_i, c] }
-        types = Hash[types]
-
-        if types.key?(type.to_i)
-          klass = PcapNG.const_get(types[type.to_i].to_s.gsub(/_TYPE/, '').to_sym)
-          block = klass.new(endian: shb.endian)
-        else
-          block = UnknownBlock.new(endian: shb.endian)
-        end
+        klass = if BLOCK_TYPES.key?(type.to_i)
+                  BLOCK_TYPES[type.to_i]
+                else
+                  UnknownBlock
+                end
 
+        block = klass.new(endian: shb.endian)
         classify_block shb, block
         block.read(io)
       end
@@ -361,6 +327,79 @@ module PacketGen
           block.section = shb
         end
       end
+
+      def array_to_file_options(options)
+        case options
+        when Hash
+          array_to_file_options_from_hash(options)
+        when Array
+          [nil, options, Time.now, 1, false]
+        else
+          raise ArgumentError, 'unknown argument. Need either a Hash or Array'
+        end
+      end
+
+      # 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]
+
+        filename = options[:filename] || options[:file]
+        ary = options[:array] || options[:arr]
+        raise ArgumentError, ':array parameter needs to be an array' unless ary.is_a? Array
+
+        ts = options[:timestamp] || options[:ts] || Time.now
+        ts_inc = options[:ts_inc] || 1
+        append = !options[:append].nil?
+
+        [filename, ary, ts, ts_inc, append]
+      end
+
+      def create_new_shb_section
+        section = SHB.new
+        @sections << section
+        itf = IDB.new(endian: section.endian)
+        classify_block section, itf
+
+        section
+      end
+
+      # 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]
+      end
+
+      def reread(filename)
+        return if filename.nil?
+
+        clear
+        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
+        else
+          this_ts = (ts + ts_add_val).to_i
+          this_data = pkt.to_s
+        end
+        this_cap_len = this_data.size
+        this_tsh, this_tsl = calc_ts(this_ts, ts_resol)
+        EPB.new(endian: endian,
+                interface_id: 0,
+                tsh: this_tsh,
+                tsl: this_tsl,
+                cap_len: this_cap_len,
+                orig_len: this_cap_len,
+                data: this_data)
+      end
     end
   end
 end

data/lib/packetgen/pcapng/idb.rb

@@ -1,10 +1,10 @@
+# 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.
 
-# frozen_string_literal: true
-
 module PacketGen
   module PcapNG
     # {IDB} represents a Interface Description Block (IDB) of a pcapng file.
@@ -71,11 +71,7 @@ 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)
@@ -105,29 +101,7 @@ module PacketGen
         if @options_decoded && !force
           @ts_resol
         else
-          packstr = endian == :little ? 'v' : 'n'
-          idx = 0
-          options = self[:options]
-
-          while idx < options.length
-            opt_code, opt_len = options[idx, 4].unpack("#{packstr}2")
-            if opt_code == OPTION_IF_TSRESOL && opt_len == 1
-              tsresol = options[idx + 4, 1].unpack('C').first
-              @ts_resol = if (tsresol & 0x80).zero?
-                            10**-tsresol
-                          else
-                            2**-(tsresol & 0x7f)
-                          end
-
-              @options_decoded = true
-              return @ts_resol
-            else
-              idx += 4 + opt_len
-            end
-          end
-
-          @options_decoded = true
-          @ts_resol = 1E-6 # default value
+          decode_ts_resol
         end
       end
 
@@ -138,6 +112,32 @@ module PacketGen
         recalc_block_len
         super << @packets.map(&:to_s).join
       end
+
+      private
+
+      def decode_ts_resol
+        tsresol = search_for_ts_resol_opt(self[:options])
+        @options_decoded = true
+        return @ts_resol = 1E-6 if tsresol.nil?
+
+        @ts_resol = if (tsresol & 0x80).zero?
+                      10**-tsresol
+                    else
+                      2**-(tsresol & 0x7f)
+                    end
+      end
+
+      def search_for_ts_resol_opt(options)
+        packstr = endian == :little ? 'v' : 'n'
+        idx = 0
+
+        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
+
+          idx += 4 + opt_len
+        end
+      end
     end
   end
 end