dnet-ffi 0.1.3

data/lib/dnet/ip6.rb

@@ -0,0 +1,59 @@
+module Dnet
+  # /*
+  #  * IPv6 header
+  #  */
+  # struct ip6_hdr {
+  # 	union {
+  # 		struct ip6_hdr_ctl {
+  # 			uint32_t	ip6_un1_flow; /* 20 bits of flow ID */
+  # 			uint16_t	ip6_un1_plen; /* payload length */
+  # 			uint8_t		ip6_un1_nxt;  /* next header */
+  # 			uint8_t		ip6_un1_hlim; /* hop limit */
+  # 		} ip6_un1;
+  # 		uint8_t	ip6_un2_vfc;	/* 4 bits version, top 4 bits class */
+  # 	} ip6_ctlun;
+  # 	ip6_addr_t	ip6_src;
+  # 	ip6_addr_t	ip6_dst;
+  # } __attribute__((__packed__));
+
+
+  # 
+  #  Preferred extension header order from RFC 2460, 4.1:
+  #
+  #  IP_PROTO_IPV6, IP_PROTO_HOPOPTS, IP_PROTO_DSTOPTS, IP_PROTO_ROUTING,
+  #  IP_PROTO_FRAGMENT, IP_PROTO_AH, IP_PROTO_ESP, IP_PROTO_DSTOPTS, 
+  #  IP_PROTO_*
+  #
+
+  # /*
+  #  * Routing header data (IP_PROTO_ROUTING)
+  #  */
+  # struct ip6_ext_data_routing {
+  # 	uint8_t  type;			/* routing type */
+  # 	uint8_t  segleft;		/* segments left */
+  # 	/* followed by routing type specific data */
+  # } __attribute__((__packed__));
+
+
+  # struct ip6_ext_data_routing0 {
+  # 	uint8_t  type;			/* always zero */
+  # 	uint8_t  segleft;		/* segments left */
+  # 	uint8_t  reserved;		/* reserved field */
+  # 	uint8_t  slmap[3];		/* strict/loose bit map */
+  # 	ip6_addr_t  addr[1];		/* up to 23 addresses */
+  # } __attribute__((__packed__));
+
+
+  # /*
+  #  * Fragment header data (IP_PROTO_FRAGMENT)
+  #  */
+  # struct ip6_ext_data_fragment {
+  # 	uint16_t  offlg;		/* offset, reserved, and flag */
+  # 	uint32_t  ident;		/* identification */
+  # } __attribute__((__packed__));
+  # 
+  #     void ip6_checksum(void *buf, size_t len);
+
+  attach_function :ip6_checksum, [:pointer, :size_t], :void
+
+end

data/lib/dnet/rand.rb

@@ -0,0 +1,33 @@
+
+### libdnet's random number generation
+
+module Dnet
+
+  # rand_t * rand_open(void);
+  attach_function :rand_open, [], :pointer
+
+  # int rand_get(rand_t *r, void *buf, size_t len);
+  attach_function :rand_get, [:pointer, :string, :size_t], :int
+
+  # int rand_set(rand_t *r, const void *seed, size_t len);
+  attach_function :rand_set, [:pointer, :string, :size_t], :int
+
+  # int rand_add(rand_t *r, const void *buf, size_t len);
+  attach_function :rand_add, [:pointer, :string, :size_t], :int
+
+  # uint8_t rand_uint8(rand_t *r);
+  attach_function :rand_uint8, [:pointer], :uint8
+
+  # uint16 t rand_uint16(rand_t *r);
+  attach_function :rand_uint16, [:pointer], :uint16
+
+  # uint32_t rand_uint32(rand_t *r);
+  attach_function :rand_uint32, [:pointer], :uint32
+
+  # int rand_shuffle(rand_t *r, void *base, size_t nmemb, size_t size);
+  attach_function :rand_shuffle, [:pointer, :string, :size_t, :size_t], :int
+
+  # rand_t * rand_close(rand_t *r);
+  attach_function :rand_close, [:pointer], :pointer
+
+end

data/lib/dnet/route.rb

