packetgen 1.2.0 → 1.3.0

data/lib/packetgen/header/ip.rb

@@ -8,10 +8,10 @@ module PacketGen
   module Header
 
     # A IP header consists of:
-    # * a first byte ({#u8} of {Int8} type) composed of:
+    # * a first byte ({#u8} of {Types::Int8} type) composed of:
     #   * a 4-bit {#version} field,
     #   * a 4-bit IP header length ({#ihl}) field,
-    # * a total length ({#length}, {Int16} type),
+    # * a total length ({#length}, {Types::Int16} type),
     # * a ID ({#id}, +Int16+ type),
     # * a {#frag} worg (+Int16+) composed of:
     #   * 3 1-bit flags ({#flag_rsv}, {#flag_df} and {#flag_mf}),
@@ -21,7 +21,7 @@ module PacketGen
     # * a {#checksum} field (+Int16+),
     # * a source IP address ({#src}, {Addr} type),
     # * a destination IP ddress ({#dst}, +Addr+ type),
-    # * and a {#body} ({String} type).
+    # * and a {#body} ({Types::String} type).
     #
     # == Create a IP header
     #  # standalone
@@ -58,32 +58,26 @@ module PacketGen
     #  ip.dst = '127.0.0.2'
     #  ip.body.read 'this is a body'
     # @author Sylvain Daubert
-    class IP < Struct.new(:u8, :tos, :length, :id, :frag, :ttl,
-                          :protocol, :checksum, :src, :dst, :body)
-      include StructFu
-      include HeaderMethods
-      extend HeaderClassMethods
+    class IP < Base
 
       # IP address, as a group of 4 bytes
       # @author Sylvain Daubert
-      class Addr < Struct.new(:a1, :a2, :a3, :a4)
-        include StructFu
+      class Addr < Base
+        # @!attribute a1
+        #  @return [Integer] IP address first byte 
+        define_field :a1, Types::Int8
+        # @!attribute a2
+        #  @return [Integer] IP address seconf byte 
+        define_field :a2, Types::Int8
+        # @!attribute a3
+        #  @return [Integer] IP address third byte 
+        define_field :a3, Types::Int8
+        # @!attribute a4
+        #  @return [Integer] IP address fourth byte 
+        define_field :a4, Types::Int8
 
         IPV4_ADDR_REGEX = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/
 
-        # @param [Hash] options
-        # @option options [Integer] :a1
-        # @option options [Integer] :a2
-        # @option options [Integer] :a3
-        # @option options [Integer] :a4
-        def initialize(options={})
-          super Int8.new(options[:a1]),
-                Int8.new(options[:a2]),
-                Int8.new(options[:a3]),
-                Int8.new(options[:a4])
-
-        end
-
         # Read a dotted address
         # @param [String] str
         # @return [self]
@@ -99,27 +93,10 @@ module PacketGen
           self
         end
 
-        # Read a Addr from a string
-        # @param [String] str binary string
-        # @return [self]
-        def read(str)
-          return self if str.nil?
-          raise ParseError, 'string too short for IP::Addr' if str.size < self.sz
-          force_binary str
-          [:a1, :a2, :a3, :a4].each_with_index do |byte, i|
-            self[byte].read str[i, 1]
-          end
-        end
-
-        [:a1, :a2, :a3, :a4].each do |sym|
-          class_eval "def #{sym}; self[:#{sym}].to_i; end\n" \
-                     "def #{sym}=(v); self[:#{sym}].read v; end" 
-        end
-
         # Addr in human readable form (dotted format)
         # @return [String]
         def to_human
-          members.map { |m| "#{self[m].to_i}" }.join('.')
+          fields.map { |f| "#{self[f].to_i}" }.join('.')
         end
 
         # Addr as an integer
@@ -130,32 +107,41 @@ module PacketGen
         end
       end
 
