[thirdparty/systemd.git] / src / libsystemd / sd-rtnl / rtnl-types.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2014 Tom Gundersen <teg@jklm.no>

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <stddef.h>
#include <stdint.h>
#include <sys/socket.h>
#include <linux/netlink.h>
#include <linux/rtnetlink.h>
#include <linux/in6.h>
#include <linux/veth.h>
#include <linux/if_bridge.h>
#include <linux/if_addr.h>
#include <linux/if.h>

#include "macro.h"
#include "util.h"

#include "rtnl-types.h"

static const NLTypeSystem rtnl_link_type_system;

static const NLType rtnl_link_info_data_veth_types[VETH_INFO_MAX + 1] = {
        [VETH_INFO_PEER]  = { .type = NLA_NESTED, .type_system = &rtnl_link_type_system, .size = sizeof(struct ifinfomsg) },
};


static const NLType rtnl_link_info_data_macvlan_types[IFLA_MACVLAN_MAX + 1] = {
        [IFLA_MACVLAN_MODE]  = { .type = NLA_U32 },
        [IFLA_MACVLAN_FLAGS] = { .type = NLA_U16 },
};

static const NLType rtnl_link_info_data_bridge_types[IFLA_BRIDGE_MAX + 1] = {
        [IFLA_BRIDGE_FLAGS]     = { .type = NLA_U16 },
        [IFLA_BRIDGE_MODE]      = { .type = NLA_U16 },
/*
        [IFLA_BRIDGE_VLAN_INFO] = { .type = NLA_BINARY,
                                    .len = sizeof(struct bridge_vlan_info), },
*/
};

static const NLType rtnl_link_info_data_vlan_types[IFLA_VLAN_MAX + 1] = {
        [IFLA_VLAN_ID]          = { .type = NLA_U16 },
/*
        [IFLA_VLAN_FLAGS]       = { .len = sizeof(struct ifla_vlan_flags) },
        [IFLA_VLAN_EGRESS_QOS]  = { .type = NLA_NESTED },
        [IFLA_VLAN_INGRESS_QOS] = { .type = NLA_NESTED },
*/
        [IFLA_VLAN_PROTOCOL]    = { .type = NLA_U16 },
};

static const NLType rtnl_link_info_data_bond_types[IFLA_BOND_MAX + 1] = {
        [IFLA_BOND_MODE]                = { .type = NLA_U8 },
        [IFLA_BOND_ACTIVE_SLAVE]        = { .type = NLA_U32 },
#ifdef IFLA_BOND_MIIMON
        [IFLA_BOND_MIIMON]              = { .type = NLA_U32 },
        [IFLA_BOND_UPDELAY]             = { .type = NLA_U32 },
        [IFLA_BOND_DOWNDELAY]           = { .type = NLA_U32 },
        [IFLA_BOND_USE_CARRIER]         = { .type = NLA_U8 },
        [IFLA_BOND_ARP_INTERVAL]        = { .type = NLA_U32 },
/*
        [IFLA_BOND_ARP_IP_TARGET]       = { .type = NLA_NESTED },
*/
        [IFLA_BOND_ARP_VALIDATE]        = { .type = NLA_U32 },
        [IFLA_BOND_ARP_ALL_TARGETS]     = { .type = NLA_U32 },
        [IFLA_BOND_PRIMARY]             = { .type = NLA_U32 },
        [IFLA_BOND_PRIMARY_RESELECT]    = { .type = NLA_U8 },
        [IFLA_BOND_FAIL_OVER_MAC]       = { .type = NLA_U8 },
        [IFLA_BOND_XMIT_HASH_POLICY]    = { .type = NLA_U8 },
        [IFLA_BOND_RESEND_IGMP]         = { .type = NLA_U32 },
        [IFLA_BOND_NUM_PEER_NOTIF]      = { .type = NLA_U8 },
        [IFLA_BOND_ALL_SLAVES_ACTIVE]   = { .type = NLA_U8 },
        [IFLA_BOND_MIN_LINKS]           = { .type = NLA_U32 },
        [IFLA_BOND_LP_INTERVAL]         = { .type = NLA_U32 },
        [IFLA_BOND_PACKETS_PER_SLAVE]   = { .type = NLA_U32 },
        [IFLA_BOND_AD_LACP_RATE]        = { .type = NLA_U8 },
        [IFLA_BOND_AD_SELECT]           = { .type = NLA_U8 },
/*
        [IFLA_BOND_AD_INFO]             = { .type = NLA_NESTED },
*/
#endif
};