@@ -0,0 +1,103 @@
+
+### dnet(3) routing interface
+
+module Dnet
+
+  module Route
+    # Routing table entry
+    #
+    #   struct route_entry {
+    #      struct addr    route_dst;   /* destination address */
+    #      struct addr    route_gw;    /* gateway address */
+    #   };
+    class Entry < ::FFI::Struct
+      include ::FFI::DRY::StructHelper
+    
+      dsl_layout do
+        struct :dst, ::Dnet::Addr, :dest => 'destination gateway'
+        struct :gw,  ::Dnet::Addr, :dest => 'gateway address'
+      end
+    end
+
+    # Obtains a handle to access the kernel route(4) table.
+    class Handle < LoopableHandle
+      attr_reader :handle
+
+      # Obtains a handle to access the kernel route(4) table. Uses dnet(3)'s 
+      # route_open() under the hood.
+      def initialize
+        if (@handle = ::Dnet.route_open()).address == 0
+          raise H_ERR.new("unable to open route handle")
+        end
+        _handle_opened!
+      end
+
+      # Closes the routing handle handle. Uses dnet(3)'s route_close() under the
+      # hood.
+      def close
+        _do_if_open { _handle_closed! ; ::Dnet.route_close(@fw) }
+      end
+
+      # Iterates over the kernel route(4) table, invoking the specified block
+      # with each route cast as a Entry object. Uses dnet(3)'s route_loop() 
+      # function under the hood.
+      def loop &block
+        _loop ::Dnet, :route_loop, Entry, &block
+      end
+
+      # Retrieves the routing table entry for the destination 'dst' (supplied as
+      # a String argument and parsed via dnet(3)'s addr_aton() function). Uses 
+      # dnet(3)'s route_get() under the hood.
+      def get(dst)
+        _check_open!
+        re = Entry.new
+        if( re.dst.set_string(dst) and ::Dnet.route_get(@handle, re) == 0 )
+          return re 
+        end
+      end
+
+
+      # Adds a new routing table entry (supplied as a Entry). Uses dnet(3)'s 
+      # route_add() under the hood.
+      def add(entry)
+        _check_open!
+        ::Dnet.route_add(@handle, entry)
+      end
+
+      # Delete's the specified route entry for the destination prefix specified
+      # by the destination 'dst' (supplied as a String argument and parsed
+      # by dnet(3)'s addr_aton function). 
+      def delete(dst)
+        _check_open!
+        re = Entry.new
+        if( re.dst.set_string(dst) and ::Dnet.route_get(@handle, re) == 0 )
+          return re 
+        end
+      end
+    end # Handle
+
+    def self.open(*args)
+      Handle.open(*args){|*y| yield(*y) if block_given? }
+    end
+
+    def self.entries
+      Handle.entries
+    end
+
+    def self.each_entry(*args)
+      Handle.each_entry(*args){|*y| yield(*y) }
+    end
+  end # Route
+
+  # just an alias for Route::Handle
+  RouteHandle = Route::Handle
+
+  callback :route_handler, [:route_t, :string], :int
+  attach_function :route_open, [], :route_t
+  attach_function :route_add, [:route_t, Route::Entry], :int
+  attach_function :route_delete, [:route_t, Route::Entry], :int
+  attach_function :route_get, [:route_t, Route::Entry], :int
+  attach_function :route_loop, [:route_t, :route_handler, :ulong], :int
+  attach_function :route_close, [:route_t], :route_t
+
+end

data/lib/dnet/tcp.rb