-      # @param [Hash] options
-      # @option options [Integer] :version
-      # @option options [Integer] :ihl this header size in 4-byte words
-      # @option options [Integer] :tos
-      # @option options [Integer] :length IP packet length, including this header
-      # @option options [Integer] :id
-      # @option options [Integer] :frag
-      # @option options [Integer] :ttl
-      # @option options [Integer] :protocol
-      # @option options [Integer] :checksum IP header checksum
-      # @option options [String] :src IP source dotted address
-      # @option options [String] :dst IP destination dotted address
-      def initialize(options={})
-        super Int8.new(((options[:version] || 4) << 4) | (options[:ihl] || 5)),
-              Int8.new(options[:tos] || 0),
-              Int16.new(options[:length] || 20),
-              Int16.new(options[:id] || rand(65535)),
-              Int16.new(options[:frag] || 0),
-              Int8.new(options[:ttl] || 64),
-              Int8.new(options[:protocol]),
-              Int16.new(options[:checksum] || 0),
-              Addr.new.from_human(options[:src] || '127.0.0.1'),
-              Addr.new.from_human(options[:dst] || '127.0.0.1'),
-              StructFu::String.new.read(options[:body])
-      end
-
+      # @!attribute u8
+      #  First byte of IP header. May be accessed through {#version} and {#ihl}.
+      #  @return [Integer] first byte of IP header.
+      define_field :u8, Types::Int8, default: 0x45
+      # @!attribute tos
+      #   @return [Integer] 8-bit Type of Service value
+      define_field :tos, Types::Int8, default: 0
+      # @!attribute length
+      #   @return [Integer] 16-bit IP total length
+      define_field :length, Types::Int16, default: 20
+      # @!attribute id
+      #   @return [Integer] 16-bit ID
+      define_field :id, Types::Int16, default: -> { rand(65535) }
+      # @!attribute frag
+      #   @return [Integer] 16-bit frag word
+      define_field :frag, Types::Int16, default: 0
+      # @!attribute ttl
+      #   @return [Integer] 8-bit Time To Live value
+      define_field :ttl, Types::Int8, default: 64
+      # @!attribute protocol
+      #   @return [Integer] 8-bit upper protocol value
+      define_field :protocol, Types::Int8
+      # @!attribute checksum
+      #   @return [Integer] 16-bit IP header checksum
+      define_field :checksum, Types::Int16, default: 0
+      # @!attribute src
+      #   @return [Addr] source IP address
+      define_field :src, Addr, default: '127.0.0.1'
+      # @!attribute dst
+      #   @return [Addr] destination IP address
+      define_field :dst, Addr, default: '127.0.0.1'
+      # @!attribute body
+      #  @return [Types::String,Header::Base]
+      define_field :body, Types::String
+      
       # @!attribute version
       #   @return [Integer] 4-bit version attribute
       # @!attribute ihl
@@ -172,28 +158,7 @@ module PacketGen
       #   @return [Integer] 13-bit fragment offset
       define_bit_fields_on :frag, :flag_rsv, :flag_df, :flag_mf, :fragment_offset, 13
 
-      # Read a IP header from a string
-      # @param [String] str binary string
-      # @return [self]
-      def read(str)
-        return self if str.nil?
-        raise ParseError, 'string too short for IP' if str.size < self.sz
-        force_binary str
-        self[:u8].read str[0, 1]
-        self[:tos].read str[1, 1]
-        self[:length].read str[2, 2]
-        self[:id].read str[4, 2]
-        self[:frag].read str[6, 2]
-        self[:ttl].read str[8, 1]
-        self[:protocol].read str[9, 1]
-        self[:checksum].read str[10, 2]
-        self[:src].read str[12, 4]
-        self[:dst].read str[16, 4]
-        self[:body].read str[20..-1]
-        self
-      end
-
-       # Compute checksum and set +checksum+ field
+      # Compute checksum and set +checksum+ field
       # @return [Integer]
       def calc_checksum
         checksum = (self[:u8].to_i << 8) | self.tos
@@ -216,127 +181,6 @@ module PacketGen
         self[:length].value = self.sz
       end
 