typedef enum NLUnionLinkInfoData {
        NL_UNION_LINK_INFO_DATA_BOND,
        NL_UNION_LINK_INFO_DATA_BRIDGE,
        NL_UNION_LINK_INFO_DATA_VLAN,
        NL_UNION_LINK_INFO_DATA_VETH,
        NL_UNION_LINK_INFO_DATA_MACVLAN,
        _NL_UNION_LINK_INFO_DATA_MAX,
        _NL_UNION_LINK_INFO_DATA_INVALID = -1
} NLUnionLinkInfoData;

const char *nl_union_link_info_data_to_string(NLUnionLinkInfoData p) _const_;
NLUnionLinkInfoData nl_union_link_info_data_from_string(const char *p) _pure_;

static const char* const nl_union_link_info_data_table[_NL_UNION_LINK_INFO_DATA_MAX] = {
        [NL_UNION_LINK_INFO_DATA_BOND] = "bond",
        [NL_UNION_LINK_INFO_DATA_BRIDGE] = "bridge",
        [NL_UNION_LINK_INFO_DATA_VLAN] = "vlan",
        [NL_UNION_LINK_INFO_DATA_VETH] = "veth",
        [NL_UNION_LINK_INFO_DATA_MACVLAN] = "macvlan",
};

DEFINE_STRING_TABLE_LOOKUP(nl_union_link_info_data, NLUnionLinkInfoData);

static const NLTypeSystem rtnl_link_info_data_type_systems[_NL_UNION_LINK_INFO_DATA_MAX] = {
        [NL_UNION_LINK_INFO_DATA_BOND] =    { .max = ELEMENTSOF(rtnl_link_info_data_bond_types) - 1,
                                              .types = rtnl_link_info_data_bond_types },
        [NL_UNION_LINK_INFO_DATA_BRIDGE] =  { .max = ELEMENTSOF(rtnl_link_info_data_bridge_types) - 1,
                                              .types = rtnl_link_info_data_bridge_types },
        [NL_UNION_LINK_INFO_DATA_VLAN] =    { .max = ELEMENTSOF(rtnl_link_info_data_vlan_types) - 1,
                                              .types = rtnl_link_info_data_vlan_types },
        [NL_UNION_LINK_INFO_DATA_VETH] =    { .max = ELEMENTSOF(rtnl_link_info_data_veth_types) - 1,
                                              .types = rtnl_link_info_data_veth_types },
        [NL_UNION_LINK_INFO_DATA_MACVLAN] = { .max = ELEMENTSOF(rtnl_link_info_data_macvlan_types) - 1,
                                              .types = rtnl_link_info_data_macvlan_types },
};

static const NLTypeSystemUnion rtnl_link_info_data_type_system_union = {
        .num = _NL_UNION_LINK_INFO_DATA_MAX,
        .lookup = nl_union_link_info_data_from_string,
        .type_systems = rtnl_link_info_data_type_systems,
        .match = IFLA_INFO_KIND,
};

static const NLType rtnl_link_info_types[IFLA_INFO_MAX + 1] = {
        [IFLA_INFO_KIND]        = { .type = NLA_STRING },
        [IFLA_INFO_DATA]        = { .type = NLA_UNION, .type_system_union = &rtnl_link_info_data_type_system_union},
/*
        [IFLA_INFO_XSTATS],
        [IFLA_INFO_SLAVE_KIND]  = { .type = NLA_STRING },
        [IFLA_INFO_SLAVE_DATA]  = { .type = NLA_NESTED },
*/
};

static const NLTypeSystem rtnl_link_info_type_system = {
        .max = ELEMENTSOF(rtnl_link_info_types) - 1,
        .types = rtnl_link_info_types,
};

