src/network/networkd-setlink.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include <netinet/in.h>
   4 #include <linux/if.h>
   5 #include <linux/if_arp.h>
   6
   7 #include "missing_network.h"
   8 #include "netlink-util.h"
   9 #include "networkd-can.h"
  10 #include "networkd-link.h"
  11 #include "networkd-manager.h"
  12 #include "networkd-queue.h"
  13 #include "networkd-setlink.h"
  14 #include "string-table.h"
  15
  16 static const char *const set_link_operation_table[_SET_LINK_OPERATION_MAX] = {
  17         [SET_LINK_ADDRESS_GENERATION_MODE] = "IPv6LL address generation mode",
  18         [SET_LINK_BOND]                    = "bond configurations",
  19         [SET_LINK_BRIDGE]                  = "bridge configurations",
  20         [SET_LINK_BRIDGE_VLAN]             = "bridge VLAN configurations",
  21         [SET_LINK_CAN]                     = "CAN interface configurations",
  22         [SET_LINK_FLAGS]                   = "link flags",
  23         [SET_LINK_GROUP]                   = "interface group",
  24         [SET_LINK_MAC]                     = "MAC address",
  25         [SET_LINK_MASTER]                  = "master interface",
  26         [SET_LINK_MTU]                     = "MTU",
  27 };
  28
  29 DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(set_link_operation, SetLinkOperation);
  30
  31 static int get_link_default_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
  32         return link_getlink_handler_internal(rtnl, m, link, "Failed to sync link information");
  33 }
  34
  35 static int get_link_master_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
  36         if (get_link_default_handler(rtnl, m, link) > 0)
  37                 link->master_set = true;
  38         return 0;
  39 }
  40
  41 static int get_link_update_flag_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
  42         assert(link);
  43         assert(link->set_flags_messages > 0);
  44
  45         link->set_flags_messages--;
  46
  47         return get_link_default_handler(rtnl, m, link);
  48 }
  49
  50 static int set_link_handler_internal(
  51                 sd_netlink *rtnl,
  52                 sd_netlink_message *m,
  53                 Link *link,
  54                 SetLinkOperation op,
  55                 bool ignore,
  56                 link_netlink_message_handler_t get_link_handler) {
  57
  58         int r;
  59
  60         assert(m);
  61         assert(link);
  62         assert(link->set_link_messages > 0);
  63         assert(op >= 0 && op < _SET_LINK_OPERATION_MAX);
  64
  65         link->set_link_messages--;
  66
  67         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
  68                 goto on_error;
  69
  70         r = sd_netlink_message_get_errno(m);
  71         if (r < 0) {
  72                 const char *error_msg;
  73
  74                 error_msg = strjoina("Failed to set ", set_link_operation_to_string(op), ignore ? ", ignoring" : "");
  75                 log_link_message_warning_errno(link, m, r, error_msg);
  76
  77                 if (!ignore)
  78                         link_enter_failed(link);
  79                 goto on_error;
  80         }
  81
  82         log_link_debug(link, "%s set.", set_link_operation_to_string(op));
  83
  84         if (get_link_handler) {
  85                 r = link_call_getlink(link, get_link_handler);
  86                 if (r < 0) {
  87                         link_enter_failed(link);
  88                         goto on_error;
  89                 }
  90         }
  91
  92         if (link->set_link_messages == 0)
  93                 link_check_ready(link);
  94
  95         return 1;
  96
  97 on_error:
  98         switch (op) {
  99         case SET_LINK_FLAGS:
 100                 assert(link->set_flags_messages > 0);
 101                 link->set_flags_messages--;
 102                 break;
 103         case SET_LINK_MASTER:
 104                 link->master_set = true;
 105                 break;
 106         default:
 107                 break;
 108         }
 109
 110         return 0;
 111 }
 112
 113 static int link_set_addrgen_mode_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
 114         int r;
 115
 116         r = set_link_handler_internal(rtnl, m, link, SET_LINK_ADDRESS_GENERATION_MODE, /* ignore = */ true, NULL);
 117         if (r <= 0)
 118                 return r;
 119
 120         r = link_drop_ipv6ll_addresses(link);
 121         if (r < 0) {
 122                 log_link_warning_errno(link, r, "Failed to drop IPv6LL addresses: %m");
 123                 link_enter_failed(link);
 124         }
 125
 126         return 0;
 127 }
 128
 129 static int link_set_bond_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
 130         return set_link_handler_internal(rtnl, m, link, SET_LINK_BOND, /* ignore = */ false, NULL);
 131 }
 132
 133 static int link_set_bridge_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
 134         return set_link_handler_internal(rtnl, m, link, SET_LINK_BRIDGE, /* ignore = */ true, NULL);
 135 }
 136
 137 static int link_set_bridge_vlan_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
 138         return set_link_handler_internal(rtnl, m, link, SET_LINK_BRIDGE_VLAN, /* ignore = */ false, NULL);
 139 }
 140
 141 static int link_set_can_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
 142         return set_link_handler_internal(rtnl, m, link, SET_LINK_CAN, /* ignore = */ false, NULL);
 143 }
 144
 145 static int link_set_flags_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
 146         return set_link_handler_internal(rtnl, m, link, SET_LINK_FLAGS, /* ignore = */ false, get_link_update_flag_handler);
 147 }
 148
 149 static int link_set_group_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
 150         return set_link_handler_internal(rtnl, m, link, SET_LINK_GROUP, /* ignore = */ false, NULL);
 151 }
 152
 153 static int link_set_mac_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
 154         return set_link_handler_internal(rtnl, m, link, SET_LINK_MAC, /* ignore = */ true, get_link_default_handler);
 155 }
 156
 157 static int link_set_mac_allow_retry_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
 158         int r;
 159
 160         assert(m);
 161         assert(link);
 162         assert(link->set_link_messages > 0);
 163
 164         link->set_link_messages--;
 165
 166         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 167                 return 0;
 168
 169         r = sd_netlink_message_get_errno(m);
 170         if (r == -EBUSY) {
 171                 /* Most real network devices refuse to set its hardware address with -EBUSY when its
 172                  * operstate is not down. See, eth_prepare_mac_addr_change() in net/ethernet/eth.c
 173                  * of kernel. */
 174
 175                 log_link_message_debug_errno(link, m, r, "Failed to set MAC address, retrying again: %m");
 176
 177                 r = link_request_to_set_mac(link, /* allow_retry = */ false);
 178                 if (r < 0)
 179                         link_enter_failed(link);
 180
 181                 return 0;
 182         }
 183
 184         /* set_link_mac_handler() also decrement set_link_messages, so once increment the value. */
 185         link->set_link_messages++;
 186         return link_set_mac_handler(rtnl, m, link);
 187 }
 188
 189 static int link_set_master_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
 190         return set_link_handler_internal(rtnl, m, link, SET_LINK_MASTER, /* ignore = */ false, get_link_master_handler);
 191 }
 192
 193 static int link_unset_master_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
 194         /* Some devices do not support setting master ifindex. Let's ignore error on unsetting master ifindex. */
 195         return set_link_handler_internal(rtnl, m, link, SET_LINK_MASTER, /* ignore = */ true, get_link_master_handler);
 196 }
 197
 198 static int link_set_mtu_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
 199         int r;
 200
 201         r = set_link_handler_internal(rtnl, m, link, SET_LINK_MTU, /* ignore = */ true, get_link_default_handler);
 202         if (r <= 0)
 203                 return r;
 204
 205         /* The kernel resets ipv6 mtu after changing device mtu;
 206          * we must set this here, after we've set device mtu */
 207         r = link_set_ipv6_mtu(link);
 208         if (r < 0)
 209                 log_link_warning_errno(link, r, "Failed to set IPv6 MTU, ignoring: %m");
 210
 211         return 0;
 212 }
 213
 214 static int link_configure(
 215                 Link *link,
 216                 SetLinkOperation op,
 217                 void *userdata,
 218                 link_netlink_message_handler_t callback) {
 219
 220         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
 221         int r;
 222
 223         assert(link);
 224         assert(link->manager);
 225         assert(link->manager->rtnl);
 226         assert(link->network);
 227         assert(op >= 0 && op < _SET_LINK_OPERATION_MAX);
 228         assert(callback);
 229
 230         log_link_debug(link, "Setting %s", set_link_operation_to_string(op));
 231
 232         if (op == SET_LINK_BOND) {
 233                 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_NEWLINK, link->master_ifindex);
 234                 if (r < 0)
 235                         return log_link_debug_errno(link, r, "Could not allocate RTM_NEWLINK message: %m");
 236         } else if (op == SET_LINK_CAN) {
 237                 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_NEWLINK, link->ifindex);
 238                 if (r < 0)
 239                         return log_link_debug_errno(link, r, "Could not allocate RTM_NEWLINK message: %m");
 240         } else {
 241                 r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
 242                 if (r < 0)
 243                         return log_link_debug_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
 244         }
 245
 246         switch (op) {
 247         case SET_LINK_ADDRESS_GENERATION_MODE:
 248                 r = sd_netlink_message_open_container(req, IFLA_AF_SPEC);
 249                 if (r < 0)
 250                         return log_link_debug_errno(link, r, "Could not open IFLA_AF_SPEC container: %m");
 251
 252                 r = sd_netlink_message_open_container(req, AF_INET6);
 253                 if (r < 0)
 254                         return log_link_debug_errno(link, r, "Could not open AF_INET6 container: %m");
 255
 256                 r = sd_netlink_message_append_u8(req, IFLA_INET6_ADDR_GEN_MODE, PTR_TO_UINT8(userdata));
 257                 if (r < 0)
 258                         return log_link_debug_errno(link, r, "Could not append IFLA_INET6_ADDR_GEN_MODE attribute: %m");
 259
 260                 r = sd_netlink_message_close_container(req);
 261                 if (r < 0)
 262                         return log_link_debug_errno(link, r, "Could not close AF_INET6 container: %m");
 263
 264                 r = sd_netlink_message_close_container(req);
 265                 if (r < 0)
 266                         return log_link_debug_errno(link, r, "Could not close IFLA_AF_SPEC container: %m");
 267                 break;
 268         case SET_LINK_BOND:
 269                 r = sd_netlink_message_set_flags(req, NLM_F_REQUEST | NLM_F_ACK);
 270                 if (r < 0)
 271                         return log_link_debug_errno(link, r, "Could not set netlink message flags: %m");
 272
 273                 r = sd_netlink_message_open_container(req, IFLA_LINKINFO);
 274                 if (r < 0)
 275                         return log_link_debug_errno(link, r, "Could not open IFLA_LINKINFO container: %m");
 276
 277                 r = sd_netlink_message_open_container_union(req, IFLA_INFO_DATA, "bond");
 278                 if (r < 0)
 279                         return log_link_debug_errno(link, r, "Could not open IFLA_INFO_DATA container: %m");
 280
 281                 if (link->network->active_slave) {
 282                         r = sd_netlink_message_append_u32(req, IFLA_BOND_ACTIVE_SLAVE, link->ifindex);
 283                         if (r < 0)
 284                                 return log_link_debug_errno(link, r, "Could not append IFLA_BOND_ACTIVE_SLAVE attribute: %m");
 285                 }
 286
 287                 if (link->network->primary_slave) {
 288                         r = sd_netlink_message_append_u32(req, IFLA_BOND_PRIMARY, link->ifindex);
 289                         if (r < 0)
 290                                 return log_link_debug_errno(link, r, "Could not append IFLA_BOND_PRIMARY attribute: %m");
 291                 }
 292
 293                 r = sd_netlink_message_close_container(req);
 294                 if (r < 0)
 295                         return log_link_debug_errno(link, r, "Could not close IFLA_INFO_DATA container: %m");
 296
 297                 r = sd_netlink_message_close_container(req);
 298                 if (r < 0)
 299                         return log_link_debug_errno(link, r, "Could not close IFLA_LINKINFO container: %m");
 300
 301                 break;
 302         case SET_LINK_BRIDGE:
 303                 r = sd_rtnl_message_link_set_family(req, AF_BRIDGE);
 304                 if (r < 0)
 305                         return log_link_debug_errno(link, r, "Could not set message family: %m");
 306
 307                 r = sd_netlink_message_open_container(req, IFLA_PROTINFO);
 308                 if (r < 0)
 309                         return log_link_debug_errno(link, r, "Could not open IFLA_PROTINFO container: %m");
 310
 311                 if (link->network->use_bpdu >= 0) {
 312                         r = sd_netlink_message_append_u8(req, IFLA_BRPORT_GUARD, link->network->use_bpdu);
 313                         if (r < 0)
 314                                 return log_link_debug_errno(link, r, "Could not append IFLA_BRPORT_GUARD attribute: %m");
 315                 }
 316
 317                 if (link->network->hairpin >= 0) {
 318                         r = sd_netlink_message_append_u8(req, IFLA_BRPORT_MODE, link->network->hairpin);
 319                         if (r < 0)
 320                                 return log_link_debug_errno(link, r, "Could not append IFLA_BRPORT_MODE attribute: %m");
 321                 }
 322
 323                 if (link->network->fast_leave >= 0) {
 324                         r = sd_netlink_message_append_u8(req, IFLA_BRPORT_FAST_LEAVE, link->network->fast_leave);
 325                         if (r < 0)
 326                                 return log_link_debug_errno(link, r, "Could not append IFLA_BRPORT_FAST_LEAVE attribute: %m");
 327                 }
 328
 329                 if (link->network->allow_port_to_be_root >= 0) {
 330                         r = sd_netlink_message_append_u8(req, IFLA_BRPORT_PROTECT, link->network->allow_port_to_be_root);
 331                         if (r < 0)
 332                                 return log_link_debug_errno(link, r, "Could not append IFLA_BRPORT_PROTECT attribute: %m");
 333                 }
 334
 335                 if (link->network->unicast_flood >= 0) {
 336                         r = sd_netlink_message_append_u8(req, IFLA_BRPORT_UNICAST_FLOOD, link->network->unicast_flood);
 337                         if (r < 0)
 338                                 return log_link_debug_errno(link, r, "Could not append IFLA_BRPORT_UNICAST_FLOOD attribute: %m");
 339                 }
 340
 341                 if (link->network->multicast_flood >= 0) {
 342                         r = sd_netlink_message_append_u8(req, IFLA_BRPORT_MCAST_FLOOD, link->network->multicast_flood);
 343                         if (r < 0)
 344                                 return log_link_debug_errno(link, r, "Could not append IFLA_BRPORT_MCAST_FLOOD attribute: %m");
 345                 }
 346
 347                 if (link->network->multicast_to_unicast >= 0) {
 348                         r = sd_netlink_message_append_u8(req, IFLA_BRPORT_MCAST_TO_UCAST, link->network->multicast_to_unicast);
 349                         if (r < 0)
 350                                 return log_link_debug_errno(link, r, "Could not append IFLA_BRPORT_MCAST_TO_UCAST attribute: %m");
 351                 }
 352
 353                 if (link->network->neighbor_suppression >= 0) {
 354                         r = sd_netlink_message_append_u8(req, IFLA_BRPORT_NEIGH_SUPPRESS, link->network->neighbor_suppression);
 355                         if (r < 0)
 356                                 return log_link_debug_errno(link, r, "Could not append IFLA_BRPORT_NEIGH_SUPPRESS attribute: %m");
 357                 }
 358
 359                 if (link->network->learning >= 0) {
 360                         r = sd_netlink_message_append_u8(req, IFLA_BRPORT_LEARNING, link->network->learning);
 361                         if (r < 0)
 362                                 return log_link_debug_errno(link, r, "Could not append IFLA_BRPORT_LEARNING attribute: %m");
 363                 }
 364
 365                 if (link->network->bridge_proxy_arp >= 0) {
 366                         r = sd_netlink_message_append_u8(req, IFLA_BRPORT_PROXYARP, link->network->bridge_proxy_arp);
 367                         if (r < 0)
 368                                 return log_link_debug_errno(link, r, "Could not append IFLA_BRPORT_PROXYARP attribute: %m");
 369                 }
 370
 371                 if (link->network->bridge_proxy_arp_wifi >= 0) {
 372                         r = sd_netlink_message_append_u8(req, IFLA_BRPORT_PROXYARP_WIFI, link->network->bridge_proxy_arp_wifi);
 373                         if (r < 0)
 374                                 return log_link_debug_errno(link, r, "Could not append IFLA_BRPORT_PROXYARP_WIFI attribute: %m");
 375                 }
 376
 377                 if (link->network->cost != 0) {
 378                         r = sd_netlink_message_append_u32(req, IFLA_BRPORT_COST, link->network->cost);
 379                         if (r < 0)
 380                                 return log_link_debug_errno(link, r, "Could not append IFLA_BRPORT_COST attribute: %m");
 381                 }
 382
 383                 if (link->network->priority != LINK_BRIDGE_PORT_PRIORITY_INVALID) {
 384                         r = sd_netlink_message_append_u16(req, IFLA_BRPORT_PRIORITY, link->network->priority);
 385                         if (r < 0)
 386                                 return log_link_debug_errno(link, r, "Could not append IFLA_BRPORT_PRIORITY attribute: %m");
 387                 }
 388
 389                 if (link->network->multicast_router != _MULTICAST_ROUTER_INVALID) {
 390                         r = sd_netlink_message_append_u8(req, IFLA_BRPORT_MULTICAST_ROUTER, link->network->multicast_router);
 391                         if (r < 0)
 392                                 return log_link_debug_errno(link, r, "Could not append IFLA_BRPORT_MULTICAST_ROUTER attribute: %m");
 393                 }
 394
 395                 r = sd_netlink_message_close_container(req);
 396                 if (r < 0)
 397                         return log_link_debug_errno(link, r, "Could not close IFLA_PROTINFO container: %m");
 398                 break;
 399         case SET_LINK_BRIDGE_VLAN:
 400                 r = sd_rtnl_message_link_set_family(req, AF_BRIDGE);
 401                 if (r < 0)
 402                         return log_link_debug_errno(link, r, "Could not set message family: %m");
 403
 404                 r = sd_netlink_message_open_container(req, IFLA_AF_SPEC);
 405                 if (r < 0)
 406                         return log_link_debug_errno(link, r, "Could not open IFLA_AF_SPEC container: %m");
 407
 408                 if (!link->network->bridge) {
 409                         /* master needs BRIDGE_FLAGS_SELF flag */
 410                         r = sd_netlink_message_append_u16(req, IFLA_BRIDGE_FLAGS, BRIDGE_FLAGS_SELF);
 411                         if (r < 0)
 412                                 return log_link_debug_errno(link, r, "Could not append IFLA_BRIDGE_FLAGS attribute: %m");
 413                 }
 414
 415                 r = bridge_vlan_append_info(link, req, link->network->pvid, link->network->br_vid_bitmap, link->network->br_untagged_bitmap);
 416                 if (r < 0)
 417                         return log_link_debug_errno(link, r, "Could not append VLANs: %m");
 418
 419                 r = sd_netlink_message_close_container(req);
 420                 if (r < 0)
 421                         return log_link_debug_errno(link, r, "Could not close IFLA_AF_SPEC container: %m");
 422
 423                 break;
 424         case SET_LINK_CAN:
 425                 r = can_set_netlink_message(link, req);
 426                 if (r < 0)
 427                         return r;
 428                 break;
 429         case SET_LINK_FLAGS: {
 430                 unsigned ifi_change = 0, ifi_flags = 0;
 431
 432                 if (link->network->arp >= 0) {
 433                         ifi_change |= IFF_NOARP;
 434                         SET_FLAG(ifi_flags, IFF_NOARP, link->network->arp == 0);
 435                 }
 436
 437                 if (link->network->multicast >= 0) {
 438                         ifi_change |= IFF_MULTICAST;
 439                         SET_FLAG(ifi_flags, IFF_MULTICAST, link->network->multicast);
 440                 }
 441
 442                 if (link->network->allmulticast >= 0) {
 443                         ifi_change |= IFF_ALLMULTI;
 444                         SET_FLAG(ifi_flags, IFF_ALLMULTI, link->network->allmulticast);
 445                 }
 446
 447                 if (link->network->promiscuous >= 0) {
 448                         ifi_change |= IFF_PROMISC;
 449                         SET_FLAG(ifi_flags, IFF_PROMISC, link->network->promiscuous);
 450                 }
 451
 452                 r = sd_rtnl_message_link_set_flags(req, ifi_flags, ifi_change);
 453                 if (r < 0)
 454                         return log_link_debug_errno(link, r, "Could not set link flags: %m");
 455
 456                 break;
 457         }
 458         case SET_LINK_GROUP:
 459                 r = sd_netlink_message_append_u32(req, IFLA_GROUP, link->network->group);
 460                 if (r < 0)
 461                         return log_link_debug_errno(link, r, "Could not append IFLA_GROUP attribute: %m");
 462                 break;
 463         case SET_LINK_MAC:
 464                 r = sd_netlink_message_append_ether_addr(req, IFLA_ADDRESS, link->network->mac);
 465                 if (r < 0)
 466                         return log_link_debug_errno(link, r, "Could not append IFLA_ADDRESS attribute: %m");
 467                 break;
 468         case SET_LINK_MASTER:
 469                 r = sd_netlink_message_append_u32(req, IFLA_MASTER, PTR_TO_UINT32(userdata));
 470                 if (r < 0)
 471                         return log_link_debug_errno(link, r, "Could not append IFLA_MASTER attribute: %m");
 472                 break;
 473         case SET_LINK_MTU:
 474                 r = sd_netlink_message_append_u32(req, IFLA_MTU, PTR_TO_UINT32(userdata));
 475                 if (r < 0)
 476                         return log_link_debug_errno(link, r, "Could not append IFLA_MTU attribute: %m");
 477                 break;
 478         default:
 479                 assert_not_reached();
 480         }
 481
 482         r = netlink_call_async(link->manager->rtnl, NULL, req, callback,
 483                                link_netlink_destroy_callback, link);
 484         if (r < 0)
 485                 return log_link_debug_errno(link, r, "Could not send RTM_SETLINK message: %m");
 486
 487         link_ref(link);
 488         return 0;
 489 }
 490
 491 static bool netdev_is_ready(NetDev *netdev) {
 492         assert(netdev);
 493
 494         if (netdev->state != NETDEV_STATE_READY)
 495                 return false;
 496         if (netdev->ifindex == 0)
 497                 return false;
 498
 499         return true;
 500 }
 501
 502 static bool link_is_ready_to_call_set_link(Request *req) {
 503         SetLinkOperation op;
 504         Link *link;
 505         int r;
 506
 507         assert(req);
 508
 509         link = req->link;
 510         op = PTR_TO_INT(req->set_link_operation_ptr);
 511
 512         if (!IN_SET(link->state, LINK_STATE_INITIALIZED, LINK_STATE_CONFIGURING, LINK_STATE_CONFIGURED))
 513                 return false;
 514
 515         switch (op) {
 516         case SET_LINK_BOND:
 517         case SET_LINK_BRIDGE:
 518         case SET_LINK_BRIDGE_VLAN:
 519                 if (!link->master_set)
 520                         return false;
 521                 break;
 522         case SET_LINK_CAN:
 523                 /* Do not check link->set_flgas_messages here, as it is ok even if link->flags
 524                  * is outdated, and checking the counter causes a deadlock. */
 525                 if (FLAGS_SET(link->flags, IFF_UP)) {
 526                         /* The CAN interface must be down to configure bitrate, etc... */
 527                         r = link_down(link);
 528                         if (r < 0) {
 529                                 link_enter_failed(link);
 530                                 return false;
 531                         }
 532                 }
 533                 break;
 534         case SET_LINK_MAC:
 535                 if (req->netlink_handler == link_set_mac_handler) {
 536                         /* This is the second trial to set MTU. On the first attempt
 537                          * req->netlink_handler points to link_set_mac_allow_retry_handler().
 538                          * The first trial failed as the interface was up. */
 539                         r = link_down(link);
 540                         if (r < 0) {
 541                                 link_enter_failed(link);
 542                                 return false;
 543                         }
 544                 }
 545                 break;
 546         case SET_LINK_MASTER: {
 547                 uint32_t m = 0;
 548
 549                 assert(link->network);
 550
 551                 if (link->network->batadv) {
 552                         if (!netdev_is_ready(link->network->batadv))
 553                                 return false;
 554                         m = link->network->batadv->ifindex;
 555                 } else if (link->network->bond) {
 556                         if (!netdev_is_ready(link->network->bond))
 557                                 return false;
 558                         m = link->network->bond->ifindex;
 559
 560                         /* Do not check link->set_flgas_messages here, as it is ok even if link->flags
 561                          * is outdated, and checking the counter causes a deadlock. */
 562                         if (FLAGS_SET(link->flags, IFF_UP)) {
 563                                 /* link must be down when joining to bond master. */
 564                                 r = link_down(link);
 565                                 if (r < 0) {
 566                                         link_enter_failed(link);
 567                                         return false;
 568                                 }
 569                         }
 570                 } else if (link->network->bridge) {
 571                         if (!netdev_is_ready(link->network->bridge))
 572                                 return false;
 573                         m = link->network->bridge->ifindex;
 574                 } else if (link->network->vrf) {
 575                         if (!netdev_is_ready(link->network->vrf))
 576                                 return false;
 577                         m = link->network->vrf->ifindex;
 578                 }
 579
 580                 req->userdata = UINT32_TO_PTR(m);
 581                 break;
 582         }
 583         default:
 584                 break;
 585         }
 586
 587         return true;
 588 }
 589
 590 int request_process_set_link(Request *req) {
 591         SetLinkOperation op;
 592         int r;
 593
 594         assert(req);
 595         assert(req->link);
 596         assert(req->type == REQUEST_TYPE_SET_LINK);
 597         assert(req->netlink_handler);
 598
 599         op = PTR_TO_INT(req->set_link_operation_ptr);
 600
 601         assert(op >= 0 && op < _SET_LINK_OPERATION_MAX);
 602
 603         if (!link_is_ready_to_call_set_link(req))
 604                 return 0;
 605
 606         r = link_configure(req->link, op, req->userdata, req->netlink_handler);
 607         if (r < 0)
 608                 return log_link_error_errno(req->link, r, "Failed to set %s: %m",
 609                                             set_link_operation_to_string(op));
 610
 611         if (op == SET_LINK_FLAGS)
 612                 req->link->set_flags_messages++;
 613
 614         return 1;
 615 }
 616
 617 static int link_request_set_link(
 618                 Link *link,
 619                 SetLinkOperation op,
 620                 link_netlink_message_handler_t netlink_handler,
 621                 Request **ret) {
 622
 623         Request *req;
 624         int r;
 625
 626         assert(link);
 627         assert(op >= 0 && op < _SET_LINK_OPERATION_MAX);
 628         assert(netlink_handler);
 629
 630         r = link_queue_request(link, REQUEST_TYPE_SET_LINK, INT_TO_PTR(op), false,
 631                                &link->set_link_messages, netlink_handler, &req);
 632         if (r < 0)
 633                 return log_link_error_errno(link, r, "Failed to request to set %s: %m",
 634                                             set_link_operation_to_string(op));
 635
 636         log_link_debug(link, "Requested to set %s", set_link_operation_to_string(op));
 637
 638         if (ret)
 639                 *ret = req;
 640         return 0;
 641 }
 642
 643 int link_request_to_set_addrgen_mode(Link *link) {
 644         Request *req;
 645         uint8_t mode;
 646         int r;
 647
 648         assert(link);
 649         assert(link->network);
 650
 651         if (!socket_ipv6_is_supported())
 652                 return 0;
 653
 654         if (!link_ipv6ll_enabled(link))
 655                 mode = IN6_ADDR_GEN_MODE_NONE;
 656         else if (link->network->ipv6ll_address_gen_mode >= 0)
 657                 mode = link->network->ipv6ll_address_gen_mode;
 658         else if (in6_addr_is_set(&link->network->ipv6ll_stable_secret))
 659                 mode = IN6_ADDR_GEN_MODE_STABLE_PRIVACY;
 660         else
 661                 mode = IN6_ADDR_GEN_MODE_EUI64;
 662
 663         r = link_request_set_link(link, SET_LINK_ADDRESS_GENERATION_MODE, link_set_addrgen_mode_handler, &req);
 664         if (r < 0)
 665                 return r;
 666
 667         req->userdata = UINT8_TO_PTR(mode);
 668         return 0;
 669 }
 670
 671 int link_request_to_set_bond(Link *link) {
 672         assert(link);
 673         assert(link->network);
 674
 675         if (!link->network->bond)
 676                 return 0;
 677
 678         return link_request_set_link(link, SET_LINK_BOND, link_set_bond_handler, NULL);
 679 }
 680
 681 int link_request_to_set_bridge(Link *link) {
 682         assert(link);
 683         assert(link->network);
 684
 685         if (!link->network->bridge)
 686                 return 0;
 687
 688         return link_request_set_link(link, SET_LINK_BRIDGE, link_set_bridge_handler, NULL);
 689 }
 690
 691 int link_request_to_set_bridge_vlan(Link *link) {
 692         assert(link);
 693         assert(link->network);
 694
 695         if (!link->network->use_br_vlan)
 696                 return 0;
 697
 698         if (!link->network->bridge && !streq_ptr(link->kind, "bridge"))
 699                 return 0;
 700
 701         return link_request_set_link(link, SET_LINK_BRIDGE_VLAN, link_set_bridge_vlan_handler, NULL);
 702 }
 703
 704 int link_request_to_set_can(Link *link) {
 705         assert(link);
 706         assert(link->network);
 707
 708         if (link->iftype != ARPHRD_CAN)
 709                 return 0;
 710
 711         if (!streq_ptr(link->kind, "can"))
 712                 return 0;
 713
 714         return link_request_set_link(link, SET_LINK_CAN, link_set_can_handler, NULL);
 715 }
 716
 717 int link_request_to_set_flags(Link *link) {
 718         assert(link);
 719         assert(link->network);
 720
 721         if (link->network->arp < 0 &&
 722             link->network->multicast < 0 &&
 723             link->network->allmulticast < 0 &&
 724             link->network->promiscuous < 0)
 725                 return 0;
 726
 727         return link_request_set_link(link, SET_LINK_FLAGS, link_set_flags_handler, NULL);
 728 }
 729
 730 int link_request_to_set_group(Link *link) {
 731         assert(link);
 732         assert(link->network);
 733
 734         if (!link->network->group_set)
 735                 return 0;
 736
 737         return link_request_set_link(link, SET_LINK_GROUP, link_set_group_handler, NULL);
 738 }
 739
 740 int link_request_to_set_mac(Link *link, bool allow_retry) {
 741         assert(link);
 742         assert(link->network);
 743
 744         if (!link->network->mac)
 745                 return 0;
 746
 747         if (link->hw_addr.length != sizeof(struct ether_addr)) {
 748                 /* Note that for now we only support changing hardware addresses on Ethernet. */
 749                 log_link_debug(link, "Size of the hardware address (%zu) does not match the size of MAC address (%zu), ignoring.",
 750                                link->hw_addr.length, sizeof(struct ether_addr));
 751                 return 0;
 752         }
 753
 754         if (ether_addr_equal(&link->hw_addr.ether, link->network->mac))
 755                 return 0;
 756
 757         return link_request_set_link(link, SET_LINK_MAC,
 758                                      allow_retry ? link_set_mac_allow_retry_handler : link_set_mac_handler,
 759                                      NULL);
 760 }
 761
 762 int link_request_to_set_master(Link *link) {
 763         assert(link);
 764         assert(link->network);
 765
 766         link->master_set = false;
 767
 768         if (link->network->batadv || link->network->bond || link->network->bridge || link->network->vrf)
 769                 return link_request_set_link(link, SET_LINK_MASTER, link_set_master_handler, NULL);
 770         else
 771                 return link_request_set_link(link, SET_LINK_MASTER, link_unset_master_handler, NULL);
 772 }
 773
 774 int link_request_to_set_mtu(Link *link, uint32_t mtu) {
 775         Request *req;
 776         const char *origin;
 777         uint32_t min_mtu;
 778         int r;
 779
 780         assert(link);
 781         assert(link->network);
 782
 783         min_mtu = link->min_mtu;
 784         origin = "the minimum MTU of the interface";
 785         if (link_ipv6_enabled(link)) {
 786                 /* IPv6 protocol requires a minimum MTU of IPV6_MTU_MIN(1280) bytes on the interface. Bump up
 787                  * MTU bytes to IPV6_MTU_MIN. */
 788                 if (min_mtu < IPV6_MIN_MTU) {
 789                         min_mtu = IPV6_MIN_MTU;
 790                         origin = "the minimum IPv6 MTU";
 791                 }
 792                 if (min_mtu < link->network->ipv6_mtu) {
 793                         min_mtu = link->network->ipv6_mtu;
 794                         origin = "the requested IPv6 MTU in IPv6MTUBytes=";
 795                 }
 796         }
 797
 798         if (mtu < min_mtu) {
 799                 log_link_warning(link, "Bumping the requested MTU %"PRIu32" to %s (%"PRIu32")",
 800                                  mtu, origin, min_mtu);
 801                 mtu = min_mtu;
 802         }
 803
 804         if (mtu > link->max_mtu) {
 805                 log_link_warning(link, "Reducing the requested MTU %"PRIu32" to the interface's maximum MTU %"PRIu32".",
 806                                  mtu, link->max_mtu);
 807                 mtu = link->max_mtu;
 808         }
 809
 810         if (link->mtu == mtu)
 811                 return 0;
 812
 813         r = link_request_set_link(link, SET_LINK_MTU, link_set_mtu_handler, &req);
 814         if (r < 0)
 815                 return r;
 816
 817         req->userdata = UINT32_TO_PTR(mtu);
 818         return 0;
 819 }
 820
 821 static bool link_reduces_vlan_mtu(Link *link) {
 822         /* See netif_reduces_vlan_mtu() in kernel. */
 823         return streq_ptr(link->kind, "macsec");
 824 }
 825
 826 static uint32_t link_get_requested_mtu_by_stacked_netdevs(Link *link) {
 827         uint32_t mtu = 0;
 828         NetDev *dev;
 829
 830         HASHMAP_FOREACH(dev, link->network->stacked_netdevs)
 831                 if (dev->kind == NETDEV_KIND_VLAN && dev->mtu > 0)
 832                         /* See vlan_dev_change_mtu() in kernel. */
 833                         mtu = MAX(mtu, link_reduces_vlan_mtu(link) ? dev->mtu + 4 : dev->mtu);
 834
 835                 else if (dev->kind == NETDEV_KIND_MACVLAN && dev->mtu > mtu)
 836                         /* See macvlan_change_mtu() in kernel. */
 837                         mtu = dev->mtu;
 838
 839         return mtu;
 840 }
 841
 842 int link_configure_mtu(Link *link) {
 843         uint32_t mtu;
 844
 845         assert(link);
 846         assert(link->network);
 847
 848         if (link->network->mtu > 0)
 849                 return link_request_to_set_mtu(link, link->network->mtu);
 850
 851         mtu = link_get_requested_mtu_by_stacked_netdevs(link);
 852         if (link->mtu >= mtu)
 853                 return 0;
 854
 855         log_link_notice(link, "Bumping MTU bytes from %"PRIu32" to %"PRIu32" because of stacked device. "
 856                         "If it is not desired, then please explicitly specify MTUBytes= setting.",
 857                         link->mtu, mtu);
 858
 859         return link_request_to_set_mtu(link, mtu);
 860 }
 861
 862 static int link_up_or_down_handler_internal(sd_netlink *rtnl, sd_netlink_message *m, Link *link, bool up, bool check_ready) {
 863         int r;
 864
 865         assert(m);
 866         assert(link);
 867
 868         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 869                 goto on_error;
 870
 871         r = sd_netlink_message_get_errno(m);
 872         if (r < 0)
 873                 log_link_message_warning_errno(link, m, r, up ?
 874                                                "Could not bring up interface, ignoring" :
 875                                                "Could not bring down interface, ignoring");
 876
 877         r = link_call_getlink(link, get_link_update_flag_handler);
 878         if (r < 0) {
 879                 link_enter_failed(link);
 880                 goto on_error;
 881         }
 882
 883         if (check_ready) {
 884                 link->activated = true;
 885                 link_check_ready(link);
 886         }
 887
 888         return 1;
 889
 890 on_error:
 891         assert(link->set_flags_messages > 0);
 892         link->set_flags_messages--;
 893
 894         return 0;
 895 }
 896
 897 static int link_activate_up_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
 898         return link_up_or_down_handler_internal(rtnl, m, link, true, true);
 899 }
 900
 901 static int link_activate_down_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
 902         return link_up_or_down_handler_internal(rtnl, m, link, false, true);
 903 }
 904
 905 static int link_up_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
 906         return link_up_or_down_handler_internal(rtnl, m, link, true, false);
 907 }
 908
 909 static int link_down_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
 910         return link_up_or_down_handler_internal(rtnl, m, link, false, false);
 911 }
 912
 913 static const char *up_or_down(bool up) {
 914         return up ? "up" : "down";
 915 }
 916
 917 static int link_up_or_down(Link *link, bool up, link_netlink_message_handler_t callback) {
 918         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
 919         int r;
 920
 921         assert(link);
 922         assert(link->manager);
 923         assert(link->manager->rtnl);
 924         assert(callback);
 925
 926         log_link_debug(link, "Bringing link %s", up_or_down(up));
 927
 928         r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
 929         if (r < 0)
 930                 return log_link_debug_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
 931
 932         r = sd_rtnl_message_link_set_flags(req, up ? IFF_UP : 0, IFF_UP);
 933         if (r < 0)
 934                 return log_link_debug_errno(link, r, "Could not set link flags: %m");
 935
 936         r = netlink_call_async(link->manager->rtnl, NULL, req, callback,
 937                                link_netlink_destroy_callback, link);
 938         if (r < 0)
 939                 return log_link_debug_errno(link, r, "Could not send rtnetlink message: %m");
 940
 941         link_ref(link);
 942
 943         return 0;
 944 }
 945
 946 int link_down(Link *link) {
 947         int r;
 948
 949         assert(link);
 950
 951         r = link_up_or_down(link, false, link_down_handler);
 952         if (r < 0)
 953                 return log_link_error_errno(link, r, "Failed to bring down interface: %m");
 954
 955         link->set_flags_messages++;
 956         return 0;
 957 }
 958
 959 static bool link_is_ready_to_activate(Link *link) {
 960         assert(link);
 961
 962         if (!IN_SET(link->state, LINK_STATE_INITIALIZED, LINK_STATE_CONFIGURING, LINK_STATE_CONFIGURED))
 963                 return false;
 964
 965         if (link->set_link_messages > 0)
 966                 return false;
 967
 968         return true;
 969 }
 970
 971 int request_process_activation(Request *req) {
 972         Link *link;
 973         bool up;
 974         int r;
 975
 976         assert(req);
 977         assert(req->link);
 978         assert(req->type == REQUEST_TYPE_ACTIVATE_LINK);
 979         assert(req->netlink_handler);
 980
 981         link = req->link;
 982         up = PTR_TO_INT(req->userdata);
 983
 984         if (!link_is_ready_to_activate(link))
 985                 return 0;
 986
 987         r = link_up_or_down(link, up, req->netlink_handler);
 988         if (r < 0)
 989                 return log_link_error_errno(link, r, "Failed to bring %s: %m", up_or_down(up));
 990
 991         return 1;
 992 }
 993
 994 int link_request_to_activate(Link *link) {
 995         Request *req;
 996         bool up;
 997         int r;
 998
 999         assert(link);
1000         assert(link->network);
1001
1002         switch (link->network->activation_policy) {
1003         case ACTIVATION_POLICY_BOUND:
1004                 r = link_handle_bound_to_list(link);
1005                 if (r < 0)
1006                         return r;
1007                 _fallthrough_;
1008         case ACTIVATION_POLICY_MANUAL:
1009                 link->activated = true;
1010                 link_check_ready(link);
1011                 return 0;
1012         case ACTIVATION_POLICY_UP:
1013         case ACTIVATION_POLICY_ALWAYS_UP:
1014                 up = true;
1015                 break;
1016         case ACTIVATION_POLICY_DOWN:
1017         case ACTIVATION_POLICY_ALWAYS_DOWN:
1018                 up = false;
1019                 break;
1020         default:
1021                 assert_not_reached();
1022         }
1023
1024         link->activated = false;
1025
1026         r = link_queue_request(link, REQUEST_TYPE_ACTIVATE_LINK, NULL, false, &link->set_flags_messages,
1027                                up ? link_activate_up_handler : link_activate_down_handler, &req);
1028         if (r < 0)
1029                 return log_link_error_errno(link, r, "Failed to request to activate link: %m");
1030
1031         req->userdata = INT_TO_PTR(up);
1032
1033         log_link_debug(link, "Requested to activate link");
1034         return 0;
1035 }
1036
1037 static bool link_is_ready_to_bring_up_or_down(Link *link) {
1038         assert(link);
1039
1040         if (link->state == LINK_STATE_UNMANAGED)
1041                 return true;
1042
1043         if (!IN_SET(link->state, LINK_STATE_CONFIGURING, LINK_STATE_CONFIGURED))
1044                 return false;
1045
1046         if (link->set_link_messages > 0)
1047                 return false;
1048
1049         if (!link->activated)
1050                 return false;
1051
1052         return true;
1053 }
1054
1055 int request_process_link_up_or_down(Request *req) {
1056         Link *link;
1057         bool up;
1058         int r;
1059
1060         assert(req);
1061         assert(req->link);
1062         assert(req->type == REQUEST_TYPE_UP_DOWN);
1063
1064         link = req->link;
1065         up = PTR_TO_INT(req->userdata);
1066
1067         if (!link_is_ready_to_bring_up_or_down(link))
1068                 return 0;
1069
1070         r = link_up_or_down(link, up, req->netlink_handler);
1071         if (r < 0)
1072                 return log_link_error_errno(link, r, "Failed to bring %s: %m", up_or_down(up));
1073
1074         return 1;
1075 }
1076
1077 int link_request_to_bring_up_or_down(Link *link, bool up) {
1078         Request *req;
1079         int r;
1080
1081         assert(link);
1082
1083         r = link_queue_request(link, REQUEST_TYPE_UP_DOWN, NULL, false, &link->set_flags_messages,
1084                                up ? link_up_handler : link_down_handler, &req);
1085         if (r < 0)
1086                 return log_link_error_errno(link, r, "Failed to request to bring %s link: %m",
1087                                             up_or_down(up));
1088
1089         req->userdata = INT_TO_PTR(up);
1090
1091         log_link_debug(link, "Requested to bring link %s", up_or_down(up));
1092         return 0;
1093 }