Basic generation and parsing of rtattr values

lib/netlink/constants.rb

@@ -1,6 +1,6 @@
 require 'socket'
 class Socket
-  # From /usr/include/bits/socket.h
+  # From bits/socket.h
   PF_NETLINK		= 16		unless defined? Socket::PF_NETLINK
   AF_NETLINK		= PF_NETLINK	unless defined? Socket::AF_NETLINK
 end
@@ -145,5 +145,57 @@ module Netlink
   RTPROT_BOOT		= 3
   RTPROT_STATIC		= 4
   
-  # MORE TO GO
+  # XXXX MORE TO GO
+
+  RTA_UNSPEC		= 0
+  RTA_DST		= 1
+  RTA_SRC		= 2
+  RTA_IIF		= 3
+  RTA_OIF		= 4
+  RTA_GATEWAY		= 5
+  RTA_PRIORITY		= 6
+  RTA_PREFSRC		= 7
+  RTA_METRICS		= 8
+  RTA_MULTIPATH		= 9
+  RTA_FLOW		= 11
+  RTA_CACHEINFO		= 12
+  RTA_TABLE		= 15
+  
+  # from linux/if_link.h
+  IFLA_UNSPEC		= 0
+  IFLA_ADDRESS		= 1
+  IFLA_BROADCAST	= 2
+  IFLA_IFNAME		= 3
+  IFLA_MTU		= 4
+  IFLA_LINK		= 5
+  IFLA_QDISC		= 6
+  IFLA_STATS		= 7
+  IFLA_COST		= 8
+  IFLA_PRIORITY		= 9
+  IFLA_MASTER		= 10
+  IFLA_WIRELESS		= 11
+  IFLA_PROTINFO		= 12
+  IFLA_TXQLEN		= 13
+  IFLA_MAP		= 14
+  IFLA_WEIGHT		= 15
+  IFLA_OPERSTATE	= 16
+  IFLA_LINKMODE		= 17
+  IFLA_LINKINFO		= 18
+  IFLA_NET_NS_PID	= 19
+  IFLA_IFALIAS		= 20
+  IFLA_NUM_VF		= 21
+  IFLA_VFINFO_LIST	= 22
+  IFLA_STATS64		= 23
+  IFLA_VF_PORTS		= 24
+  IFLA_PORT_SELF	= 25
+
+  # from linux/if_addr.h
+  IFA_UNSPEC		= 0
+  IFA_ADDRESS		= 1
+  IFA_LOCAL		= 2
+  IFA_LABEL		= 3
+  IFA_BROADCAST		= 4
+  IFA_ANYCAST		= 5
+  IFA_CACHEINFO		= 6
+  IFA_MULTICAST		= 7
 end

lib/netlink/message.rb

@@ -6,16 +6,36 @@ module Netlink
     # Map of numeric message type code => message class
     CODE_TO_MESSAGE = {}
 
+    # Defines each of the possible field types
+    TYPE_INFO = {
+      :uchar	=> { :pattern => "C" },
+      :uint16	=> { :pattern => "S" },
+      :uint32	=> { :pattern => "L" },
+      :char	=> { :pattern => "c" },
+      :int16	=> { :pattern => "s" },
+      :int32	=> { :pattern => "l" },
+      :ushort	=> { :pattern => "S_" },
+      :uint	=> { :pattern => "I" },
+      :ulong	=> { :pattern => "L_" },
+      :short	=> { :pattern => "s_" },
+      :int	=> { :pattern => "i" },
+      :long	=> { :pattern => "l_" },
+      :binary	=> { :pattern => "a*", :default => "" },
+      :cstring	=> { :pattern => "Z*", :default => "" },
+      :stats32	=> { :pattern => "L*", :default => [] },
+      :stats64	=> { :pattern => "Q*", :default => [] },
+    }
+
     # You can initialize a message from a Hash or from another
     # instance of itself.
     #
     #   class Foo < Message