static const NLType rtnl_link_types[IFLA_MAX + 1] = {
        [IFLA_ADDRESS]          = { .type = NLA_ETHER_ADDR, },
        [IFLA_BROADCAST]        = { .type = NLA_ETHER_ADDR, },
        [IFLA_IFNAME]           = { .type = NLA_STRING, .size = IFNAMSIZ - 1, },
        [IFLA_MTU]              = { .type = NLA_U32 },
        [IFLA_LINK]             = { .type = NLA_U32 },
/*
        [IFLA_QDISC],
        [IFLA_STATS],
        [IFLA_COST],
        [IFLA_PRIORITY],
*/
        [IFLA_MASTER]           = { .type = NLA_U32 },
/*
        [IFLA_WIRELESS],
        [IFLA_PROTINFO],
*/
        [IFLA_TXQLEN]           = { .type = NLA_U32 },
/*
        [IFLA_MAP]              = { .len = sizeof(struct rtnl_link_ifmap) },
*/
        [IFLA_WEIGHT]           = { .type = NLA_U32 },
        [IFLA_OPERSTATE]        = { .type = NLA_U8 },
        [IFLA_LINKMODE]         = { .type = NLA_U8 },
        [IFLA_LINKINFO]         = { .type = NLA_NESTED, .type_system = &rtnl_link_info_type_system },
        [IFLA_NET_NS_PID]       = { .type = NLA_U32 },
        [IFLA_IFALIAS]          = { .type = NLA_STRING, .size = IFALIASZ - 1 },
/*
        [IFLA_NUM_VF],
        [IFLA_VFINFO_LIST]      = {. type = NLA_NESTED, },
        [IFLA_STATS64],
        [IFLA_VF_PORTS]         = { .type = NLA_NESTED },
        [IFLA_PORT_SELF]        = { .type = NLA_NESTED },
        [IFLA_AF_SPEC]          = { .type = NLA_NESTED },
        [IFLA_VF_PORTS],
        [IFLA_PORT_SELF],
        [IFLA_AF_SPEC],
*/
        [IFLA_GROUP]            = { .type = NLA_U32 },
        [IFLA_NET_NS_FD]        = { .type = NLA_U32 },
        [IFLA_EXT_MASK]         = { .type = NLA_U32 },
        [IFLA_PROMISCUITY]      = { .type = NLA_U32 },
        [IFLA_NUM_TX_QUEUES]    = { .type = NLA_U32 },
        [IFLA_NUM_RX_QUEUES]    = { .type = NLA_U32 },
        [IFLA_CARRIER]          = { .type = NLA_U8 },
/*
        [IFLA_PHYS_PORT_ID]     = { .type = NLA_BINARY, .len = MAX_PHYS_PORT_ID_LEN },
*/
};

static const NLTypeSystem rtnl_link_type_system = {
        .max = ELEMENTSOF(rtnl_link_types) - 1,
        .types = rtnl_link_types,
};

static const NLType rtnl_address_types[IFA_MAX + 1] = {
        [IFA_ADDRESS]           = { .type = NLA_IN_ADDR },
        [IFA_LOCAL]             = { .type = NLA_IN_ADDR },
        [IFA_LABEL]             = { .type = NLA_STRING, .size = IFNAMSIZ - 1 },
        [IFA_BROADCAST]         = { .type = NLA_IN_ADDR }, /* 6? */
        [IFA_CACHEINFO]         = { .type = NLA_CACHE_INFO, .size = sizeof(struct ifa_cacheinfo) },
/*
        [IFA_ANYCAST],
        [IFA_MULTICAST],
*/
#ifdef IFA_FLAGS
        [IFA_FLAGS]             = { .type = NLA_U32 },
#endif
};

static const NLTypeSystem rtnl_address_type_system = {
        .max = ELEMENTSOF(rtnl_address_types) - 1,
        .types = rtnl_address_types,
};

static const NLType rtnl_route_types[RTA_MAX + 1] = {
        [RTA_DST]               = { .type = NLA_IN_ADDR }, /* 6? */
        [RTA_SRC]               = { .type = NLA_IN_ADDR }, /* 6? */
        [RTA_IIF]               = { .type = NLA_U32 },
        [RTA_OIF]               = { .type = NLA_U32 },
        [RTA_GATEWAY]           = { .type = NLA_IN_ADDR },
        [RTA_PRIORITY]          = { .type = NLA_U32 },
        [RTA_PREFSRC]           = { .type = NLA_IN_ADDR }, /* 6? */
/*
        [RTA_METRICS]           = { .type = NLA_NESTED },
        [RTA_MULTIPATH]         = { .len = sizeof(struct rtnexthop) },
*/
        [RTA_FLOW]              = { .type = NLA_U32 }, /* 6? */
/*
        RTA_CACHEINFO,
        RTA_TABLE,
        RTA_MARK,
        RTA_MFC_STATS,
*/
};

static const NLTypeSystem rtnl_route_type_system = {
        .max = ELEMENTSOF(rtnl_route_types) - 1,
        .types = rtnl_route_types,
};

