packetgen 3.1.3 → 3.1.8

data/lib/packetgen/header/tcp.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 Header
     # TCP header ({https://tools.ietf.org/html/rfc793 RFC 793})
@@ -121,7 +121,7 @@ module PacketGen
       # @!attribute options
       #  TCP options
       #  @return [Options]
-      define_field :options, TCP::Options
+      define_field :options, TCP::Options, builder: ->(h, t) { t.new(length_from: -> { h.data_offset > 5 ? (h.data_offset - 5) * 4 : 0 }) }
       # @!attribute body
       #  @return [Types::String,Header::Base]
       define_field :body, Types::String
@@ -189,25 +189,6 @@ module PacketGen
       #  @return [Boolean] 1-bit FIN flag
       define_bit_fields_on :u16, :_, 7, :flag_ns, :flag_cwr, :flag_ece, :flag_urg,
                            :flag_ack, :flag_psh, :flag_rst, :flag_syn, :flag_fin
-      # Read a TCP header from a string
-      # @param [String] str binary string
-      # @return [self]
-      def read(str)
-        return self if str.nil?
-
-        force_binary str
-        self[:sport].read str[0, 2]
-        self[:dport].read str[2, 2]
-        self[:seqnum].read str[4, 4]
-        self[:acknum].read str[8, 4]
-        self[:u16].read str[12, 2]
-        self[:window].read str[14, 2]
-        self[:checksum].read str[16, 2]
-        self[:urg_pointer].read str[18, 2]
-        self[:options].read str[20, (self.data_offset - 5) * 4] if self.data_offset > 5
-        self[:body].read str[self.data_offset * 4..-1]
-        self
-      end
 
       # Compute checksum and set +checksum+ field
       # @return [Integer]
@@ -235,7 +216,7 @@ module PacketGen
           doff = Inspect.int_dec_hex(data_offset, 1)
           str << shift << Inspect::FMT_ATTR % ['', 'data_offset', doff]
           str << shift << Inspect::FMT_ATTR % ['', 'reserved', reserved]
-          flags = ''.dup
+          flags = +''
           %w[ns cwr ece urg ack psh rst syn fin].each do |fl|
             flags << (send("flag_#{fl}?") ? fl[0].upcase : '.')
           end

data/lib/packetgen/header/tcp/option.rb

@@ -1,16 +1,18 @@
+# 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 Header
     class TCP
       # Base class to describe a TCP option
       # @author Sylvain Daubert
       class Option < Types::Fields
+        include Types::Fieldable
+
         # EOL option value
         EOL_KIND       = 0
         # NOP option value
@@ -91,15 +93,15 @@ module PacketGen
         # Setter for value attribute
         # @param[String,Integer]
         # @return [String, Integer]
-        def value=(v)
+        def value=(val)
           case self[:value]
           when Types::Int
             self.length = 2 + self[:value].sz
-          when String
-            self.length = 2 + Types::String.new.read(v).sz
+          when Types::String
+            self.length = 2 + Types::String.new.read(val).sz
           end
-          self[:value].read v
-          v
+          self[:value].read val
+          val
         end
 
         # Get binary string
@@ -112,10 +114,8 @@ module PacketGen
         # Get option as a human readable string
         # @return [String]
         def to_human
-          str = self.class == Option ? +"unk-#{kind}" : self.class.to_s.sub(/.*::/, '')
-          if (length > 2) && !self[:value].to_s.empty?
-            str << ":#{self[:value].to_s.inspect}"
-          end
+          str = self.instance_of?(Option) ? +"unk-#{kind}" : self.class.to_s.sub(/.*::/, '')
+          str << ":#{self[:value].to_s.inspect}" if (length > 2) && !self[:value].to_s.empty?
           str
         end
 

data/lib/packetgen/header/tcp/options.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_relative 'option'
 
 module PacketGen

data/lib/packetgen/header/tftp.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 Header
     # A TFTP (Trivial File Transfer Protocol,
@@ -49,10 +49,10 @@ module PacketGen
     class TFTP < Base
       # Known opcodes
       OPCODES = {
-        'RRQ'   => 1,
-        'WRQ'   => 2,
-        'DATA'  => 3,
-        'ACK'   => 4,
+        'RRQ' => 1,
+        'WRQ' => 2,
+        'DATA' => 3,
+        'ACK' => 4,
         'Error' => 5
       }.freeze
 

