dnet-ffi 0.1.3

data/lib/dnet/eth.rb

@@ -0,0 +1,143 @@
+# Bindings for dnet(3)'s eth_* API
+
+module Dnet
+  
+  # FFI implementation of dnet(3)'s eth_addr struct.
+  class EthAddr < ::FFI::Struct
+    include ::FFI::DRY::StructHelper
+    
+    # struct eth_addr { ... } eth_addr_t;
+    dsl_layout{ array :data, [:uchar, ETH_ADDR_LEN] }
+
+    # Adds the ability to initialize a new EthAddr with a mac address
+    # string such as 'de:ad:be:ef:ba:be'. This argument is only parsed
+    # if it is passed as the only String argument.
+    def initialize(*args)
+      if args.size == 1 and (s=args[0]).is_a? String
+        super()
+        self.addr = s
+      else
+        super(*args)
+      end
+    end
+    
+    def addr=(val)
+      unless val.to_s =~ /^#{Dnet::Util::RX_MAC_ADDR}$/
+        raise(ArgumentError, "invalid mac address #{val.inspect}")
+      end
+      raw = ::Dnet::Util.unhexify(val, /[:-]/)
+      self[:data].to_ptr.write_string(raw, ETH_ADDR_LEN)
+    end
+
+    # Returns the MAC address as an array of unsigned char values.
+    def chars; self[:data].to_a ; end
+
+    # Returns the MAC address as a string with colon-separated hex-bytes.
+    def string; chars.map {|x| "%0.2x" % x }.join(':'); end
+  end
+
+
+  module Eth
+    #
+    #   struct :dst,   EthAddr, :desc => 'destination address'
+    #   struct :src,   EthAddr, :desc => 'source address'
+    #   field  :etype, :ushort, :desc => 'ethernet payload type'
+    #
+    class Hdr < ::FFI::Struct
+      include ::FFI::DRY::StructHelper
+      include ::Dnet::NetEndianHelper
+      
+      module Etype
+        include ::FFI::DRY::ConstMap
+        slurp_constants ::Dnet, "ETH_TYPE_"
+        def list; @@list ||= super();  end
+      end
+
+      dsl_layout do
+        struct :dst,   EthAddr, :desc => 'destination address'
+        struct :src,   EthAddr, :desc => 'source address'
+        field  :etype, :ushort, :desc => 'ethernet payload type'
+      end
+
+      def lookup_etype
+        Etype[ self.etype ]
+      end
+
+      alias _divert_set_eth etype=
+
+      def etype=(val)
+        if val.kind_of? String or val.kind_of? Symbol
+          val = Etype[ val ] or raise(ArgumentError, "invalid eth type #{val}")
+        end
+        _divert_set_eth(val)
+      end
+    end
+
+    # Obtains a new handle to transmit raw Ethernet frames via the specified
+    # network device.
+    #
+    class Handle < ::Dnet::Handle
+      # Uses dnet(3)'s eth_open under the hood:
+      def initialize(dev)
+        @handle=Dnet.eth_open(dev.to_s)
+        if @handle.address == 0
+          raise H_ERR.new("Unable to open device: #{dev.inspect}") 
+        end
+        _handle_opened!
+      end
+
+      # Closes the handle. Uses dnet(3)'s eth_close() under the hood:
+      def close
+        _do_if_open { _handle_closed!; Dnet.eth_close(@handle) }
+      end
+
+      # Retrieves the hardware MAC address for this interface and returns it
+      # as a EthAddr object. Uses dnet(3)'s eth_get() function under the hood.
+      def macaddr()
+        _check_open!
+        ea = EthAddr.new
+        return nil unless Dnet.eth_get(@handle, ea) == 0
+        return ea
+      end
+
+      # Configures the hardware MAC address for this interface to the specified
+      # address supplied as a string of colon-separated hex-bytes (example: 
+      # "de:ad:be:ef:01"). Uses dnet(3)'s addr_aton() to parse ea_str and 
+      # eth_set() to set the address under the hood.
+      def macaddr=(ea_str)
+        _check_open!
+        if ( ea=EthAddr.new(ea_str.to_s) and Dnet.eth_set(@handle, ea) == 0 )
+          return true
+        end
+      end
+
+      # Transmits an ethernet frame (supplied as a String, sbuf). Uses dnet(3)'s 
+      # eth_send() function under the hood.
+      def eth_send(sbuf)
+        _check_open!
+        sbuf = sbuf.to_s
+        (buf = ::FFI::MemoryPointer.from_string(sbuf)).autorelease = true
+        Dnet.eth_send(@handle, buf, sbuf.size)
+      end
+
+    end # Handle
+
+    def self.open(*args)
+      Handle.open(*args){|*y| yield(*y) if block_given? }
+    end
+
+    def self.eth_send(dev, *args)
+      Handle.open(dev){|h| h.eth_send(*args) }
+    end
+  end # Eth
+
+  # This is just an alias for ::Dnet::Eth::Handle
+  EthHandle = Eth::Handle
+
+  attach_function :eth_open, [:string], :eth_t
+  attach_function :eth_get, [:eth_t, EthAddr], :int
+  attach_function :eth_set, [:eth_t, EthAddr], :int
+  attach_function :eth_send, [:eth_t, :pointer, :size_t], :ssize_t
+  attach_function :eth_close, [:eth_t], :eth_t
+
+end # Dnet

