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 "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] = {
 125         [NL_UNION_LINK_INFO_DATA_BOND] =    { .max = ELEMENTSOF(rtnl_link_info_data_bond_types) - 1,
 126                                               .types = rtnl_link_info_data_bond_types },
 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? */
 219 /*
 220         [IFA_ANYCAST],
 221         [IFA_CACHEINFO]         = { .len = sizeof(struct ifa_cacheinfo) },
 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 }