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         [IFLA_IPTUN_ENCAP_TYPE]          = { .type = NETLINK_TYPE_U16},
 200         [IFLA_IPTUN_ENCAP_FLAGS]         = { .type = NETLINK_TYPE_U16},
 201         [IFLA_IPTUN_ENCAP_SPORT]         = { .type = NETLINK_TYPE_U16},
 202         [IFLA_IPTUN_ENCAP_DPORT]         = { .type = NETLINK_TYPE_U16},
 203 };
 204
 205 static  const NLType rtnl_link_info_data_ipgre_types[IFLA_GRE_MAX + 1] = {
 206         [IFLA_GRE_LINK]         = { .type = NETLINK_TYPE_U32 },
 207         [IFLA_GRE_IFLAGS]       = { .type = NETLINK_TYPE_U16 },
 208         [IFLA_GRE_OFLAGS]       = { .type = NETLINK_TYPE_U16 },
 209         [IFLA_GRE_IKEY]         = { .type = NETLINK_TYPE_U32 },
 210         [IFLA_GRE_OKEY]         = { .type = NETLINK_TYPE_U32 },
 211         [IFLA_GRE_LOCAL]        = { .type = NETLINK_TYPE_IN_ADDR },
 212         [IFLA_GRE_REMOTE]       = { .type = NETLINK_TYPE_IN_ADDR },
 213         [IFLA_GRE_TTL]          = { .type = NETLINK_TYPE_U8 },
 214         [IFLA_GRE_TOS]          = { .type = NETLINK_TYPE_U8 },
 215         [IFLA_GRE_PMTUDISC]     = { .type = NETLINK_TYPE_U8 },
 216         [IFLA_GRE_FLOWINFO]     = { .type = NETLINK_TYPE_U32 },
 217         [IFLA_GRE_FLAGS]        = { .type = NETLINK_TYPE_U32 },
 218         [IFLA_GRE_ENCAP_TYPE]   = { .type = NETLINK_TYPE_U16 },
 219         [IFLA_GRE_ENCAP_FLAGS]  = { .type = NETLINK_TYPE_U16 },
 220         [IFLA_GRE_ENCAP_SPORT]  = { .type = NETLINK_TYPE_U16 },
 221         [IFLA_GRE_ENCAP_DPORT]  = { .type = NETLINK_TYPE_U16 },
 222 };
 223
 224 static const NLType rtnl_link_info_data_ipvti_types[IFLA_VTI_MAX + 1] = {
 225         [IFLA_VTI_LINK]         = { .type = NETLINK_TYPE_U32 },
 226         [IFLA_VTI_IKEY]         = { .type = NETLINK_TYPE_U32 },
 227         [IFLA_VTI_OKEY]         = { .type = NETLINK_TYPE_U32 },
 228         [IFLA_VTI_LOCAL]        = { .type = NETLINK_TYPE_IN_ADDR  },
 229         [IFLA_VTI_REMOTE]       = { .type = NETLINK_TYPE_IN_ADDR  },
 230 };
 231
 232 static const NLType rtnl_link_info_data_ip6tnl_types[IFLA_IPTUN_MAX + 1] = {
 233         [IFLA_IPTUN_LINK]                = { .type = NETLINK_TYPE_U32 },
 234         [IFLA_IPTUN_LOCAL]               = { .type = NETLINK_TYPE_IN_ADDR },
 235         [IFLA_IPTUN_REMOTE]              = { .type = NETLINK_TYPE_IN_ADDR },
 236         [IFLA_IPTUN_TTL]                 = { .type = NETLINK_TYPE_U8 },
 237         [IFLA_IPTUN_FLAGS]               = { .type = NETLINK_TYPE_U32 },
 238         [IFLA_IPTUN_PROTO]               = { .type = NETLINK_TYPE_U8 },
 239         [IFLA_IPTUN_ENCAP_LIMIT]         = { .type = NETLINK_TYPE_U8 },
 240         [IFLA_IPTUN_FLOWINFO]            = { .type = NETLINK_TYPE_U32},
 241 };
 242
 243 /* these strings must match the .kind entries in the kernel */
 244 static const char* const nl_union_link_info_data_table[_NL_UNION_LINK_INFO_DATA_MAX] = {
 245         [NL_UNION_LINK_INFO_DATA_BOND] = "bond",
 246         [NL_UNION_LINK_INFO_DATA_BRIDGE] = "bridge",
 247         [NL_UNION_LINK_INFO_DATA_VLAN] = "vlan",
 248         [NL_UNION_LINK_INFO_DATA_VETH] = "veth",
 249         [NL_UNION_LINK_INFO_DATA_DUMMY] = "dummy",
 250         [NL_UNION_LINK_INFO_DATA_MACVLAN] = "macvlan",
 251         [NL_UNION_LINK_INFO_DATA_IPVLAN] = "ipvlan",
 252         [NL_UNION_LINK_INFO_DATA_VXLAN] = "vxlan",
 253         [NL_UNION_LINK_INFO_DATA_IPIP_TUNNEL] = "ipip",
 254         [NL_UNION_LINK_INFO_DATA_IPGRE_TUNNEL] = "gre",
 255         [NL_UNION_LINK_INFO_DATA_IPGRETAP_TUNNEL] = "gretap",
 256         [NL_UNION_LINK_INFO_DATA_IP6GRE_TUNNEL] = "ip6gre",
 257         [NL_UNION_LINK_INFO_DATA_IP6GRETAP_TUNNEL] = "ip6gretap",
 258         [NL_UNION_LINK_INFO_DATA_SIT_TUNNEL] = "sit",
 259         [NL_UNION_LINK_INFO_DATA_VTI_TUNNEL] = "vti",
 260         [NL_UNION_LINK_INFO_DATA_VTI6_TUNNEL] = "vti6",
 261         [NL_UNION_LINK_INFO_DATA_IP6TNL_TUNNEL] = "ip6tnl",
 262 };
 263
 264 DEFINE_STRING_TABLE_LOOKUP(nl_union_link_info_data, NLUnionLinkInfoData);
 265
 266 static const NLTypeSystem rtnl_link_info_data_type_systems[_NL_UNION_LINK_INFO_DATA_MAX] = {
 267         [NL_UNION_LINK_INFO_DATA_BOND] =        { .count = ELEMENTSOF(rtnl_link_info_data_bond_types),
 268                                                   .types = rtnl_link_info_data_bond_types },
 269         [NL_UNION_LINK_INFO_DATA_BRIDGE] =      { .count = ELEMENTSOF(rtnl_link_info_data_bridge_types),
 270                                                   .types = rtnl_link_info_data_bridge_types },
 271         [NL_UNION_LINK_INFO_DATA_VLAN] =        { .count = ELEMENTSOF(rtnl_link_info_data_vlan_types),
 272                                                   .types = rtnl_link_info_data_vlan_types },
 273         [NL_UNION_LINK_INFO_DATA_VETH] =        { .count = ELEMENTSOF(rtnl_link_info_data_veth_types),
 274                                                   .types = rtnl_link_info_data_veth_types },
 275         [NL_UNION_LINK_INFO_DATA_MACVLAN] =     { .count = ELEMENTSOF(rtnl_link_info_data_macvlan_types),
 276                                                   .types = rtnl_link_info_data_macvlan_types },
 277         [NL_UNION_LINK_INFO_DATA_IPVLAN] =      { .count = ELEMENTSOF(rtnl_link_info_data_ipvlan_types),
 278                                                   .types = rtnl_link_info_data_ipvlan_types },
 279         [NL_UNION_LINK_INFO_DATA_VXLAN] =       { .count = ELEMENTSOF(rtnl_link_info_data_vxlan_types),
 280                                                   .types = rtnl_link_info_data_vxlan_types },
 281         [NL_UNION_LINK_INFO_DATA_IPIP_TUNNEL] = { .count = ELEMENTSOF(rtnl_link_info_data_iptun_types),
 282                                                   .types = rtnl_link_info_data_iptun_types },
 283         [NL_UNION_LINK_INFO_DATA_IPGRE_TUNNEL] =  { .count = ELEMENTSOF(rtnl_link_info_data_ipgre_types),
 284                                                     .types = rtnl_link_info_data_ipgre_types },
 285         [NL_UNION_LINK_INFO_DATA_IPGRETAP_TUNNEL] =  { .count = ELEMENTSOF(rtnl_link_info_data_ipgre_types),
 286                                                     .types = rtnl_link_info_data_ipgre_types },
 287         [NL_UNION_LINK_INFO_DATA_IP6GRE_TUNNEL] =  { .count = ELEMENTSOF(rtnl_link_info_data_ipgre_types),
 288                                                     .types = rtnl_link_info_data_ipgre_types },
 289         [NL_UNION_LINK_INFO_DATA_IP6GRETAP_TUNNEL] =  { .count = ELEMENTSOF(rtnl_link_info_data_ipgre_types),
 290                                                     .types = rtnl_link_info_data_ipgre_types },
 291         [NL_UNION_LINK_INFO_DATA_SIT_TUNNEL] =  { .count = ELEMENTSOF(rtnl_link_info_data_iptun_types),
 292                                                   .types = rtnl_link_info_data_iptun_types },
 293         [NL_UNION_LINK_INFO_DATA_VTI_TUNNEL] =  { .count = ELEMENTSOF(rtnl_link_info_data_ipvti_types),
 294                                                   .types = rtnl_link_info_data_ipvti_types },
 295         [NL_UNION_LINK_INFO_DATA_VTI6_TUNNEL] =  { .count = ELEMENTSOF(rtnl_link_info_data_ipvti_types),
 296                                                   .types = rtnl_link_info_data_ipvti_types },
 297         [NL_UNION_LINK_INFO_DATA_IP6TNL_TUNNEL] =  { .count = ELEMENTSOF(rtnl_link_info_data_ip6tnl_types),
 298                                                      .types = rtnl_link_info_data_ip6tnl_types },
 299
 300 };
 301
 302 static const NLTypeSystemUnion rtnl_link_info_data_type_system_union = {
 303         .num = _NL_UNION_LINK_INFO_DATA_MAX,
 304         .lookup = nl_union_link_info_data_from_string,
 305         .type_systems = rtnl_link_info_data_type_systems,
 306         .match_type = NL_MATCH_SIBLING,
 307         .match = IFLA_INFO_KIND,
 308 };
 309
 310 static const NLType rtnl_link_info_types[IFLA_INFO_MAX + 1] = {
 311         [IFLA_INFO_KIND]        = { .type = NETLINK_TYPE_STRING },
 312         [IFLA_INFO_DATA]        = { .type = NETLINK_TYPE_UNION, .type_system_union = &rtnl_link_info_data_type_system_union},
 313 /*
 314         [IFLA_INFO_XSTATS],
 315         [IFLA_INFO_SLAVE_KIND]  = { .type = NETLINK_TYPE_STRING },
 316         [IFLA_INFO_SLAVE_DATA]  = { .type = NETLINK_TYPE_NESTED },
 317 */
 318 };
 319
 320 static const NLTypeSystem rtnl_link_info_type_system = {
 321         .count = ELEMENTSOF(rtnl_link_info_types),
 322         .types = rtnl_link_info_types,
 323 };
 324
 325 static const struct NLType rtnl_prot_info_bridge_port_types[IFLA_BRPORT_MAX + 1] = {
 326         [IFLA_BRPORT_STATE]             = { .type = NETLINK_TYPE_U8 },
 327         [IFLA_BRPORT_COST]              = { .type = NETLINK_TYPE_U32 },
 328         [IFLA_BRPORT_PRIORITY]          = { .type = NETLINK_TYPE_U16 },
 329         [IFLA_BRPORT_MODE]              = { .type = NETLINK_TYPE_U8 },
 330         [IFLA_BRPORT_GUARD]             = { .type = NETLINK_TYPE_U8 },
 331         [IFLA_BRPORT_PROTECT]           = { .type = NETLINK_TYPE_U8 },
 332         [IFLA_BRPORT_LEARNING]          = { .type = NETLINK_TYPE_U8 },
 333         [IFLA_BRPORT_UNICAST_FLOOD]     = { .type = NETLINK_TYPE_U8 },
 334 };
 335
 336 static const NLTypeSystem rtnl_prot_info_type_systems[AF_MAX] = {
 337         [AF_BRIDGE] =   { .count = ELEMENTSOF(rtnl_prot_info_bridge_port_types),
 338                           .types = rtnl_prot_info_bridge_port_types },
 339 };
 340
 341 static const NLTypeSystemUnion rtnl_prot_info_type_system_union = {
 342         .num = AF_MAX,
 343         .type_systems = rtnl_prot_info_type_systems,
 344         .match_type = NL_MATCH_PROTOCOL,
 345 };
 346
 347 static const struct NLType rtnl_af_spec_inet6_types[IFLA_INET6_MAX + 1] = {
 348         [IFLA_INET6_FLAGS]              = { .type = NETLINK_TYPE_U32 },
 349 /*
 350         IFLA_INET6_CONF,
 351         IFLA_INET6_STATS,
 352         IFLA_INET6_MCAST,
 353         IFLA_INET6_CACHEINFO,
 354         IFLA_INET6_ICMP6STATS,
 355 */
 356         [IFLA_INET6_TOKEN]              = { .type = NETLINK_TYPE_IN_ADDR },
 357         [IFLA_INET6_ADDR_GEN_MODE]      = { .type = NETLINK_TYPE_U8 },
 358 };
 359
 360 static const NLTypeSystem rtnl_af_spec_inet6_type_system = {
 361         .count = ELEMENTSOF(rtnl_af_spec_inet6_types),
 362         .types = rtnl_af_spec_inet6_types,
 363 };
 364
 365 static const NLType rtnl_af_spec_types[AF_MAX + 1] = {
 366         [AF_INET6] =    { .type = NETLINK_TYPE_NESTED, .type_system = &rtnl_af_spec_inet6_type_system },
 367 };
 368
 369 static const NLTypeSystem rtnl_af_spec_type_system = {
 370         .count = ELEMENTSOF(rtnl_af_spec_types),
 371         .types = rtnl_af_spec_types,
 372 };
 373
 374 static const NLType rtnl_link_types[IFLA_MAX + 1 ] = {
 375         [IFLA_ADDRESS]          = { .type = NETLINK_TYPE_ETHER_ADDR, },
 376         [IFLA_BROADCAST]        = { .type = NETLINK_TYPE_ETHER_ADDR, },
 377         [IFLA_IFNAME]           = { .type = NETLINK_TYPE_STRING, .size = IFNAMSIZ - 1, },
 378         [IFLA_MTU]              = { .type = NETLINK_TYPE_U32 },
 379         [IFLA_LINK]             = { .type = NETLINK_TYPE_U32 },
 380 /*
 381         [IFLA_QDISC],
 382         [IFLA_STATS],
 383         [IFLA_COST],
 384         [IFLA_PRIORITY],
 385 */
 386         [IFLA_MASTER]           = { .type = NETLINK_TYPE_U32 },
 387 /*
 388         [IFLA_WIRELESS],
 389 */
 390         [IFLA_PROTINFO]         = { .type = NETLINK_TYPE_UNION, .type_system_union = &rtnl_prot_info_type_system_union },
 391         [IFLA_TXQLEN]           = { .type = NETLINK_TYPE_U32 },
 392 /*
 393         [IFLA_MAP]              = { .len = sizeof(struct rtnl_link_ifmap) },
 394 */
 395         [IFLA_WEIGHT]           = { .type = NETLINK_TYPE_U32 },
 396         [IFLA_OPERSTATE]        = { .type = NETLINK_TYPE_U8 },
 397         [IFLA_LINKMODE]         = { .type = NETLINK_TYPE_U8 },
 398         [IFLA_LINKINFO]         = { .type = NETLINK_TYPE_NESTED, .type_system = &rtnl_link_info_type_system },
 399         [IFLA_NET_NS_PID]       = { .type = NETLINK_TYPE_U32 },
 400         [IFLA_IFALIAS]          = { .type = NETLINK_TYPE_STRING, .size = IFALIASZ - 1 },
 401 /*
 402         [IFLA_NUM_VF],
 403         [IFLA_VFINFO_LIST]      = {. type = NETLINK_TYPE_NESTED, },
 404         [IFLA_STATS64],
 405         [IFLA_VF_PORTS]         = { .type = NETLINK_TYPE_NESTED },
 406         [IFLA_PORT_SELF]        = { .type = NETLINK_TYPE_NESTED },
 407 */
 408         [IFLA_AF_SPEC]          = { .type = NETLINK_TYPE_NESTED, .type_system = &rtnl_af_spec_type_system },
 409 /*
 410         [IFLA_VF_PORTS],
 411         [IFLA_PORT_SELF],
 412         [IFLA_AF_SPEC],
 413 */
 414         [IFLA_GROUP]            = { .type = NETLINK_TYPE_U32 },
 415         [IFLA_NET_NS_FD]        = { .type = NETLINK_TYPE_U32 },
 416         [IFLA_EXT_MASK]         = { .type = NETLINK_TYPE_U32 },
 417         [IFLA_PROMISCUITY]      = { .type = NETLINK_TYPE_U32 },
 418         [IFLA_NUM_TX_QUEUES]    = { .type = NETLINK_TYPE_U32 },
 419         [IFLA_NUM_RX_QUEUES]    = { .type = NETLINK_TYPE_U32 },
 420         [IFLA_CARRIER]          = { .type = NETLINK_TYPE_U8 },
 421 /*
 422         [IFLA_PHYS_PORT_ID]     = { .type = NETLINK_TYPE_BINARY, .len = MAX_PHYS_PORT_ID_LEN },
 423 */
 424 };
 425
 426 static const NLTypeSystem rtnl_link_type_system = {
 427         .count = ELEMENTSOF(rtnl_link_types),
 428         .types = rtnl_link_types,
 429 };
 430
 431 /* IFA_FLAGS was defined in kernel 3.14, but we still support older
 432  * kernels where IFA_MAX is lower. */
 433 static const NLType rtnl_address_types[CONST_MAX(IFA_MAX, IFA_FLAGS) + 1] = {
 434         [IFA_ADDRESS]           = { .type = NETLINK_TYPE_IN_ADDR },
 435         [IFA_LOCAL]             = { .type = NETLINK_TYPE_IN_ADDR },
 436         [IFA_LABEL]             = { .type = NETLINK_TYPE_STRING, .size = IFNAMSIZ - 1 },
 437         [IFA_BROADCAST]         = { .type = NETLINK_TYPE_IN_ADDR }, /* 6? */
 438         [IFA_CACHEINFO]         = { .type = NETLINK_TYPE_CACHE_INFO, .size = sizeof(struct ifa_cacheinfo) },
 439 /*
 440         [IFA_ANYCAST],
 441         [IFA_MULTICAST],
 442 */
 443         [IFA_FLAGS]             = { .type = NETLINK_TYPE_U32 },
 444 };
 445
 446 static const NLTypeSystem rtnl_address_type_system = {
 447         .count = ELEMENTSOF(rtnl_address_types),
 448         .types = rtnl_address_types,
 449 };
 450
 451 static const NLType rtnl_route_types[RTA_MAX + 1] = {
 452         [RTA_DST]               = { .type = NETLINK_TYPE_IN_ADDR }, /* 6? */
 453         [RTA_SRC]               = { .type = NETLINK_TYPE_IN_ADDR }, /* 6? */
 454         [RTA_IIF]               = { .type = NETLINK_TYPE_U32 },
 455         [RTA_OIF]               = { .type = NETLINK_TYPE_U32 },
 456         [RTA_GATEWAY]           = { .type = NETLINK_TYPE_IN_ADDR },
 457         [RTA_PRIORITY]          = { .type = NETLINK_TYPE_U32 },
 458         [RTA_PREFSRC]           = { .type = NETLINK_TYPE_IN_ADDR }, /* 6? */
 459 /*
 460         [RTA_METRICS]           = { .type = NETLINK_TYPE_NESTED },
 461         [RTA_MULTIPATH]         = { .len = sizeof(struct rtnexthop) },
 462 */
 463         [RTA_FLOW]              = { .type = NETLINK_TYPE_U32 }, /* 6? */
 464 /*
 465         RTA_CACHEINFO,
 466         RTA_TABLE,
 467         RTA_MARK,
 468         RTA_MFC_STATS,
 469 */
 470 };
 471
 472 static const NLTypeSystem rtnl_route_type_system = {
 473         .count = ELEMENTSOF(rtnl_route_types),
 474         .types = rtnl_route_types,
 475 };
 476
 477 static const NLType rtnl_neigh_types[NDA_MAX + 1] = {
 478         [NDA_DST]               = { .type = NETLINK_TYPE_IN_ADDR },
 479         [NDA_LLADDR]            = { .type = NETLINK_TYPE_ETHER_ADDR },
 480         [NDA_CACHEINFO]         = { .type = NETLINK_TYPE_CACHE_INFO, .size = sizeof(struct nda_cacheinfo) },
 481         [NDA_PROBES]            = { .type = NETLINK_TYPE_U32 },
 482         [NDA_VLAN]              = { .type = NETLINK_TYPE_U16 },
 483         [NDA_PORT]              = { .type = NETLINK_TYPE_U16 },
 484         [NDA_VNI]               = { .type = NETLINK_TYPE_U32 },
 485         [NDA_IFINDEX]           = { .type = NETLINK_TYPE_U32 },
 486 };
 487
 488 static const NLTypeSystem rtnl_neigh_type_system = {
 489         .count = ELEMENTSOF(rtnl_neigh_types),
 490         .types = rtnl_neigh_types,
 491 };
 492
 493 static const NLType rtnl_types[RTM_MAX + 1] = {
 494         [NLMSG_DONE]   = { .type = NETLINK_TYPE_NESTED, .type_system = &empty_type_system, .size = 0 },
 495         [NLMSG_ERROR]  = { .type = NETLINK_TYPE_NESTED, .type_system = &empty_type_system, .size = sizeof(struct nlmsgerr) },
 496         [RTM_NEWLINK]  = { .type = NETLINK_TYPE_NESTED, .type_system = &rtnl_link_type_system, .size = sizeof(struct ifinfomsg) },
 497         [RTM_DELLINK]  = { .type = NETLINK_TYPE_NESTED, .type_system = &rtnl_link_type_system, .size = sizeof(struct ifinfomsg) },
 498         [RTM_GETLINK]  = { .type = NETLINK_TYPE_NESTED, .type_system = &rtnl_link_type_system, .size = sizeof(struct ifinfomsg) },
 499         [RTM_SETLINK]  = { .type = NETLINK_TYPE_NESTED, .type_system = &rtnl_link_type_system, .size = sizeof(struct ifinfomsg) },
 500         [RTM_NEWADDR]  = { .type = NETLINK_TYPE_NESTED, .type_system = &rtnl_address_type_system, .size = sizeof(struct ifaddrmsg) },
 501         [RTM_DELADDR]  = { .type = NETLINK_TYPE_NESTED, .type_system = &rtnl_address_type_system, .size = sizeof(struct ifaddrmsg) },
 502         [RTM_GETADDR]  = { .type = NETLINK_TYPE_NESTED, .type_system = &rtnl_address_type_system, .size = sizeof(struct ifaddrmsg) },
 503         [RTM_NEWROUTE] = { .type = NETLINK_TYPE_NESTED, .type_system = &rtnl_route_type_system, .size = sizeof(struct rtmsg) },
 504         [RTM_DELROUTE] = { .type = NETLINK_TYPE_NESTED, .type_system = &rtnl_route_type_system, .size = sizeof(struct rtmsg) },
 505         [RTM_GETROUTE] = { .type = NETLINK_TYPE_NESTED, .type_system = &rtnl_route_type_system, .size = sizeof(struct rtmsg) },
 506         [RTM_NEWNEIGH] = { .type = NETLINK_TYPE_NESTED, .type_system = &rtnl_neigh_type_system, .size = sizeof(struct ndmsg) },
 507         [RTM_DELNEIGH] = { .type = NETLINK_TYPE_NESTED, .type_system = &rtnl_neigh_type_system, .size = sizeof(struct ndmsg) },
 508         [RTM_GETNEIGH] = { .type = NETLINK_TYPE_NESTED, .type_system = &rtnl_neigh_type_system, .size = sizeof(struct ndmsg) },
 509 };
 510
 511 const NLTypeSystem type_system_root = {
 512         .count = ELEMENTSOF(rtnl_types),
 513         .types = rtnl_types,
 514 };
 515
 516 uint16_t type_get_type(const NLType *type) {
 517         assert(type);
 518         return type->type;
 519 }
 520
 521 size_t type_get_size(const NLType *type) {
 522         assert(type);
 523         return type->size;
 524 }
 525
 526 void type_get_type_system(const NLType *nl_type, const NLTypeSystem **ret) {
 527         assert(nl_type);
 528         assert(ret);
 529         assert(nl_type->type == NETLINK_TYPE_NESTED);
 530         assert(nl_type->type_system);
 531
 532         *ret = nl_type->type_system;
 533 }
 534
 535 void type_get_type_system_union(const NLType *nl_type, const NLTypeSystemUnion **ret) {
 536         assert(nl_type);
 537         assert(ret);
 538         assert(nl_type->type == NETLINK_TYPE_UNION);
 539         assert(nl_type->type_system_union);
 540
 541         *ret = nl_type->type_system_union;
 542 }
 543
 544 uint16_t type_system_get_count(const NLTypeSystem *type_system) {
 545         assert(type_system);
 546         return type_system->count;
 547 }
 548
 549 int type_system_get_type(const NLTypeSystem *type_system, const NLType **ret, uint16_t type) {
 550         const NLType *nl_type;
 551
 552         assert(ret);
 553         assert(type_system);
 554         assert(type_system->types);
 555
 556         if (type >= type_system->count)
 557                 return -EOPNOTSUPP;
 558
 559         nl_type = &type_system->types[type];
 560
 561         if (nl_type->type == NETLINK_TYPE_UNSPEC)
 562                 return -EOPNOTSUPP;
 563
 564         *ret = nl_type;
 565
 566         return 0;
 567 }
 568
 569 int type_system_get_type_system(const NLTypeSystem *type_system, const NLTypeSystem **ret, uint16_t type) {
 570         const NLType *nl_type;
 571         int r;
 572
 573         assert(ret);
 574
 575         r = type_system_get_type(type_system, &nl_type, type);
 576         if (r < 0)
 577                 return r;
 578
 579         type_get_type_system(nl_type, ret);
 580         return 0;
 581 }
 582
 583 int type_system_get_type_system_union(const NLTypeSystem *type_system, const NLTypeSystemUnion **ret, uint16_t type) {
 584         const NLType *nl_type;
 585         int r;
 586
 587         assert(ret);
 588
 589         r = type_system_get_type(type_system, &nl_type, type);
 590         if (r < 0)
 591                 return r;
 592
 593         type_get_type_system_union(nl_type, ret);
 594         return 0;
 595 }
 596
 597 int type_system_union_get_type_system(const NLTypeSystemUnion *type_system_union, const NLTypeSystem **ret, const char *key) {
 598         int type;
 599
 600         assert(type_system_union);
 601         assert(type_system_union->match_type == NL_MATCH_SIBLING);
 602         assert(type_system_union->lookup);
 603         assert(type_system_union->type_systems);
 604         assert(ret);
 605         assert(key);
 606
 607         type = type_system_union->lookup(key);
 608         if (type < 0)
 609                 return -EOPNOTSUPP;
 610
 611         assert(type < type_system_union->num);
 612
 613         *ret = &type_system_union->type_systems[type];
 614
 615         return 0;
 616 }
 617
 618 int type_system_union_protocol_get_type_system(const NLTypeSystemUnion *type_system_union, const NLTypeSystem **ret, uint16_t protocol) {
 619         const NLTypeSystem *type_system;
 620
 621         assert(type_system_union);
 622         assert(type_system_union->type_systems);
 623         assert(type_system_union->match_type == NL_MATCH_PROTOCOL);
 624         assert(ret);
 625
 626         if (protocol >= type_system_union->num)
 627                 return -EOPNOTSUPP;
 628
 629         type_system = &type_system_union->type_systems[protocol];
 630         if (!type_system->types)
 631                 return -EOPNOTSUPP;
 632
 633         *ret = type_system;
 634
 635         return 0;
 636 }