data/lib/packetgen/header/udp.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 Header
     # UDP header ({https://tools.ietf.org/html/rfc768 RFC 768})
@@ -71,7 +71,7 @@ module PacketGen
       # option is set.
       def initialize(options={})
         super
-        self.length += self[:body].sz if self[:body].sz > 0
+        self.length += self[:body].sz if self[:body].sz.positive?
       end
 
       # Compute checksum and set +checksum+ field

data/lib/packetgen/headerable.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
   # This mixin module defines minimal API for a class to act as a header
   # in {Packet}.
@@ -85,9 +85,10 @@ module PacketGen
     # @return [self]
     # @raise [NotImplementedError]
     def read(str)
+      # Do not call super and rescue NoMethodError: too slow
+      raise NotImplementedError, "#{self.class} should implement #read" if method(:read).super_method.nil?
+
       super
-    rescue NoMethodError
-      raise NotImplementedError, "#{self.class} should implement #read"
     end
   end
 end

data/lib/packetgen/inject.rb

@@ -0,0 +1,23 @@
+# 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 inject packets on wire
+  # @author Sylvain Daubert
+  # @api private
+  # @since 3.1.4
+  module Inject
+    # Inject given data onto wire
+    # @param [String] iface interface name
+    # @param [String,Packet,Header::Base] data to inject
+    # @return [void]
+    def self.inject(iface:, data:)
+      PCAPRUBWrapper.inject(iface: iface, data: data.to_s)
+    end
+  end
+end

data/lib/packetgen/inspect.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
   # {Inspect} module provides methods to help writing +inspect+
   # @api private
@@ -37,6 +37,25 @@ module PacketGen
       "%-16s (0x%0#{hexsize}x)" % [value.to_i, value.to_i]
     end
 
+    # @param [String] str
+    # @param [Integer] int
+    # @param [Integer] hexsize
+    # @return [String]
+    def self.enum_human_hex(str, int, hexsize)
+      "%-16s (0x%0#{hexsize}x)" % [str, int]
+    end
+
+    # Simple formatter to inspect an attribute
+    # @param [String] type attribute type
+    # @param [String] attr attribute name
+    # @param [String] value
+    # @param [Integer] level
+    # @return [String]
+    def self.format(type, attr, value, level=1)
+      str = Inspect.shift_level(level)
+      str << Inspect::FMT_ATTR % [type, attr, value]
+    end
+
     # Format an attribute for +#inspect+.
     # 3 cases are handled:
     # * attribute value is a {Types::Int}: show value as integer and in
@@ -48,24 +67,8 @@ module PacketGen
     # @param [Integer] level
     # @return [String]
     def self.inspect_attribute(attr, value, level=1)
-      str = shift_level(level)
-      val = case value
-            when Types::Enum
-              "%-16s (0x%0#{value.sz * 2}x)" % [value.to_human, value.to_i]
-            when Types::Int
-              int_dec_hex(value, value.sz * 2)
-            when Integer
-              int_dec_hex(value, value.sz * 2)
-            when String
-              value.to_s.inspect
-            else
-              if value.respond_to? :to_human
-                value.to_human
-              else
-                value.to_s.inspect
-              end
-            end
-      str << FMT_ATTR % [value.class.to_s.sub(/.*::/, ''), attr, val]
+      type = value.class.to_s.sub(/.*::/, '')
+      self.format(type, attr, value.format_inspect, level)
     end
 
     # Format a ASN.1 attribute for +#inspect+.

data/lib/packetgen/packet.rb

@@ -1,12 +1,12 @@
 # coding: utf-8
+# 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 'pcaprub'
+# rubocop:disable Metrics/ClassLength
 
 module PacketGen
   # An object of type {Packet} handles a network packet. This packet may contain
@@ -79,36 +79,31 @@ 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)
+    def self.capture(**kwargs, &block)
+      capture = Capture.new(**kwargs)
       if block_given?
-        capture.start { |packet| yield packet }
+        capture.start(&block)
       else
         capture.start
       end
       capture.packets
     end
 
-    # Read packets from +filename+. Mays read Pcap and Pcap-NG formats.
+    # Read packets from +filename+. May read Pcap and Pcap-NG formats.
     #