@@ -0,0 +1,103 @@
+module Dnet
+  module Tcp
+
+    # TCP header, without options
+    #
+    #   field :sport,  :uint16, :desc => 'source port'
+    #   field :dport,  :uint16, :desc => 'destination port'
+    #   field :seq,    :uint32, :desc => 'sequence number'
+    #   field :ack,    :uint32, :desc => 'acknowledgment number'
+    #   field :off_x2, :uint8,  :desc => 'data offset(& 0xf0) unused (& 0x0f)'
+    #   field :flags,  :uint8,  :desc => 'control flags'
+    #   field :win,    :uint16, :desc => 'window'
+    #   field :sum,    :uint16, :desc => 'checksum'
+    #   field :urgp,   :uint16, :desc => 'urgent pointer'
+    #
+    class Hdr < ::FFI::Struct
+      include ::FFI::DRY::StructHelper
+      include ::Dnet::NetEndianHelper
+    
+      dsl_layout do
+        field :sport,  :uint16, :desc => 'source port'
+        field :dport,  :uint16, :desc => 'destination port'
+        field :seq,    :uint32, :desc => 'sequence number'
+        field :ack,    :uint32, :desc => 'acknowledgment number'
+        field :off_x2, :uint8,  :desc => 'data offset(& 0xf0) unused (& 0x0f)'
+        field :flags,  :uint8,  :desc => 'control flags'
+        field :win,    :uint16, :desc => 'window'
+        field :sum,    :uint16, :desc => 'checksum'
+        field :urgp,   :uint16, :desc => 'urgent pointer'
+      end
+
+      # TCP control flags (flags)
+      module Flags
+        include ::FFI::DRY::ConstFlagsMap
+        slurp_constants(::Dnet, "TH_")
+        def self.list; @@list ||= super() ; end
+      end
+
+      #  #define \
+      #    tcp_pack_hdr(hdr, sport, dport, seq, ack, flags, win, urp) do { \
+      #      struct tcp_hdr *tcp_pack_p = (struct tcp_hdr *)(hdr);    \
+      #      tcp_pack_p->th_sport = htons(sport);                     \
+      #      tcp_pack_p->th_dport = htons(dport);                     \
+      #      tcp_pack_p->th_seq = htonl(seq);                         \
+      #      tcp_pack_p->th_ack = htonl(ack);                         \
+      #      tcp_pack_p->th_x2 = 0; tcp_pack_p->th_off = 5;           \
+      #      tcp_pack_p->th_flags = flags;                            \
+      #      tcp_pack_p->th_win = htons(win);                         \
+      #      tcp_pack_p->th_urp = htons(urp);                         \
+      #  } while (0)
+
+    end
+
+    #
+    # TCP option (following TCP header)
+    #
+    #   struct tcp_opt {
+    #      uint8_t        opt_type;  /* option type */
+    #      uint8_t        opt_len;   /* option length >= TCP_OPT_LEN */
+    #      union tcp_opt_data {
+    #        uint16_t    mss;           /* TCP_OPT_MSS */
+    #        uint8_t        wscale;     /* TCP_OPT_WSCALE */
+    #        uint16_t    sack[19];      /* TCP_OPT_SACK */
+    #        uint32_t    echo;          /* TCP_OPT_ECHO{REPLY} */
+    #        uint32_t    timestamp[2];  /* TCP_OPT_TIMESTAMP */
+    #        uint32_t    cc;            /* TCP_OPT_CC{NEW,ECHO} */
+    #        uint8_t        cksum;      /* TCP_OPT_ALTSUM */
+    #        uint8_t        md5[16];    /* TCP_OPT_MD5 */
+    #        uint8_t        data8[TCP_OPT_LEN_MAX - TCP_OPT_LEN];
+    #      } opt_data;
+    #   } __attribute__((__packed__));
+    #
+    class Opt < ::FFI::Struct
+      include ::FFI::DRY::StructHelper
+      include ::Dnet::NetEndianHelper
+
+      DATA_LEN = TCP_OPT_LEN_MAX - TCP_OPT_LEN
+    
+      dsl_layout do
+        field :otype,  :uint8
+        field :len,    :uint8
+        array :data8,  [:uint8, DATA_LEN]
+      end
+
+      # Options (otype) - http://www.iana.org/assignments/tcp-parameters
+      module Otype
+        include ::FFI::DRY::ConstMap
+        slurp_constants(::Dnet, "TCP_OTYPE_")
+        def self.list; @@list ||= super() ; end
+      end
+
+    end # class Opt
+
+    # TCP FSM states
+    module State
+      include ::FFI::DRY::ConstMap
+      slurp_constants(::Dnet, "TCP_STATE_")
+      def self.list; @@list ||= super() ; end
+    end
+
+  end # module Tcp
+end # module Dnet
+

data/lib/dnet/tun.rb

@@ -0,0 +1,24 @@
+
+### libdnet's tunnel interface
+
+module Dnet
+
+  # tun_t * tun_open(struct addr *src, struct addr *dst, int mtu);
+  attach_function :tun_open, [:pointer, :pointer, :int], :pointer
+
+  # int tun_fileno(tun_t *t);
+  attach_function :tun_fileno, [:pointer], :int
+
+  # const char * tun_name(tun_t *t);
+  attach_function :tun_name, [:pointer], :string
+
+  # ssize_t tun_send(tun_t *t, const void *buf, size_t size);
+  attach_function :tun_send, [:pointer, :string, :size_t], :ssize_t
+
+  # ssize_t tun_recv(tun_t *t, void *buf, size_t size);
+  attach_function :tun_recv, [:pointer, :string, :size_t], :ssize_t
+
+  # tun_t * tun_close(tun_t *t);
+  attach_function :tun_close, [:pointer], :pointer
+
+end

