src/libsystemd/sd-netlink/netlink-types.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2014 Tom Gundersen <teg@jklm.no>
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <stdint.h>
  23 #include <sys/socket.h>
  24 #include <linux/netlink.h>
  25 #include <linux/rtnetlink.h>
  26 #include <linux/in6.h>
  27 #include <linux/veth.h>
  28 #include <linux/if_bridge.h>
  29 #include <linux/if_addr.h>
  30 #include <linux/if.h>
  31
  32 #include <linux/ip.h>
  33 #include <linux/if_link.h>
  34 #include <linux/if_tunnel.h>
  35
  36 #include "macro.h"
  37 #include "util.h"
  38
  39 #include "netlink-types.h"
  40 #include "missing.h"
  41
  42 /* Maximum ARP IP target defined in kernel */
  43 #define BOND_MAX_ARP_TARGETS    16
  44
  45 typedef enum {
  46         BOND_ARP_TARGETS_0,
  47         BOND_ARP_TARGETS_1,
  48         BOND_ARP_TARGETS_2,
  49         BOND_ARP_TARGETS_3,
  50         BOND_ARP_TARGETS_4,
  51         BOND_ARP_TARGETS_5,
  52         BOND_ARP_TARGETS_6,
  53         BOND_ARP_TARGETS_7,
  54         BOND_ARP_TARGETS_8,
  55         BOND_ARP_TARGETS_9,
  56         BOND_ARP_TARGETS_10,
  57         BOND_ARP_TARGETS_11,
  58         BOND_ARP_TARGETS_12,
  59         BOND_ARP_TARGETS_13,
  60         BOND_ARP_TARGETS_14,
  61         BOND_ARP_TARGETS_MAX = BOND_MAX_ARP_TARGETS,
  62 } BondArpTargets;
  63
  64 struct NLType {
  65         uint16_t type;
  66         size_t size;
  67         const NLTypeSystem *type_system;
  68         const NLTypeSystemUnion *type_system_union;
  69 };
  70
  71 struct NLTypeSystem {
  72         uint16_t count;
  73         const NLType *types;
  74 };
  75
  76 static const NLTypeSystem rtnl_link_type_system;
  77
  78 static const NLType empty_types[1] = {
  79         /* fake array to avoid .types==NULL, which denotes invalid type-systems */
  80 };
  81
  82 static const NLTypeSystem empty_type_system = {
  83         .count = 0,
  84         .types = empty_types,
  85 };
  86
  87 static const NLType rtnl_link_info_data_veth_types[VETH_INFO_MAX + 1] = {
  88         [VETH_INFO_PEER]  = { .type = NETLINK_TYPE_NESTED, .type_system = &rtnl_link_type_system, .size = sizeof(struct ifinfomsg) },
  89 };
  90
  91 static const NLType rtnl_link_info_data_ipvlan_types[IFLA_IPVLAN_MAX + 1] = {
  92         [IFLA_IPVLAN_MODE]  = { .type = NETLINK_TYPE_U16 },
  93 };
  94
  95 static const NLType rtnl_link_info_data_macvlan_types[IFLA_MACVLAN_MAX + 1] = {
  96         [IFLA_MACVLAN_MODE]  = { .type = NETLINK_TYPE_U32 },
  97         [IFLA_MACVLAN_FLAGS] = { .type = NETLINK_TYPE_U16 },
  98 };
  99
 100 static const NLType rtnl_link_info_data_bridge_types[IFLA_BRIDGE_MAX + 1] = {
 101         [IFLA_BRIDGE_FLAGS]     = { .type = NETLINK_TYPE_U16 },
 102         [IFLA_BRIDGE_MODE]      = { .type = NETLINK_TYPE_U16 },
 103 /*
 104         [IFLA_BRIDGE_VLAN_INFO] = { .type = NETLINK_TYPE_BINARY,
 105                                     .len = sizeof(struct bridge_vlan_info), },
 106 */
 107 };
 108
 109 static const NLType rtnl_link_info_data_vlan_types[IFLA_VLAN_MAX + 1] = {
 110         [IFLA_VLAN_ID]          = { .type = NETLINK_TYPE_U16 },
 111 /*
 112         [IFLA_VLAN_FLAGS]       = { .len = sizeof(struct ifla_vlan_flags) },
 113         [IFLA_VLAN_EGRESS_QOS]  = { .type = NETLINK_TYPE_NESTED },
 114         [IFLA_VLAN_INGRESS_QOS] = { .type = NETLINK_TYPE_NESTED },
 115 */
 116         [IFLA_VLAN_PROTOCOL]    = { .type = NETLINK_TYPE_U16 },
 117 };
 118
 119 static const NLType rtnl_link_info_data_vxlan_types[IFLA_VXLAN_MAX+1] = {
 120         [IFLA_VXLAN_ID]         = { .type = NETLINK_TYPE_U32 },
 121         [IFLA_VXLAN_GROUP]      = { .type = NETLINK_TYPE_IN_ADDR },
 122         [IFLA_VXLAN_LINK]       = { .type = NETLINK_TYPE_U32 },
 123         [IFLA_VXLAN_LOCAL]      = { .type = NETLINK_TYPE_U32},
 124         [IFLA_VXLAN_TTL]        = { .type = NETLINK_TYPE_U8 },
 125         [IFLA_VXLAN_TOS]        = { .type = NETLINK_TYPE_U8 },
 126         [IFLA_VXLAN_LEARNING]   = { .type = NETLINK_TYPE_U8 },
 127         [IFLA_VXLAN_AGEING]     = { .type = NETLINK_TYPE_U32 },
 128         [IFLA_VXLAN_LIMIT]      = { .type = NETLINK_TYPE_U32 },
 129         [IFLA_VXLAN_PORT_RANGE] = { .type = NETLINK_TYPE_U32},
 130         [IFLA_VXLAN_PROXY]      = { .type = NETLINK_TYPE_U8 },
 131         [IFLA_VXLAN_RSC]        = { .type = NETLINK_TYPE_U8 },
 132         [IFLA_VXLAN_L2MISS]     = { .type = NETLINK_TYPE_U8 },
 133         [IFLA_VXLAN_L3MISS]     = { .type = NETLINK_TYPE_U8 },
 134 };
 135
 136 static const NLType rtnl_bond_arp_target_types[BOND_ARP_TARGETS_MAX + 1] = {
 137         [BOND_ARP_TARGETS_0]        = { .type = NETLINK_TYPE_U32 },
 138         [BOND_ARP_TARGETS_1]        = { .type = NETLINK_TYPE_U32 },
 139         [BOND_ARP_TARGETS_2]        = { .type = NETLINK_TYPE_U32 },
 140         [BOND_ARP_TARGETS_3]        = { .type = NETLINK_TYPE_U32 },
 141         [BOND_ARP_TARGETS_4]        = { .type = NETLINK_TYPE_U32 },
 142         [BOND_ARP_TARGETS_5]        = { .type = NETLINK_TYPE_U32 },
 143         [BOND_ARP_TARGETS_6]        = { .type = NETLINK_TYPE_U32 },
 144         [BOND_ARP_TARGETS_7]        = { .type = NETLINK_TYPE_U32 },
 145         [BOND_ARP_TARGETS_8]        = { .type = NETLINK_TYPE_U32 },
 146         [BOND_ARP_TARGETS_9]        = { .type = NETLINK_TYPE_U32 },
 147         [BOND_ARP_TARGETS_10]       = { .type = NETLINK_TYPE_U32 },
 148         [BOND_ARP_TARGETS_11]       = { .type = NETLINK_TYPE_U32 },
 149         [BOND_ARP_TARGETS_12]       = { .type = NETLINK_TYPE_U32 },
 150         [BOND_ARP_TARGETS_13]       = { .type = NETLINK_TYPE_U32 },
 151         [BOND_ARP_TARGETS_14]       = { .type = NETLINK_TYPE_U32 },
 152         [BOND_ARP_TARGETS_MAX]      = { .type = NETLINK_TYPE_U32 },
 153 };
 154
 155 static const NLTypeSystem rtnl_bond_arp_type_system = {
 156         .count = ELEMENTSOF(rtnl_bond_arp_target_types),
 157         .types = rtnl_bond_arp_target_types,
 158 };
 159
 160 static const NLType rtnl_link_info_data_bond_types[IFLA_BOND_MAX + 1] = {
 161         [IFLA_BOND_MODE]                = { .type = NETLINK_TYPE_U8 },
 162         [IFLA_BOND_ACTIVE_SLAVE]        = { .type = NETLINK_TYPE_U32 },
 163         [IFLA_BOND_MIIMON]              = { .type = NETLINK_TYPE_U32 },
 164         [IFLA_BOND_UPDELAY]             = { .type = NETLINK_TYPE_U32 },
 165         [IFLA_BOND_DOWNDELAY]           = { .type = NETLINK_TYPE_U32 },
 166         [IFLA_BOND_USE_CARRIER]         = { .type = NETLINK_TYPE_U8 },
 167         [IFLA_BOND_ARP_INTERVAL]        = { .type = NETLINK_TYPE_U32 },
 168         [IFLA_BOND_ARP_IP_TARGET]       = { .type = NETLINK_TYPE_NESTED, .type_system = &rtnl_bond_arp_type_system },
 169         [IFLA_BOND_ARP_VALIDATE]        = { .type = NETLINK_TYPE_U32 },
 170         [IFLA_BOND_ARP_ALL_TARGETS]     = { .type = NETLINK_TYPE_U32 },
 171         [IFLA_BOND_PRIMARY]             = { .type = NETLINK_TYPE_U32 },
 172         [IFLA_BOND_PRIMARY_RESELECT]    = { .type = NETLINK_TYPE_U8 },
 173         [IFLA_BOND_FAIL_OVER_MAC]       = { .type = NETLINK_TYPE_U8 },
 174         [IFLA_BOND_XMIT_HASH_POLICY]    = { .type = NETLINK_TYPE_U8 },
 175         [IFLA_BOND_RESEND_IGMP]         = { .type = NETLINK_TYPE_U32 },
 176         [IFLA_BOND_NUM_PEER_NOTIF]      = { .type = NETLINK_TYPE_U8 },
 177         [IFLA_BOND_ALL_SLAVES_ACTIVE]   = { .type = NETLINK_TYPE_U8 },
 178         [IFLA_BOND_MIN_LINKS]           = { .type = NETLINK_TYPE_U32 },
 179         [IFLA_BOND_LP_INTERVAL]         = { .type = NETLINK_TYPE_U32 },
 180         [IFLA_BOND_PACKETS_PER_SLAVE]   = { .type = NETLINK_TYPE_U32 },
 181         [IFLA_BOND_AD_LACP_RATE]        = { .type = NETLINK_TYPE_U8 },
 182         [IFLA_BOND_AD_SELECT]           = { .type = NETLINK_TYPE_U8 },
 183         [IFLA_BOND_AD_INFO]             = { .type = NETLINK_TYPE_NESTED },
 184 };
 185
 186 static const NLType rtnl_link_info_data_iptun_types[IFLA_IPTUN_MAX + 1] = {
 187         [IFLA_IPTUN_LINK]                = { .type = NETLINK_TYPE_U32 },
 188         [IFLA_IPTUN_LOCAL]               = { .type = NETLINK_TYPE_IN_ADDR },
 189         [IFLA_IPTUN_REMOTE]              = { .type = NETLINK_TYPE_IN_ADDR },
 190         [IFLA_IPTUN_TTL]                 = { .type = NETLINK_TYPE_U8 },
 191         [IFLA_IPTUN_TOS]                 = { .type = NETLINK_TYPE_U8 },
 192         [IFLA_IPTUN_PMTUDISC]            = { .type = NETLINK_TYPE_U8 },
 193         [IFLA_IPTUN_FLAGS]               = { .type = NETLINK_TYPE_U16 },
 194         [IFLA_IPTUN_PROTO]               = { .type = NETLINK_TYPE_U8 },
 195         [IFLA_IPTUN_6RD_PREFIX]          = { .type = NETLINK_TYPE_IN_ADDR },
 196         [IFLA_IPTUN_6RD_RELAY_PREFIX]    = { .type = NETLINK_TYPE_U32 },
 197         [IFLA_IPTUN_6RD_PREFIXLEN]       = { .type = NETLINK_TYPE_U16 },
 198         [IFLA_IPTUN_6RD_RELAY_PREFIXLEN] = { .type = NETLINK_TYPE_U16 },
 199 };
 200
 201 static  const NLType rtnl_link_info_data_ipgre_types[IFLA_GRE_MAX + 1] = {
 202         [IFLA_GRE_LINK]     = { .type = NETLINK_TYPE_U32 },
 203         [IFLA_GRE_IFLAGS]   = { .type = NETLINK_TYPE_U16 },
 204         [IFLA_GRE_OFLAGS]   = { .type = NETLINK_TYPE_U16 },
 205         [IFLA_GRE_IKEY]     = { .type = NETLINK_TYPE_U32 },
 206         [IFLA_GRE_OKEY]     = { .type = NETLINK_TYPE_U32 },
 207         [IFLA_GRE_LOCAL]    = { .type = NETLINK_TYPE_IN_ADDR },
 208         [IFLA_GRE_REMOTE]   = { .type = NETLINK_TYPE_IN_ADDR },
 209         [IFLA_GRE_TTL]      = { .type = NETLINK_TYPE_U8 },
 210         [IFLA_GRE_TOS]      = { .type = NETLINK_TYPE_U8 },
 211         [IFLA_GRE_PMTUDISC] = { .type = NETLINK_TYPE_U8 },
 212 };
 213
 214 static const NLType rtnl_link_info_data_ipvti_types[IFLA_VTI_MAX + 1] = {
 215         [IFLA_VTI_LINK]         = { .type = NETLINK_TYPE_U32 },
 216         [IFLA_VTI_IKEY]         = { .type = NETLINK_TYPE_U32 },
 217         [IFLA_VTI_OKEY]         = { .type = NETLINK_TYPE_U32 },
 218         [IFLA_VTI_LOCAL]        = { .type = NETLINK_TYPE_IN_ADDR  },
 219         [IFLA_VTI_REMOTE]       = { .type = NETLINK_TYPE_IN_ADDR  },
 220 };
 221
 222 static const NLType rtnl_link_info_data_ip6tnl_types[IFLA_IPTUN_MAX + 1] = {
 223         [IFLA_IPTUN_LINK]                = { .type = NETLINK_TYPE_U32 },
 224         [IFLA_IPTUN_LOCAL]               = { .type = NETLINK_TYPE_IN_ADDR },
 225         [IFLA_IPTUN_REMOTE]              = { .type = NETLINK_TYPE_IN_ADDR },
 226         [IFLA_IPTUN_TTL]                 = { .type = NETLINK_TYPE_U8 },
 227         [IFLA_IPTUN_FLAGS]               = { .type = NETLINK_TYPE_U32 },
 228         [IFLA_IPTUN_PROTO]               = { .type = NETLINK_TYPE_U8 },
 229         [IFLA_IPTUN_ENCAP_LIMIT]         = { .type = NETLINK_TYPE_U8 },
 230         [IFLA_IPTUN_FLOWINFO]            = { .type = NETLINK_TYPE_U32},
 231 };
 232
 233 /* these strings must match the .kind entries in the kernel */
 234 static const char* const nl_union_link_info_data_table[_NL_UNION_LINK_INFO_DATA_MAX] = {
 235         [NL_UNION_LINK_INFO_DATA_BOND] = "bond",
 236         [NL_UNION_LINK_INFO_DATA_BRIDGE] = "bridge",
 237         [NL_UNION_LINK_INFO_DATA_VLAN] = "vlan",
 238         [NL_UNION_LINK_INFO_DATA_VETH] = "veth",
 239         [NL_UNION_LINK_INFO_DATA_DUMMY] = "dummy",
 240         [NL_UNION_LINK_INFO_DATA_MACVLAN] = "macvlan",
 241         [NL_UNION_LINK_INFO_DATA_IPVLAN] = "ipvlan",
 242         [NL_UNION_LINK_INFO_DATA_VXLAN] = "vxlan",
 243         [NL_UNION_LINK_INFO_DATA_IPIP_TUNNEL] = "ipip",
 244         [NL_UNION_LINK_INFO_DATA_IPGRE_TUNNEL] = "gre",
 245         [NL_UNION_LINK_INFO_DATA_IPGRETAP_TUNNEL] = "gretap",
 246         [NL_UNION_LINK_INFO_DATA_IP6GRE_TUNNEL] = "ip6gre",
 247         [NL_UNION_LINK_INFO_DATA_IP6GRETAP_TUNNEL] = "ip6gretap",
 248         [NL_UNION_LINK_INFO_DATA_SIT_TUNNEL] = "sit",
 249         [NL_UNION_LINK_INFO_DATA_VTI_TUNNEL] = "vti",
 250         [NL_UNION_LINK_INFO_DATA_VTI6_TUNNEL] = "vti6",
 251         [NL_UNION_LINK_INFO_DATA_IP6TNL_TUNNEL] = "ip6tnl",
 252 };
 253
 254 DEFINE_STRING_TABLE_LOOKUP(nl_union_link_info_data, NLUnionLinkInfoData);
 255
 256 static const NLTypeSystem rtnl_link_info_data_type_systems[_NL_UNION_LINK_INFO_DATA_MAX] = {
 257         [NL_UNION_LINK_INFO_DATA_BOND] =        { .count = ELEMENTSOF(rtnl_link_info_data_bond_types),
 258                                                   .types = rtnl_link_info_data_bond_types },
 259         [NL_UNION_LINK_INFO_DATA_BRIDGE] =      { .count = ELEMENTSOF(rtnl_link_info_data_bridge_types),
 260                                                   .types = rtnl_link_info_data_bridge_types },
 261         [NL_UNION_LINK_INFO_DATA_VLAN] =        { .count = ELEMENTSOF(rtnl_link_info_data_vlan_types),
 262                                                   .types = rtnl_link_info_data_vlan_types },
 263         [NL_UNION_LINK_INFO_DATA_VETH] =        { .count = ELEMENTSOF(rtnl_link_info_data_veth_types),
 264                                                   .types = rtnl_link_info_data_veth_types },
 265         [NL_UNION_LINK_INFO_DATA_MACVLAN] =     { .count = ELEMENTSOF(rtnl_link_info_data_macvlan_types),
 266                                                   .types = rtnl_link_info_data_macvlan_types },
 267         [NL_UNION_LINK_INFO_DATA_IPVLAN] =      { .count = ELEMENTSOF(rtnl_link_info_data_ipvlan_types),
 268                                                   .types = rtnl_link_info_data_ipvlan_types },
 269         [NL_UNION_LINK_INFO_DATA_VXLAN] =       { .count = ELEMENTSOF(rtnl_link_info_data_vxlan_types),
 270                                                   .types = rtnl_link_info_data_vxlan_types },
 271         [NL_UNION_LINK_INFO_DATA_IPIP_TUNNEL] = { .count = ELEMENTSOF(rtnl_link_info_data_iptun_types),
 272                                                   .types = rtnl_link_info_data_iptun_types },
 273         [NL_UNION_LINK_INFO_DATA_IPGRE_TUNNEL] =  { .count = ELEMENTSOF(rtnl_link_info_data_ipgre_types),
 274                                                     .types = rtnl_link_info_data_ipgre_types },
 275         [NL_UNION_LINK_INFO_DATA_IPGRETAP_TUNNEL] =  { .count = ELEMENTSOF(rtnl_link_info_data_ipgre_types),
 276                                                     .types = rtnl_link_info_data_ipgre_types },
 277         [NL_UNION_LINK_INFO_DATA_IP6GRE_TUNNEL] =  { .count = ELEMENTSOF(rtnl_link_info_data_ipgre_types),
 278                                                     .types = rtnl_link_info_data_ipgre_types },
 279         [NL_UNION_LINK_INFO_DATA_IP6GRETAP_TUNNEL] =  { .count = ELEMENTSOF(rtnl_link_info_data_ipgre_types),
 280                                                     .types = rtnl_link_info_data_ipgre_types },
 281         [NL_UNION_LINK_INFO_DATA_SIT_TUNNEL] =  { .count = ELEMENTSOF(rtnl_link_info_data_iptun_types),
 282                                                   .types = rtnl_link_info_data_iptun_types },
 283         [NL_UNION_LINK_INFO_DATA_VTI_TUNNEL] =  { .count = ELEMENTSOF(rtnl_link_info_data_ipvti_types),
 284                                                   .types = rtnl_link_info_data_ipvti_types },
 285         [NL_UNION_LINK_INFO_DATA_VTI6_TUNNEL] =  { .count = ELEMENTSOF(rtnl_link_info_data_ipvti_types),
 286                                                   .types = rtnl_link_info_data_ipvti_types },
 287         [NL_UNION_LINK_INFO_DATA_IP6TNL_TUNNEL] =  { .count = ELEMENTSOF(rtnl_link_info_data_ip6tnl_types),
 288                                                      .types = rtnl_link_info_data_ip6tnl_types },
 289
 290 };
 291
 292 static const NLTypeSystemUnion rtnl_link_info_data_type_system_union = {
 293         .num = _NL_UNION_LINK_INFO_DATA_MAX,
 294         .lookup = nl_union_link_info_data_from_string,
 295         .type_systems = rtnl_link_info_data_type_systems,
 296         .match_type = NL_MATCH_SIBLING,
 297         .match = IFLA_INFO_KIND,
 298 };
 299
 300 static const NLType rtnl_link_info_types[IFLA_INFO_MAX + 1] = {
 301         [IFLA_INFO_KIND]        = { .type = NETLINK_TYPE_STRING },
 302         [IFLA_INFO_DATA]        = { .type = NETLINK_TYPE_UNION, .type_system_union = &rtnl_link_info_data_type_system_union},
 303 /*
 304         [IFLA_INFO_XSTATS],
 305         [IFLA_INFO_SLAVE_KIND]  = { .type = NETLINK_TYPE_STRING },
 306         [IFLA_INFO_SLAVE_DATA]  = { .type = NETLINK_TYPE_NESTED },
 307 */
 308 };
 309
 310 static const NLTypeSystem rtnl_link_info_type_system = {
 311         .count = ELEMENTSOF(rtnl_link_info_types),
 312         .types = rtnl_link_info_types,
 313 };
 314
 315 static const struct NLType rtnl_prot_info_bridge_port_types[IFLA_BRPORT_MAX + 1] = {
 316         [IFLA_BRPORT_STATE]             = { .type = NETLINK_TYPE_U8 },
 317         [IFLA_BRPORT_COST]              = { .type = NETLINK_TYPE_U32 },
 318         [IFLA_BRPORT_PRIORITY]          = { .type = NETLINK_TYPE_U16 },
 319         [IFLA_BRPORT_MODE]              = { .type = NETLINK_TYPE_U8 },
 320         [IFLA_BRPORT_GUARD]             = { .type = NETLINK_TYPE_U8 },
 321         [IFLA_BRPORT_PROTECT]           = { .type = NETLINK_TYPE_U8 },
 322         [IFLA_BRPORT_LEARNING]          = { .type = NETLINK_TYPE_U8 },
 323         [IFLA_BRPORT_UNICAST_FLOOD]     = { .type = NETLINK_TYPE_U8 },
 324 };
 325
 326 static const NLTypeSystem rtnl_prot_info_type_systems[AF_MAX] = {
 327         [AF_BRIDGE] =   { .count = ELEMENTSOF(rtnl_prot_info_bridge_port_types),
 328                           .types = rtnl_prot_info_bridge_port_types },
 329 };
 330
 331 static const NLTypeSystemUnion rtnl_prot_info_type_system_union = {
 332         .num = AF_MAX,
 333         .type_systems = rtnl_prot_info_type_systems,
 334         .match_type = NL_MATCH_PROTOCOL,
 335 };
 336
 337 static const struct NLType rtnl_af_spec_inet6_types[IFLA_INET6_MAX + 1] = {
 338         [IFLA_INET6_FLAGS]              = { .type = NETLINK_TYPE_U32 },
 339 /*
 340         IFLA_INET6_CONF,
 341         IFLA_INET6_STATS,
 342         IFLA_INET6_MCAST,
 343         IFLA_INET6_CACHEINFO,
 344         IFLA_INET6_ICMP6STATS,
 345 */
 346         [IFLA_INET6_TOKEN]              = { .type = NETLINK_TYPE_IN_ADDR },
 347         [IFLA_INET6_ADDR_GEN_MODE]      = { .type = NETLINK_TYPE_U8 },
 348 };
 349
 350 static const NLTypeSystem rtnl_af_spec_inet6_type_system = {
 351         .count = ELEMENTSOF(rtnl_af_spec_inet6_types),
 352         .types = rtnl_af_spec_inet6_types,
 353 };
 354
 355 static const NLType rtnl_af_spec_types[AF_MAX + 1] = {
 356         [AF_INET6] =    { .type = NETLINK_TYPE_NESTED, .type_system = &rtnl_af_spec_inet6_type_system },
 357 };
 358
 359 static const NLTypeSystem rtnl_af_spec_type_system = {
 360         .count = ELEMENTSOF(rtnl_af_spec_types),
 361         .types = rtnl_af_spec_types,
 362 };
 363
 364 static const NLType rtnl_link_types[IFLA_MAX + 1 ] = {
 365         [IFLA_ADDRESS]          = { .type = NETLINK_TYPE_ETHER_ADDR, },
 366         [IFLA_BROADCAST]        = { .type = NETLINK_TYPE_ETHER_ADDR, },
 367         [IFLA_IFNAME]           = { .type = NETLINK_TYPE_STRING, .size = IFNAMSIZ - 1, },
 368         [IFLA_MTU]              = { .type = NETLINK_TYPE_U32 },
 369         [IFLA_LINK]             = { .type = NETLINK_TYPE_U32 },
 370 /*
 371         [IFLA_QDISC],
 372         [IFLA_STATS],
 373         [IFLA_COST],
 374         [IFLA_PRIORITY],
 375 */
 376         [IFLA_MASTER]           = { .type = NETLINK_TYPE_U32 },
 377 /*
 378         [IFLA_WIRELESS],
 379 */
 380         [IFLA_PROTINFO]         = { .type = NETLINK_TYPE_UNION, .type_system_union = &rtnl_prot_info_type_system_union },
 381         [IFLA_TXQLEN]           = { .type = NETLINK_TYPE_U32 },
 382 /*
 383         [IFLA_MAP]              = { .len = sizeof(struct rtnl_link_ifmap) },
 384 */
 385         [IFLA_WEIGHT]           = { .type = NETLINK_TYPE_U32 },
 386         [IFLA_OPERSTATE]        = { .type = NETLINK_TYPE_U8 },
 387         [IFLA_LINKMODE]         = { .type = NETLINK_TYPE_U8 },
 388         [IFLA_LINKINFO]         = { .type = NETLINK_TYPE_NESTED, .type_system = &rtnl_link_info_type_system },
 389         [IFLA_NET_NS_PID]       = { .type = NETLINK_TYPE_U32 },
 390         [IFLA_IFALIAS]          = { .type = NETLINK_TYPE_STRING, .size = IFALIASZ - 1 },
 391 /*
 392         [IFLA_NUM_VF],
 393         [IFLA_VFINFO_LIST]      = {. type = NETLINK_TYPE_NESTED, },
 394         [IFLA_STATS64],
 395         [IFLA_VF_PORTS]         = { .type = NETLINK_TYPE_NESTED },
 396         [IFLA_PORT_SELF]        = { .type = NETLINK_TYPE_NESTED },
 397 */
 398         [IFLA_AF_SPEC]          = { .type = NETLINK_TYPE_NESTED, .type_system = &rtnl_af_spec_type_system },
 399 /*
 400         [IFLA_VF_PORTS],
 401         [IFLA_PORT_SELF],
 402         [IFLA_AF_SPEC],
 403 */
 404         [IFLA_GROUP]            = { .type = NETLINK_TYPE_U32 },
 405         [IFLA_NET_NS_FD]        = { .type = NETLINK_TYPE_U32 },
 406         [IFLA_EXT_MASK]         = { .type = NETLINK_TYPE_U32 },
 407         [IFLA_PROMISCUITY]      = { .type = NETLINK_TYPE_U32 },
 408         [IFLA_NUM_TX_QUEUES]    = { .type = NETLINK_TYPE_U32 },
 409         [IFLA_NUM_RX_QUEUES]    = { .type = NETLINK_TYPE_U32 },
 410         [IFLA_CARRIER]          = { .type = NETLINK_TYPE_U8 },
 411 /*
 412         [IFLA_PHYS_PORT_ID]     = { .type = NETLINK_TYPE_BINARY, .len = MAX_PHYS_PORT_ID_LEN },
 413 */
 414 };
 415
 416 static const NLTypeSystem rtnl_link_type_system = {
 417         .count = ELEMENTSOF(rtnl_link_types),
 418         .types = rtnl_link_types,
 419 };
 420
 421 /* IFA_FLAGS was defined in kernel 3.14, but we still support older
 422  * kernels where IFA_MAX is lower. */
 423 static const NLType rtnl_address_types[CONST_MAX(IFA_MAX, IFA_FLAGS) + 1] = {
 424         [IFA_ADDRESS]           = { .type = NETLINK_TYPE_IN_ADDR },
 425         [IFA_LOCAL]             = { .type = NETLINK_TYPE_IN_ADDR },
 426         [IFA_LABEL]             = { .type = NETLINK_TYPE_STRING, .size = IFNAMSIZ - 1 },
 427         [IFA_BROADCAST]         = { .type = NETLINK_TYPE_IN_ADDR }, /* 6? */
 428         [IFA_CACHEINFO]         = { .type = NETLINK_TYPE_CACHE_INFO, .size = sizeof(struct ifa_cacheinfo) },
 429 /*
 430         [IFA_ANYCAST],
 431         [IFA_MULTICAST],
 432 */
 433         [IFA_FLAGS]             = { .type = NETLINK_TYPE_U32 },
 434 };
 435
 436 static const NLTypeSystem rtnl_address_type_system = {
 437         .count = ELEMENTSOF(rtnl_address_types),
 438         .types = rtnl_address_types,
 439 };
 440
 441 static const NLType rtnl_route_types[RTA_MAX + 1] = {
 442         [RTA_DST]               = { .type = NETLINK_TYPE_IN_ADDR }, /* 6? */
 443         [RTA_SRC]               = { .type = NETLINK_TYPE_IN_ADDR }, /* 6? */
 444         [RTA_IIF]               = { .type = NETLINK_TYPE_U32 },
 445         [RTA_OIF]               = { .type = NETLINK_TYPE_U32 },
 446         [RTA_GATEWAY]           = { .type = NETLINK_TYPE_IN_ADDR },
 447         [RTA_PRIORITY]          = { .type = NETLINK_TYPE_U32 },
 448         [RTA_PREFSRC]           = { .type = NETLINK_TYPE_IN_ADDR }, /* 6? */
 449 /*
 450         [RTA_METRICS]           = { .type = NETLINK_TYPE_NESTED },
 451         [RTA_MULTIPATH]         = { .len = sizeof(struct rtnexthop) },
 452 */
 453         [RTA_FLOW]              = { .type = NETLINK_TYPE_U32 }, /* 6? */
 454 /*
 455         RTA_CACHEINFO,
 456         RTA_TABLE,
 457         RTA_MARK,
 458         RTA_MFC_STATS,
 459 */
 460 };
 461
 462 static const NLTypeSystem rtnl_route_type_system = {
 463         .count = ELEMENTSOF(rtnl_route_types),
 464         .types = rtnl_route_types,
 465 };
 466
 467 static const NLType rtnl_neigh_types[NDA_MAX + 1] = {
 468         [NDA_DST]               = { .type = NETLINK_TYPE_IN_ADDR },
 469         [NDA_LLADDR]            = { .type = NETLINK_TYPE_ETHER_ADDR },
 470         [NDA_CACHEINFO]         = { .type = NETLINK_TYPE_CACHE_INFO, .size = sizeof(struct nda_cacheinfo) },
 471         [NDA_PROBES]            = { .type = NETLINK_TYPE_U32 },
 472         [NDA_VLAN]              = { .type = NETLINK_TYPE_U16 },
 473         [NDA_PORT]              = { .type = NETLINK_TYPE_U16 },
 474         [NDA_VNI]               = { .type = NETLINK_TYPE_U32 },
 475         [NDA_IFINDEX]           = { .type = NETLINK_TYPE_U32 },
 476 };
 477
 478 static const NLTypeSystem rtnl_neigh_type_system = {
 479         .count = ELEMENTSOF(rtnl_neigh_types),
 480         .types = rtnl_neigh_types,
 481 };
 482
 483 static const NLType rtnl_types[RTM_MAX + 1] = {
 484         [NLMSG_DONE]   = { .type = NETLINK_TYPE_NESTED, .type_system = &empty_type_system, .size = 0 },
 485         [NLMSG_ERROR]  = { .type = NETLINK_TYPE_NESTED, .type_system = &empty_type_system, .size = sizeof(struct nlmsgerr) },
 486         [RTM_NEWLINK]  = { .type = NETLINK_TYPE_NESTED, .type_system = &rtnl_link_type_system, .size = sizeof(struct ifinfomsg) },
 487         [RTM_DELLINK]  = { .type = NETLINK_TYPE_NESTED, .type_system = &rtnl_link_type_system, .size = sizeof(struct ifinfomsg) },
 488         [RTM_GETLINK]  = { .type = NETLINK_TYPE_NESTED, .type_system = &rtnl_link_type_system, .size = sizeof(struct ifinfomsg) },
 489         [RTM_SETLINK]  = { .type = NETLINK_TYPE_NESTED, .type_system = &rtnl_link_type_system, .size = sizeof(struct ifinfomsg) },
 490         [RTM_NEWADDR]  = { .type = NETLINK_TYPE_NESTED, .type_system = &rtnl_address_type_system, .size = sizeof(struct ifaddrmsg) },
 491         [RTM_DELADDR]  = { .type = NETLINK_TYPE_NESTED, .type_system = &rtnl_address_type_system, .size = sizeof(struct ifaddrmsg) },
 492         [RTM_GETADDR]  = { .type = NETLINK_TYPE_NESTED, .type_system = &rtnl_address_type_system, .size = sizeof(struct ifaddrmsg) },
 493         [RTM_NEWROUTE] = { .type = NETLINK_TYPE_NESTED, .type_system = &rtnl_route_type_system, .size = sizeof(struct rtmsg) },
 494         [RTM_DELROUTE] = { .type = NETLINK_TYPE_NESTED, .type_system = &rtnl_route_type_system, .size = sizeof(struct rtmsg) },
 495         [RTM_GETROUTE] = { .type = NETLINK_TYPE_NESTED, .type_system = &rtnl_route_type_system, .size = sizeof(struct rtmsg) },
 496         [RTM_NEWNEIGH] = { .type = NETLINK_TYPE_NESTED, .type_system = &rtnl_neigh_type_system, .size = sizeof(struct ndmsg) },
 497         [RTM_DELNEIGH] = { .type = NETLINK_TYPE_NESTED, .type_system = &rtnl_neigh_type_system, .size = sizeof(struct ndmsg) },
 498         [RTM_GETNEIGH] = { .type = NETLINK_TYPE_NESTED, .type_system = &rtnl_neigh_type_system, .size = sizeof(struct ndmsg) },
 499 };
 500
 501 const NLTypeSystem type_system_root = {
 502         .count = ELEMENTSOF(rtnl_types),
 503         .types = rtnl_types,
 504 };
 505
 506 uint16_t type_get_type(const NLType *type) {
 507         assert(type);
 508         return type->type;
 509 }
 510
 511 size_t type_get_size(const NLType *type) {
 512         assert(type);
 513         return type->size;
 514 }
 515
 516 void type_get_type_system(const NLType *nl_type, const NLTypeSystem **ret) {
 517         assert(nl_type);
 518         assert(ret);
 519         assert(nl_type->type == NETLINK_TYPE_NESTED);
 520         assert(nl_type->type_system);
 521
 522         *ret = nl_type->type_system;
 523 }
 524
 525 void type_get_type_system_union(const NLType *nl_type, const NLTypeSystemUnion **ret) {
 526         assert(nl_type);
 527         assert(ret);
 528         assert(nl_type->type == NETLINK_TYPE_UNION);
 529         assert(nl_type->type_system_union);
 530
 531         *ret = nl_type->type_system_union;
 532 }
 533
 534 uint16_t type_system_get_count(const NLTypeSystem *type_system) {
 535         assert(type_system);
 536         return type_system->count;
 537 }
 538
 539 int type_system_get_type(const NLTypeSystem *type_system, const NLType **ret, uint16_t type) {
 540         const NLType *nl_type;
 541
 542         assert(ret);
 543         assert(type_system);
 544         assert(type_system->types);
 545
 546         if (type >= type_system->count)
 547                 return -EOPNOTSUPP;
 548
 549         nl_type = &type_system->types[type];
 550
 551         if (nl_type->type == NETLINK_TYPE_UNSPEC)
 552                 return -EOPNOTSUPP;
 553
 554         *ret = nl_type;
 555
 556         return 0;
 557 }
 558
 559 int type_system_get_type_system(const NLTypeSystem *type_system, const NLTypeSystem **ret, uint16_t type) {
 560         const NLType *nl_type;
 561         int r;
 562
 563         assert(ret);
 564
 565         r = type_system_get_type(type_system, &nl_type, type);
 566         if (r < 0)
 567                 return r;
 568
 569         type_get_type_system(nl_type, ret);
 570         return 0;
 571 }
 572
 573 int type_system_get_type_system_union(const NLTypeSystem *type_system, const NLTypeSystemUnion **ret, uint16_t type) {
 574         const NLType *nl_type;
 575         int r;
 576
 577         assert(ret);
 578
 579         r = type_system_get_type(type_system, &nl_type, type);
 580         if (r < 0)
 581                 return r;
 582
 583         type_get_type_system_union(nl_type, ret);
 584         return 0;
 585 }
 586
 587 int type_system_union_get_type_system(const NLTypeSystemUnion *type_system_union, const NLTypeSystem **ret, const char *key) {
 588         int type;
 589
 590         assert(type_system_union);
 591         assert(type_system_union->match_type == NL_MATCH_SIBLING);
 592         assert(type_system_union->lookup);
 593         assert(type_system_union->type_systems);
 594         assert(ret);
 595         assert(key);
 596
 597         type = type_system_union->lookup(key);
 598         if (type < 0)
 599                 return -EOPNOTSUPP;
 600
 601         assert(type < type_system_union->num);
 602
 603         *ret = &type_system_union->type_systems[type];
 604
 605         return 0;
 606 }
 607
 608 int type_system_union_protocol_get_type_system(const NLTypeSystemUnion *type_system_union, const NLTypeSystem **ret, uint16_t protocol) {
 609         const NLTypeSystem *type_system;
 610
 611         assert(type_system_union);
 612         assert(type_system_union->type_systems);
 613         assert(type_system_union->match_type == NL_MATCH_PROTOCOL);
 614         assert(ret);
 615
 616         if (protocol >= type_system_union->num)
 617                 return -EOPNOTSUPP;
 618
 619         type_system = &type_system_union->type_systems[protocol];
 620         if (!type_system->types)
 621                 return -EOPNOTSUPP;
 622
 623         *ret = type_system;
 624
 625         return 0;
 626 }