-    # For more control, see {PcapNG::File} or +PCAPRUB::Pcap+.
+    # For more control (on Pcap-ng only), see {PcapNG::File}.
     # @param [String] filename PcapNG or Pcap file.
     # @return [Array<Packet>]
+    # @raise [ArgumentError] unknown file format
     # @author Sylvain Daubert
     # @author Kent Gruber - Pcap format
     # @since 2.0.0 Also read Pcap format.
     def self.read(filename)
-      PcapNG::File.new.read_packets filename
+      PcapNG::File.new.read_packets(filename)
     rescue StandardError => e
       raise ArgumentError, e unless File.extname(filename.downcase) == '.pcap'
 
-      packets = []
-      PCAPRUB::Pcap.open_offline(filename).each_packet do |packet|
-        next unless (packet = PacketGen.parse(packet.to_s))
-
-        packets << packet
-      end
-      packets
+      Pcap.read(filename)
     end
 
     # Write packets to +filename+
@@ -132,11 +127,13 @@ module PacketGen
     # @param [String] protocol
     # @param [Hash] options protocol specific options
     # @return [self]
-    # @raise [ArgumentError] unknown protocol
+    # @raise [BindingError] unknown protocol
     def add(protocol, options={})
       klass = check_protocol(protocol)
 
-      header = klass.new(options.merge!(packet: self))
+      # options[:packet]= self is speedier than options.merge(packet: self)
+      options[:packet] = self
+      header = klass.new(options)
       add_header header
       self
     end
@@ -146,12 +143,14 @@ module PacketGen
     # @param [String] protocol protocol to insert
     # @param [Hash] options protocol specific options
     # @return [self]
-    # @raise [ArgumentError] unknown protocol
+    # @raise [BindingError] unknown protocol
     def insert(prev, protocol, options={})
       klass = check_protocol(protocol)
 
       nxt = prev.body
-      header = klass.new(options.merge!(packet: self))
+      # options[:packet]= self is speedier than options.merge(packet: self)
+      options[:packet] = self
+      header = klass.new(options)
       add_header header, previous_header: prev
       idx = headers.index(prev) + 1
       headers[idx, 0] = header
@@ -217,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(filename: filename, array: [self])
+      PcapNG::File.new.array_to_file(file: filename, array: [self])
     end
     alias write to_f
 
@@ -251,10 +250,11 @@ module PacketGen
     #    from binding with first other's one. Use only when current header field
     #    has its value set accordingly.
     # @return [self] +self+ with new headers from +other+
+    # @raise [BindingError] do not known how to encapsulate
     # @since 1.1.0
     def encapsulate(other, parsing: false)
       other.headers.each_with_index do |h, i|
-        add_header h, parsing: (i > 0) || parsing
+        add_header h, parsing: i.positive? || parsing
       end
     end
 
@@ -262,36 +262,32 @@ module PacketGen
     # @param [Array<Header>] hdrs
     # @return [self] +self+ with some headers removed
     # @raise [FormatError] any headers not in +self+
-    # @raise [FormatError] removed headers result in an unknown binding
+    # @raise [BindingError] removed headers result in an unknown binding
     # @since 1.1.0
     def decapsulate(*hdrs)
       hdrs.each do |hdr|
-        idx = headers.index(hdr)
-        raise FormatError, 'header not in packet!' if idx.nil?
-
-        prev_hdr = idx > 0 ? headers[idx - 1] : nil
-        next_hdr = (idx + 1) < headers.size ? headers[idx + 1] : nil
-        headers.delete_at(idx)
+        prev_hdr = previous_header(hdr)
+        next_hdr = next_header(hdr)
+        headers.delete(hdr)
         add_header(next_hdr, previous_header: prev_hdr) if prev_hdr && next_hdr
       end
-    rescue ArgumentError => ex
-      raise FormatError, ex.message
+    rescue ArgumentError => e
+      raise FormatError, e.message
     end
 
     # Parse a binary string and populate Packet from it.
     # @param [String] binary_str
     # @param [String,nil] first_header First protocol header. +nil+ means discover it!
     # @return [Packet] self