data/lib/dnet/fw.rb

@@ -0,0 +1,106 @@
+
+### dnet(3)'s firewalling interface
+
+module Dnet
+
+  module Fw
+    #
+    #   array  :device,  [:uint8, INTF_NAME_LEN], :desc => 'interface name'
+    #   field  :op,      :uint8,        :desc => 'operation'
+    #   field  :dir,     :uint8,        :desc => 'direction'
+    #   field  :proto,   :uint8,        :desc => 'IP protocol'
+    #   struct :src,     ::Dnet::Addr,  :desc => 'src address / net'
+    #   struct :dst,     ::Dnet::Addr,  :desc => 'dst address / net'
+    #   array  :sport,   [:uint16, 2],  :desc => 'src port-range / ICMP type'
+    #   array  :dport,   [:uint16, 2],  :desc => 'dst port-range / ICMP code'
+    #
+    class Rule < ::FFI::Struct
+      include ::FFI::DRY::StructHelper
+      
+      dsl_layout do
+        array  :device,  [:uint8, INTF_NAME_LEN], :desc => 'interface name'
+        field  :op,      :uint8,        :desc => 'operation'
+        field  :dir,     :uint8,        :desc => 'direction'
+        field  :proto,   :uint8,        :desc => 'IP protocol'
+        struct :src,     ::Dnet::Addr,  :desc => 'src address / net'
+        struct :dst,     ::Dnet::Addr,  :desc => 'dst address / net'
+        array  :sport,   [:uint16, 2],  :desc => 'src port-range / ICMP type'
+        array  :dport,   [:uint16, 2],  :desc => 'dst port-range / ICMP code'
+      end
+
+      # Alias to ::Dnet::Ip::Proto
+      Proto = ::Dnet::Ip::Proto
+
+      module Op 
+        include ::FFI::DRY::ConstFlagsMap
+        ALLOW = 1
+        BLOCK = 2
+        def self.list ; @@list ||= super(); end
+      end
+
+      module Dir
+        include ::FFI::DRY::ConstFlagsMap
+        IN  = 1
+        OUT = 2
+        def self.list ; @@list ||= super(); end
+      end
+
+      def device; self[:device].to_ptr.read_string ; end
+
+      def device=(val)
+        dev = ::Dnet.truncate_cstr(val.to_s, INTF_NAME_LEN)
+        self[:device].to_ptr.write_string(dev, dev.size)
+      end
+    end
+
+    # Fw::Handle is used to obtain a handle to access the local network 
+    # firewall configuration.
+    class Handle < ::Dnet::LoopableHandle
+
+      # Uses dnet(3)'s fw_open() function under the hood.
+      def initialize
+        if (@handle = Dnet.fw_open()).address == 0
+          raise H_ERR.new("unable to open fw handle")
+        end
+        _handle_opened!
+      end
+
+      # Closes the firewall handle. Uses dnet(3)'s fw_close() under the hood.
+      def close
+        _do_if_open { _handle_closed! ; Dnet.fw_close(@handle) }
+      end
+
+      # Iterates over the active firewall ruleset, invoking the specified 
+      # block with each rule cast as a Rule object.  Uses dnet(3)'s fw_loop() 
+      # function under the hood.
+      def loop &block
+        _loop ::Dnet, :fw_loop, Rule, &block
+      end
+
+      # Adds the specified Rule entry to the ruleset. Uses dnet(3)'s 
+      # fw_add() function under the hood.
+      def add(fw_rule)
+        Dnet.fw_add @handle, fw_rule
+      end
+
+      # Deletes the specified firewall rule. Uses dnet(3)'s fw_delete() function
+      # under the hood.
+      def delete(fw_rule)
+        Dnet.fw_delete @handle, fw_rule
+      end
+    end
+
+    # an alias for Fw::Handle
+    FwHandle = Fw::Handle
+
+  end
+
+  callback :fw_handler, [Fw::Rule, :ulong], :int
+
+  attach_function :fw_open, [], :fw_t
+  attach_function :fw_add, [:fw_t, Fw::Rule], :int
+  attach_function :fw_delete, [:fw_t, Fw::Rule], :int
+  attach_function :fw_loop, [:fw_t, :fw_handler, :ulong], :int
+  attach_function :fw_close, [:fw_t], :fw_t
+
+end