-    #     field :foo, "C", 0xff
+    #     field :foo, :char, :default=>255
-    #     field :bar, "L", 0
+    #     field :bar, :long
     #   end
     #   msg = Foo.new(:bar => 123)  # or ("bar" => 123)
     #   msg2 = Foo.new(msg)
-    #   msg3 = Foo.new(:qux => 999) # error, no method qux=
+    #   msg3 = Foo.new(:qux => 999) # error, no method "qux="
     def initialize(h={})
       if h.instance_of?(self.class)
         @attrs = h.to_hash.dup
@@ -54,12 +74,13 @@ module Netlink
       codes.each { |code| CODE_TO_MESSAGE[code] = self }
     end
     
-    # Define a field for this message, which creates accessor methods. The
+    # Define a field for this message, which creates accessor methods and
-    # "pattern" is the Array#pack or String#unpack code to extract this field.    
+    # sets up data required to pack and unpack the structure.
-    def self.field(name, pattern, default=nil, opt={})
+    def self.field(name, type, opt={})
+      info = TYPE_INFO[type]
       self::FIELDS << name
-      self::FORMAT << pattern
+      self::FORMAT << info[:pattern]
-      self::DEFAULTS[name] = default
+      self::DEFAULTS[name] = opt.fetch(:default) { info.fetch(:default, 0) }
       define_method name do
         @attrs.fetch name
       end
@@ -68,19 +89,6 @@ module Netlink
       end
     end
 
-    def self.uchar(name, *args);	field name, "C", 0, *args; end
-    def self.uint16(name, *args);	field name, "S", 0, *args; end
-    def self.uint32(name, *args);	field name, "L", 0, *args; end
-    def self.char(name, *args);		field name, "c", 0, *args; end
-    def self.int16(name, *args);	field name, "s", 0, *args; end
-    def self.int32(name, *args);	field name, "l", 0, *args; end
-    def self.ushort(name, *args);	field name, "S_", 0, *args; end
-    def self.uint(name, *args);		field name, "I", 0, *args; end
-    def self.ulong(name, *args);	field name, "L_", 0, *args; end
-    def self.short(name, *args);	field name, "s_", 0, *args; end
-    def self.int(name, *args);		field name, "i", 0, *args; end
-    def self.long(name, *args);		field name, "l_", 0, *args; end
-    
     # Returns the packed binary representation of this message (without
     # header, and not padded to NLMSG_ALIGNTO bytes)    
     def to_s
@@ -92,9 +100,9 @@ module Netlink
     end
     
     # Convert a binary representation of this message into an object instance
-    def self.parse(str)
+    def self.parse(data)
       res = new
-      str.unpack(self::FORMAT).zip(self::FIELDS).each do |val, key|
+      data.unpack(self::FORMAT).zip(self::FIELDS).each do |val, key|
         res[key] = val
       end
       res
@@ -114,38 +122,149 @@ module Netlink
     def self.pad(str)
       str << PADDING[0, align(str.bytesize) - str.bytesize]
     end
-
   end
 