-      # Getter for TOS attribute
-      # @return [Integer]
-      def tos
-        self[:tos].to_i
-      end
-
-      # Setter for TOS attribute
-      # @param [Integer] tos
-      # @return [Integer]
-      def tos=(tos)
-        self[:tos].value = tos
-      end
-
-      # Getter for length attribute
-      # @return [Integer]
-      def length
-        self[:length].to_i
-      end
-
-      # Setter for length attribute
-      # @param [Integer] length
-      # @return [Integer]
-      def length=(length)
-        self[:length].value = length
-      end
-
-      # Getter for id attribute
-      # @return [Integer]
-      def id
-        self[:id].to_i
-      end
-
-      # Setter for id attribute
-      # @param [Integer] id
-      # @return [Integer]
-      def id=(id)
-        self[:id].value = id
-      end
-
-      # Getter for  frag attribute
-      # @return [Integer]
-      def frag
-        self[:frag].to_i
-      end
-
-      # Setter for frag attribute
-      # @param [Integer] frag
-      # @return [Integer]
-      def frag=(frag)
-        self[:frag].value = frag
-      end
-
-      # Getter for ttl attribute
-      # @return [Integer]
-      def ttl
-        self[:ttl].to_i
-      end
-
-      # Setter for ttl attribute
-      # @param [Integer] ttl
-      # @return [Integer]
-      def ttl=(ttl)
-        self[:ttl].value = ttl
-      end
-
-      # Getter for protocol attribute
-      # @return [Integer]
-      def protocol
-        self[:protocol].to_i
-      end
-
-      # Setter for  protocol attribute
-      # @param [Integer] protocol
-      # @return [Integer]
-      def protocol=(protocol)
-        self[:protocol].value = protocol
-      end
-
-      # Getter for checksum attribute
-      # @return [Integer]
-      def checksum
-        self[:checksum].to_i
-      end
-
-      # Setter for  checksum attribute
-      # @param [Integer] checksum
-      # @return [Integer]
-      def checksum=(checksum)
-        self[:checksum].value = checksum
-      end
-
-      # Get IP source address
-      # @return [String] dotted address
-      def src
-        self[:src].to_human
-      end
-      alias :source :src
-
-      # Set IP source address
-      # @param [String] addr dotted IP address
-      # @return [String]
-      def src=(addr)
-        self[:src].from_human addr
-      end
-      alias :source= :src=
-
-      # Get IP destination address
-      # @return [String] dotted address
-      def dst
-        self[:dst].to_human
-      end
-      alias :destination :dst
-
-      # Set IP destination address
-      # @param [String] addr dotted IP address
-      # @return [String]
-      def dst=(addr)
-        self[:dst].from_human addr
-      end
-      alias :destination= :dst=
-
       # Get IP part of pseudo header checksum.
       # @return [Integer]
       def pseudo_header_checksum

data/lib/packetgen/header/ipv6.rb

@@ -9,12 +9,12 @@ module PacketGen
   module Header
 
     # A IPv6 header consists of:
-    # * a first 32-bit word ({#u32}, of {Int32} type) composoed of:
+    # * a first 32-bit word ({#u32}, of {Types::Int32} type) composoed of:
     #   * a 4-bit {#version} field,
     #   * a 8-bit {#traffic_class} field,
     #   * a 20-bit {#flow_label} field,
-    # * a payload length field ({#length}, {Int16} type}),
-    # * a next header field ({#next}, {Int8} type),
+    # * a payload length field ({#length}, {Types::Int16} type}),
+    # * a next header field ({#next}, {Types::Int8} type),
     # * a hop-limit field ({#hop}, +Int8+ type),
     # * a source address field ({#src}, {IPv6::Addr} type),
     # * a destination address field ({#dst}, +IPv6::Addr+ type),
@@ -43,35 +43,44 @@ module PacketGen
     #  ipv6.dst = '2001:1234:5678:abcd::123'
     #  ipv6.body.read 'this is a body'
     # @author Sylvain Daubert
-    class IPv6 < Struct.new(:u32, :length, :next, :hop, :src, :dst, :body)
-      include StructFu
-      include HeaderMethods
-      extend HeaderClassMethods
+    class IPv6 < Base
 
       # IPv6 address, as a group of 8 2-byte words
       # @author Sylvain Daubert
