packetgen 3.1.1 → 3.1.6

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.
@@ -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
@@ -71,22 +71,15 @@ 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[: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
 
@@ -95,6 +88,7 @@ module PacketGen
       # @return [self]
       def <<(xpb)
         @packets << xpb
+        xpb.interface = self
         self
       end
 
@@ -105,29 +99,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 +110,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].unpack1('C') if opt_code == OPTION_IF_TSRESOL && opt_len == 1
+
+          idx += 4 + opt_len
+        end
+      end
     end
   end
 end

data/lib/packetgen/pcapng/shb.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
     # {SHB} represents a Section Header Block (SHB) of a pcapng file.
@@ -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
@@ -89,51 +89,18 @@ 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?
 
-        type_str = io.read(4)
-        unless type_str == PcapNG::SHB_TYPE.to_s
-          type = type_str.unpack('H*').join
-          raise InvalidFileError, "Incorrect type (#{type})for Section Header Block"
-        end
-
-        block_len_str = io.read(4)
-
-        magic_str = io.read(4)
-        case @endian
-        when :little
-          case magic_str
-          when MAGIC_LITTLE
-          when MAGIC_BIG
-            force_endianness :big
-          else
-            raise InvalidFileError, 'Incorrect magic for Section Header Block'
-          end
-        when :big
-          case magic_str
-          when MAGIC_BIG
-          when MAGIC_LITTLE
-            force_endianness :little
-          else
-            raise InvalidFileError, 'Incorrect magic for Section Header Block'
-          end
+        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
 
@@ -142,6 +109,7 @@ module PacketGen
       # @return [self]
       def <<(idb)
         @interfaces << idb
+        idb.section = self
         self
       end
 
@@ -149,25 +117,55 @@ module PacketGen
       # @return [String]
       def to_s
         body = @interfaces.map(&:to_s).join
-        unless self.section_len == SECTION_LEN_UNDEFINED
-          self.section_len = body.size
-        end
+        self.section_len = body.size unless self.section_len == SECTION_LEN_UNDEFINED
+
         pad_field :options
         recalc_block_len
         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
+      # @param [IO] io
+      # @return [String] type string
+      def check_shb(io)
+        type_str = io.read(4)
+        return type_str if type_str == PcapNG::SHB_TYPE.to_s
+
+        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

data/lib/packetgen/pcapng/spb.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
     # {SPB} represents a Section Simple Packet Block (SPB) of a pcapng file.
@@ -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
@@ -60,29 +60,17 @@ 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[: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 > 0)
-                     [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
@@ -94,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

@@ -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
     # {UnknownBlock} is used to handle unsupported blocks of a pcapng file.
@@ -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

@@ -0,0 +1,81 @@
+# 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 'pcaprub'
+
+module PacketGen
+  # Wrapper around PCAPRUB
+  # @author Sylvain Daubert
+  # @api private
+  # @since 3.1.4
+  module PCAPRUBWrapper
+    # timeout for PCAPRUB
+    TIMEOUT = 1
+    # Default snaplen to use
+    DEFAULT_SNAPLEN = 0xffff
+    # Default promisc value to use
+    DEFAULT_PROMISC = false
+
+    # Open an interface for capturing
+    # @param [String] iface interface name
+    # @param [Integer] snaplen
+    # @param [Boolean] promisc
+    # @param [Boolean] monitor
+    # @return [PCAPRUB::Pcap]
+    # @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]
+    # @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(&block)
+    end
+
+    # rubocop:enable Metrics/ParameterLists
+
+    # Inject given data onto wire
+    # @param [String] iface interface name
+    # @param [String] data to inject
+    # @return [void]
+    def self.inject(iface:, data:)
+      pcap = self.open_iface(iface: iface)
+      pcap.inject(data)
+      pcap.close
+    end
+
+    # Read a PCAP file
+    # @param [String] filename
+    # @yieldparam [String] data binary packet data
+    # @return [void]
+    # @author Kent Gruber
+    def self.read_pcap(filename:, &block)
+      PCAPRUB::Pcap.open_offline(filename).each_packet(&block)
+    end
+  end
+end