xref: /linux/tools/net/ynl/lib/ynl.py (revision 8faabc041a001140564f718dabe37753e88b37fa)
1# SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
2
3from collections import namedtuple
4from enum import Enum
5import functools
6import os
7import random
8import socket
9import struct
10from struct import Struct
11import sys
12import yaml
13import ipaddress
14import uuid
15import queue
16import selectors
17import time
18
19from .nlspec import SpecFamily
20
21#
22# Generic Netlink code which should really be in some library, but I can't quickly find one.
23#
24
25
26class Netlink:
27    # Netlink socket
28    SOL_NETLINK = 270
29
30    NETLINK_ADD_MEMBERSHIP = 1
31    NETLINK_CAP_ACK = 10
32    NETLINK_EXT_ACK = 11
33    NETLINK_GET_STRICT_CHK = 12
34
35    # Netlink message
36    NLMSG_ERROR = 2
37    NLMSG_DONE = 3
38
39    NLM_F_REQUEST = 1
40    NLM_F_ACK = 4
41    NLM_F_ROOT = 0x100
42    NLM_F_MATCH = 0x200
43
44    NLM_F_REPLACE = 0x100
45    NLM_F_EXCL = 0x200
46    NLM_F_CREATE = 0x400
47    NLM_F_APPEND = 0x800
48
49    NLM_F_CAPPED = 0x100
50    NLM_F_ACK_TLVS = 0x200
51
52    NLM_F_DUMP = NLM_F_ROOT | NLM_F_MATCH
53
54    NLA_F_NESTED = 0x8000
55    NLA_F_NET_BYTEORDER = 0x4000
56
57    NLA_TYPE_MASK = NLA_F_NESTED | NLA_F_NET_BYTEORDER
58
59    # Genetlink defines
60    NETLINK_GENERIC = 16
61
62    GENL_ID_CTRL = 0x10
63
64    # nlctrl
65    CTRL_CMD_GETFAMILY = 3
66
67    CTRL_ATTR_FAMILY_ID = 1
68    CTRL_ATTR_FAMILY_NAME = 2
69    CTRL_ATTR_MAXATTR = 5
70    CTRL_ATTR_MCAST_GROUPS = 7
71
72    CTRL_ATTR_MCAST_GRP_NAME = 1
73    CTRL_ATTR_MCAST_GRP_ID = 2
74
75    # Extack types
76    NLMSGERR_ATTR_MSG = 1
77    NLMSGERR_ATTR_OFFS = 2
78    NLMSGERR_ATTR_COOKIE = 3
79    NLMSGERR_ATTR_POLICY = 4
80    NLMSGERR_ATTR_MISS_TYPE = 5
81    NLMSGERR_ATTR_MISS_NEST = 6
82
83    # Policy types
84    NL_POLICY_TYPE_ATTR_TYPE = 1
85    NL_POLICY_TYPE_ATTR_MIN_VALUE_S = 2
86    NL_POLICY_TYPE_ATTR_MAX_VALUE_S = 3
87    NL_POLICY_TYPE_ATTR_MIN_VALUE_U = 4
88    NL_POLICY_TYPE_ATTR_MAX_VALUE_U = 5
89    NL_POLICY_TYPE_ATTR_MIN_LENGTH = 6
90    NL_POLICY_TYPE_ATTR_MAX_LENGTH = 7
91    NL_POLICY_TYPE_ATTR_POLICY_IDX = 8
92    NL_POLICY_TYPE_ATTR_POLICY_MAXTYPE = 9
93    NL_POLICY_TYPE_ATTR_BITFIELD32_MASK = 10
94    NL_POLICY_TYPE_ATTR_PAD = 11
95    NL_POLICY_TYPE_ATTR_MASK = 12
96
97    AttrType = Enum('AttrType', ['flag', 'u8', 'u16', 'u32', 'u64',
98                                  's8', 's16', 's32', 's64',
99                                  'binary', 'string', 'nul-string',
100                                  'nested', 'nested-array',
101                                  'bitfield32', 'sint', 'uint'])
102
103class NlError(Exception):
104  def __init__(self, nl_msg):
105    self.nl_msg = nl_msg
106    self.error = -nl_msg.error
107
108  def __str__(self):
109    return f"Netlink error: {os.strerror(self.error)}\n{self.nl_msg}"
110
111
112class ConfigError(Exception):
113    pass
114
115
116class NlAttr:
117    ScalarFormat = namedtuple('ScalarFormat', ['native', 'big', 'little'])
118    type_formats = {
119        'u8' : ScalarFormat(Struct('B'), Struct("B"),  Struct("B")),
120        's8' : ScalarFormat(Struct('b'), Struct("b"),  Struct("b")),
121        'u16': ScalarFormat(Struct('H'), Struct(">H"), Struct("<H")),
122        's16': ScalarFormat(Struct('h'), Struct(">h"), Struct("<h")),
123        'u32': ScalarFormat(Struct('I'), Struct(">I"), Struct("<I")),
124        's32': ScalarFormat(Struct('i'), Struct(">i"), Struct("<i")),
125        'u64': ScalarFormat(Struct('Q'), Struct(">Q"), Struct("<Q")),
126        's64': ScalarFormat(Struct('q'), Struct(">q"), Struct("<q"))
127    }
128
129    def __init__(self, raw, offset):
130        self._len, self._type = struct.unpack("HH", raw[offset : offset + 4])
131        self.type = self._type & ~Netlink.NLA_TYPE_MASK
132        self.is_nest = self._type & Netlink.NLA_F_NESTED
133        self.payload_len = self._len
134        self.full_len = (self.payload_len + 3) & ~3
135        self.raw = raw[offset + 4 : offset + self.payload_len]
136
137    @classmethod
138    def get_format(cls, attr_type, byte_order=None):
139        format = cls.type_formats[attr_type]
140        if byte_order:
141            return format.big if byte_order == "big-endian" \
142                else format.little
143        return format.native
144
145    def as_scalar(self, attr_type, byte_order=None):
146        format = self.get_format(attr_type, byte_order)
147        return format.unpack(self.raw)[0]
148
149    def as_auto_scalar(self, attr_type, byte_order=None):
150        if len(self.raw) != 4 and len(self.raw) != 8:
151            raise Exception(f"Auto-scalar len payload be 4 or 8 bytes, got {len(self.raw)}")
152        real_type = attr_type[0] + str(len(self.raw) * 8)
153        format = self.get_format(real_type, byte_order)
154        return format.unpack(self.raw)[0]
155
156    def as_strz(self):
157        return self.raw.decode('ascii')[:-1]
158
159    def as_bin(self):
160        return self.raw
161
162    def as_c_array(self, type):
163        format = self.get_format(type)
164        return [ x[0] for x in format.iter_unpack(self.raw) ]
165
166    def __repr__(self):
167        return f"[type:{self.type} len:{self._len}] {self.raw}"
168
169
170class NlAttrs:
171    def __init__(self, msg, offset=0):
172        self.attrs = []
173
174        while offset < len(msg):
175            attr = NlAttr(msg, offset)
176            offset += attr.full_len
177            self.attrs.append(attr)
178
179    def __iter__(self):
180        yield from self.attrs
181
182    def __repr__(self):
183        msg = ''
184        for a in self.attrs:
185            if msg:
186                msg += '\n'
187            msg += repr(a)
188        return msg
189
190
191class NlMsg:
192    def __init__(self, msg, offset, attr_space=None):
193        self.hdr = msg[offset : offset + 16]
194
195        self.nl_len, self.nl_type, self.nl_flags, self.nl_seq, self.nl_portid = \
196            struct.unpack("IHHII", self.hdr)
197
198        self.raw = msg[offset + 16 : offset + self.nl_len]
199
200        self.error = 0
201        self.done = 0
202
203        extack_off = None
204        if self.nl_type == Netlink.NLMSG_ERROR:
205            self.error = struct.unpack("i", self.raw[0:4])[0]
206            self.done = 1
207            extack_off = 20
208        elif self.nl_type == Netlink.NLMSG_DONE:
209            self.error = struct.unpack("i", self.raw[0:4])[0]
210            self.done = 1
211            extack_off = 4
212
213        self.extack = None
214        if self.nl_flags & Netlink.NLM_F_ACK_TLVS and extack_off:
215            self.extack = dict()
216            extack_attrs = NlAttrs(self.raw[extack_off:])
217            for extack in extack_attrs:
218                if extack.type == Netlink.NLMSGERR_ATTR_MSG:
219                    self.extack['msg'] = extack.as_strz()
220                elif extack.type == Netlink.NLMSGERR_ATTR_MISS_TYPE:
221                    self.extack['miss-type'] = extack.as_scalar('u32')
222                elif extack.type == Netlink.NLMSGERR_ATTR_MISS_NEST:
223                    self.extack['miss-nest'] = extack.as_scalar('u32')
224                elif extack.type == Netlink.NLMSGERR_ATTR_OFFS:
225                    self.extack['bad-attr-offs'] = extack.as_scalar('u32')
226                elif extack.type == Netlink.NLMSGERR_ATTR_POLICY:
227                    self.extack['policy'] = self._decode_policy(extack.raw)
228                else:
229                    if 'unknown' not in self.extack:
230                        self.extack['unknown'] = []
231                    self.extack['unknown'].append(extack)
232
233            if attr_space:
234                # We don't have the ability to parse nests yet, so only do global
235                if 'miss-type' in self.extack and 'miss-nest' not in self.extack:
236                    miss_type = self.extack['miss-type']
237                    if miss_type in attr_space.attrs_by_val:
238                        spec = attr_space.attrs_by_val[miss_type]
239                        self.extack['miss-type'] = spec['name']
240                        if 'doc' in spec:
241                            self.extack['miss-type-doc'] = spec['doc']
242
243    def _decode_policy(self, raw):
244        policy = {}
245        for attr in NlAttrs(raw):
246            if attr.type == Netlink.NL_POLICY_TYPE_ATTR_TYPE:
247                type = attr.as_scalar('u32')
248                policy['type'] = Netlink.AttrType(type).name
249            elif attr.type == Netlink.NL_POLICY_TYPE_ATTR_MIN_VALUE_S:
250                policy['min-value'] = attr.as_scalar('s64')
251            elif attr.type == Netlink.NL_POLICY_TYPE_ATTR_MAX_VALUE_S:
252                policy['max-value'] = attr.as_scalar('s64')
253            elif attr.type == Netlink.NL_POLICY_TYPE_ATTR_MIN_VALUE_U:
254                policy['min-value'] = attr.as_scalar('u64')
255            elif attr.type == Netlink.NL_POLICY_TYPE_ATTR_MAX_VALUE_U:
256                policy['max-value'] = attr.as_scalar('u64')
257            elif attr.type == Netlink.NL_POLICY_TYPE_ATTR_MIN_LENGTH:
258                policy['min-length'] = attr.as_scalar('u32')
259            elif attr.type == Netlink.NL_POLICY_TYPE_ATTR_MAX_LENGTH:
260                policy['max-length'] = attr.as_scalar('u32')
261            elif attr.type == Netlink.NL_POLICY_TYPE_ATTR_BITFIELD32_MASK:
262                policy['bitfield32-mask'] = attr.as_scalar('u32')
263            elif attr.type == Netlink.NL_POLICY_TYPE_ATTR_MASK:
264                policy['mask'] = attr.as_scalar('u64')
265        return policy
266
267    def cmd(self):
268        return self.nl_type
269
270    def __repr__(self):
271        msg = f"nl_len = {self.nl_len} ({len(self.raw)}) nl_flags = 0x{self.nl_flags:x} nl_type = {self.nl_type}"
272        if self.error:
273            msg += '\n\terror: ' + str(self.error)
274        if self.extack:
275            msg += '\n\textack: ' + repr(self.extack)
276        return msg
277
278
279class NlMsgs:
280    def __init__(self, data, attr_space=None):
281        self.msgs = []
282
283        offset = 0
284        while offset < len(data):
285            msg = NlMsg(data, offset, attr_space=attr_space)
286            offset += msg.nl_len
287            self.msgs.append(msg)
288
289    def __iter__(self):
290        yield from self.msgs
291
292
293genl_family_name_to_id = None
294
295
296def _genl_msg(nl_type, nl_flags, genl_cmd, genl_version, seq=None):
297    # we prepend length in _genl_msg_finalize()
298    if seq is None:
299        seq = random.randint(1, 1024)
300    nlmsg = struct.pack("HHII", nl_type, nl_flags, seq, 0)
301    genlmsg = struct.pack("BBH", genl_cmd, genl_version, 0)
302    return nlmsg + genlmsg
303
304
305def _genl_msg_finalize(msg):
306    return struct.pack("I", len(msg) + 4) + msg
307
308
309def _genl_load_families():
310    with socket.socket(socket.AF_NETLINK, socket.SOCK_RAW, Netlink.NETLINK_GENERIC) as sock:
311        sock.setsockopt(Netlink.SOL_NETLINK, Netlink.NETLINK_CAP_ACK, 1)
312
313        msg = _genl_msg(Netlink.GENL_ID_CTRL,
314                        Netlink.NLM_F_REQUEST | Netlink.NLM_F_ACK | Netlink.NLM_F_DUMP,
315                        Netlink.CTRL_CMD_GETFAMILY, 1)
316        msg = _genl_msg_finalize(msg)
317
318        sock.send(msg, 0)
319
320        global genl_family_name_to_id
321        genl_family_name_to_id = dict()
322
323        while True:
324            reply = sock.recv(128 * 1024)
325            nms = NlMsgs(reply)
326            for nl_msg in nms:
327                if nl_msg.error:
328                    print("Netlink error:", nl_msg.error)
329                    return
330                if nl_msg.done:
331                    return
332
333                gm = GenlMsg(nl_msg)
334                fam = dict()
335                for attr in NlAttrs(gm.raw):
336                    if attr.type == Netlink.CTRL_ATTR_FAMILY_ID:
337                        fam['id'] = attr.as_scalar('u16')
338                    elif attr.type == Netlink.CTRL_ATTR_FAMILY_NAME:
339                        fam['name'] = attr.as_strz()
340                    elif attr.type == Netlink.CTRL_ATTR_MAXATTR:
341                        fam['maxattr'] = attr.as_scalar('u32')
342                    elif attr.type == Netlink.CTRL_ATTR_MCAST_GROUPS:
343                        fam['mcast'] = dict()
344                        for entry in NlAttrs(attr.raw):
345                            mcast_name = None
346                            mcast_id = None
347                            for entry_attr in NlAttrs(entry.raw):
348                                if entry_attr.type == Netlink.CTRL_ATTR_MCAST_GRP_NAME:
349                                    mcast_name = entry_attr.as_strz()
350                                elif entry_attr.type == Netlink.CTRL_ATTR_MCAST_GRP_ID:
351                                    mcast_id = entry_attr.as_scalar('u32')
352                            if mcast_name and mcast_id is not None:
353                                fam['mcast'][mcast_name] = mcast_id
354                if 'name' in fam and 'id' in fam:
355                    genl_family_name_to_id[fam['name']] = fam
356
357
358class GenlMsg:
359    def __init__(self, nl_msg):
360        self.nl = nl_msg
361        self.genl_cmd, self.genl_version, _ = struct.unpack_from("BBH", nl_msg.raw, 0)
362        self.raw = nl_msg.raw[4:]
363
364    def cmd(self):
365        return self.genl_cmd
366
367    def __repr__(self):
368        msg = repr(self.nl)
369        msg += f"\tgenl_cmd = {self.genl_cmd} genl_ver = {self.genl_version}\n"
370        for a in self.raw_attrs:
371            msg += '\t\t' + repr(a) + '\n'
372        return msg
373
374
375class NetlinkProtocol:
376    def __init__(self, family_name, proto_num):
377        self.family_name = family_name
378        self.proto_num = proto_num
379
380    def _message(self, nl_type, nl_flags, seq=None):
381        if seq is None:
382            seq = random.randint(1, 1024)
383        nlmsg = struct.pack("HHII", nl_type, nl_flags, seq, 0)
384        return nlmsg
385
386    def message(self, flags, command, version, seq=None):
387        return self._message(command, flags, seq)
388
389    def _decode(self, nl_msg):
390        return nl_msg
391
392    def decode(self, ynl, nl_msg, op):
393        msg = self._decode(nl_msg)
394        if op is None:
395            op = ynl.rsp_by_value[msg.cmd()]
396        fixed_header_size = ynl._struct_size(op.fixed_header)
397        msg.raw_attrs = NlAttrs(msg.raw, fixed_header_size)
398        return msg
399
400    def get_mcast_id(self, mcast_name, mcast_groups):
401        if mcast_name not in mcast_groups:
402            raise Exception(f'Multicast group "{mcast_name}" not present in the spec')
403        return mcast_groups[mcast_name].value
404
405    def msghdr_size(self):
406        return 16
407
408
409class GenlProtocol(NetlinkProtocol):
410    def __init__(self, family_name):
411        super().__init__(family_name, Netlink.NETLINK_GENERIC)
412
413        global genl_family_name_to_id
414        if genl_family_name_to_id is None:
415            _genl_load_families()
416
417        self.genl_family = genl_family_name_to_id[family_name]
418        self.family_id = genl_family_name_to_id[family_name]['id']
419
420    def message(self, flags, command, version, seq=None):
421        nlmsg = self._message(self.family_id, flags, seq)
422        genlmsg = struct.pack("BBH", command, version, 0)
423        return nlmsg + genlmsg
424
425    def _decode(self, nl_msg):
426        return GenlMsg(nl_msg)
427
428    def get_mcast_id(self, mcast_name, mcast_groups):
429        if mcast_name not in self.genl_family['mcast']:
430            raise Exception(f'Multicast group "{mcast_name}" not present in the family')
431        return self.genl_family['mcast'][mcast_name]
432
433    def msghdr_size(self):
434        return super().msghdr_size() + 4
435
436
437class SpaceAttrs:
438    SpecValuesPair = namedtuple('SpecValuesPair', ['spec', 'values'])
439
440    def __init__(self, attr_space, attrs, outer = None):
441        outer_scopes = outer.scopes if outer else []
442        inner_scope = self.SpecValuesPair(attr_space, attrs)
443        self.scopes = [inner_scope] + outer_scopes
444
445    def lookup(self, name):
446        for scope in self.scopes:
447            if name in scope.spec:
448                if name in scope.values:
449                    return scope.values[name]
450                spec_name = scope.spec.yaml['name']
451                raise Exception(
452                    f"No value for '{name}' in attribute space '{spec_name}'")
453        raise Exception(f"Attribute '{name}' not defined in any attribute-set")
454
455
456#
457# YNL implementation details.
458#
459
460
461class YnlFamily(SpecFamily):
462    def __init__(self, def_path, schema=None, process_unknown=False,
463                 recv_size=0):
464        super().__init__(def_path, schema)
465
466        self.include_raw = False
467        self.process_unknown = process_unknown
468
469        try:
470            if self.proto == "netlink-raw":
471                self.nlproto = NetlinkProtocol(self.yaml['name'],
472                                               self.yaml['protonum'])
473            else:
474                self.nlproto = GenlProtocol(self.yaml['name'])
475        except KeyError:
476            raise Exception(f"Family '{self.yaml['name']}' not supported by the kernel")
477
478        self._recv_dbg = False
479        # Note that netlink will use conservative (min) message size for
480        # the first dump recv() on the socket, our setting will only matter
481        # from the second recv() on.
482        self._recv_size = recv_size if recv_size else 131072
483        # Netlink will always allocate at least PAGE_SIZE - sizeof(skb_shinfo)
484        # for a message, so smaller receive sizes will lead to truncation.
485        # Note that the min size for other families may be larger than 4k!
486        if self._recv_size < 4000:
487            raise ConfigError()
488
489        self.sock = socket.socket(socket.AF_NETLINK, socket.SOCK_RAW, self.nlproto.proto_num)
490        self.sock.setsockopt(Netlink.SOL_NETLINK, Netlink.NETLINK_CAP_ACK, 1)
491        self.sock.setsockopt(Netlink.SOL_NETLINK, Netlink.NETLINK_EXT_ACK, 1)
492        self.sock.setsockopt(Netlink.SOL_NETLINK, Netlink.NETLINK_GET_STRICT_CHK, 1)
493
494        self.async_msg_ids = set()
495        self.async_msg_queue = queue.Queue()
496
497        for msg in self.msgs.values():
498            if msg.is_async:
499                self.async_msg_ids.add(msg.rsp_value)
500
501        for op_name, op in self.ops.items():
502            bound_f = functools.partial(self._op, op_name)
503            setattr(self, op.ident_name, bound_f)
504
505
506    def ntf_subscribe(self, mcast_name):
507        mcast_id = self.nlproto.get_mcast_id(mcast_name, self.mcast_groups)
508        self.sock.bind((0, 0))
509        self.sock.setsockopt(Netlink.SOL_NETLINK, Netlink.NETLINK_ADD_MEMBERSHIP,
510                             mcast_id)
511
512    def set_recv_dbg(self, enabled):
513        self._recv_dbg = enabled
514
515    def _recv_dbg_print(self, reply, nl_msgs):
516        if not self._recv_dbg:
517            return
518        print("Recv: read", len(reply), "bytes,",
519              len(nl_msgs.msgs), "messages", file=sys.stderr)
520        for nl_msg in nl_msgs:
521            print("  ", nl_msg, file=sys.stderr)
522
523    def _encode_enum(self, attr_spec, value):
524        enum = self.consts[attr_spec['enum']]
525        if enum.type == 'flags' or attr_spec.get('enum-as-flags', False):
526            scalar = 0
527            if isinstance(value, str):
528                value = [value]
529            for single_value in value:
530                scalar += enum.entries[single_value].user_value(as_flags = True)
531            return scalar
532        else:
533            return enum.entries[value].user_value()
534
535    def _get_scalar(self, attr_spec, value):
536        try:
537            return int(value)
538        except (ValueError, TypeError) as e:
539            if 'enum' not in attr_spec:
540                raise e
541        return self._encode_enum(attr_spec, value)
542
543    def _add_attr(self, space, name, value, search_attrs):
544        try:
545            attr = self.attr_sets[space][name]
546        except KeyError:
547            raise Exception(f"Space '{space}' has no attribute '{name}'")
548        nl_type = attr.value
549
550        if attr.is_multi and isinstance(value, list):
551            attr_payload = b''
552            for subvalue in value:
553                attr_payload += self._add_attr(space, name, subvalue, search_attrs)
554            return attr_payload
555
556        if attr["type"] == 'nest':
557            nl_type |= Netlink.NLA_F_NESTED
558            attr_payload = b''
559            sub_space = attr['nested-attributes']
560            sub_attrs = SpaceAttrs(self.attr_sets[sub_space], value, search_attrs)
561            for subname, subvalue in value.items():
562                attr_payload += self._add_attr(sub_space, subname, subvalue, sub_attrs)
563        elif attr["type"] == 'flag':
564            if not value:
565                # If value is absent or false then skip attribute creation.
566                return b''
567            attr_payload = b''
568        elif attr["type"] == 'string':
569            attr_payload = str(value).encode('ascii') + b'\x00'
570        elif attr["type"] == 'binary':
571            if isinstance(value, bytes):
572                attr_payload = value
573            elif isinstance(value, str):
574                attr_payload = bytes.fromhex(value)
575            elif isinstance(value, dict) and attr.struct_name:
576                attr_payload = self._encode_struct(attr.struct_name, value)
577            else:
578                raise Exception(f'Unknown type for binary attribute, value: {value}')
579        elif attr['type'] in NlAttr.type_formats or attr.is_auto_scalar:
580            scalar = self._get_scalar(attr, value)
581            if attr.is_auto_scalar:
582                attr_type = attr["type"][0] + ('32' if scalar.bit_length() <= 32 else '64')
583            else:
584                attr_type = attr["type"]
585            format = NlAttr.get_format(attr_type, attr.byte_order)
586            attr_payload = format.pack(scalar)
587        elif attr['type'] in "bitfield32":
588            scalar_value = self._get_scalar(attr, value["value"])
589            scalar_selector = self._get_scalar(attr, value["selector"])
590            attr_payload = struct.pack("II", scalar_value, scalar_selector)
591        elif attr['type'] == 'sub-message':
592            msg_format = self._resolve_selector(attr, search_attrs)
593            attr_payload = b''
594            if msg_format.fixed_header:
595                attr_payload += self._encode_struct(msg_format.fixed_header, value)
596            if msg_format.attr_set:
597                if msg_format.attr_set in self.attr_sets:
598                    nl_type |= Netlink.NLA_F_NESTED
599                    sub_attrs = SpaceAttrs(msg_format.attr_set, value, search_attrs)
600                    for subname, subvalue in value.items():
601                        attr_payload += self._add_attr(msg_format.attr_set,
602                                                       subname, subvalue, sub_attrs)
603                else:
604                    raise Exception(f"Unknown attribute-set '{msg_format.attr_set}'")
605        else:
606            raise Exception(f'Unknown type at {space} {name} {value} {attr["type"]}')
607
608        pad = b'\x00' * ((4 - len(attr_payload) % 4) % 4)
609        return struct.pack('HH', len(attr_payload) + 4, nl_type) + attr_payload + pad
610
611    def _decode_enum(self, raw, attr_spec):
612        enum = self.consts[attr_spec['enum']]
613        if enum.type == 'flags' or attr_spec.get('enum-as-flags', False):
614            i = 0
615            value = set()
616            while raw:
617                if raw & 1:
618                    value.add(enum.entries_by_val[i].name)
619                raw >>= 1
620                i += 1
621        else:
622            value = enum.entries_by_val[raw].name
623        return value
624
625    def _decode_binary(self, attr, attr_spec):
626        if attr_spec.struct_name:
627            decoded = self._decode_struct(attr.raw, attr_spec.struct_name)
628        elif attr_spec.sub_type:
629            decoded = attr.as_c_array(attr_spec.sub_type)
630        else:
631            decoded = attr.as_bin()
632            if attr_spec.display_hint:
633                decoded = self._formatted_string(decoded, attr_spec.display_hint)
634        return decoded
635
636    def _decode_array_attr(self, attr, attr_spec):
637        decoded = []
638        offset = 0
639        while offset < len(attr.raw):
640            item = NlAttr(attr.raw, offset)
641            offset += item.full_len
642
643            if attr_spec["sub-type"] == 'nest':
644                subattrs = self._decode(NlAttrs(item.raw), attr_spec['nested-attributes'])
645                decoded.append({ item.type: subattrs })
646            elif attr_spec["sub-type"] == 'binary':
647                subattrs = item.as_bin()
648                if attr_spec.display_hint:
649                    subattrs = self._formatted_string(subattrs, attr_spec.display_hint)
650                decoded.append(subattrs)
651            elif attr_spec["sub-type"] in NlAttr.type_formats:
652                subattrs = item.as_scalar(attr_spec['sub-type'], attr_spec.byte_order)
653                if attr_spec.display_hint:
654                    subattrs = self._formatted_string(subattrs, attr_spec.display_hint)
655                decoded.append(subattrs)
656            else:
657                raise Exception(f'Unknown {attr_spec["sub-type"]} with name {attr_spec["name"]}')
658        return decoded
659
660    def _decode_nest_type_value(self, attr, attr_spec):
661        decoded = {}
662        value = attr
663        for name in attr_spec['type-value']:
664            value = NlAttr(value.raw, 0)
665            decoded[name] = value.type
666        subattrs = self._decode(NlAttrs(value.raw), attr_spec['nested-attributes'])
667        decoded.update(subattrs)
668        return decoded
669
670    def _decode_unknown(self, attr):
671        if attr.is_nest:
672            return self._decode(NlAttrs(attr.raw), None)
673        else:
674            return attr.as_bin()
675
676    def _rsp_add(self, rsp, name, is_multi, decoded):
677        if is_multi == None:
678            if name in rsp and type(rsp[name]) is not list:
679                rsp[name] = [rsp[name]]
680                is_multi = True
681            else:
682                is_multi = False
683
684        if not is_multi:
685            rsp[name] = decoded
686        elif name in rsp:
687            rsp[name].append(decoded)
688        else:
689            rsp[name] = [decoded]
690
691    def _resolve_selector(self, attr_spec, search_attrs):
692        sub_msg = attr_spec.sub_message
693        if sub_msg not in self.sub_msgs:
694            raise Exception(f"No sub-message spec named {sub_msg} for {attr_spec.name}")
695        sub_msg_spec = self.sub_msgs[sub_msg]
696
697        selector = attr_spec.selector
698        value = search_attrs.lookup(selector)
699        if value not in sub_msg_spec.formats:
700            raise Exception(f"No message format for '{value}' in sub-message spec '{sub_msg}'")
701
702        spec = sub_msg_spec.formats[value]
703        return spec
704
705    def _decode_sub_msg(self, attr, attr_spec, search_attrs):
706        msg_format = self._resolve_selector(attr_spec, search_attrs)
707        decoded = {}
708        offset = 0
709        if msg_format.fixed_header:
710            decoded.update(self._decode_struct(attr.raw, msg_format.fixed_header));
711            offset = self._struct_size(msg_format.fixed_header)
712        if msg_format.attr_set:
713            if msg_format.attr_set in self.attr_sets:
714                subdict = self._decode(NlAttrs(attr.raw, offset), msg_format.attr_set)
715                decoded.update(subdict)
716            else:
717                raise Exception(f"Unknown attribute-set '{attr_space}' when decoding '{attr_spec.name}'")
718        return decoded
719
720    def _decode(self, attrs, space, outer_attrs = None):
721        rsp = dict()
722        if space:
723            attr_space = self.attr_sets[space]
724            search_attrs = SpaceAttrs(attr_space, rsp, outer_attrs)
725
726        for attr in attrs:
727            try:
728                attr_spec = attr_space.attrs_by_val[attr.type]
729            except (KeyError, UnboundLocalError):
730                if not self.process_unknown:
731                    raise Exception(f"Space '{space}' has no attribute with value '{attr.type}'")
732                attr_name = f"UnknownAttr({attr.type})"
733                self._rsp_add(rsp, attr_name, None, self._decode_unknown(attr))
734                continue
735
736            if attr_spec["type"] == 'nest':
737                subdict = self._decode(NlAttrs(attr.raw), attr_spec['nested-attributes'], search_attrs)
738                decoded = subdict
739            elif attr_spec["type"] == 'string':
740                decoded = attr.as_strz()
741            elif attr_spec["type"] == 'binary':
742                decoded = self._decode_binary(attr, attr_spec)
743            elif attr_spec["type"] == 'flag':
744                decoded = True
745            elif attr_spec.is_auto_scalar:
746                decoded = attr.as_auto_scalar(attr_spec['type'], attr_spec.byte_order)
747            elif attr_spec["type"] in NlAttr.type_formats:
748                decoded = attr.as_scalar(attr_spec['type'], attr_spec.byte_order)
749                if 'enum' in attr_spec:
750                    decoded = self._decode_enum(decoded, attr_spec)
751                elif attr_spec.display_hint:
752                    decoded = self._formatted_string(decoded, attr_spec.display_hint)
753            elif attr_spec["type"] == 'indexed-array':
754                decoded = self._decode_array_attr(attr, attr_spec)
755            elif attr_spec["type"] == 'bitfield32':
756                value, selector = struct.unpack("II", attr.raw)
757                if 'enum' in attr_spec:
758                    value = self._decode_enum(value, attr_spec)
759                    selector = self._decode_enum(selector, attr_spec)
760                decoded = {"value": value, "selector": selector}
761            elif attr_spec["type"] == 'sub-message':
762                decoded = self._decode_sub_msg(attr, attr_spec, search_attrs)
763            elif attr_spec["type"] == 'nest-type-value':
764                decoded = self._decode_nest_type_value(attr, attr_spec)
765            else:
766                if not self.process_unknown:
767                    raise Exception(f'Unknown {attr_spec["type"]} with name {attr_spec["name"]}')
768                decoded = self._decode_unknown(attr)
769
770            self._rsp_add(rsp, attr_spec["name"], attr_spec.is_multi, decoded)
771
772        return rsp
773
774    def _decode_extack_path(self, attrs, attr_set, offset, target):
775        for attr in attrs:
776            try:
777                attr_spec = attr_set.attrs_by_val[attr.type]
778            except KeyError:
779                raise Exception(f"Space '{attr_set.name}' has no attribute with value '{attr.type}'")
780            if offset > target:
781                break
782            if offset == target:
783                return '.' + attr_spec.name
784
785            if offset + attr.full_len <= target:
786                offset += attr.full_len
787                continue
788            if attr_spec['type'] != 'nest':
789                raise Exception(f"Can't dive into {attr.type} ({attr_spec['name']}) for extack")
790            offset += 4
791            subpath = self._decode_extack_path(NlAttrs(attr.raw),
792                                               self.attr_sets[attr_spec['nested-attributes']],
793                                               offset, target)
794            if subpath is None:
795                return None
796            return '.' + attr_spec.name + subpath
797
798        return None
799
800    def _decode_extack(self, request, op, extack):
801        if 'bad-attr-offs' not in extack:
802            return
803
804        msg = self.nlproto.decode(self, NlMsg(request, 0, op.attr_set), op)
805        offset = self.nlproto.msghdr_size() + self._struct_size(op.fixed_header)
806        path = self._decode_extack_path(msg.raw_attrs, op.attr_set, offset,
807                                        extack['bad-attr-offs'])
808        if path:
809            del extack['bad-attr-offs']
810            extack['bad-attr'] = path
811
812    def _struct_size(self, name):
813        if name:
814            members = self.consts[name].members
815            size = 0
816            for m in members:
817                if m.type in ['pad', 'binary']:
818                    if m.struct:
819                        size += self._struct_size(m.struct)
820                    else:
821                        size += m.len
822                else:
823                    format = NlAttr.get_format(m.type, m.byte_order)
824                    size += format.size
825            return size
826        else:
827            return 0
828
829    def _decode_struct(self, data, name):
830        members = self.consts[name].members
831        attrs = dict()
832        offset = 0
833        for m in members:
834            value = None
835            if m.type == 'pad':
836                offset += m.len
837            elif m.type == 'binary':
838                if m.struct:
839                    len = self._struct_size(m.struct)
840                    value = self._decode_struct(data[offset : offset + len],
841                                                m.struct)
842                    offset += len
843                else:
844                    value = data[offset : offset + m.len]
845                    offset += m.len
846            else:
847                format = NlAttr.get_format(m.type, m.byte_order)
848                [ value ] = format.unpack_from(data, offset)
849                offset += format.size
850            if value is not None:
851                if m.enum:
852                    value = self._decode_enum(value, m)
853                elif m.display_hint:
854                    value = self._formatted_string(value, m.display_hint)
855                attrs[m.name] = value
856        return attrs
857
858    def _encode_struct(self, name, vals):
859        members = self.consts[name].members
860        attr_payload = b''
861        for m in members:
862            value = vals.pop(m.name) if m.name in vals else None
863            if m.type == 'pad':
864                attr_payload += bytearray(m.len)
865            elif m.type == 'binary':
866                if m.struct:
867                    if value is None:
868                        value = dict()
869                    attr_payload += self._encode_struct(m.struct, value)
870                else:
871                    if value is None:
872                        attr_payload += bytearray(m.len)
873                    else:
874                        attr_payload += bytes.fromhex(value)
875            else:
876                if value is None:
877                    value = 0
878                format = NlAttr.get_format(m.type, m.byte_order)
879                attr_payload += format.pack(value)
880        return attr_payload
881
882    def _formatted_string(self, raw, display_hint):
883        if display_hint == 'mac':
884            formatted = ':'.join('%02x' % b for b in raw)
885        elif display_hint == 'hex':
886            if isinstance(raw, int):
887                formatted = hex(raw)
888            else:
889                formatted = bytes.hex(raw, ' ')
890        elif display_hint in [ 'ipv4', 'ipv6' ]:
891            formatted = format(ipaddress.ip_address(raw))
892        elif display_hint == 'uuid':
893            formatted = str(uuid.UUID(bytes=raw))
894        else:
895            formatted = raw
896        return formatted
897
898    def handle_ntf(self, decoded):
899        msg = dict()
900        if self.include_raw:
901            msg['raw'] = decoded
902        op = self.rsp_by_value[decoded.cmd()]
903        attrs = self._decode(decoded.raw_attrs, op.attr_set.name)
904        if op.fixed_header:
905            attrs.update(self._decode_struct(decoded.raw, op.fixed_header))
906
907        msg['name'] = op['name']
908        msg['msg'] = attrs
909        self.async_msg_queue.put(msg)
910
911    def check_ntf(self):
912        while True:
913            try:
914                reply = self.sock.recv(self._recv_size, socket.MSG_DONTWAIT)
915            except BlockingIOError:
916                return
917
918            nms = NlMsgs(reply)
919            self._recv_dbg_print(reply, nms)
920            for nl_msg in nms:
921                if nl_msg.error:
922                    print("Netlink error in ntf!?", os.strerror(-nl_msg.error))
923                    print(nl_msg)
924                    continue
925                if nl_msg.done:
926                    print("Netlink done while checking for ntf!?")
927                    continue
928
929                decoded = self.nlproto.decode(self, nl_msg, None)
930                if decoded.cmd() not in self.async_msg_ids:
931                    print("Unexpected msg id while checking for ntf", decoded)
932                    continue
933
934                self.handle_ntf(decoded)
935
936    def poll_ntf(self, duration=None):
937        start_time = time.time()
938        selector = selectors.DefaultSelector()
939        selector.register(self.sock, selectors.EVENT_READ)
940
941        while True:
942            try:
943                yield self.async_msg_queue.get_nowait()
944            except queue.Empty:
945                if duration is not None:
946                    timeout = start_time + duration - time.time()
947                    if timeout <= 0:
948                        return
949                else:
950                    timeout = None
951                events = selector.select(timeout)
952                if events:
953                    self.check_ntf()
954
955    def operation_do_attributes(self, name):
956      """
957      For a given operation name, find and return a supported
958      set of attributes (as a dict).
959      """
960      op = self.find_operation(name)
961      if not op:
962        return None
963
964      return op['do']['request']['attributes'].copy()
965
966    def _encode_message(self, op, vals, flags, req_seq):
967        nl_flags = Netlink.NLM_F_REQUEST | Netlink.NLM_F_ACK
968        for flag in flags or []:
969            nl_flags |= flag
970
971        msg = self.nlproto.message(nl_flags, op.req_value, 1, req_seq)
972        if op.fixed_header:
973            msg += self._encode_struct(op.fixed_header, vals)
974        search_attrs = SpaceAttrs(op.attr_set, vals)
975        for name, value in vals.items():
976            msg += self._add_attr(op.attr_set.name, name, value, search_attrs)
977        msg = _genl_msg_finalize(msg)
978        return msg
979
980    def _ops(self, ops):
981        reqs_by_seq = {}
982        req_seq = random.randint(1024, 65535)
983        payload = b''
984        for (method, vals, flags) in ops:
985            op = self.ops[method]
986            msg = self._encode_message(op, vals, flags, req_seq)
987            reqs_by_seq[req_seq] = (op, msg, flags)
988            payload += msg
989            req_seq += 1
990
991        self.sock.send(payload, 0)
992
993        done = False
994        rsp = []
995        op_rsp = []
996        while not done:
997            reply = self.sock.recv(self._recv_size)
998            nms = NlMsgs(reply, attr_space=op.attr_set)
999            self._recv_dbg_print(reply, nms)
1000            for nl_msg in nms:
1001                if nl_msg.nl_seq in reqs_by_seq:
1002                    (op, req_msg, req_flags) = reqs_by_seq[nl_msg.nl_seq]
1003                    if nl_msg.extack:
1004                        self._decode_extack(req_msg, op, nl_msg.extack)
1005                else:
1006                    op = None
1007                    req_flags = []
1008
1009                if nl_msg.error:
1010                    raise NlError(nl_msg)
1011                if nl_msg.done:
1012                    if nl_msg.extack:
1013                        print("Netlink warning:")
1014                        print(nl_msg)
1015
1016                    if Netlink.NLM_F_DUMP in req_flags:
1017                        rsp.append(op_rsp)
1018                    elif not op_rsp:
1019                        rsp.append(None)
1020                    elif len(op_rsp) == 1:
1021                        rsp.append(op_rsp[0])
1022                    else:
1023                        rsp.append(op_rsp)
1024                    op_rsp = []
1025
1026                    del reqs_by_seq[nl_msg.nl_seq]
1027                    done = len(reqs_by_seq) == 0
1028                    break
1029
1030                decoded = self.nlproto.decode(self, nl_msg, op)
1031
1032                # Check if this is a reply to our request
1033                if nl_msg.nl_seq not in reqs_by_seq or decoded.cmd() != op.rsp_value:
1034                    if decoded.cmd() in self.async_msg_ids:
1035                        self.handle_ntf(decoded)
1036                        continue
1037                    else:
1038                        print('Unexpected message: ' + repr(decoded))
1039                        continue
1040
1041                rsp_msg = self._decode(decoded.raw_attrs, op.attr_set.name)
1042                if op.fixed_header:
1043                    rsp_msg.update(self._decode_struct(decoded.raw, op.fixed_header))
1044                op_rsp.append(rsp_msg)
1045
1046        return rsp
1047
1048    def _op(self, method, vals, flags=None, dump=False):
1049        req_flags = flags or []
1050        if dump:
1051            req_flags.append(Netlink.NLM_F_DUMP)
1052
1053        ops = [(method, vals, req_flags)]
1054        return self._ops(ops)[0]
1055
1056    def do(self, method, vals, flags=None):
1057        return self._op(method, vals, flags)
1058
1059    def dump(self, method, vals):
1060        return self._op(method, vals, dump=True)
1061
1062    def do_multi(self, ops):
1063        return self._ops(ops)
1064