-      class Addr < Struct.new(:a1, :a2, :a3, :a4, :a5, :a6, :a7, :a8)
-        include StructFu
-
-        # @param [Hash] options
-        # @option options [Integer] :a1
-        # @option options [Integer] :a2
-        # @option options [Integer] :a3
-        # @option options [Integer] :a4
-        # @option options [Integer] :a5
-        # @option options [Integer] :a6
-        # @option options [Integer] :a7
-        # @option options [Integer] :a8
-        def initialize(options={})
-          super Int16.new(options[:a1]),
-                Int16.new(options[:a2]),
-                Int16.new(options[:a3]),
-                Int16.new(options[:a4]),
-                Int16.new(options[:a5]),
-                Int16.new(options[:a6]),
-                Int16.new(options[:a7]),
-                Int16.new(options[:a8])
-        end
+      class Addr < Base
+
+        # @!attribute a1
+        #  1st 2-byte word of IPv6 address
+        #  @return [Integer]
+        define_field :a1, Types::Int16
+        # @!attribute a2
+        #  2nd 2-byte word of IPv6 address
+        #  @return [Integer]
+        define_field :a2, Types::Int16
+        # @!attribute a3
+        #  3rd 2-byte word of IPv6 address
+        #  @return [Integer]
+        define_field :a3, Types::Int16
+        # @!attribute a4
+        #  4th 2-byte word of IPv6 address
+        #  @return [Integer]
+        define_field :a4, Types::Int16
+        # @!attribute a5
+        #  5th 2-byte word of IPv6 address
+        #  @return [Integer]
+        define_field :a5, Types::Int16
+        # @!attribute a6
+        #  6th 2-byte word of IPv6 address
+        #  @return [Integer]
+        define_field :a6, Types::Int16
+        # @!attribute a7
+        #  7th 2-byte word of IPv6 address
+        #  @return [Integer]
+        define_field :a7, Types::Int16
+        # @!attribute a8
+        #  8th 2-byte word of IPv6 address
+        #  @return [Integer]
+        define_field :a8, Types::Int16
 
         # Read a colon-delimited address
         # @param [String] str
@@ -92,57 +101,47 @@ module PacketGen
           self
         end
 
-        # Read a Addr6 from a binary string
-        # @param [String] str
-        # @return [self]
-        def read(str)
-          force_binary str
-          self[:a1].read str[0, 2]
-          self[:a2].read str[2, 2]
-          self[:a3].read str[4, 2]
-          self[:a4].read str[6, 2]
-          self[:a5].read str[8, 2]
-          self[:a6].read str[10, 2]
-          self[:a7].read str[12, 2]
-          self[:a8].read str[14, 2]
-          self
-        end
-
-        %i(a1 a2 a3 a4 a5 a6 a7 a8).each do |sym|
-          class_eval "def #{sym}; self[:#{sym}].to_i; end\n" \
-                     "def #{sym}=(v); self[:#{sym}].read v; end" 
-        end
-
         # Addr6 in human readable form (colon-delimited hex string)
         # @return [String]
         def to_human
           IPAddr.new(to_a.map { |a| a.to_i.to_s(16) }.join(':')).to_s
         end
-      end
 
-      # @param [Hash] options
-      # @option options [Integer] :version
-      # @option options [Integer] :traffic_class
-      # @option options [Integer] :flow_label
-      # @option options [Integer] :length payload length
-      # @option options [Integer] :next
-      # @option options [Integer] :hop
-      # @option options [String] :src colon-delimited source address
-      # @option options [String] :dst colon-delimited destination address
-      # @option options [String] :body binary string
-      def initialize(options={})
-        super Int32.new(0x60000000),
-              Int16.new(options[:length]),
-              Int8.new(options[:next]),
-              Int8.new(options[:hop] || 64),
-              Addr.new.from_human(options[:src] || '::1'),
-              Addr.new.from_human(options[:dst] || '::1'),
-              StructFu::String.new.read(options[:body])
-        self.version = options[:version] if options[:version]
-        self.traffic_class = options[:traffic_class] if options[:traffic_class]
-        self.flow_label = options[:flow_label] if options[:flow_label]
+        # Return an array of address 16-bit words
+        # @return [Array<Integer>]
+        def to_a
+          @fields.values
+        end
       end
 