data/lib/dnet/helpers.rb

@@ -0,0 +1,164 @@
+# This file contains various helper methods, modules, and classes used 
+# throughout the Dnet FFI bindings.
+
+module Dnet
+  attach_function :htons, [:uint16], :uint16
+  attach_function :ntohs, [:uint16], :uint16
+  attach_function :htonl, [:uint32], :uint32
+  attach_function :ntohl, [:uint32], :uint32
+
+
+  # Produces a null-terminated string from 'val', if max is supplied,
+  # it is taken as a maximum length. If 'val' is longer than max, it will
+  # be truncated to max-1 with a terminating null.
+  def self.truncate_cstr(val, max=nil)
+    ret = (max and val.size > (max-1))? val[0,max-1] : val
+    ret << "\x00"
+    return ret
+  end
+
+  # An exception class raised on Handle related errors.
+  class HandleError < Exception; end
+
+  # A helper used for maintaining open/close state on libdnet's handles and 
+  # volatile objects.
+  module HandleHelpers
+
+    # shorthand for the HandleError exception class
+    H_ERR = HandleError
+
+    def open? ; _handle_open? ; end
+    def closed? ; (not _handle_open?) ; end
+
+    private
+      def _handle_opened!
+        @handle_open = true
+      end
+
+      def _handle_closed!
+        @handle_open = false
+      end
+
+      def _check_open!
+        raise H_ERR.new("handle is closed") unless @handle_open
+      end
+
+      def _handle_open?
+        @handle_open
+      end
+
+      def _do_if_open
+        yield if @handle_open
+      end
+  end
+
+  class Handle
+    include HandleHelpers
+
+    attr_reader :handle
+
+    # Opens a new handle object, optionally yielding it to a block.
+    #
+    # If a block is supplied, the handle will be closed after completion
+    # and the result of the block returned. Otherwise, the new handle is 
+    # returned in an open state.
+    def self.open(*args)
+      o=new(*args)
+      return o unless block_given?
+      begin yield(o) ensure o.close end
+    end
+  end
+
+  class LoopableHandle < Handle
+
+    def entries
+      ary = []
+      self.loop {|e| ary << e.copy }
+      return ary
+    end
+
+    # Yields each entry via a new instance through loop() to a block
+    def self.each_entry(*args)
+      open(*args) {|a| a.loop {|e| yield e } }
+    end
+
+    # Returns all entries as an array.
+    def self.entries(*args)
+      open(*args) {|a| a.entries }
+    end
+
+    private
+      # Generic helper for libdnet's *_loop method interfaces.
+      # Calls Dnet."loop_meth" to loop through some sort of entry which is cast
+      # to a new instance of 'entry_cast' class and yielded to a block.
+      def _loop(nspace, loop_meth, entry_cast)
+        _check_open!
+        b = lambda {|e, i| yield entry_cast.new(e); nil } 
+        nspace.__send__ loop_meth, @handle, b, self.object_id
+      end
+
+  end # LoopableHandle
+
+  # A special helper for network packet structures which use big-endian or
+  # "network" byte-order. This helper generates read/write accessors that
+  # automatically call the appropriate byte conversion function, ntohs/ntohl
+  # for 'reading' a 16/32 bit field, and htons/htonl for writing to one.
+  #
+  # NOTE this helper does not currently do anything special for 64-bit values 
+  # at all.
+  #
+  # This helper relies on a included loaded FFI::DRY::StructHelper module
+  # to do its magic. Always include this module as follows:
+  #
+  #   class YourStruct < ::FFI::Struct # or ::FFI::ManagedStruct, (or Union?)
+  #     include ::FFI::DRY::StructHelper
+  #     include ::Dnet::NetEndianHelper
+  #     ...
+  #
+  module NetEndianHelper
+
+    I16_convert = [::Dnet.method(:ntohs), ::Dnet.method(:htons)]
+    U16_convert = [::Dnet.method(:ntohs), ::Dnet.method(:htons)]
+    I32_convert = [::Dnet.method(:ntohl), ::Dnet.method(:htonl)]
+    U32_convert = [::Dnet.method(:ntohl), ::Dnet.method(:htonl)]
+
+    BYTE_ORDER_METH = {
+      Dnet.find_type(:uint16) => I16_convert,
+      Dnet.find_type(:int16)  => I16_convert,
+      Dnet.find_type(:int32)  => I32_convert,
+      Dnet.find_type(:uint32) => I32_convert,
+    }
+
+    module ClassMethods
+      private
+      def _class_meths_from_dsl_metadata(meta)
+        (@dsl_metadata = meta).each do |spec|
+          name = spec[:name]
+          type = spec[:type]
+          if type.kind_of? Symbol and mp=BYTE_ORDER_METH[ Dnet.find_type(type) ]
+            unless instance_methods.include?(:"#{name}")
+              define_method(:"#{name}"){ mp[0].call(self[name]) }
+            end
+            unless instance_methods.include?(:"#{name}=")
+              define_method(:"#{name}="){|val| self[name] = mp[1].call(val) }
+            end
+          else
+            unless instance_methods.include?(:"#{name}")
+              define_method(:"#{name}"){ self[name] } 
+            end
+            unless instance_methods.include?(:"#{name}=")
+              define_method(:"#{name}="){|val| self[name]=val }
+            end 
+          end
+        end
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+  end
+
+end
+

