From 49a72682a3b1a7fefb1abdd01c3015d3e80297ab Mon Sep 17 00:00:00 2001 From: Brian Candler Date: Sun, 1 May 2011 00:09:34 +0100 Subject: [PATCH] Allow attributes to be defined inline (singleton type) --- lib/netlink/message.rb | 17 +++++++-- lib/netlink/route.rb | 80 ++++++++++++++++++------------------------ 2 files changed, 49 insertions(+), 48 deletions(-) diff --git a/lib/netlink/message.rb b/lib/netlink/message.rb index ff16360..a165594 100644 --- a/lib/netlink/message.rb +++ b/lib/netlink/message.rb @@ -38,6 +38,16 @@ module Netlink def self.define_type(name, opt) TYPE_INFO[name] = opt end + + # Return a type info hash given a type id. Raises IndexError if not found. + def self.find_type(type) + case type + when nil, Hash + type + else + TYPE_INFO.fetch(type) + end + end define_type :uchar, :pattern => "C" define_type :uint16, :pattern => "S" @@ -52,6 +62,7 @@ module Netlink define_type :int, :pattern => "i" define_type :long, :pattern => "l_" define_type :binary, :pattern => "a*", :default => EMPTY_STRING + # cstring has \x00 terminator when sent over wire define_type :cstring, :pattern => "Z*", :default => EMPTY_STRING # L2 addresses are presented as ASCII hex. You may optionally include @@ -158,7 +169,7 @@ module Netlink # field :foo, :uchar # field :foo, :uchar, :default=>0xff # use this default value def self.field(name, type, opt={}) - info = TYPE_INFO[type] + info = find_type(type) self::FIELDS << name self::FORMAT << info[:pattern] self::DEFAULTS[name] = opt.fetch(:default) { info.fetch(:default, 0) } @@ -223,8 +234,8 @@ module Netlink # type (if not provided, it will just be returned as a raw binary string) # rtattr :foo, 12 # rtattr :foo, 12, :uint - def self.rtattr(name, code, type=nil, opt={}) - info = TYPE_INFO[type] + def self.rtattr(name, code, type=nil) + info = find_type(type) self::RTATTRS[code] = [name, info] define_method name do @attrs[name] # rtattrs are optional, non-existent returns nil diff --git a/lib/netlink/route.rb b/lib/netlink/route.rb index 77944cf..4172b92 100644 --- a/lib/netlink/route.rb +++ b/lib/netlink/route.rb @@ -18,10 +18,6 @@ module Netlink :tx_window_errors, :rx_compressed, :tx_compressed - # struct rta_cacheinfo - RTACacheInfo = Struct.new :clntref, :lastuse, :expires, :error, :used, :id, :ts, :tsage - # struct ifa_cacheinfo - IFACacheInfo = Struct.new :prefered, :valid, :cstamp, :tstamp # struct ifmap IFMap = Struct.new :mem_start, :mem_end, :base_addr, :irq, :dma, :port @@ -29,19 +25,6 @@ module Netlink class Link < RtattrMessage code RTM_NEWLINK, RTM_DELLINK, RTM_GETLINK - IFMAP_PACK = "QQQSCC".freeze #:nodoc: - define_type :ifmap, - :pack => lambda { |val,obj| val.to_a.pack(IFMAP_PACK) }, - :unpack => lambda { |str,obj| IFMap.new(*(str.unpack(IFMAP_PACK))) } - - define_type :linkstats32, - :pack => lambda { |val,obj| val.to_a.pack("L23") }, - :unpack => lambda { |str,obj| LinkStats.new(*(str.unpack("L23"))) } - - define_type :linkstats64, - :pack => lambda { |val,obj| val.to_a.pack("Q23") }, - :unpack => lambda { |str,obj| LinkStats.new(*(str.unpack("Q23"))) } - field :family, :uchar # Socket::AF_* field :pad, :uchar field :type, :ushort # ARPHRD_* @@ -54,13 +37,18 @@ module Netlink rtattr :mtu, IFLA_MTU, :uint32 rtattr :link, IFLA_LINK, :int32 rtattr :qdisc, IFLA_QDISC, :cstring - rtattr :stats32, IFLA_STATS, :linkstats32 + rtattr :stats32, IFLA_STATS, + :pack => lambda { |val,obj| val.to_a.pack("L23") }, + :unpack => lambda { |str,obj| LinkStats.new(*(str.unpack("L23"))) } rtattr :cost, IFLA_COST rtattr :master, IFLA_MASTER, :uint32 rtattr :wireless, IFLA_WIRELESS rtattr :protinfo, IFLA_PROTINFO, :uchar rtattr :txqlen, IFLA_TXQLEN, :uint32 - rtattr :map, IFLA_MAP, :ifmap + IFMAP_PACK = "QQQSCC".freeze #:nodoc: + rtattr :map, IFLA_MAP, + :pack => lambda { |val,obj| val.to_a.pack(IFMAP_PACK) }, + :unpack => lambda { |str,obj| IFMap.new(*(str.unpack(IFMAP_PACK))) } rtattr :weight, IFLA_WEIGHT, :uint32 rtattr :operstate, IFLA_OPERSTATE, :uchar rtattr :linkmode, IFLA_LINKMODE, :uchar @@ -69,7 +57,9 @@ module Netlink rtattr :ifalias, IFLA_IFALIAS, :cstring rtattr :num_vf, IFLA_NUM_VF, :uint32 rtattr :vfinfo_list, IFLA_VFINFO_LIST - rtattr :stats64, IFLA_STATS64, :linkstats64 + rtattr :stats64, IFLA_STATS64, + :pack => lambda { |val,obj| val.to_a.pack("Q23") }, + :unpack => lambda { |str,obj| LinkStats.new(*(str.unpack("Q23"))) } rtattr :vf_ports, IFLA_VF_PORTS rtattr :port_self, IFLA_PORT_SELF @@ -79,14 +69,13 @@ module Netlink end end + # struct ifa_cacheinfo + IFACacheInfo = Struct.new :prefered, :valid, :cstamp, :tstamp + # struct ifaddrmsg class Addr < RtattrMessage code RTM_NEWADDR, RTM_DELADDR, RTM_GETADDR - define_type :ifa_cacheinfo, - :pack => lambda { |val,obj| val.to_a.pack("L*") }, - :unpack => lambda { |str,obj| IFACacheInfo.new(*(str.unpack("L*"))) } - field :family, :uchar # Socket::AF_* field :prefixlen, :uchar field :flags, :uchar # IFA_F_* @@ -97,32 +86,19 @@ module Netlink rtattr :label, IFA_LABEL, :cstring rtattr :broadcast, IFA_BROADCAST, :l3addr rtattr :anycast, IFA_ANYCAST, :l3addr - rtattr :cacheinfo, IFA_CACHEINFO, :ifa_cacheinfo + rtattr :cacheinfo, IFA_CACHEINFO, + :pack => lambda { |val,obj| val.to_a.pack("L*") }, + :unpack => lambda { |str,obj| IFACacheInfo.new(*(str.unpack("L*"))) } rtattr :multicast, IFA_MULTICAST, :l3addr end + # struct rta_cacheinfo + RTACacheInfo = Struct.new :clntref, :lastuse, :expires, :error, :used, :id, :ts, :tsage + # struct rtmsg class Route < RtattrMessage code RTM_NEWROUTE, RTM_DELROUTE, RTM_GETROUTE - define_type :rta_cacheinfo, - :pack => lambda { |val,obj| val.to_a.pack("L*") }, - :unpack => lambda { |str,obj| RTACacheInfo.new(*(str.unpack("L*"))) } - - # Route metrics are themselves packed using the rtattr format. - # In the kernel, the dst.metrics structure is an array of u32. - METRIC_PACK = "SSL".freeze #:nodoc: - METRIC_SIZE = [0,0,0].pack(METRIC_PACK).bytesize #:nodoc: - define_type :rtmetrics, - :pack => lambda { |metrics,obj| - metrics.map { |code,val| [METRIC_SIZE,code,val].pack(METRIC_PACK) }.join - }, - :unpack => lambda { |str,obj| - res = {} # in kernel the dst.metrics structure is array of u32 - RtattrMessage.unpack_rtattr(str) { |code,val| res[code] = val.unpack("L").first } - res - } - field :family, :uchar # Socket::AF_* field :dst_len, :uchar field :src_len, :uchar @@ -139,10 +115,24 @@ module Netlink rtattr :gateway, RTA_GATEWAY, :l3addr rtattr :priority, RTA_PRIORITY, :uint32 rtattr :prefsrc, RTA_PREFSRC, :l3addr - rtattr :metrics, RTA_METRICS, :rtmetrics + # Route metrics are themselves packed using the rtattr format. + # In the kernel, the dst.metrics structure is an array of u32. + METRIC_PACK = "SSL".freeze #:nodoc: + METRIC_SIZE = [0,0,0].pack(METRIC_PACK).bytesize #:nodoc: + rtattr :metrics, RTA_METRICS, # {RTAX_* => Integer} + :pack => lambda { |metrics,obj| + metrics.map { |code,val| [METRIC_SIZE,code,val].pack(METRIC_PACK) }.join + }, + :unpack => lambda { |str,obj| + res = {} + RtattrMessage.unpack_rtattr(str) { |code,val| res[code] = val.unpack("L").first } + res + } rtattr :multipath, RTA_MULTIPATH rtattr :flow, RTA_FLOW - rtattr :cacheinfo, RTA_CACHEINFO, :rta_cacheinfo + rtattr :cacheinfo, RTA_CACHEINFO, + :pack => lambda { |val,obj| val.to_a.pack("L*") }, + :unpack => lambda { |str,obj| RTACacheInfo.new(*(str.unpack("L*"))) } rtattr :table2, RTA_TABLE, :uint32 # NOTE: table in two places! end