-  class Link < Message
+  # This is a class for a Message which is followed by Rtattr key/value pairs.
+  # We assume that any particular attribute is not repeated, so it maps to
+  # a single attribute in the underlying hash.
+  class RtattrMessage < Message
+    RTATTR_PACK = "S_S_".freeze #:nodoc:
+    RTATTR_SIZE = [0,0].pack(RTATTR_PACK).bytesize #:nodoc:
+
+    def self.inherited(subclass) #:nodoc:
+      super
+      subclass.const_set(:RTATTRS, {})
+    end
+
+    def self.rtattr(name, code, type=nil, opt={})
+      info = TYPE_INFO[type]
+      self::RTATTRS[code] = [name, info && info[:pattern]]
+      define_method name do
+        @attrs.fetch name
+      end
+      define_method "#{name}=" do |val|
+        @attrs.store name, val
+      end
+    end
+
+    def self.attr_offset #:nodoc:
+      @attr_offset ||= Message.align(new.to_s.bytesize)
+    end
+    
+    def to_s
+      data = super
+      self.class::RTATTRS.each do |code, (name, pattern)|
+        if val = @attrs[name]
+          Message.pad(data)
+          val = Array(val).pack(pattern) if pattern
+          data << [val.bytesize+RTATTR_SIZE, code].pack(RTATTR_PACK) << val
+        end
+      end
+      data
+    end
+    
+    def self.parse(data)
+      res = super
+      ptr = attr_offset
+      while ptr < data.bytesize
+        raise "Truncated rtattr header!" if ptr + RTATTR_SIZE > data.bytesize
+        len, code = data[ptr, RTATTR_SIZE].unpack(RTATTR_PACK)
+        raise "Truncated rtattr body!" if ptr + len > data.bytesize
+        raise "Invalid rtattr len!" if len < RTATTR_SIZE
+        res._add_attr(code, data[ptr+RTATTR_SIZE, len-RTATTR_SIZE])
+        ptr = Message.align(ptr + len)
+      end
+      res
+    end
+    
+    def _add_attr(code, val) # :nodoc:
+      name, pattern = self.class::RTATTRS[code]
+      if name
+        if pattern
+          val = val.unpack(pattern)
+          val = val.first if val.size == 1
+        end
+        warn "Duplicate attribute #{name} (#{code}): #{@attrs[name].inspect} -> #{val.inspect}" if @attrs[name]
+        @attrs[name] = val
+      else
+        warn "Unknown attribute #{code}, value #{val.inspect}"
+        @attrs[code] = val
+      end
+    end
+  end
+
+  class Link < RtattrMessage
     code RTM_NEWLINK, RTM_DELLINK, RTM_GETLINK
-    uchar :family
+    field :family, :uchar
-    uchar :pad
+    field :pad, :uchar
-    ushort :type
+    field :type, :ushort
-    int :index
+    field :index, :int
-    uint :flags
+    field :flags, :uint
-    uint :change
+    field :change, :uint
+    rtattr :address, IFLA_ADDRESS
+    rtattr :broadcast, IFLA_BROADCAST
+    rtattr :ifname, IFLA_IFNAME, :cstring
+    rtattr :mtu, IFLA_MTU, :uint32
+    rtattr :link, IFLA_LINK, :int32
+    rtattr :qdisc, IFLA_QDISC, :cstring
+    rtattr :stats, IFLA_STATS, :stats32
+    rtattr :cost, IFLA_COST
+    rtattr :master, IFLA_MASTER
+    rtattr :wireless, IFLA_WIRELESS
+    rtattr :protinfo, IFLA_PROTINFO
+    rtattr :txqlen, IFLA_TXQLEN, :uint32
+    rtattr :map, IFLA_MAP
+    rtattr :weight, IFLA_WEIGHT
+    rtattr :operstate, IFLA_OPERSTATE, :uchar
+    rtattr :linkmode, IFLA_LINKMODE, :uchar
+    rtattr :linkinfo, IFLA_LINKINFO
+    rtattr :net_ns_pid, IFLA_NET_NS_PID
+    rtattr :ifalias, IFLA_IFALIAS
+    rtattr :num_vf, IFLA_NUM_VF, :uint32
+    rtattr :vfinfo_list, IFLA_VFINFO_LIST
+    rtattr :stats64, IFLA_STATS64, :stats64
+    rtattr :vf_ports, IFLA_VF_PORTS
+    rtattr :port_self, IFLA_PORT_SELF
   end
 
-  class Addr < Message
+  class Addr < RtattrMessage
     code RTM_NEWADDR, RTM_DELADDR, RTM_GETADDR
