src/network/netdev/bridge.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include <net/if.h>
   4 #include <netinet/in.h>
   5 #include <linux/if_arp.h>
   6 #include <linux/if_bridge.h>
   7
   8 #include "bridge.h"
   9 #include "netlink-util.h"
  10 #include "networkd-manager.h"
  11 #include "string-table.h"
  12 #include "vlan-util.h"
  13
  14 assert_cc((int) MULTICAST_ROUTER_NONE            == (int) MDB_RTR_TYPE_DISABLED);
  15 assert_cc((int) MULTICAST_ROUTER_TEMPORARY_QUERY == (int) MDB_RTR_TYPE_TEMP_QUERY);
  16 assert_cc((int) MULTICAST_ROUTER_PERMANENT       == (int) MDB_RTR_TYPE_PERM);
  17 assert_cc((int) MULTICAST_ROUTER_TEMPORARY       == (int) MDB_RTR_TYPE_TEMP);
  18
  19 static const char* const multicast_router_table[_MULTICAST_ROUTER_MAX] = {
  20         [MULTICAST_ROUTER_NONE]            = "no",
  21         [MULTICAST_ROUTER_TEMPORARY_QUERY] = "query",
  22         [MULTICAST_ROUTER_PERMANENT]       = "permanent",
  23         [MULTICAST_ROUTER_TEMPORARY]       = "temporary",
  24 };
  25
  26 DEFINE_STRING_TABLE_LOOKUP_WITH_BOOLEAN(multicast_router, MulticastRouter, _MULTICAST_ROUTER_INVALID);
  27 DEFINE_CONFIG_PARSE_ENUM(config_parse_multicast_router, multicast_router, MulticastRouter,
  28                          "Failed to parse bridge multicast router setting");
  29
  30 /* callback for bridge netdev's parameter set */
  31 static int netdev_bridge_set_handler(sd_netlink *rtnl, sd_netlink_message *m, NetDev *netdev) {
  32         int r;
  33
  34         assert(netdev);
  35         assert(m);
  36
  37         r = sd_netlink_message_get_errno(m);
  38         if (r < 0) {
  39                 log_netdev_warning_errno(netdev, r, "Bridge parameters could not be set: %m");
  40                 return 1;
  41         }
  42
  43         log_netdev_debug(netdev, "Bridge parameters set success");
  44
  45         return 1;
  46 }
  47
  48 static int netdev_bridge_post_create(NetDev *netdev, Link *link, sd_netlink_message *m) {
  49         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
  50         Bridge *b;
  51         int r;
  52
  53         assert(netdev);
  54
  55         b = BRIDGE(netdev);
  56
  57         assert(b);
  58
  59         r = sd_rtnl_message_new_link(netdev->manager->rtnl, &req, RTM_NEWLINK, netdev->ifindex);
  60         if (r < 0)
  61                 return log_netdev_error_errno(netdev, r, "Could not allocate RTM_SETLINK message: %m");
  62
  63         r = sd_netlink_message_set_flags(req, NLM_F_REQUEST | NLM_F_ACK);
  64         if (r < 0)
  65                 return log_link_error_errno(link, r, "Could not set netlink flags: %m");
  66
  67         r = sd_netlink_message_open_container(req, IFLA_LINKINFO);
  68         if (r < 0)
  69                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_LINKINFO attribute: %m");
  70
  71         r = sd_netlink_message_open_container_union(req, IFLA_INFO_DATA, netdev_kind_to_string(netdev->kind));
  72         if (r < 0)
  73                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_INFO_DATA attribute: %m");
  74
  75         /* convert to jiffes */
  76         if (b->forward_delay != USEC_INFINITY) {
  77                 r = sd_netlink_message_append_u32(req, IFLA_BR_FORWARD_DELAY, usec_to_jiffies(b->forward_delay));
  78                 if (r < 0)
  79                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BR_FORWARD_DELAY attribute: %m");
  80         }
  81
  82         if (b->hello_time > 0) {
  83                 r = sd_netlink_message_append_u32(req, IFLA_BR_HELLO_TIME, usec_to_jiffies(b->hello_time));
  84                 if (r < 0)
  85                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BR_HELLO_TIME attribute: %m");
  86         }
  87
  88         if (b->max_age > 0) {
  89                 r = sd_netlink_message_append_u32(req, IFLA_BR_MAX_AGE, usec_to_jiffies(b->max_age));
  90                 if (r < 0)
  91                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BR_MAX_AGE attribute: %m");
  92         }
  93
  94         if (b->ageing_time != USEC_INFINITY) {
  95                 r = sd_netlink_message_append_u32(req, IFLA_BR_AGEING_TIME, usec_to_jiffies(b->ageing_time));
  96                 if (r < 0)
  97                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BR_AGEING_TIME attribute: %m");
  98         }
  99
 100         if (b->priority > 0) {
 101                 r = sd_netlink_message_append_u16(req, IFLA_BR_PRIORITY, b->priority);
 102                 if (r < 0)
 103                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BR_PRIORITY attribute: %m");
 104         }
 105
 106         if (b->group_fwd_mask > 0) {
 107                 r = sd_netlink_message_append_u16(req, IFLA_BR_GROUP_FWD_MASK, b->group_fwd_mask);
 108                 if (r < 0)
 109                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BR_GROUP_FWD_MASK attribute: %m");
 110         }
 111
 112         if (b->default_pvid != VLANID_INVALID) {
 113                 r = sd_netlink_message_append_u16(req, IFLA_BR_VLAN_DEFAULT_PVID, b->default_pvid);
 114                 if (r < 0)
 115                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BR_VLAN_DEFAULT_PVID attribute: %m");
 116         }
 117
 118         if (b->mcast_querier >= 0) {
 119                 r = sd_netlink_message_append_u8(req, IFLA_BR_MCAST_QUERIER, b->mcast_querier);
 120                 if (r < 0)
 121                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BR_MCAST_QUERIER attribute: %m");
 122         }
 123
 124         if (b->mcast_snooping >= 0) {
 125                 r = sd_netlink_message_append_u8(req, IFLA_BR_MCAST_SNOOPING, b->mcast_snooping);
 126                 if (r < 0)
 127                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BR_MCAST_SNOOPING attribute: %m");
 128         }
 129
 130         if (b->vlan_filtering >= 0) {
 131                 r = sd_netlink_message_append_u8(req, IFLA_BR_VLAN_FILTERING, b->vlan_filtering);
 132                 if (r < 0)
 133                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BR_VLAN_FILTERING attribute: %m");
 134         }
 135
 136         if (b->vlan_protocol >= 0) {
 137                 r = sd_netlink_message_append_u16(req, IFLA_BR_VLAN_PROTOCOL, b->vlan_protocol);
 138                 if (r < 0)
 139                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BR_VLAN_PROTOCOL attribute: %m");
 140         }
 141
 142         if (b->stp >= 0) {
 143                 r = sd_netlink_message_append_u32(req, IFLA_BR_STP_STATE, b->stp);
 144                 if (r < 0)
 145                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BR_STP_STATE attribute: %m");
 146         }
 147
 148         if (b->igmp_version > 0) {
 149                 r = sd_netlink_message_append_u8(req, IFLA_BR_MCAST_IGMP_VERSION, b->igmp_version);
 150                 if (r < 0)
 151                         return log_netdev_error_errno(netdev, r, "Could not append IFLA_BR_MCAST_IGMP_VERSION attribute: %m");
 152         }
 153
 154         r = sd_netlink_message_close_container(req);
 155         if (r < 0)
 156                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_LINKINFO attribute: %m");
 157
 158         r = sd_netlink_message_close_container(req);
 159         if (r < 0)
 160                 return log_netdev_error_errno(netdev, r, "Could not append IFLA_INFO_DATA attribute: %m");
 161
 162         r = netlink_call_async(netdev->manager->rtnl, NULL, req, netdev_bridge_set_handler,
 163                                netdev_destroy_callback, netdev);
 164         if (r < 0)
 165                 return log_netdev_error_errno(netdev, r, "Could not send rtnetlink message: %m");
 166
 167         netdev_ref(netdev);
 168
 169         return r;
 170 }
 171
 172 int config_parse_bridge_igmp_version(
 173                 const char *unit,
 174                 const char *filename,
 175                 unsigned line,
 176                 const char *section,
 177                 unsigned section_line,
 178                 const char *lvalue,
 179                 int ltype,
 180                 const char *rvalue,
 181                 void *data,
 182                 void *userdata) {
 183
 184         Bridge *b = userdata;
 185         uint8_t u;
 186         int r;
 187
 188         assert(filename);
 189         assert(lvalue);
 190         assert(rvalue);
 191         assert(data);
 192
 193         if (isempty(rvalue)) {
 194                 b->igmp_version = 0; /* 0 means unset. */
 195                 return 0;
 196         }
 197
 198         r = safe_atou8(rvalue, &u);
 199         if (r < 0) {
 200                 log_syntax(unit, LOG_WARNING, filename, line, r,
 201                            "Failed to parse bridge's multicast IGMP version number '%s', ignoring assignment: %m",
 202                            rvalue);
 203                 return 0;
 204         }
 205         if (!IN_SET(u, 2, 3)) {
 206                 log_syntax(unit, LOG_WARNING, filename, line, 0,
 207                            "Invalid bridge's multicast IGMP version number '%s', ignoring assignment.", rvalue);
 208                 return 0;
 209         }
 210
 211         b->igmp_version = u;
 212
 213         return 0;
 214 }
 215
 216 int config_parse_bridge_port_priority(
 217                 const char *unit,
 218                 const char *filename,
 219                 unsigned line,
 220                 const char *section,
 221                 unsigned section_line,
 222                 const char *lvalue,
 223                 int ltype,
 224                 const char *rvalue,
 225                 void *data,
 226                 void *userdata) {
 227
 228         uint16_t i;
 229         int r;
 230
 231         assert(filename);
 232         assert(lvalue);
 233         assert(rvalue);
 234         assert(data);
 235
 236         /* This is used in networkd-network-gperf.gperf. */
 237
 238         r = safe_atou16(rvalue, &i);
 239         if (r < 0) {
 240                 log_syntax(unit, LOG_WARNING, filename, line, r,
 241                            "Failed to parse bridge port priority, ignoring: %s", rvalue);
 242                 return 0;
 243         }
 244
 245         if (i > LINK_BRIDGE_PORT_PRIORITY_MAX) {
 246                 log_syntax(unit, LOG_WARNING, filename, line, 0,
 247                            "Bridge port priority is larger than maximum %u, ignoring: %s",
 248                            LINK_BRIDGE_PORT_PRIORITY_MAX, rvalue);
 249                 return 0;
 250         }
 251
 252         *((uint16_t *)data) = i;
 253
 254         return 0;
 255 }
 256
 257 static void bridge_init(NetDev *n) {
 258         Bridge *b;
 259
 260         b = BRIDGE(n);
 261
 262         assert(b);
 263
 264         b->mcast_querier = -1;
 265         b->mcast_snooping = -1;
 266         b->vlan_filtering = -1;
 267         b->vlan_protocol = -1;
 268         b->stp = -1;
 269         b->default_pvid = VLANID_INVALID;
 270         b->forward_delay = USEC_INFINITY;
 271         b->ageing_time = USEC_INFINITY;
 272 }
 273
 274 const NetDevVTable bridge_vtable = {
 275         .object_size = sizeof(Bridge),
 276         .init = bridge_init,
 277         .sections = NETDEV_COMMON_SECTIONS "Bridge\0",
 278         .post_create = netdev_bridge_post_create,
 279         .create_type = NETDEV_CREATE_MASTER,
 280         .iftype = ARPHRD_ETHER,
 281         .generate_mac = true,
 282 };