271 lines
7.6 KiB
Python
271 lines
7.6 KiB
Python
'''
|
|
Netlink message generation/parsing
|
|
|
|
Copyright 2007 Johannes Berg <johannes@sipsolutions.net>
|
|
|
|
GPLv2+; See copying for details.
|
|
'''
|
|
|
|
import os
|
|
import socket
|
|
import struct
|
|
|
|
try:
|
|
# try to use Python 2.5's netlink support
|
|
_dummysock = socket.socket(socket.AF_NETLINK, socket.SOCK_RAW, 0)
|
|
_dummysock.bind((0, 0))
|
|
del _dummysock
|
|
|
|
def _nl_bind(descriptor, addr):
|
|
descriptor.bind(addr)
|
|
|
|
def _nl_getsockname(descriptor):
|
|
return descriptor.getsockname()
|
|
|
|
def _nl_send(descriptor, msg):
|
|
descriptor.send(msg)
|
|
|
|
def _nl_recv(descriptor, bufs=16384):
|
|
return descriptor.recvfrom(bufs)
|
|
except socket.error:
|
|
# or fall back to the _netlink C module
|
|
try:
|
|
import _netlink
|
|
|
|
def _nl_bind(descriptor, addr):
|
|
_netlink.bind(descriptor.fileno(), addr[1])
|
|
|
|
def _nl_getsockname(descriptor):
|
|
return _netlink.getsockname(descriptor.fileno())
|
|
|
|
def _nl_send(descriptor, msg):
|
|
_netlink.send(descriptor.fileno(), msg)
|
|
|
|
def _nl_recv(descriptor, bufs=16384):
|
|
return _netlink.recvfrom(descriptor.fileno(), bufs)
|
|
except ImportError:
|
|
# or fall back to the ctypes module
|
|
import ctypes
|
|
|
|
libc = ctypes.CDLL(None)
|
|
|
|
class SOCKADDR_NL(ctypes.Structure):
|
|
_fields_ = [("nl_family", ctypes.c_ushort),
|
|
("nl_pad", ctypes.c_ushort),
|
|
("nl_pid", ctypes.c_int),
|
|
("nl_groups", ctypes.c_int)]
|
|
|
|
def _nl_bind(descriptor, addr):
|
|
addr = SOCKADDR_NL(socket.AF_NETLINK, 0, os.getpid(), 0)
|
|
return libc.bind(descriptor.fileno(),
|
|
ctypes.pointer(addr),
|
|
ctypes.sizeof(addr))
|
|
|
|
def _nl_getsockname(descriptor):
|
|
addr = SOCKADDR_NL(0, 0, 0, 0)
|
|
len = ctypes.c_int(ctypes.sizeof(addr))
|
|
libc.getsockname(descriptor.fileno(),
|
|
ctypes.pointer(addr),
|
|
ctypes.pointer(len))
|
|
return addr.nl_pid, addr.nl_groups
|
|
|
|
def _nl_send(descriptor, msg):
|
|
return libc.send(descriptor.fileno(), msg, len(msg), 0)
|
|
|
|
def _nl_recv(descriptor, bufs=16384):
|
|
addr = SOCKADDR_NL(0, 0, 0, 0)
|
|
len = ctypes.c_int(ctypes.sizeof(addr))
|
|
buf = ctypes.create_string_buffer(bufs)
|
|
|
|
r = libc.recvfrom(descriptor.fileno(),
|
|
buf, bufs, 0,
|
|
ctypes.pointer(addr), ctypes.pointer(len))
|
|
|
|
ret = ctypes.string_at(ctypes.pointer(buf), r)
|
|
return ret, (addr.nl_pid, addr.nl_groups)
|
|
|
|
|
|
# flags
|
|
NLM_F_REQUEST = 1
|
|
NLM_F_MULTI = 2
|
|
NLM_F_ACK = 4
|
|
NLM_F_ECHO = 8
|
|
|
|
# types
|
|
NLMSG_NOOP = 1
|
|
NLMSG_ERROR = 2
|
|
NLMSG_DONE = 3
|
|
NLMSG_OVERRUN = 4
|
|
NLMSG_MIN_TYPE = 0x10
|
|
|
|
|
|
class Attr:
|
|
def __init__(self, attr_type, data, *values):
|
|
self.type = attr_type
|
|
if len(values):
|
|
self.data = struct.pack(data, *values)
|
|
else:
|
|
self.data = data
|
|
|
|
def _dump(self):
|
|
hdr = struct.pack("HH", len(self.data) + 4, self.type)
|
|
length = len(self.data)
|
|
pad = ((length + 4 - 1) & ~3) - length
|
|
return hdr + self.data + b'\0' * pad
|
|
|
|
def __repr__(self):
|
|
return '<Attr type %d, data "%s">' % (self.type, repr(self.data))
|
|
|
|
def u16(self):
|
|
return struct.unpack('H', self.data)[0]
|
|
|
|
def s16(self):
|
|
return struct.unpack('h', self.data)[0]
|
|
|
|
def u32(self):
|
|
return struct.unpack('I', self.data)[0]
|
|
|
|
def s32(self):
|
|
return struct.unpack('i', self.data)[0]
|
|
|
|
def str(self):
|
|
return self.data
|
|
|
|
def nulstr(self):
|
|
return self.data.split('\0')[0]
|
|
|
|
def nested(self):
|
|
return parse_attributes(self.data)
|
|
|
|
|
|
class StrAttr(Attr):
|
|
def __init__(self, attr_type, data):
|
|
Attr.__init__(self, attr_type, "%ds" % len(data), data.encode('utf-8'))
|
|
|
|
|
|
class NulStrAttr(Attr):
|
|
def __init__(self, attr_type, data):
|
|
Attr.__init__(self,
|
|
attr_type, "%dsB" % len(data), data.encode('utf-8'), 0)
|
|
|
|
|
|
class U32Attr(Attr):
|
|
def __init__(self, attr_type, val):
|
|
Attr.__init__(self, attr_type, "I", val)
|
|
|
|
|
|
class U8Attr(Attr):
|
|
def __init__(self, attr_type, val):
|
|
Attr.__init__(self, attr_type, "B", val)
|
|
|
|
|
|
class Nested(Attr):
|
|
def __init__(self, attr_type, attrs):
|
|
self.attrs = attrs
|
|
self.type = attr_type
|
|
|
|
def _dump(self):
|
|
contents = []
|
|
for attr in self.attrs:
|
|
contents.append(attr._dump())
|
|
contents = ''.join(contents)
|
|
length = len(contents)
|
|
hdr = struct.pack("HH", length + 4, self.type)
|
|
return hdr + contents
|
|
|
|
NETLINK_ROUTE = 0
|
|
NETLINK_UNUSED = 1
|
|
NETLINK_USERSOCK = 2
|
|
NETLINK_FIREWALL = 3
|
|
NETLINK_INET_DIAG = 4
|
|
NETLINK_NFLOG = 5
|
|
NETLINK_XFRM = 6
|
|
NETLINK_SELINUX = 7
|
|
NETLINK_ISCSI = 8
|
|
NETLINK_AUDIT = 9
|
|
NETLINK_FIB_LOOKUP = 10
|
|
NETLINK_CONNECTOR = 11
|
|
NETLINK_NETFILTER = 12
|
|
NETLINK_IP6_FW = 13
|
|
NETLINK_DNRTMSG = 14
|
|
NETLINK_KOBJECT_UEVENT = 15
|
|
NETLINK_GENERIC = 16
|
|
|
|
|
|
class Message:
|
|
def __init__(self, msg_type, flags=0, seq=-1, payload=None):
|
|
self.type = msg_type
|
|
self.flags = flags
|
|
self.seq = seq
|
|
self.pid = -1
|
|
payload = payload or []
|
|
if isinstance(payload, list):
|
|
contents = []
|
|
for attr in payload:
|
|
contents.append(attr._dump())
|
|
self.payload = b''.join(contents)
|
|
else:
|
|
self.payload = payload
|
|
|
|
def send(self, conn):
|
|
if self.seq == -1:
|
|
self.seq = conn.seq()
|
|
|
|
self.pid = conn.pid
|
|
length = len(self.payload)
|
|
|
|
hdr = struct.pack("IHHII", length + 4 * 4, self.type,
|
|
self.flags, self.seq, self.pid)
|
|
conn.send(hdr + self.payload)
|
|
|
|
def __repr__(self):
|
|
return '<netlink.Message type=%d, pid=%d, seq=%d, flags=0x%x "%s">' % (
|
|
self.type, self.pid, self.seq, self.flags, repr(self.payload))
|
|
|
|
|
|
class Connection:
|
|
|
|
def __init__(self, nltype, groups=0, unexpected_msg_handler=None):
|
|
self.descriptor = socket.socket(socket.AF_NETLINK,
|
|
socket.SOCK_RAW, nltype)
|
|
self.descriptor.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 65536)
|
|
self.descriptor.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 65536)
|
|
_nl_bind(self.descriptor, (0, groups))
|
|
self.pid, self.groups = _nl_getsockname(self.descriptor)
|
|
self._seq = 0
|
|
self.unexpected = unexpected_msg_handler
|
|
|
|
def send(self, msg):
|
|
_nl_send(self.descriptor, msg)
|
|
|
|
def recv(self):
|
|
contents, (nlpid, nlgrps) = _nl_recv(self.descriptor)
|
|
# XXX: Python doesn't give us message flags, check
|
|
# len(contents) vs. msglen for TRUNC
|
|
msglen, msg_type, flags, seq, pid = struct.unpack("IHHII",
|
|
contents[:16])
|
|
msg = Message(msg_type, flags, seq, contents[16:])
|
|
msg.pid = pid
|
|
if msg.type == NLMSG_ERROR:
|
|
errno = -struct.unpack("i", msg.payload[:4])[0]
|
|
if errno != 0:
|
|
err = OSError("Netlink error: %s (%d)" % (
|
|
os.strerror(errno), errno))
|
|
err.errno = errno
|
|
raise err
|
|
return msg
|
|
|
|
def seq(self):
|
|
self._seq += 1
|
|
return self._seq
|
|
|
|
|
|
def parse_attributes(data):
|
|
attrs = {}
|
|
while len(data):
|
|
attr_len, attr_type = struct.unpack("HH", data[:4])
|
|
attrs[attr_type] = Attr(attr_type, data[4:attr_len])
|
|
attr_len = ((attr_len + 4 - 1) & ~3)
|
|
data = data[attr_len:]
|
|
return attrs
|