+      # @!attribute u32
+      #  First 32-bit word of IPv6 header
+      #  @return [Integer]
+      define_field :u32, Types::Int32, default: 0x6000_0000
+      # @!attribute length
+      #  16-bit word of IPv6 payload length
+      #  @return [Integer]
+      define_field :length, Types::Int16
+      # @!attribute next
+      #  8-bit IPv6 next payload value
+      #  @return [Integer]
+      define_field :next, Types::Int8
+      # @!attribute hop
+      #  8-bit IPv6 hop limit
+      #  @return [Integer]
+      define_field :hop, Types::Int8, default: 64
+      # @!attribute src
+      #  IPv6 source address
+      #  @return [Addr]
+      define_field :src, Addr, default: '::1'
+      # @!attribute dst
+      #  IPv6 destination address
+      #  @return [Addr]
+      define_field :dst, Addr, default: '::1'
+      # @!attribute body
+      #  @return [Types::String,Header::Base]
+      define_field :body, Types::String
+
       # @!attribute version
       #   @return [Integer] 4-bit version attribute
       # @!attribute traffic_class
@@ -151,108 +150,18 @@ module PacketGen
       #   @return [Integer] 20-bit flow_label attribute
       define_bit_fields_on :u32, :version, 4, :traffic_class, 8, :flow_label, 20
 
-      # Read a IP header from a string
-      # @param [String] str binary string
-      # @return [self]
-      def read(str)
-        return self if str.nil?
-        raise ParseError, 'string too short for IPv6' if str.size < self.sz
-        force_binary str
-        first32 = str[0, 4].unpack('N').first
-        self.version = first32 >> 28
-        self.traffic_class = (first32 >> 20) & 0xff
-        self.flow_label = first32 & 0xfffff
-
-        self[:length].read str[4, 2]
-        self[:next].read str[6, 1]
-        self[:hop].read str[7, 1]
-        self[:src].read str[8, 16]
-        self[:dst].read str[24, 16]
-        self[:body].read str[40..-1]
-        self
-      end
-
       # Compute length and set +len+ field
       # @return [Integer]
       def calc_length
         self.length = body.sz
       end
 
-      # @!attribute length
-      #   16-bit payload length attribute
-      #   @return [Integer]
-      def length
-        self[:length].to_i
-      end
-
-      # @param [Integer] i
-      # @return [Integer]
-      def length=(i)
-        self[:length].read i
-      end
-
-      # Getter for next attribute
-      # @return [Integer]
-      def next
-        self[:next].to_i
-      end
-
-      # Setter for next attribute
-      # @param [Integer] i
-      # @return [Integer]
-      def next=(i)
-        self[:next].read i
-      end
-
-      # Getter for hop attribute
-      # @return [Integer]
-      def hop
-        self[:hop].to_i
-      end
-
-      # Setter for hop attribute
-      # @param [Integer] i
-      # @return [Integer]
-      def hop=(i)
-        self[:hop].read i
-      end
-
-      # Getter for src attribute
-      # @return [String]
-      def src
-        self[:src].to_human
-      end
-      alias :source :src
-
-      # Setter for src attribute
-      # @param [String] addr
-      # @return [Integer]
-      def src=(addr)
-        self[:src].from_human addr
-      end
-      alias :source= :src=
-
-      # Getter for dst attribute
-      # @return [String]
-      def dst
-        self[:dst].to_human
-      end
-      alias :destination :dst
-
-      # Setter for dst attribute
-      # @param [String] addr
-      # @return [Integer]
-      def dst=(addr)
-        self[:dst].from_human addr
-      end
-      alias :destination= :dst=
-
       # Get IPv6 part of pseudo header checksum.
       # @return [Integer]
       def pseudo_header_checksum
         sum = 0
-        self[:src].each { |word| sum += word.to_i }
-        self[:dst].each { |word| sum += word.to_i }
+        self[:src].to_a.each { |word| sum += word.to_i }
+        self[:dst].to_a.each { |word| sum += word.to_i }
         sum
       end