-    uchar :family
+    field :family, :uchar
-    uchar :prefixlen
+    field :prefixlen, :uchar
-    uchar :flags
+    field :flags, :uchar
-    uchar :scope
+    field :scope, :uchar
-    int :index
+    field :index, :int
+    rtattr :address, IFA_ADDRESS
+    rtattr :local, IFA_LOCAL
+    rtattr :label, IFA_LABEL, :cstring
+    rtattr :broadcast, IFA_BROADCAST
+    rtattr :anycase, IFA_ANYCAST
+    rtattr :cacheinfo, IFA_CACHEINFO
+    rtattr :multicast, IFA_MULTICAST
   end
 
-  class Route < Message
+  class Route < RtattrMessage
     code RTM_NEWROUTE, RTM_DELROUTE, RTM_GETROUTE
-    uchar :family
+    field :family, :uchar
-    uchar :dst_len
+    field :dst_len, :uchar
-    uchar :src_len
+    field :src_len, :uchar
-    uchar :tos
+    field :tos, :uchar
-    uchar :table
+    field :table, :uchar
-    uchar :protocol
+    field :protocol, :uchar
-    uchar :scope
+    field :scope, :uchar
-    uchar :type
+    field :type, :uchar
-    uint :flags
+    field :flags, :uint
+    rtattr :dst, RTA_DST
+    rtattr :src, RTA_SRC
+    rtattr :iif, RTA_IIF, :uint32
+    rtattr :oif, RTA_OIF, :uint32
+    rtattr :gateway, RTA_GATEWAY
+    rtattr :priority, RTA_PRIORITY, :uint32
+    rtattr :prefsrc, RTA_PREFSRC
+    rtattr :metrics, RTA_METRICS
+    rtattr :multipath, RTA_MULTIPATH
+    rtattr :flow, RTA_FLOW
+    rtattr :cacheinfo, RTA_CACHEINFO
+    rtattr :table2, RTA_TABLE, :uint32   # NOTE: table in two places!
   end
 end

lib/netlink/nlsocket.rb

@@ -7,7 +7,6 @@ module Netlink
     DEFAULT_TIMEOUT = 2
 
     SOCKADDR_PACK = "SSLL".freeze #:nodoc:
-    SOCKADDR_SIZE = 12 # :nodoc:
 
     # Generate a sockaddr_nl. Pass :pid and/or :groups.
     def self.sockaddr(opt={})
@@ -71,7 +70,7 @@ module Netlink
     end
 
     NLMSGHDR_PACK = "LSSLL".freeze  # :nodoc:
-    NLMSGHDR_SIZE = 16 # :nodoc:
+    NLMSGHDR_SIZE = [0,0,0,0,0].pack(NLMSGHDR_PACK).bytesize # :nodoc:
 
     # Build a message comprising header+body. It is not padded at the end.
     def build_message(type, body, flags=NLM_F_REQUEST, seq=(@seq += 1), pid=@pid)
@@ -164,6 +163,7 @@ module Netlink
         len, type, flags, seq, pid = mesg[ptr,NLMSGHDR_SIZE].unpack(NLMSGHDR_PACK)
         STDERR.puts "  len=#{len}, type=#{type}, flags=#{flags}, seq=#{seq}, pid=#{pid}" if $DEBUG
         raise "Truncated netlink message!" if ptr + len > mesg.bytesize
+        raise "Invalid netlink len!" if len < NLMSGHDR_SIZE
         data = mesg[ptr+NLMSGHDR_SIZE, len-NLMSGHDR_SIZE]
         STDERR.puts "  data=#{data.inspect}" if $DEBUG && !data.empty?
         yield type, flags, seq, pid, data

lib/netlink/rtsocket.rb

@@ -47,7 +47,10 @@ end
 if __FILE__ == $0
   require 'pp'
   nl = Netlink::RTSocket.new
+  puts "*** routes ***"
   pp nl.route_list(:family => Socket::AF_INET)
+  puts "*** links ***"
   pp nl.link_list(:family => Socket::AF_INET)
+  puts "*** addrs ***"
   pp nl.addr_list(:family => Socket::AF_INET)
 end