static const NLType rtnl_types[RTM_MAX + 1] = {
        [NLMSG_ERROR]  = { .type = NLA_META, .size = sizeof(struct nlmsgerr) },
        [RTM_NEWLINK]  = { .type = NLA_NESTED, .type_system = &rtnl_link_type_system, .size = sizeof(struct ifinfomsg) },
        [RTM_DELLINK]  = { .type = NLA_NESTED, .type_system = &rtnl_link_type_system, .size = sizeof(struct ifinfomsg) },
        [RTM_GETLINK]  = { .type = NLA_NESTED, .type_system = &rtnl_link_type_system, .size = sizeof(struct ifinfomsg) },
        [RTM_SETLINK]  = { .type = NLA_NESTED, .type_system = &rtnl_link_type_system, .size = sizeof(struct ifinfomsg) },
        [RTM_NEWADDR]  = { .type = NLA_NESTED, .type_system = &rtnl_address_type_system, .size = sizeof(struct ifaddrmsg) },
        [RTM_DELADDR]  = { .type = NLA_NESTED, .type_system = &rtnl_address_type_system, .size = sizeof(struct ifaddrmsg) },
        [RTM_GETADDR]  = { .type = NLA_NESTED, .type_system = &rtnl_address_type_system, .size = sizeof(struct ifaddrmsg) },
        [RTM_NEWROUTE] = { .type = NLA_NESTED, .type_system = &rtnl_route_type_system, .size = sizeof(struct rtmsg) },
        [RTM_DELROUTE] = { .type = NLA_NESTED, .type_system = &rtnl_route_type_system, .size = sizeof(struct rtmsg) },
        [RTM_GETROUTE] = { .type = NLA_NESTED, .type_system = &rtnl_route_type_system, .size = sizeof(struct rtmsg) },
};

const NLTypeSystem rtnl_type_system = {
        .max = ELEMENTSOF(rtnl_types) - 1,
        .types = rtnl_types,
};

int type_system_get_type(const NLTypeSystem *type_system, const NLType **ret, uint16_t type) {
        const NLType *nl_type;

        assert(ret);

        if (!type_system)
                type_system = &rtnl_type_system;

        assert(type_system->types);

        if (type > type_system->max)
                return -ENOTSUP;

        nl_type = &type_system->types[type];

        if (nl_type->type == NLA_UNSPEC)
                return -ENOTSUP;

        *ret = nl_type;

        return 0;
}

int type_system_get_type_system(const NLTypeSystem *type_system, const NLTypeSystem **ret, uint16_t type) {
        const NLType *nl_type;
        int r;

        assert(ret);

        r = type_system_get_type(type_system, &nl_type, type);
        if (r < 0)
                return r;

        assert_return(nl_type->type == NLA_NESTED, -EINVAL);

        assert(nl_type->type_system);

        *ret = nl_type->type_system;

        return 0;
}

int type_system_get_type_system_union(const NLTypeSystem *type_system, const NLTypeSystemUnion **ret, uint16_t type) {
        const NLType *nl_type;
        int r;

        assert(ret);

        r = type_system_get_type(type_system, &nl_type, type);
        if (r < 0)
                return r;

        assert_return(nl_type->type == NLA_UNION, -EINVAL);

        assert(nl_type->type_system_union);

        *ret = nl_type->type_system_union;

        return 0;
}