data/lib/dnet/icmp.rb

@@ -0,0 +1,304 @@
+
+module Dnet::Icmp
+
+  # ICMP header structure
+  #
+  #   struct icmp_hdr {
+  #     uint8_t    icmp_type;  /* type of message */
+  #     uint8_t    icmp_code;  /* type sub code */
+  #     uint16_t  icmp_cksum;  /* ones complement cksum of struct */
+  #   };
+  #
+  class Hdr < ::FFI::Struct
+    include ::FFI::DRY::StructHelper
+    include ::Dnet::NetEndianHelper
+    
+    dsl_layout do
+      field :icmp_type,    :uint8
+      field :icmp_code,    :uint8
+      field :icmp_cksum,   :uint16
+    end
+
+    module IcmpType
+      include ::FFI::DRY::ConstFlagsMap
+      slurp_constants(::Dnet, "ICMP_TYPE_")
+      def list; @@list ||= super(); end
+    end
+
+    module IcmpCode
+      module UNREACH
+        include ::FFI::DRY::ConstFlagsMap
+        slurp_constants(::Dnet, "ICMP_UNREACH_")
+        def list; @@list ||= super(); end
+      end
+
+      module REDIRECT
+        include ::FFI::DRY::ConstFlagsMap
+        slurp_constants(::Dnet, "ICMP_REDIRECT_")
+        def list; @@list ||= super(); end
+      end
+
+      module RTRADVERT
+        include ::FFI::DRY::ConstFlagsMap
+        slurp_constants(::Dnet, "ICMP_RTRADVERT_")
+        def list; @@list ||= super(); end
+      end
+
+      module TIMEEXCEED
+        include ::FFI::DRY::ConstFlagsMap
+        slurp_constants(::Dnet, "ICMP_TIMEEXCEED_")
+        def list; @@list ||= super(); end
+      end
+
+      module PARAMPROB
+        include ::FFI::DRY::ConstFlagsMap
+        slurp_constants(::Dnet, "ICMP_PARAMPROB_")
+        def list; @@list ||= super(); end
+      end
+
+      module PHOTURIS
+        include ::FFI::DRY::ConstFlagsMap
+        slurp_constants(::Dnet, "ICMP_PHOTURIS_")
+        def list; @@list ||= super(); end
+      end
+
+    end # module IcmpCode
+
+    # Various ICMP message structures
+    module Msg
+
+      # Echo message data structure
+      # 
+      #   struct icmp_msg_echo {
+      #     uint16_t  icmp_id;
+      #     uint16_t  icmp_seq;
+      #     uint8_t   icmp_data __flexarr;  /* optional data */
+      #   };
+      # 
+      class Echo < ::FFI::Struct
+        include ::FFI::DRY::StructHelper
+        include ::Dnet::NetEndianHelper
+      
+        dsl_layout do
+          field :icmp_id, :uint16
+          field :seq,     :uint16
+          field :data,    :uint8    # flexarr ... optional data
+        end
+      end
+
+      # Fragmentation-needed (unreachable) message data structure
+      # 
+      #   struct icmp_msg_needfrag {
+      #     uint16_t  icmp_void;    /* must be zero */
+      #     uint16_t  icmp_mtu;    /* MTU of next-hop network */
+      #     uint8_t   icmp_ip __flexarr;  /* IP hdr + 8 bytes of pkt */
+      #   };
+      # 
+      class NeedFrag < ::FFI::Struct
+        include ::FFI::DRY::StructHelper
+        include ::Dnet::NetEndianHelper
+      
+        dsl_layout do
+          field :icmp_void, :uint16
+          field :mtu,       :uint16
+          field :ip,        :uint8    # flexarr ... IP hdr + 8 bytes of pkt
+        end
+      end
+
+      # Unreachable, source quench, redirect, time exceeded,
+      # parameter problem message data structure
+      # 
+      #   struct icmp_msg_quote {
+      #     uint32_t  icmp_void;    /* must be zero */
+      #     uint8_t   icmp_ip __flexarr;  /* IP hdr + 8 bytes of pkt */
+      #   };
+      # 
+      class Quote < ::FFI::Struct
+        include ::FFI::DRY::StructHelper
+        include ::Dnet::NetEndianHelper
+      
+        dsl_layout do
+          field :icmp_void, :uint32 
+          field :ip,        :uint8     # flexxarr ... IP hdr + 8 bytes of pkt
+        end
+      end
+
+      # Router advertisement message data structure, RFC 1256
+      # 
+      #   struct icmp_msg_rtradvert {
+      #     uint8_t    icmp_num_addrs;    /* # of address / pref pairs */
+      #     uint8_t    icmp_wpa;    /* words / address == 2 */
+      #     uint16_t   icmp_lifetime;    /* route lifetime in seconds */
+      #     struct icmp_msg_rtr_data {
+      #       uint32_t  icmp_void;
+      #       uint32_t  icmp_pref;  /* router preference (usu 0) */
+      #     } icmp_rtr __flexarr;      /* variable # of routers */
+      #   };
+      # 
+      class RtrAdvert < ::FFI::Struct
+        include ::FFI::DRY::StructHelper
+        include ::Dnet::NetEndianHelper
+
+        class RtrData < ::FFI::Struct
+          include ::FFI::DRY::StructHelper
+          include ::Dnet::NetEndianHelper
+        
+          dsl_layout do
+            field :icmp_void, :uint32
+            field :pref,      :uint32
+          end
+        end
+
+        dsl_layout do
+          field  :num_addrs, :uint8
+          field  :wpa,       :uint8
+          field  :lifetime,  :uint16
+          struct :router,    RtrData    # flexarr ... variable # of routers
+        end
+      end
+
+      # Timestamp message data structure
+      # 
+      #   struct icmp_msg_tstamp {
+      #     uint32_t  icmp_id;    /* identifier */
+      #     uint32_t  icmp_seq;    /* sequence number */
+      #     uint32_t  icmp_ts_orig;    /* originate timestamp */
+      #     uint32_t  icmp_ts_rx;    /* receive timestamp */
+      #     uint32_t  icmp_ts_tx;    /* transmit timestamp */
+      #   };
+      # 
+      class Timestamp < ::FFI::Struct
+        include ::FFI::DRY::StructHelper
+        include ::Dnet::NetEndianHelper
+      
+        dsl_layout do
+          field :icmp_id, :uint32
+          field :seq,     :uint32
+          field :ts_orig, :uint32
+          field :ts_rx,   :uint32
+          field :ts_tx,   :uint32
+        end
+      end
+
+      # Address mask message data structure, RFC 950
+      # 
+      #   struct icmp_msg_mask {
+      #     uint32_t  icmp_id;    /* identifier */
+      #     uint32_t  icmp_seq;    /* sequence number */
+      #     uint32_t  icmp_mask;    /* address mask */
+      #   };
+      # 
+      class Mask < ::FFI::Struct
+        include ::FFI::DRY::StructHelper
+        include ::Dnet::NetEndianHelper
+
+        dsl_layout do
+          field :icmp_id, :uint32
+          field :seq,     :uint32
+          field :mask,    :uint32
+        end
+      end
+
+      # Traceroute message data structure, RFC 1393, RFC 1812
+      # 
+      #   struct icmp_msg_traceroute {
+      #     uint16_t  icmp_id;    /* identifier */
+      #     uint16_t  icmp_void;    /* unused */
+      #     uint16_t  icmp_ohc;    /* outbound hop count */
+      #     uint16_t  icmp_rhc;    /* return hop count */
+      #     uint32_t  icmp_speed;    /* link speed, bytes/sec */
+      #     uint32_t  icmp_mtu;    /* MTU in bytes */
+      #   };
+      # 
+      class Traceroute < ::FFI::Struct
+        include ::FFI::DRY::StructHelper
+        include ::Dnet::NetEndianHelper
+      
+        dsl_layout do
+          field :icmp_id,   :uint16
+          field :icmp_void, :uint16
+          field :ohc,       :uint16
+          field :rhc,       :uint16
+          field :speed,     :uint16
+          field :mtu,       :uint16
+        end
+      end
+
+      # Domain name reply message data structure, RFC 1788
+      # 
+      #   struct icmp_msg_dnsreply {
+      #     uint16_t  icmp_id;    /* identifier */
+      #     uint16_t  icmp_seq;    /* sequence number */
+      #     uint32_t  icmp_ttl;    /* time-to-live */
+      #     uint8_t    icmp_names __flexarr;  /* variable number of names */
+      #   };
+      # 
+      class DnsReply < ::FFI::Struct
+        include ::FFI::DRY::StructHelper
+        include ::Dnet::NetEndianHelper
+      
+        dsl_layout do
+          field :icmp_id, :uint16
+          field :seq,     :uint16
+          field :ttl,     :uint16
+          field :names,   :uint8    # flexarr ... variable # of names
+        end
+      end
+
+      # Generic identifier, sequence number data structure
+      # 
+      #   struct icmp_msg_idseq {
+      #     uint16_t  icmp_id;
+      #     uint16_t  icmp_seq;
+      #   };
+      # 
+      class IdSeq < ::FFI::Struct
+        include ::FFI::DRY::StructHelper
+        include ::Dnet::NetEndianHelper
+      
+        dsl_layout do
+          field :icmp_id, :uint16
+          field :seq,     :uint16
+        end
+      end
+
+    end # module Msg
+  end
+
+  # /*
+  #  * ICMP message union
+  #  */
+  # union icmp_msg {
+  #   struct icmp_msg_echo     echo;  /* ICMP_ECHO{REPLY} */
+  #   struct icmp_msg_quote     unreach;  /* ICMP_UNREACH */
+  #   struct icmp_msg_needfrag   needfrag;  /* ICMP_UNREACH_NEEDFRAG */
+  #   struct icmp_msg_quote     srcquench;  /* ICMP_SRCQUENCH */
+  #   struct icmp_msg_quote     redirect;  /* ICMP_REDIRECT (set to 0) */
+  #   uint32_t       rtrsolicit;  /* ICMP_RTRSOLICIT */
+  #   struct icmp_msg_rtradvert  rtradvert;  /* ICMP_RTRADVERT */
+  #   struct icmp_msg_quote     timexceed;  /* ICMP_TIMEXCEED */
+  #   struct icmp_msg_quote     paramprob;  /* ICMP_PARAMPROB */
+  #   struct icmp_msg_tstamp     tstamp;  /* ICMP_TSTAMP{REPLY} */
+  #   struct icmp_msg_idseq     info;  /* ICMP_INFO{REPLY} */
+  #   struct icmp_msg_mask     mask;  /* ICMP_MASK{REPLY} */
+  #   struct icmp_msg_traceroute traceroute;  /* ICMP_TRACEROUTE */
+  #   struct icmp_msg_idseq     dns;    /* ICMP_DNS */
+  #   struct icmp_msg_dnsreply   dnsreply;  /* ICMP_DNSREPLY */
+  # };
+
+  # #define icmp_pack_hdr(hdr, type, code) do {        \
+  #   struct icmp_hdr *icmp_pack_p = (struct icmp_hdr *)(hdr);  \
+  #   icmp_pack_p->icmp_type = type; icmp_pack_p->icmp_code = code;  \
+  # } while (0)
+
+  # #define icmp_pack_hdr_echo(hdr, type, code, id, seq, data, len) do {  \
+  #   struct icmp_msg_echo *echo_pack_p = (struct icmp_msg_echo *)  \
+  #     ((uint8_t *)(hdr) + ICMP_HDR_LEN);      \
+  #   icmp_pack_hdr(hdr, type, code);          \
+  #   echo_pack_p->icmp_id = htons(id);        \
+  #   echo_pack_p->icmp_seq = htons(seq);        \
+  #   memmove(echo_pack_p->icmp_data, data, len);      \
+  # } while (0)
+
+
+end # module Dnet::Icmp