-    # @raise [ArgumentError] +first_header+ is an unknown header
+    # @raise [ParseError] +first_header+ is an unknown header
+    # @raise [BindingError] unknwon binding between some headers
     def parse(binary_str, first_header: nil)
       headers.clear
 
       if first_header.nil?
         # No decoding forced for first header. Have to guess it!
         first_header = guess_first_header(binary_str)
-        if first_header.nil?
-          raise ParseError, 'cannot identify first header in string'
-        end
+        raise ParseError, 'cannot identify first header in string' if first_header.nil?
       end
 
       add first_header
@@ -374,6 +370,35 @@ module PacketGen
       headers.last
     end
 
+    # Give header index in packet
+    # @param [Headerable] hdr
+    # @return [Integer]
+    # @raise [FormatError] +hdr+ not in packet
+    def header_index(hdr)
+      idx = headers.index(hdr)
+      raise FormatError, 'header not in packet!' if idx.nil?
+
+      idx
+    end
+
+    # Give header previous +hdr+ in packet
+    # @param [Headerable] hdr
+    # @return [Headerable,nil] May return +nil+ if +hdr+ is the first header in packet
+    # @raise [FormatError] +hdr+ not in packet
+    def previous_header(hdr)
+      idx = header_index(hdr)
+      idx.positive? ? headers[idx - 1] : nil
+    end
+
+    # Give header next +hdr+ in packet
+    # @param [Headerable] hdr
+    # @return [Headerable,nil] May return +nil+ if +hdr+ is the last header in packet
+    # @raise [FormatError] +hdr+ not in packet
+    def next_header(hdr)
+      idx = header_index(hdr)
+      (idx + 1) < headers.size ? headers[idx + 1] : nil
+    end
+
     # @overload header(klass, layer=1)
     #  @param [Class] klass
     #  @param [Integer] layer
@@ -388,9 +413,8 @@ module PacketGen
       return header unless arg.is_a? Hash
 
       arg.each do |key, value|
-        unless header.respond_to? "#{key}="
-          raise ArgumentError, "unknown #{key} attribute for #{klass}"
-        end
+        raise ArgumentError, "unknown #{key} attribute for #{klass}" unless header.respond_to? "#{key}="
+
         header.send "#{key}=", value
       end
 
@@ -408,26 +432,15 @@ module PacketGen
     end
 
     # Add a header to packet
-    # @param [Header::Base] header
-    # @param [Header::Base] previous_header
+    # @param [Headerable] header
+    # @param [Headerable] previous_header
     # @param [Boolean] parsing
     # @return [void]
+    # @raise [BindingError]
     def add_header(header, previous_header: nil, parsing: false)
       prev_header = previous_header || last_header
-      if prev_header
-        bindings = prev_header.class.known_headers[header.class]
-        bindings = prev_header.class.known_headers[header.class.superclass] if bindings.nil?
-        if bindings.nil?
-          msg = "#{prev_header.class} knowns no layer association with #{header.protocol_name}. ".dup
-          msg << "Try #{prev_header.class}.bind_layer(#{header.class}, "
-          msg << "#{prev_header.method_name}_proto_field: "
-          msg << "value_for_#{header.method_name})"
-          raise ArgumentError, msg
-        end
+      add_to_previous_header(prev_header, header, parsing) if prev_header
 
-        bindings.set(prev_header) if !bindings.empty? && !parsing
-        prev_header[:body] = header
-      end
       header.packet = self
       headers << header unless previous_header
 
@@ -436,6 +449,20 @@ module PacketGen
       add_magic_header_method header
     end
 
+    # Bind +header+ to +prev_header+.
+    # @param [Headerable] prev_header
+    # @param [Headerable] header
+    # @param [Boolean] parsing
+    # @return [void]
+    # @raise [BindingError]
+    def add_to_previous_header(prev_header, header, parsing)
+      bindings = prev_header.class.known_headers[header.class] || prev_header.class.known_headers[header.class.superclass]
+      raise BindingError.new(prev_header, header) if bindings.nil?
+
+      bindings.set(prev_header) if !bindings.empty? && !parsing
+      prev_header[:body] = header
+    end
+
     # Add method to access +header+
     # @param [Header::Base] header
     # @return [void]
@@ -497,5 +524,7 @@ module PacketGen
   end
 end
 
+# rubocop:enable Metrics/ClassLength
+
 require_relative 'headerable'
 require_relative 'header'