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