data/lib/dnet/typedefs.rb

@@ -0,0 +1,12 @@
+
+module Dnet
+
+  typedef :uint32,  :ip_addr_t
+
+  typedef :pointer, :eth_t
+  typedef :pointer, :fw_t
+  typedef :pointer, :intf_t
+  typedef :pointer, :ip_t
+  typedef :pointer, :route_t
+
+end

data/lib/dnet/udp.rb

@@ -0,0 +1,31 @@
+module Dnet
+
+  class Udp
+    class Hdr < ::FFI::Struct
+      include ::FFI::DRY::StructHelper 
+      include ::Dnet::NetEndianHelper
+
+      # struct udp_hdr {
+      #   uint16_t	uh_sport;	/* source port */
+      #  	uint16_t	uh_dport;	/* destination port */
+      #  	uint16_t	uh_ulen;	/* udp length (including header) */
+      #  	uint16_t	uh_sum;		/* udp checksum */
+      # };
+      dsl_layout do
+        field :sport,   :uint16
+        field :dport,   :uint16
+        field :len,     :uint16
+        field :sum,     :uint16
+      end
+    end
+  end
+
+
+  #  #define udp_pack_hdr(hdr, sport, dport, ulen) do {		\
+  #  	struct udp_hdr *udp_pack_p = (struct udp_hdr *)(hdr);	\
+  #  	udp_pack_p->uh_sport = htons(sport);			\
+  #  	udp_pack_p->uh_dport = htons(dport);			\
+  #  	udp_pack_p->uh_ulen = htons(ulen);			\
+  #  } while (0)
+
+end

data/lib/dnet/util.rb

@@ -0,0 +1,70 @@
+
+module Dnet
+  module Util
+    RX_IP4_ADDR = /(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)/
+    RX_MAC_ADDR = /(?:(?:[a-f0-9]{1,2}[:-])?{5}[a-f0-9]{1,2})/i
+
+    # A number of helper methods which can be used to extend class, instance, 
+    # or module
+    module Helpers
+
+      def unhexify(str, d=/\s*/)
+        str.to_s.strip.gsub(/([A-Fa-f0-9]{1,2})#{d}?/) { $1.hex.chr }
+      end
+
+      # Attempts to derive a memory pointer and length from an "anonymous" object.
+      # Returns an an array object containing [len, pointer]
+      #
+      # buf can be a String or FFI::Pointer. If it is a Pointer, bsz must also
+      # be supplied for the length. If bsz is included with a String, the string
+      # will be truncated if it is longer.
+      #
+      # This is mostly used to support multiple argument types in various 
+      # functions.
+      def derive_pointer(buf, bsz=nil)
+        case buf
+        when ::FFI::Pointer
+          raise "no length specified for pointer" if bsz.nil?
+          raise "size must be a number >= 0" unless bsz.is_a? Numeric and bsz >= 0
+          raise "null pointer #{buf.inspect}" if buf.address == 0
+          pbuf = buf
+        when String
+          buf = buf[0,bsz] if bsz
+          pbuf = ::FFI::MemoryPointer.from_string(buf)
+          bsz = buf.size
+        else
+          raise "cannot derive a pointer and size from a #{buf.class}"
+        end
+        return [pbuf, bsz]
+      end
+      
+      # takes a IPv4 number and returns it as a 32-bit number
+      def ipv4_atol(str)
+        unless str =~ /^#{::Dnet::Util::RX_IP4_ADDR}$/
+          raise(::ArgumentError, "invalid IP address #{str.inspect}")
+        else
+          u32=0
+          str.split('.',4).each {|o| u32 = ((u32 << 8) | o.to_i) }
+          return u32
+        end
+      end
+
+      # takes a 32-bit number and returns it as an IPv4 address string.
+      def ipv4_ltoa(int)
+        unless(int.is_a? Numeric and int <= 0xffffffff)
+          raise(::ArgumentError, "not a long integer: #{int.inspect}")
+        end
+        ret = []
+        4.times do 
+          ret.unshift(int & 0xff)
+          int >>= 8
+        end
+        ret.join('.')
+      end
+
+    end # module Helpers
+
+    extend(::Dnet::Util::Helpers)
+  end # module Util
+
+end