int type_system_union_get_type_system(const NLTypeSystemUnion *type_system_union, const NLTypeSystem **ret, const char *key) {
        int type;

        assert(type_system_union);
        assert(type_system_union->lookup);
        assert(type_system_union->type_systems);
        assert(ret);
        assert(key);

        type = type_system_union->lookup(key);
        if (type < 0)
                return -ENOTSUP;

        assert(type < type_system_union->num);

        *ret = &type_system_union->type_systems[type];

        return 0;
}
Commit	Line	Data
d8e538ec TG	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 <stddef.h>
	23	#include <stdint.h>
	24	#include <sys/socket.h>
	25	#include <linux/netlink.h>
	26	#include <linux/rtnetlink.h>
	27	#include <linux/in6.h>
	28	#include <linux/veth.h>
	29	#include <linux/if_bridge.h>
	30	#include <linux/if_addr.h>
	31	#include <linux/if.h>
	32
	33	#include "macro.h"
	34	#include "util.h"
	35
	36	#include "rtnl-types.h"
	37
	38	static const NLTypeSystem rtnl_link_type_system;
	39
	40	static const NLType rtnl_link_info_data_veth_types[VETH_INFO_MAX + 1] = {
	41	[VETH_INFO_PEER] = { .type = NLA_NESTED, .type_system = &rtnl_link_type_system, .size = sizeof(struct ifinfomsg) },
	42	};
	43
	44
	45	static const NLType rtnl_link_info_data_macvlan_types[IFLA_MACVLAN_MAX + 1] = {
	46	[IFLA_MACVLAN_MODE] = { .type = NLA_U32 },
	47	[IFLA_MACVLAN_FLAGS] = { .type = NLA_U16 },
	48	};
	49
	50	static const NLType rtnl_link_info_data_bridge_types[IFLA_BRIDGE_MAX + 1] = {
	51	[IFLA_BRIDGE_FLAGS] = { .type = NLA_U16 },
	52	[IFLA_BRIDGE_MODE] = { .type = NLA_U16 },
	53	/*
	54	[IFLA_BRIDGE_VLAN_INFO] = { .type = NLA_BINARY,
	55	.len = sizeof(struct bridge_vlan_info), },
	56	*/
	57	};
	58
	59	static const NLType rtnl_link_info_data_vlan_types[IFLA_VLAN_MAX + 1] = {
	60	[IFLA_VLAN_ID] = { .type = NLA_U16 },
	61	/*
	62	[IFLA_VLAN_FLAGS] = { .len = sizeof(struct ifla_vlan_flags) },
	63	[IFLA_VLAN_EGRESS_QOS] = { .type = NLA_NESTED },
	64	[IFLA_VLAN_INGRESS_QOS] = { .type = NLA_NESTED },
65	*/
66	[IFLA_VLAN_PROTOCOL] = { .type = NLA_U16 },
67	};
68
69	static const NLType rtnl_link_info_data_bond_types[IFLA_BOND_MAX + 1] = {
70	[IFLA_BOND_MODE] = { .type = NLA_U8 },
71	[IFLA_BOND_ACTIVE_SLAVE] = { .type = NLA_U32 },
72	#ifdef IFLA_BOND_MIIMON
73	[IFLA_BOND_MIIMON] = { .type = NLA_U32 },
74	[IFLA_BOND_UPDELAY] = { .type = NLA_U32 },
75	[IFLA_BOND_DOWNDELAY] = { .type = NLA_U32 },
76	[IFLA_BOND_USE_CARRIER] = { .type = NLA_U8 },
77	[IFLA_BOND_ARP_INTERVAL] = { .type = NLA_U32 },
78	/*
79	[IFLA_BOND_ARP_IP_TARGET] = { .type = NLA_NESTED },
80	*/
81	[IFLA_BOND_ARP_VALIDATE] = { .type = NLA_U32 },
82	[IFLA_BOND_ARP_ALL_TARGETS] = { .type = NLA_U32 },
83	[IFLA_BOND_PRIMARY] = { .type = NLA_U32 },
84	[IFLA_BOND_PRIMARY_RESELECT] = { .type = NLA_U8 },
85	[IFLA_BOND_FAIL_OVER_MAC] = { .type = NLA_U8 },
86	[IFLA_BOND_XMIT_HASH_POLICY] = { .type = NLA_U8 },
87	[IFLA_BOND_RESEND_IGMP] = { .type = NLA_U32 },
88	[IFLA_BOND_NUM_PEER_NOTIF] = { .type = NLA_U8 },
89	[IFLA_BOND_ALL_SLAVES_ACTIVE] = { .type = NLA_U8 },
90	[IFLA_BOND_MIN_LINKS] = { .type = NLA_U32 },
91	[IFLA_BOND_LP_INTERVAL] = { .type = NLA_U32 },
92	[IFLA_BOND_PACKETS_PER_SLAVE] = { .type = NLA_U32 },
93	[IFLA_BOND_AD_LACP_RATE] = { .type = NLA_U8 },
94	[IFLA_BOND_AD_SELECT] = { .type = NLA_U8 },
95	/*
96	[IFLA_BOND_AD_INFO] = { .type = NLA_NESTED },
97	*/
98	#endif
99	};
100
101	typedef enum NLUnionLinkInfoData {
102	NL_UNION_LINK_INFO_DATA_BOND,
103	NL_UNION_LINK_INFO_DATA_BRIDGE,
104	NL_UNION_LINK_INFO_DATA_VLAN,
105	NL_UNION_LINK_INFO_DATA_VETH,
106	NL_UNION_LINK_INFO_DATA_MACVLAN,
107	_NL_UNION_LINK_INFO_DATA_MAX,
108	_NL_UNION_LINK_INFO_DATA_INVALID = -1
109	} NLUnionLinkInfoData;
110
111	const char *nl_union_link_info_data_to_string(NLUnionLinkInfoData p) _const_;
112	NLUnionLinkInfoData nl_union_link_info_data_from_string(const char *p) _pure_;
113
114	static const char* const nl_union_link_info_data_table[_NL_UNION_LINK_INFO_DATA_MAX] = {
115	[NL_UNION_LINK_INFO_DATA_BOND] = "bond",
116	[NL_UNION_LINK_INFO_DATA_BRIDGE] = "bridge",
117	[NL_UNION_LINK_INFO_DATA_VLAN] = "vlan",
118	[NL_UNION_LINK_INFO_DATA_VETH] = "veth",
119	[NL_UNION_LINK_INFO_DATA_MACVLAN] = "macvlan",
120	};
121
122	DEFINE_STRING_TABLE_LOOKUP(nl_union_link_info_data, NLUnionLinkInfoData);
123
124	static const NLTypeSystem rtnl_link_info_data_type_systems[_NL_UNION_LINK_INFO_DATA_MAX] = {
3cbbb3e6 TG	125	[NL_UNION_LINK_INFO_DATA_BOND] = { .max = ELEMENTSOF(rtnl_link_info_data_bond_types) - 1,
3cbbb3e6 TG	126	.types = rtnl_link_info_data_bond_types },
d8e538ec TG	127	[NL_UNION_LINK_INFO_DATA_BRIDGE] = { .max = ELEMENTSOF(rtnl_link_info_data_bridge_types) - 1,
	128	.types = rtnl_link_info_data_bridge_types },
	129	[NL_UNION_LINK_INFO_DATA_VLAN] = { .max = ELEMENTSOF(rtnl_link_info_data_vlan_types) - 1,
	130	.types = rtnl_link_info_data_vlan_types },
	131	[NL_UNION_LINK_INFO_DATA_VETH] = { .max = ELEMENTSOF(rtnl_link_info_data_veth_types) - 1,
	132	.types = rtnl_link_info_data_veth_types },
	133	[NL_UNION_LINK_INFO_DATA_MACVLAN] = { .max = ELEMENTSOF(rtnl_link_info_data_macvlan_types) - 1,
	134	.types = rtnl_link_info_data_macvlan_types },
	135	};
	136
	137	static const NLTypeSystemUnion rtnl_link_info_data_type_system_union = {
	138	.num = _NL_UNION_LINK_INFO_DATA_MAX,
	139	.lookup = nl_union_link_info_data_from_string,
	140	.type_systems = rtnl_link_info_data_type_systems,
	141	.match = IFLA_INFO_KIND,
	142	};
	143
	144	static const NLType rtnl_link_info_types[IFLA_INFO_MAX + 1] = {
	145	[IFLA_INFO_KIND] = { .type = NLA_STRING },
	146	[IFLA_INFO_DATA] = { .type = NLA_UNION, .type_system_union = &rtnl_link_info_data_type_system_union},
	147	/*
	148	[IFLA_INFO_XSTATS],
	149	[IFLA_INFO_SLAVE_KIND] = { .type = NLA_STRING },
	150	[IFLA_INFO_SLAVE_DATA] = { .type = NLA_NESTED },
	151	*/
	152	};
	153
	154	static const NLTypeSystem rtnl_link_info_type_system = {
	155	.max = ELEMENTSOF(rtnl_link_info_types) - 1,
	156	.types = rtnl_link_info_types,
	157	};
	158
	159	static const NLType rtnl_link_types[IFLA_MAX + 1] = {
	160	[IFLA_ADDRESS] = { .type = NLA_ETHER_ADDR, },
	161	[IFLA_BROADCAST] = { .type = NLA_ETHER_ADDR, },
	162	[IFLA_IFNAME] = { .type = NLA_STRING, .size = IFNAMSIZ - 1, },
	163	[IFLA_MTU] = { .type = NLA_U32 },
	164	[IFLA_LINK] = { .type = NLA_U32 },
	165	/*
	166	[IFLA_QDISC],
	167	[IFLA_STATS],
	168	[IFLA_COST],
	169	[IFLA_PRIORITY],
	170	*/
	171	[IFLA_MASTER] = { .type = NLA_U32 },
	172	/*
	173	[IFLA_WIRELESS],
	174	[IFLA_PROTINFO],
	175	*/
	176	[IFLA_TXQLEN] = { .type = NLA_U32 },
	177	/*
	178	[IFLA_MAP] = { .len = sizeof(struct rtnl_link_ifmap) },
	179	*/
	180	[IFLA_WEIGHT] = { .type = NLA_U32 },
	181	[IFLA_OPERSTATE] = { .type = NLA_U8 },
	182	[IFLA_LINKMODE] = { .type = NLA_U8 },
	183	[IFLA_LINKINFO] = { .type = NLA_NESTED, .type_system = &rtnl_link_info_type_system },
	184	[IFLA_NET_NS_PID] = { .type = NLA_U32 },
	185	[IFLA_IFALIAS] = { .type = NLA_STRING, .size = IFALIASZ - 1 },
	186	/*
	187	[IFLA_NUM_VF],
	188	[IFLA_VFINFO_LIST] = {. type = NLA_NESTED, },
	189	[IFLA_STATS64],
	190	[IFLA_VF_PORTS] = { .type = NLA_NESTED },
191	[IFLA_PORT_SELF] = { .type = NLA_NESTED },
192	[IFLA_AF_SPEC] = { .type = NLA_NESTED },
193	[IFLA_VF_PORTS],
194	[IFLA_PORT_SELF],
195	[IFLA_AF_SPEC],
196	*/
197	[IFLA_GROUP] = { .type = NLA_U32 },
198	[IFLA_NET_NS_FD] = { .type = NLA_U32 },
199	[IFLA_EXT_MASK] = { .type = NLA_U32 },
200	[IFLA_PROMISCUITY] = { .type = NLA_U32 },
201	[IFLA_NUM_TX_QUEUES] = { .type = NLA_U32 },
202	[IFLA_NUM_RX_QUEUES] = { .type = NLA_U32 },
203	[IFLA_CARRIER] = { .type = NLA_U8 },
204	/*
205	[IFLA_PHYS_PORT_ID] = { .type = NLA_BINARY, .len = MAX_PHYS_PORT_ID_LEN },
206	*/
207	};
208
209	static const NLTypeSystem rtnl_link_type_system = {
210	.max = ELEMENTSOF(rtnl_link_types) - 1,
211	.types = rtnl_link_types,
212	};
213
214	static const NLType rtnl_address_types[IFA_MAX + 1] = {
215	[IFA_ADDRESS] = { .type = NLA_IN_ADDR },
216	[IFA_LOCAL] = { .type = NLA_IN_ADDR },
217	[IFA_LABEL] = { .type = NLA_STRING, .size = IFNAMSIZ - 1 },
218	[IFA_BROADCAST] = { .type = NLA_IN_ADDR }, /* 6? */
aba496a5	219	[IFA_CACHEINFO] = { .type = NLA_CACHE_INFO, .size = sizeof(struct ifa_cacheinfo) },
d8e538ec TG	220	/*
d8e538ec TG	221	[IFA_ANYCAST],
d8e538ec TG	222	[IFA_MULTICAST],
	223	*/
	224	#ifdef IFA_FLAGS
	225	[IFA_FLAGS] = { .type = NLA_U32 },
	226	#endif
	227	};
	228
	229	static const NLTypeSystem rtnl_address_type_system = {
	230	.max = ELEMENTSOF(rtnl_address_types) - 1,
	231	.types = rtnl_address_types,
	232	};
	233
	234	static const NLType rtnl_route_types[RTA_MAX + 1] = {
	235	[RTA_DST] = { .type = NLA_IN_ADDR }, /* 6? */
	236	[RTA_SRC] = { .type = NLA_IN_ADDR }, /* 6? */
	237	[RTA_IIF] = { .type = NLA_U32 },
	238	[RTA_OIF] = { .type = NLA_U32 },
	239	[RTA_GATEWAY] = { .type = NLA_IN_ADDR },
	240	[RTA_PRIORITY] = { .type = NLA_U32 },
	241	[RTA_PREFSRC] = { .type = NLA_IN_ADDR }, /* 6? */
	242	/*
	243	[RTA_METRICS] = { .type = NLA_NESTED },
	244	[RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) },
	245	*/
	246	[RTA_FLOW] = { .type = NLA_U32 }, /* 6? */
	247	/*
	248	RTA_CACHEINFO,
	249	RTA_TABLE,
	250	RTA_MARK,
	251	RTA_MFC_STATS,
	252	*/
	253	};
	254
	255	static const NLTypeSystem rtnl_route_type_system = {
	256	.max = ELEMENTSOF(rtnl_route_types) - 1,
	257	.types = rtnl_route_types,
	258	};
	259
	260	static const NLType rtnl_types[RTM_MAX + 1] = {
	261	[NLMSG_ERROR] = { .type = NLA_META, .size = sizeof(struct nlmsgerr) },
	262	[RTM_NEWLINK] = { .type = NLA_NESTED, .type_system = &rtnl_link_type_system, .size = sizeof(struct ifinfomsg) },
	263	[RTM_DELLINK] = { .type = NLA_NESTED, .type_system = &rtnl_link_type_system, .size = sizeof(struct ifinfomsg) },
	264	[RTM_GETLINK] = { .type = NLA_NESTED, .type_system = &rtnl_link_type_system, .size = sizeof(struct ifinfomsg) },
	265	[RTM_SETLINK] = { .type = NLA_NESTED, .type_system = &rtnl_link_type_system, .size = sizeof(struct ifinfomsg) },
	266	[RTM_NEWADDR] = { .type = NLA_NESTED, .type_system = &rtnl_address_type_system, .size = sizeof(struct ifaddrmsg) },
	267	[RTM_DELADDR] = { .type = NLA_NESTED, .type_system = &rtnl_address_type_system, .size = sizeof(struct ifaddrmsg) },
	268	[RTM_GETADDR] = { .type = NLA_NESTED, .type_system = &rtnl_address_type_system, .size = sizeof(struct ifaddrmsg) },
	269	[RTM_NEWROUTE] = { .type = NLA_NESTED, .type_system = &rtnl_route_type_system, .size = sizeof(struct rtmsg) },
	270	[RTM_DELROUTE] = { .type = NLA_NESTED, .type_system = &rtnl_route_type_system, .size = sizeof(struct rtmsg) },
	271	[RTM_GETROUTE] = { .type = NLA_NESTED, .type_system = &rtnl_route_type_system, .size = sizeof(struct rtmsg) },
	272	};
	273
	274	const NLTypeSystem rtnl_type_system = {
	275	.max = ELEMENTSOF(rtnl_types) - 1,
	276	.types = rtnl_types,
	277	};
	278
	279	int type_system_get_type(const NLTypeSystem type_system, const NLType *ret, uint16_t type) {
	280	const NLType *nl_type;
	281
	282	assert(ret);
	283
	284	if (!type_system)
	285	type_system = &rtnl_type_system;
286
287	assert(type_system->types);
288
289	if (type > type_system->max)
290	return -ENOTSUP;
291
292	nl_type = &type_system->types[type];
293
294	if (nl_type->type == NLA_UNSPEC)
295	return -ENOTSUP;
296
297	*ret = nl_type;
298
299	return 0;
300	}
301
302	int type_system_get_type_system(const NLTypeSystem type_system, const NLTypeSystem *ret, uint16_t type) {
303	const NLType *nl_type;
304	int r;
305
306	assert(ret);
307
308	r = type_system_get_type(type_system, &nl_type, type);
309	if (r < 0)
310	return r;
311
312	assert_return(nl_type->type == NLA_NESTED, -EINVAL);
313
314	assert(nl_type->type_system);
315
316	*ret = nl_type->type_system;
317
318	return 0;
319	}
320
321	int type_system_get_type_system_union(const NLTypeSystem type_system, const NLTypeSystemUnion *ret, uint16_t type) {
322	const NLType *nl_type;
323	int r;
324
325	assert(ret);
326
327	r = type_system_get_type(type_system, &nl_type, type);
328	if (r < 0)
329	return r;
330
331	assert_return(nl_type->type == NLA_UNION, -EINVAL);
332
333	assert(nl_type->type_system_union);
334
335	*ret = nl_type->type_system_union;
336
337	return 0;
338	}
339
340	int type_system_union_get_type_system(const NLTypeSystemUnion type_system_union, const NLTypeSystem ret, const char key) {
341	int type;
342
343	assert(type_system_union);
344	assert(type_system_union->lookup);
345	assert(type_system_union->type_systems);
346	assert(ret);
347	assert(key);
348
349	type = type_system_union->lookup(key);
350	if (type < 0)
351	return -ENOTSUP;
352
353	assert(type < type_system_union->num);
354
355	*ret = &type_system_union->type_systems[type];
356
357	return 0;
358	}