libeap/tests/hwsim/netlink.py

   1 #
   2 # (Generic) Netlink message generation/parsing
   3 # Copyright (c) 2007    Johannes Berg <johannes@sipsolutions.net>
   4 # Copyright (c) 2014    Intel Corporation
   5 #
   6 # This software may be distributed under the terms of the BSD license.
   7 # See README for more details.
   8
   9 import struct, socket
  10
  11 # flags
  12 NLM_F_REQUEST = 1
  13 NLM_F_MULTI = 2
  14 NLM_F_ACK = 4
  15 NLM_F_ECHO = 8
  16
  17 # types
  18 NLMSG_NOOP      = 1
  19 NLMSG_ERROR     = 2
  20 NLMSG_DONE      = 3
  21 NLMSG_OVERRUN   = 4
  22 NLMSG_MIN_TYPE  = 0x10
  23
  24 class Attr(object):
  25     def __init__(self, attr_type, data, *values):
  26         self._type = attr_type
  27         if len(values):
  28             self._data = struct.pack(data, *values)
  29         else:
  30             self._data = data
  31
  32     def _dump(self):
  33         hdr = struct.pack("HH", len(self._data) + 4, self._type)
  34         length = len(self._data)
  35         pad = ((length + 4 - 1) & ~3 ) - length
  36         return hdr + self._data + '\0' * pad
  37
  38     def __repr__(self):
  39         return '<Attr type %d, data "%s">' % (self._type, repr(self._data))
  40
  41     def u16(self):
  42         return struct.unpack('H', self._data)[0]
  43     def s16(self):
  44         return struct.unpack('h', self._data)[0]
  45     def u32(self):
  46         return struct.unpack('I', self._data)[0]
  47     def s32(self):
  48         return struct.unpack('i', self._data)[0]
  49     def str(self):
  50         return self._data
  51     def nulstr(self):
  52         return self._data.split('\0')[0]
  53     def nested(self):
  54         return parse_attributes(self._data)
  55
  56 class StrAttr(Attr):
  57     def __init__(self, attr_type, data):
  58         Attr.__init__(self, attr_type, "%ds" % len(data), data)
  59
  60 class NulStrAttr(Attr):
  61     def __init__(self, attr_type, data):
  62         Attr.__init__(self, attr_type, "%dsB" % len(data), data, 0)
  63
  64 class U32Attr(Attr):
  65     def __init__(self, attr_type, val):
  66         Attr.__init__(self, attr_type, "I", val)
  67
  68 class U8Attr(Attr):
  69     def __init__(self, attr_type, val):
  70         Attr.__init__(self, attr_type, "B", val)
  71
  72 class FlagAttr(Attr):
  73     def __init__(self, attr_type):
  74         Attr.__init__(self, attr_type, "")
  75
  76 class Nested(Attr):
  77     def __init__(self, attr_type, attrs):
  78         self.attrs = attrs
  79         self.type = attr_type
  80
  81     def _dump(self):
  82         contents = []
  83         for attr in self.attrs:
  84             contents.append(attr._dump())
  85         contents = ''.join(contents)
  86         length = len(contents)
  87         hdr = struct.pack("HH", length+4, self.type)
  88         return hdr + contents
  89
  90 NETLINK_ROUTE           = 0
  91 NETLINK_UNUSED          = 1
  92 NETLINK_USERSOCK        = 2
  93 NETLINK_FIREWALL        = 3
  94 NETLINK_INET_DIAG       = 4
  95 NETLINK_NFLOG           = 5
  96 NETLINK_XFRM            = 6
  97 NETLINK_SELINUX         = 7
  98 NETLINK_ISCSI           = 8
  99 NETLINK_AUDIT           = 9
 100 NETLINK_FIB_LOOKUP      = 10
 101 NETLINK_CONNECTOR       = 11
 102 NETLINK_NETFILTER       = 12
 103 NETLINK_IP6_FW          = 13
 104 NETLINK_DNRTMSG         = 14
 105 NETLINK_KOBJECT_UEVENT  = 15
 106 NETLINK_GENERIC         = 16
 107
 108 class Message(object):
 109     def __init__(self, msg_type, flags=0, seq=-1, payload=None):
 110         self.type = msg_type
 111         self.flags = flags
 112         self.seq = seq
 113         self.pid = -1
 114         payload = payload or []
 115         if isinstance(payload, list):
 116             contents = []
 117             for attr in payload:
 118                 contents.append(attr._dump())
 119             self.payload = ''.join(contents)
 120         else:
 121             self.payload = payload
 122
 123     def send(self, conn):
 124         if self.seq == -1:
 125             self.seq = conn.seq()
 126
 127         self.pid = conn.pid
 128         length = len(self.payload)
 129
 130         hdr = struct.pack("IHHII", length + 4*4, self.type,
 131                           self.flags, self.seq, self.pid)
 132         conn.send(hdr + self.payload)
 133
 134     def __repr__(self):
 135         return '<netlink.Message type=%d, pid=%d, seq=%d, flags=0x%x "%s">' % (
 136             self.type, self.pid, self.seq, self.flags, repr(self.payload))
 137
 138     @property
 139     def ret(self):
 140         assert self.type == NLMSG_ERROR
 141         return struct.unpack("i", self.payload[:4])[0]
 142
 143     def send_and_recv(self, conn):
 144         self.send(conn)
 145         while True:
 146             m = conn.recv()
 147             if m.seq == self.seq:
 148                 return m
 149
 150 class Connection(object):
 151     def __init__(self, nltype, groups=0, unexpected_msg_handler=None):
 152         self.descriptor = socket.socket(socket.AF_NETLINK,
 153                                         socket.SOCK_RAW, nltype)
 154         self.descriptor.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 65536)
 155         self.descriptor.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 65536)
 156         self.descriptor.bind((0, groups))
 157         self.pid, self.groups = self.descriptor.getsockname()
 158         self._seq = 0
 159         self.unexpected = unexpected_msg_handler
 160     def send(self, msg):
 161         self.descriptor.send(msg)
 162     def recv(self):
 163         contents = self.descriptor.recv(16384)
 164         # XXX: python doesn't give us message flags, check
 165         #      len(contents) vs. msglen for TRUNC
 166         msglen, msg_type, flags, seq, pid = struct.unpack("IHHII",
 167                                                           contents[:16])
 168         msg = Message(msg_type, flags, seq, contents[16:])
 169         msg.pid = pid
 170         if msg.type == NLMSG_ERROR:
 171             import os
 172             errno = msg.ret
 173             if errno < 0:
 174                 err = OSError("Netlink error: %s (%d)" % (
 175                     os.strerror(-errno), -errno))
 176                 err.errno = -errno
 177                 raise err
 178         return msg
 179     def seq(self):
 180         self._seq += 1
 181         return self._seq
 182
 183 def parse_attributes(data):
 184     attrs = {}
 185     while len(data):
 186         attr_len, attr_type = struct.unpack("HH", data[:4])
 187         attrs[attr_type] = Attr(attr_type, data[4:attr_len])
 188         attr_len = ((attr_len + 4 - 1) & ~3 )
 189         data = data[attr_len:]
 190     return attrs
 191
 192
 193
 194 CTRL_CMD_UNSPEC         = 0
 195 CTRL_CMD_NEWFAMILY      = 1
 196 CTRL_CMD_DELFAMILY      = 2
 197 CTRL_CMD_GETFAMILY      = 3
 198 CTRL_CMD_NEWOPS         = 4
 199 CTRL_CMD_DELOPS         = 5
 200 CTRL_CMD_GETOPS         = 6
 201
 202 CTRL_ATTR_UNSPEC        = 0
 203 CTRL_ATTR_FAMILY_ID     = 1
 204 CTRL_ATTR_FAMILY_NAME   = 2
 205 CTRL_ATTR_VERSION       = 3
 206 CTRL_ATTR_HDRSIZE       = 4
 207 CTRL_ATTR_MAXATTR       = 5
 208 CTRL_ATTR_OPS           = 6
 209
 210 class GenlHdr(object):
 211     def __init__(self, cmd, version = 0):
 212         self.cmd = cmd
 213         self.version = version
 214     def _dump(self):
 215         return struct.pack("BBxx", self.cmd, self.version)
 216
 217 def _genl_hdr_parse(data):
 218     return GenlHdr(*struct.unpack("BBxx", data))
 219
 220 GENL_ID_CTRL            = NLMSG_MIN_TYPE
 221
 222 class GenlMessage(Message):
 223     def __init__(self, family, cmd, attrs=[], flags=0):
 224         Message.__init__(self, family, flags=flags, payload=[GenlHdr(cmd)] + attrs)
 225
 226 class GenlController(object):
 227     def __init__(self, conn):
 228         self.conn = conn
 229     def get_family_id(self, family):
 230         a = NulStrAttr(CTRL_ATTR_FAMILY_NAME, family)
 231         m = GenlMessage(GENL_ID_CTRL, CTRL_CMD_GETFAMILY, flags=NLM_F_REQUEST, attrs=[a])
 232         m.send(self.conn)
 233         m = self.conn.recv()
 234         gh = _genl_hdr_parse(m.payload[:4])
 235         attrs = parse_attributes(m.payload[4:])
 236         return attrs[CTRL_ATTR_FAMILY_ID].u16()
 237
 238 genl_controller = GenlController(Connection(NETLINK_GENERIC))