src/network/networkd-link.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.h>
   6 #include <linux/if_arp.h>
   7 #include <linux/if_link.h>
   8 #include <linux/netdevice.h>
   9 #include <sys/socket.h>
  10 #include <unistd.h>
  11
  12 #include "alloc-util.h"
  13 #include "arphrd-util.h"
  14 #include "batadv.h"
  15 #include "bond.h"
  16 #include "bridge.h"
  17 #include "bus-util.h"
  18 #include "device-private.h"
  19 #include "device-util.h"
  20 #include "dhcp-lease-internal.h"
  21 #include "env-file.h"
  22 #include "ethtool-util.h"
  23 #include "event-util.h"
  24 #include "fd-util.h"
  25 #include "fileio.h"
  26 #include "format-util.h"
  27 #include "fs-util.h"
  28 #include "glyph-util.h"
  29 #include "logarithm.h"
  30 #include "missing_network.h"
  31 #include "netlink-util.h"
  32 #include "network-internal.h"
  33 #include "networkd-address-label.h"
  34 #include "networkd-address.h"
  35 #include "networkd-bridge-fdb.h"
  36 #include "networkd-bridge-mdb.h"
  37 #include "networkd-bridge-vlan.h"
  38 #include "networkd-can.h"
  39 #include "networkd-dhcp-prefix-delegation.h"
  40 #include "networkd-dhcp-server.h"
  41 #include "networkd-dhcp4.h"
  42 #include "networkd-dhcp6.h"
  43 #include "networkd-ipv4acd.h"
  44 #include "networkd-ipv4ll.h"
  45 #include "networkd-ipv6-proxy-ndp.h"
  46 #include "networkd-link-bus.h"
  47 #include "networkd-link.h"
  48 #include "networkd-lldp-tx.h"
  49 #include "networkd-manager.h"
  50 #include "networkd-ndisc.h"
  51 #include "networkd-neighbor.h"
  52 #include "networkd-nexthop.h"
  53 #include "networkd-queue.h"
  54 #include "networkd-radv.h"
  55 #include "networkd-route-util.h"
  56 #include "networkd-route.h"
  57 #include "networkd-routing-policy-rule.h"
  58 #include "networkd-setlink.h"
  59 #include "networkd-sriov.h"
  60 #include "networkd-state-file.h"
  61 #include "networkd-sysctl.h"
  62 #include "networkd-wifi.h"
  63 #include "set.h"
  64 #include "socket-util.h"
  65 #include "stdio-util.h"
  66 #include "string-table.h"
  67 #include "strv.h"
  68 #include "tc.h"
  69 #include "tmpfile-util.h"
  70 #include "tuntap.h"
  71 #include "udev-util.h"
  72 #include "vrf.h"
  73
  74 void link_required_operstate_for_online(Link *link, LinkOperationalStateRange *ret) {
  75         assert(link);
  76         assert(ret);
  77
  78         if (link->network && operational_state_range_is_valid(&link->network->required_operstate_for_online))
  79                 /* If explicitly specified, use it as is. */
  80                 *ret = link->network->required_operstate_for_online;
  81         else if (link->iftype == ARPHRD_CAN)
  82                 /* CAN devices do not support addressing, hence defaults to 'carrier'. */
  83                 *ret = (const LinkOperationalStateRange) {
  84                         .min = LINK_OPERSTATE_CARRIER,
  85                         .max = LINK_OPERSTATE_CARRIER,
  86                 };
  87         else if (link->network && link->network->bond)
  88                 /* Bonding slaves do not support addressing. */
  89                 *ret = (const LinkOperationalStateRange) {
  90                         .min = LINK_OPERSTATE_ENSLAVED,
  91                         .max = LINK_OPERSTATE_ENSLAVED,
  92                 };
  93         else if (STRPTR_IN_SET(link->kind, "batadv", "bond", "bridge", "vrf"))
  94                 /* Some of slave interfaces may be offline. */
  95                 *ret = (const LinkOperationalStateRange) {
  96                         .min = LINK_OPERSTATE_DEGRADED_CARRIER,
  97                         .max = LINK_OPERSTATE_ROUTABLE,
  98                 };
  99         else
 100                 *ret = LINK_OPERSTATE_RANGE_DEFAULT;
 101 }
 102
 103 AddressFamily link_required_family_for_online(Link *link) {
 104         assert(link);
 105
 106         if (link->network && link->network->required_family_for_online >= 0)
 107                 return link->network->required_family_for_online;
 108
 109         if (link->network && operational_state_range_is_valid(&link->network->required_operstate_for_online))
 110                 /* If RequiredForOnline= is explicitly specified, defaults to no. */
 111                 return ADDRESS_FAMILY_NO;
 112
 113         if (STRPTR_IN_SET(link->kind, "batadv", "bond", "bridge", "vrf"))
 114                 /* As the minimum required operstate for master interfaces is 'degraded-carrier',
 115                  * we should request an address assigned to the link for backward compatibility. */
 116                 return ADDRESS_FAMILY_YES;
 117
 118         return ADDRESS_FAMILY_NO;
 119 }
 120
 121 bool link_ipv6_enabled(Link *link) {
 122         assert(link);
 123
 124         if (!socket_ipv6_is_supported())
 125                 return false;
 126
 127         if (link->iftype == ARPHRD_CAN)
 128                 return false;
 129
 130         if (!link->network)
 131                 return false;
 132
 133         if (link->network->bond)
 134                 return false;
 135
 136         if (link_may_have_ipv6ll(link, /* check_multicast = */ false))
 137                 return true;
 138
 139         if (network_has_static_ipv6_configurations(link->network))
 140                 return true;
 141
 142         return false;
 143 }
 144
 145 bool link_has_ipv6_connectivity(Link *link) {
 146         LinkAddressState ipv6_address_state;
 147
 148         assert(link);
 149
 150         link_get_address_states(link, NULL, &ipv6_address_state, NULL);
 151
 152         switch (ipv6_address_state) {
 153         case LINK_ADDRESS_STATE_ROUTABLE:
 154                 /* If the interface has a routable IPv6 address, then we assume yes. */
 155                 return true;
 156
 157         case LINK_ADDRESS_STATE_DEGRADED:
 158                 /* If the interface has only degraded IPv6 address (mostly, link-local address), then let's check
 159                  * there is an IPv6 default gateway. */
 160                 return link_has_default_gateway(link, AF_INET6);
 161
 162         case LINK_ADDRESS_STATE_OFF:
 163                 /* No IPv6 address. */
 164                 return false;
 165
 166         default:
 167                 assert_not_reached();
 168         }
 169 }
 170
 171 static bool link_is_ready_to_configure_one(Link *link, bool allow_unmanaged) {
 172         assert(link);
 173
 174         if (!IN_SET(link->state, LINK_STATE_CONFIGURING, LINK_STATE_CONFIGURED, LINK_STATE_UNMANAGED))
 175                 return false;
 176
 177         if (!link->network)
 178                 return allow_unmanaged;
 179
 180         if (!link->network->configure_without_carrier) {
 181                 if (link->set_flags_messages > 0)
 182                         return false;
 183
 184                 if (!link_has_carrier(link))
 185                         return false;
 186         }
 187
 188         if (link->set_link_messages > 0)
 189                 return false;
 190
 191         if (!link->activated)
 192                 return false;
 193
 194         return true;
 195 }
 196
 197 bool link_is_ready_to_configure(Link *link, bool allow_unmanaged) {
 198         return check_ready_for_all_sr_iov_ports(link, allow_unmanaged, link_is_ready_to_configure_one);
 199 }
 200
 201 void link_ntp_settings_clear(Link *link) {
 202         link->ntp = strv_free(link->ntp);
 203 }
 204
 205 void link_dns_settings_clear(Link *link) {
 206         if (link->n_dns != UINT_MAX)
 207                 for (unsigned i = 0; i < link->n_dns; i++)
 208                         in_addr_full_free(link->dns[i]);
 209         link->dns = mfree(link->dns);
 210         link->n_dns = UINT_MAX;
 211
 212         link->search_domains = ordered_set_free(link->search_domains);
 213         link->route_domains = ordered_set_free(link->route_domains);
 214
 215         link->dns_default_route = -1;
 216         link->llmnr = _RESOLVE_SUPPORT_INVALID;
 217         link->mdns = _RESOLVE_SUPPORT_INVALID;
 218         link->dnssec_mode = _DNSSEC_MODE_INVALID;
 219         link->dns_over_tls_mode = _DNS_OVER_TLS_MODE_INVALID;
 220
 221         link->dnssec_negative_trust_anchors = set_free_free(link->dnssec_negative_trust_anchors);
 222 }
 223
 224 static void link_free_engines(Link *link) {
 225         if (!link)
 226                 return;
 227
 228         link->dhcp_server = sd_dhcp_server_unref(link->dhcp_server);
 229
 230         link->dhcp_client = sd_dhcp_client_unref(link->dhcp_client);
 231         link->dhcp_lease = sd_dhcp_lease_unref(link->dhcp_lease);
 232         link->dhcp4_6rd_tunnel_name = mfree(link->dhcp4_6rd_tunnel_name);
 233
 234         link->lldp_rx = sd_lldp_rx_unref(link->lldp_rx);
 235         link->lldp_tx = sd_lldp_tx_unref(link->lldp_tx);
 236
 237         link->ipv4acd_by_address = hashmap_free(link->ipv4acd_by_address);
 238
 239         link->ipv4ll = sd_ipv4ll_unref(link->ipv4ll);
 240
 241         link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
 242         link->dhcp6_lease = sd_dhcp6_lease_unref(link->dhcp6_lease);
 243
 244         link->ndisc = sd_ndisc_unref(link->ndisc);
 245         link->ndisc_expire = sd_event_source_disable_unref(link->ndisc_expire);
 246         ndisc_flush(link);
 247
 248         link->radv = sd_radv_unref(link->radv);
 249 }
 250
 251 static Link *link_free(Link *link) {
 252         assert(link);
 253
 254         link_ntp_settings_clear(link);
 255         link_dns_settings_clear(link);
 256
 257         link->neighbors = set_free(link->neighbors);
 258         link->addresses = set_free(link->addresses);
 259         link->qdiscs = set_free(link->qdiscs);
 260         link->tclasses = set_free(link->tclasses);
 261
 262         link->dhcp_pd_prefixes = set_free(link->dhcp_pd_prefixes);
 263
 264         link_free_engines(link);
 265
 266         set_free(link->sr_iov_virt_port_ifindices);
 267         free(link->ifname);
 268         strv_free(link->alternative_names);
 269         free(link->kind);
 270         free(link->ssid);
 271         free(link->previous_ssid);
 272         free(link->driver);
 273
 274         unlink_and_free(link->lease_file);
 275         unlink_and_free(link->state_file);
 276
 277         sd_device_unref(link->dev);
 278         netdev_unref(link->netdev);
 279
 280         hashmap_free(link->bound_to_links);
 281         hashmap_free(link->bound_by_links);
 282
 283         set_free_with_destructor(link->slaves, link_unref);
 284
 285         network_unref(link->network);
 286
 287         sd_event_source_disable_unref(link->carrier_lost_timer);
 288
 289         return mfree(link);
 290 }
 291
 292 DEFINE_TRIVIAL_REF_UNREF_FUNC(Link, link, link_free);
 293
 294 int link_get_by_index(Manager *m, int ifindex, Link **ret) {
 295         Link *link;
 296
 297         assert(m);
 298
 299         if (ifindex <= 0)
 300                 return -EINVAL;
 301
 302         link = hashmap_get(m->links_by_index, INT_TO_PTR(ifindex));
 303         if (!link)
 304                 return -ENODEV;
 305
 306         if (ret)
 307                 *ret = link;
 308         return 0;
 309 }
 310
 311 int link_get_by_name(Manager *m, const char *ifname, Link **ret) {
 312         Link *link;
 313
 314         assert(m);
 315         assert(ifname);
 316
 317         link = hashmap_get(m->links_by_name, ifname);
 318         if (!link)
 319                 return -ENODEV;
 320
 321         if (ret)
 322                 *ret = link;
 323         return 0;
 324 }
 325
 326 int link_get_by_hw_addr(Manager *m, const struct hw_addr_data *hw_addr, Link **ret) {
 327         Link *link;
 328
 329         assert(m);
 330         assert(hw_addr);
 331
 332         link = hashmap_get(m->links_by_hw_addr, hw_addr);
 333         if (!link)
 334                 return -ENODEV;
 335
 336         if (ret)
 337                 *ret = link;
 338         return 0;
 339 }
 340
 341 int link_get_master(Link *link, Link **ret) {
 342         assert(link);
 343         assert(link->manager);
 344         assert(ret);
 345
 346         if (link->master_ifindex <= 0 || link->master_ifindex == link->ifindex)
 347                 return -ENODEV;
 348
 349         return link_get_by_index(link->manager, link->master_ifindex, ret);
 350 }
 351
 352 void link_set_state(Link *link, LinkState state) {
 353         assert(link);
 354
 355         if (link->state == state)
 356                 return;
 357
 358         log_link_debug(link, "State changed: %s -> %s",
 359                        link_state_to_string(link->state),
 360                        link_state_to_string(state));
 361
 362         link->state = state;
 363
 364         link_send_changed(link, "AdministrativeState", NULL);
 365         link_dirty(link);
 366 }
 367
 368 int link_stop_engines(Link *link, bool may_keep_dhcp) {
 369         int r, ret = 0;
 370
 371         assert(link);
 372         assert(link->manager);
 373         assert(link->manager->event);
 374
 375         bool keep_dhcp = may_keep_dhcp &&
 376                          link->network &&
 377                          !link->network->dhcp_send_decline && /* IPv4 ACD for the DHCPv4 address is running. */
 378                          (link->manager->restarting ||
 379                           FLAGS_SET(link->network->keep_configuration, KEEP_CONFIGURATION_DHCP_ON_STOP));
 380
 381         if (!keep_dhcp) {
 382                 r = sd_dhcp_client_stop(link->dhcp_client);
 383                 if (r < 0)
 384                         RET_GATHER(ret, log_link_warning_errno(link, r, "Could not stop DHCPv4 client: %m"));
 385         }
 386
 387         r = sd_dhcp_server_stop(link->dhcp_server);
 388         if (r < 0)
 389                 RET_GATHER(ret, log_link_warning_errno(link, r, "Could not stop DHCPv4 server: %m"));
 390
 391         r = sd_lldp_rx_stop(link->lldp_rx);
 392         if (r < 0)
 393                 RET_GATHER(ret, log_link_warning_errno(link, r, "Could not stop LLDP Rx: %m"));
 394
 395         r = sd_lldp_tx_stop(link->lldp_tx);
 396         if (r < 0)
 397                 RET_GATHER(ret, log_link_warning_errno(link, r, "Could not stop LLDP Tx: %m"));
 398
 399         r = sd_ipv4ll_stop(link->ipv4ll);
 400         if (r < 0)
 401                 RET_GATHER(ret, log_link_warning_errno(link, r, "Could not stop IPv4 link-local: %m"));
 402
 403         r = ipv4acd_stop(link);
 404         if (r < 0)
 405                 RET_GATHER(ret, log_link_warning_errno(link, r, "Could not stop IPv4 ACD client: %m"));
 406
 407         r = sd_dhcp6_client_stop(link->dhcp6_client);
 408         if (r < 0)
 409                 RET_GATHER(ret, log_link_warning_errno(link, r, "Could not stop DHCPv6 client: %m"));
 410
 411         r = dhcp_pd_remove(link, /* only_marked = */ false);
 412         if (r < 0)
 413                 RET_GATHER(ret, log_link_warning_errno(link, r, "Could not remove DHCPv6 PD addresses and routes: %m"));
 414
 415         r = ndisc_stop(link);
 416         if (r < 0)
 417                 RET_GATHER(ret, log_link_warning_errno(link, r, "Could not stop IPv6 Router Discovery: %m"));
 418
 419         ndisc_flush(link);
 420
 421         r = sd_radv_stop(link->radv);
 422         if (r < 0)
 423                 RET_GATHER(ret, log_link_warning_errno(link, r, "Could not stop IPv6 Router Advertisement: %m"));
 424
 425         return ret;
 426 }
 427
 428 void link_enter_failed(Link *link) {
 429         int r;
 430
 431         assert(link);
 432
 433         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 434                 return;
 435
 436         log_link_warning(link, "Failed");
 437
 438         link_set_state(link, LINK_STATE_FAILED);
 439
 440         if (!ratelimit_below(&link->automatic_reconfigure_ratelimit)) {
 441                 log_link_warning(link, "The interface entered the failed state frequently, refusing to reconfigure it automatically.");
 442                 goto stop;
 443         }
 444
 445         log_link_info(link, "Trying to reconfigure the interface.");
 446         r = link_reconfigure(link, /* force = */ true);
 447         if (r < 0) {
 448                 log_link_warning_errno(link, r, "Failed to reconfigure interface: %m");
 449                 goto stop;
 450         }
 451
 452         return;
 453
 454 stop:
 455         (void) link_stop_engines(link, /* may_keep_dhcp = */ false);
 456 }
 457
 458 void link_check_ready(Link *link) {
 459         Address *a;
 460
 461         assert(link);
 462
 463         if (link->state == LINK_STATE_CONFIGURED)
 464                 return;
 465
 466         if (link->state != LINK_STATE_CONFIGURING)
 467                 return (void) log_link_debug(link, "%s(): link is in %s state.", __func__, link_state_to_string(link->state));
 468
 469         if (!link->network)
 470                 return (void) log_link_debug(link, "%s(): link is unmanaged.", __func__);
 471
 472         if (!link->tc_configured)
 473                 return (void) log_link_debug(link, "%s(): traffic controls are not configured.", __func__);
 474
 475         if (link->set_link_messages > 0)
 476                 return (void) log_link_debug(link, "%s(): link layer is configuring.", __func__);
 477
 478         if (!link->activated)
 479                 return (void) log_link_debug(link, "%s(): link is not activated.", __func__);
 480
 481         if (link->iftype == ARPHRD_CAN)
 482                 /* let's shortcut things for CAN which doesn't need most of checks below. */
 483                 goto ready;
 484
 485         if (!link->stacked_netdevs_created)
 486                 return (void) log_link_debug(link, "%s(): stacked netdevs are not created.", __func__);
 487
 488         if (!link->static_addresses_configured)
 489                 return (void) log_link_debug(link, "%s(): static addresses are not configured.", __func__);
 490
 491         if (!link->static_address_labels_configured)
 492                 return (void) log_link_debug(link, "%s(): static address labels are not configured.", __func__);
 493
 494         if (!link->static_bridge_fdb_configured)
 495                 return (void) log_link_debug(link, "%s(): static bridge MDB entries are not configured.", __func__);
 496
 497         if (!link->static_bridge_mdb_configured)
 498                 return (void) log_link_debug(link, "%s(): static bridge MDB entries are not configured.", __func__);
 499
 500         if (!link->static_ipv6_proxy_ndp_configured)
 501                 return (void) log_link_debug(link, "%s(): static IPv6 proxy NDP addresses are not configured.", __func__);
 502
 503         if (!link->static_neighbors_configured)
 504                 return (void) log_link_debug(link, "%s(): static neighbors are not configured.", __func__);
 505
 506         if (!link->static_nexthops_configured)
 507                 return (void) log_link_debug(link, "%s(): static nexthops are not configured.", __func__);
 508
 509         if (!link->static_routes_configured)
 510                 return (void) log_link_debug(link, "%s(): static routes are not configured.", __func__);
 511
 512         if (!link->static_routing_policy_rules_configured)
 513                 return (void) log_link_debug(link, "%s(): static routing policy rules are not configured.", __func__);
 514
 515         if (!link->sr_iov_configured)
 516                 return (void) log_link_debug(link, "%s(): SR-IOV is not configured.", __func__);
 517
 518         /* IPv6LL is assigned after the link gains its carrier. */
 519         if (!link->network->configure_without_carrier &&
 520             link_ipv6ll_enabled(link) &&
 521             !in6_addr_is_set(&link->ipv6ll_address))
 522                 return (void) log_link_debug(link, "%s(): IPv6LL is not configured yet.", __func__);
 523
 524         /* All static addresses must be ready. */
 525         bool has_static_address = false;
 526         SET_FOREACH(a, link->addresses) {
 527                 if (a->source != NETWORK_CONFIG_SOURCE_STATIC)
 528                         continue;
 529                 if (!address_is_ready(a))
 530                         return (void) log_link_debug(link, "%s(): static address %s is not ready.", __func__,
 531                                                      IN_ADDR_PREFIX_TO_STRING(a->family, &a->in_addr, a->prefixlen));
 532                 has_static_address = true;
 533         }
 534
 535         /* If at least one static address is requested, do not request that dynamic addressing protocols are finished. */
 536         if (has_static_address)
 537                 goto ready;
 538
 539         /* If no dynamic addressing protocol enabled, assume the interface is ready.
 540          * Note, ignore NDisc when ConfigureWithoutCarrier= is enabled, as IPv6AcceptRA= is enabled by default. */
 541         if (!link_ipv4ll_enabled(link) && !link_dhcp4_enabled(link) &&
 542             !link_dhcp6_enabled(link) && !link_dhcp_pd_is_enabled(link) &&
 543             (link->network->configure_without_carrier || !link_ndisc_enabled(link)))
 544                 goto ready;
 545
 546         bool ipv4ll_ready =
 547                 link_ipv4ll_enabled(link) && link->ipv4ll_address_configured &&
 548                 link_check_addresses_ready(link, NETWORK_CONFIG_SOURCE_IPV4LL);
 549         bool dhcp4_ready =
 550                 link_dhcp4_enabled(link) && link->dhcp4_configured &&
 551                 link_check_addresses_ready(link, NETWORK_CONFIG_SOURCE_DHCP4);
 552         bool dhcp6_ready =
 553                 link_dhcp6_enabled(link) && link->dhcp6_configured &&
 554                 (!link->network->dhcp6_use_address ||
 555                  link_check_addresses_ready(link, NETWORK_CONFIG_SOURCE_DHCP6));
 556         bool dhcp_pd_ready =
 557                 link_dhcp_pd_is_enabled(link) && link->dhcp_pd_configured &&
 558                 (!link->network->dhcp_pd_assign ||
 559                  link_check_addresses_ready(link, NETWORK_CONFIG_SOURCE_DHCP_PD));
 560         bool ndisc_ready =
 561                 link_ndisc_enabled(link) && link->ndisc_configured &&
 562                 (!link->network->ndisc_use_autonomous_prefix ||
 563                  link_check_addresses_ready(link, NETWORK_CONFIG_SOURCE_NDISC));
 564
 565         /* If the uplink for PD is self, then request the corresponding DHCP protocol is also ready. */
 566         if (dhcp_pd_is_uplink(link, link, /* accept_auto = */ false)) {
 567                 if (link_dhcp4_enabled(link) && link->network->dhcp_use_6rd &&
 568                     sd_dhcp_lease_has_6rd(link->dhcp_lease)) {
 569                         if (!link->dhcp4_configured)
 570                                 return (void) log_link_debug(link, "%s(): DHCPv4 6rd prefix is assigned, but DHCPv4 protocol is not finished yet.", __func__);
 571                         if (!dhcp_pd_ready)
 572                                 return (void) log_link_debug(link, "%s(): DHCPv4 is finished, but prefix acquired by DHCPv4-6rd is not assigned yet.", __func__);
 573                 }
 574
 575                 if (link_dhcp6_enabled(link) && link->network->dhcp6_use_pd_prefix &&
 576                     sd_dhcp6_lease_has_pd_prefix(link->dhcp6_lease)) {
 577                         if (!link->dhcp6_configured)
 578                                 return (void) log_link_debug(link, "%s(): DHCPv6 IA_PD prefix is assigned, but DHCPv6 protocol is not finished yet.", __func__);
 579                         if (!dhcp_pd_ready)
 580                                 return (void) log_link_debug(link, "%s(): DHCPv6 is finished, but prefix acquired by DHCPv6 IA_PD is not assigned yet.", __func__);
 581                 }
 582         }
 583
 584         /* At least one dynamic addressing protocol is finished. */
 585         if (!ipv4ll_ready && !dhcp4_ready && !dhcp6_ready && !dhcp_pd_ready && !ndisc_ready)
 586                 return (void) log_link_debug(link, "%s(): dynamic addressing protocols are enabled but none of them finished yet.", __func__);
 587
 588         log_link_debug(link, "%s(): IPv4LL:%s DHCPv4:%s DHCPv6:%s DHCP-PD:%s NDisc:%s",
 589                        __func__,
 590                        yes_no(ipv4ll_ready),
 591                        yes_no(dhcp4_ready),
 592                        yes_no(dhcp6_ready),
 593                        yes_no(dhcp_pd_ready),
 594                        yes_no(ndisc_ready));
 595
 596 ready:
 597         link_set_state(link, LINK_STATE_CONFIGURED);
 598 }
 599
 600 static int link_request_static_configs(Link *link) {
 601         int r;
 602
 603         assert(link);
 604         assert(link->network);
 605         assert(link->state != _LINK_STATE_INVALID);
 606
 607         r = link_request_static_addresses(link);
 608         if (r < 0)
 609                 return r;
 610
 611         r = link_request_static_address_labels(link);
 612         if (r < 0)
 613                 return r;
 614
 615         r = link_request_static_bridge_fdb(link);
 616         if (r < 0)
 617                 return r;
 618
 619         r = link_request_static_bridge_mdb(link);
 620         if (r < 0)
 621                 return r;
 622
 623         r = link_request_static_ipv6_proxy_ndp_addresses(link);
 624         if (r < 0)
 625                 return r;
 626
 627         r = link_request_static_neighbors(link);
 628         if (r < 0)
 629                 return r;
 630
 631         r = link_request_static_nexthops(link, false);
 632         if (r < 0)
 633                 return r;
 634
 635         r = link_request_static_routes(link, false);
 636         if (r < 0)
 637                 return r;
 638
 639         r = link_request_static_routing_policy_rules(link);
 640         if (r < 0)
 641                 return r;
 642
 643         return 0;
 644 }
 645
 646 static int link_request_stacked_netdevs(Link *link) {
 647         NetDev *netdev;
 648         int r;
 649
 650         assert(link);
 651
 652         link->stacked_netdevs_created = false;
 653
 654         HASHMAP_FOREACH(netdev, link->network->stacked_netdevs) {
 655                 r = link_request_stacked_netdev(link, netdev);
 656                 if (r < 0)
 657                         return r;
 658         }
 659
 660         if (link->create_stacked_netdev_messages == 0) {
 661                 link->stacked_netdevs_created = true;
 662                 link_check_ready(link);
 663         }
 664
 665         return 0;
 666 }
 667
 668 static int link_acquire_dynamic_ipv6_conf(Link *link) {
 669         int r;
 670
 671         assert(link);
 672
 673         r = radv_start(link);
 674         if (r < 0)
 675                 return log_link_warning_errno(link, r, "Failed to start IPv6 Router Advertisement engine: %m");
 676
 677         r = ndisc_start(link);
 678         if (r < 0)
 679                 return log_link_warning_errno(link, r, "Failed to start IPv6 Router Discovery: %m");
 680
 681         r = dhcp6_start(link);
 682         if (r < 0)
 683                 return log_link_warning_errno(link, r, "Failed to start DHCPv6 client: %m");
 684
 685         return 0;
 686 }
 687
 688 static int link_acquire_dynamic_ipv4_conf(Link *link) {
 689         int r;
 690
 691         assert(link);
 692         assert(link->manager);
 693         assert(link->manager->event);
 694
 695         if (link->dhcp_client) {
 696                 r = dhcp4_start(link);
 697                 if (r < 0)
 698                         return log_link_warning_errno(link, r, "Failed to start DHCPv4 client: %m");
 699
 700                 log_link_debug(link, "Acquiring DHCPv4 lease.");
 701
 702         } else if (link->ipv4ll) {
 703                 if (in4_addr_is_set(&link->network->ipv4ll_start_address)) {
 704                         r = sd_ipv4ll_set_address(link->ipv4ll, &link->network->ipv4ll_start_address);
 705                         if (r < 0)
 706                                 return log_link_warning_errno(link, r, "Could not set IPv4 link-local start address: %m");
 707                 }
 708
 709                 r = sd_ipv4ll_start(link->ipv4ll);
 710                 if (r < 0)
 711                         return log_link_warning_errno(link, r, "Could not acquire IPv4 link-local address: %m");
 712
 713                 log_link_debug(link, "Acquiring IPv4 link-local address.");
 714         }
 715
 716         r = link_start_dhcp4_server(link);
 717         if (r < 0)
 718                 return log_link_warning_errno(link, r, "Could not start DHCP server: %m");
 719
 720         r = ipv4acd_start(link);
 721         if (r < 0)
 722                 return log_link_warning_errno(link, r, "Could not start IPv4 ACD client: %m");
 723
 724         return 0;
 725 }
 726
 727 static int link_acquire_dynamic_conf(Link *link) {
 728         int r;
 729
 730         assert(link);
 731         assert(link->network);
 732
 733         r = link_acquire_dynamic_ipv4_conf(link);
 734         if (r < 0)
 735                 return r;
 736
 737         if (in6_addr_is_set(&link->ipv6ll_address)) {
 738                 r = link_acquire_dynamic_ipv6_conf(link);
 739                 if (r < 0)
 740                         return r;
 741         }
 742
 743         if (!link_radv_enabled(link) || !link->network->dhcp_pd_announce) {
 744                 /* DHCPv6PD downstream does not require IPv6LL address. But may require RADV to be
 745                  * configured, and RADV may not be configured yet here. Only acquire subnet prefix when
 746                  * RADV is disabled, or the announcement of the prefix is disabled. Otherwise, the
 747                  * below will be called in radv_start(). */
 748                 r = dhcp_request_prefix_delegation(link);
 749                 if (r < 0)
 750                         return log_link_warning_errno(link, r, "Failed to request DHCP delegated subnet prefix: %m");
 751         }
 752
 753         if (link->lldp_tx) {
 754                 r = sd_lldp_tx_start(link->lldp_tx);
 755                 if (r < 0)
 756                         return log_link_warning_errno(link, r, "Failed to start LLDP transmission: %m");
 757         }
 758
 759         if (link->lldp_rx) {
 760                 r = sd_lldp_rx_start(link->lldp_rx);
 761                 if (r < 0)
 762                         return log_link_warning_errno(link, r, "Failed to start LLDP client: %m");
 763         }
 764
 765         return 0;
 766 }
 767
 768 int link_ipv6ll_gained(Link *link) {
 769         int r;
 770
 771         assert(link);
 772
 773         log_link_info(link, "Gained IPv6LL");
 774
 775         if (!IN_SET(link->state, LINK_STATE_CONFIGURING, LINK_STATE_CONFIGURED))
 776                 return 0;
 777
 778         r = link_acquire_dynamic_ipv6_conf(link);
 779         if (r < 0)
 780                 return r;
 781
 782         link_check_ready(link);
 783         return 0;
 784 }
 785
 786 int link_handle_bound_to_list(Link *link) {
 787         bool required_up = false;
 788         bool link_is_up = false;
 789         Link *l;
 790
 791         assert(link);
 792
 793         /* If at least one interface in bound_to_links has carrier, then make this interface up.
 794          * If all interfaces in bound_to_links do not, then make this interface down. */
 795
 796         if (hashmap_isempty(link->bound_to_links))
 797                 return 0;
 798
 799         if (link->flags & IFF_UP)
 800                 link_is_up = true;
 801
 802         HASHMAP_FOREACH(l, link->bound_to_links)
 803                 if (link_has_carrier(l)) {
 804                         required_up = true;
 805                         break;
 806                 }
 807
 808         if (!required_up && link_is_up)
 809                 return link_request_to_bring_up_or_down(link, /* up = */ false);
 810         if (required_up && !link_is_up)
 811                 return link_request_to_bring_up_or_down(link, /* up = */ true);
 812
 813         return 0;
 814 }
 815
 816 static int link_handle_bound_by_list(Link *link) {
 817         Link *l;
 818         int r;
 819
 820         assert(link);
 821
 822         /* Update up or down state of interfaces which depend on this interface's carrier state. */
 823
 824         if (hashmap_isempty(link->bound_by_links))
 825                 return 0;
 826
 827         HASHMAP_FOREACH(l, link->bound_by_links) {
 828                 r = link_handle_bound_to_list(l);
 829                 if (r < 0)
 830                         return r;
 831         }
 832
 833         return 0;
 834 }
 835
 836 static int link_put_carrier(Link *link, Link *carrier, Hashmap **h) {
 837         int r;
 838
 839         assert(link);
 840         assert(carrier);
 841
 842         if (link == carrier)
 843                 return 0;
 844
 845         if (hashmap_get(*h, INT_TO_PTR(carrier->ifindex)))
 846                 return 0;
 847
 848         r = hashmap_ensure_put(h, NULL, INT_TO_PTR(carrier->ifindex), carrier);
 849         if (r < 0)
 850                 return r;
 851
 852         link_dirty(link);
 853
 854         return 0;
 855 }
 856
 857 static int link_new_bound_by_list(Link *link) {
 858         Manager *m;
 859         Link *carrier;
 860         int r;
 861
 862         assert(link);
 863         assert(link->manager);
 864
 865         m = link->manager;
 866
 867         HASHMAP_FOREACH(carrier, m->links_by_index) {
 868                 if (!carrier->network)
 869                         continue;
 870
 871                 if (strv_isempty(carrier->network->bind_carrier))
 872                         continue;
 873
 874                 if (strv_fnmatch(carrier->network->bind_carrier, link->ifname)) {
 875                         r = link_put_carrier(link, carrier, &link->bound_by_links);
 876                         if (r < 0)
 877                                 return r;
 878                 }
 879         }
 880
 881         HASHMAP_FOREACH(carrier, link->bound_by_links) {
 882                 r = link_put_carrier(carrier, link, &carrier->bound_to_links);
 883                 if (r < 0)
 884                         return r;
 885         }
 886
 887         return 0;
 888 }
 889
 890 static int link_new_bound_to_list(Link *link) {
 891         Manager *m;
 892         Link *carrier;
 893         int r;
 894
 895         assert(link);
 896         assert(link->manager);
 897
 898         if (!link->network)
 899                 return 0;
 900
 901         if (strv_isempty(link->network->bind_carrier))
 902                 return 0;
 903
 904         m = link->manager;
 905
 906         HASHMAP_FOREACH(carrier, m->links_by_index) {
 907                 if (strv_fnmatch(link->network->bind_carrier, carrier->ifname)) {
 908                         r = link_put_carrier(link, carrier, &link->bound_to_links);
 909                         if (r < 0)
 910                                 return r;
 911                 }
 912         }
 913
 914         HASHMAP_FOREACH(carrier, link->bound_to_links) {
 915                 r = link_put_carrier(carrier, link, &carrier->bound_by_links);
 916                 if (r < 0)
 917                         return r;
 918         }
 919
 920         return 0;
 921 }
 922
 923 static void link_free_bound_to_list(Link *link) {
 924         bool updated = false;
 925         Link *bound_to;
 926
 927         assert(link);
 928
 929         while ((bound_to = hashmap_steal_first(link->bound_to_links))) {
 930                 updated = true;
 931
 932                 if (hashmap_remove(bound_to->bound_by_links, INT_TO_PTR(link->ifindex)))
 933                         link_dirty(bound_to);
 934         }
 935
 936         if (updated)
 937                 link_dirty(link);
 938 }
 939
 940 static void link_free_bound_by_list(Link *link) {
 941         bool updated = false;
 942         Link *bound_by;
 943
 944         assert(link);
 945
 946         while ((bound_by = hashmap_steal_first(link->bound_by_links))) {
 947                 updated = true;
 948
 949                 if (hashmap_remove(bound_by->bound_to_links, INT_TO_PTR(link->ifindex))) {
 950                         link_dirty(bound_by);
 951                         link_handle_bound_to_list(bound_by);
 952                 }
 953         }
 954
 955         if (updated)
 956                 link_dirty(link);
 957 }
 958
 959 static int link_append_to_master(Link *link) {
 960         Link *master;
 961         int r;
 962
 963         assert(link);
 964
 965         /* - The link may have no master.
 966          * - RTM_NEWLINK message about master interface may not be received yet. */
 967         if (link_get_master(link, &master) < 0)
 968                 return 0;
 969
 970         r = set_ensure_put(&master->slaves, NULL, link);
 971         if (r <= 0)
 972                 return r;
 973
 974         link_ref(link);
 975         return 0;
 976 }
 977
 978 static void link_drop_from_master(Link *link) {
 979         Link *master;
 980
 981         assert(link);
 982
 983         if (!link->manager)
 984                 return;
 985
 986         if (link_get_master(link, &master) < 0)
 987                 return;
 988
 989         link_unref(set_remove(master->slaves, link));
 990 }
 991
 992 static int link_drop_requests(Link *link) {
 993         Request *req;
 994         int ret = 0;
 995
 996         assert(link);
 997         assert(link->manager);
 998
 999         ORDERED_SET_FOREACH(req, link->manager->request_queue) {
1000                 if (req->link != link)
1001                         continue;
1002
1003                 /* If the request is already called, but its reply is not received, then we need to
1004                  * drop the configuration (e.g. address) here. Note, if the configuration is known,
1005                  * it will be handled later by link_drop_foreign_addresses() or so. */
1006                 if (req->waiting_reply && link->state != LINK_STATE_LINGER)
1007                         switch (req->type) {
1008                         case REQUEST_TYPE_ADDRESS: {
1009                                 Address *address = ASSERT_PTR(req->userdata);
1010
1011                                 if (address_get(link, address, NULL) < 0)
1012                                         RET_GATHER(ret, address_remove(address, link));
1013                                 break;
1014                         }
1015                         case REQUEST_TYPE_NEIGHBOR: {
1016                                 Neighbor *neighbor = ASSERT_PTR(req->userdata);
1017
1018                                 if (neighbor_get(link, neighbor, NULL) < 0)
1019                                         RET_GATHER(ret, neighbor_remove(neighbor, link));
1020                                 break;
1021                         }
1022                         case REQUEST_TYPE_NEXTHOP: {
1023                                 NextHop *nexthop = ASSERT_PTR(req->userdata);
1024
1025                                 if (nexthop_get_by_id(link->manager, nexthop->id, NULL) < 0)
1026                                         RET_GATHER(ret, nexthop_remove(nexthop, link->manager));
1027                                 break;
1028                         }
1029                         case REQUEST_TYPE_ROUTE: {
1030                                 Route *route = ASSERT_PTR(req->userdata);
1031
1032                                 if (route_get(link->manager, route, NULL) < 0)
1033                                         RET_GATHER(ret, route_remove(route, link->manager));
1034                                 break;
1035                         }
1036                         default:
1037                                 ;
1038                         }
1039
1040                 request_detach(req);
1041         }
1042
1043         return ret;
1044 }
1045
1046 static Link *link_drop(Link *link) {
1047         if (!link)
1048                 return NULL;
1049
1050         assert(link->manager);
1051
1052         link_set_state(link, LINK_STATE_LINGER);
1053
1054         /* Drop all references from other links and manager. Note that async netlink calls may have
1055          * references to the link, and they will be dropped when we receive replies. */
1056
1057         (void) link_drop_requests(link);
1058
1059         link_free_bound_to_list(link);
1060         link_free_bound_by_list(link);
1061
1062         link_clear_sr_iov_ifindices(link);
1063
1064         link_drop_from_master(link);
1065
1066         if (link->state_file)
1067                 (void) unlink(link->state_file);
1068
1069         link_clean(link);
1070
1071         STRV_FOREACH(n, link->alternative_names)
1072                 hashmap_remove(link->manager->links_by_name, *n);
1073         hashmap_remove(link->manager->links_by_name, link->ifname);
1074
1075         /* bonding master and its slaves have the same hardware address. */
1076         hashmap_remove_value(link->manager->links_by_hw_addr, &link->hw_addr, link);
1077
1078         /* The following must be called at last. */
1079         assert_se(hashmap_remove(link->manager->links_by_index, INT_TO_PTR(link->ifindex)) == link);
1080         return link_unref(link);
1081 }
1082
1083 static int link_drop_foreign_config(Link *link) {
1084         int r;
1085
1086         assert(link);
1087         assert(link->manager);
1088
1089         /* Drop foreign config, but ignore unmanaged, loopback, or critical interfaces. We do not want
1090          * to remove loopback address or addresses used for root NFS. */
1091
1092         if (IN_SET(link->state, LINK_STATE_UNMANAGED, LINK_STATE_PENDING, LINK_STATE_INITIALIZED))
1093                 return 0;
1094         if (FLAGS_SET(link->flags, IFF_LOOPBACK))
1095                 return 0;
1096         if (link->network->keep_configuration == KEEP_CONFIGURATION_YES)
1097                 return 0;
1098
1099         r = link_drop_foreign_routes(link);
1100
1101         RET_GATHER(r, link_drop_foreign_nexthops(link));
1102         RET_GATHER(r, link_drop_foreign_addresses(link));
1103         RET_GATHER(r, link_drop_foreign_neighbors(link));
1104         RET_GATHER(r, manager_drop_foreign_routing_policy_rules(link->manager));
1105
1106         return r;
1107 }
1108
1109 static int link_drop_managed_config(Link *link) {
1110         int r;
1111
1112         assert(link);
1113         assert(link->manager);
1114
1115         r = link_drop_static_routes(link);
1116         RET_GATHER(r, link_drop_static_nexthops(link));
1117         RET_GATHER(r, link_drop_static_addresses(link));
1118         RET_GATHER(r, link_drop_static_neighbors(link));
1119         RET_GATHER(r, link_drop_static_routing_policy_rules(link));
1120
1121         return r;
1122 }
1123
1124 static void link_foreignize_config(Link *link) {
1125         assert(link);
1126         assert(link->manager);
1127
1128         link_foreignize_routes(link);
1129         link_foreignize_nexthops(link);
1130         link_foreignize_addresses(link);
1131         link_foreignize_neighbors(link);
1132         link_foreignize_routing_policy_rules(link);
1133 }
1134
1135 static int link_configure(Link *link) {
1136         int r;
1137
1138         assert(link);
1139         assert(link->network);
1140         assert(link->state == LINK_STATE_INITIALIZED);
1141
1142         link_set_state(link, LINK_STATE_CONFIGURING);
1143
1144         r = link_new_bound_to_list(link);
1145         if (r < 0)
1146                 return r;
1147
1148         r = link_request_traffic_control(link);
1149         if (r < 0)
1150                 return r;
1151
1152         r = link_configure_mtu(link);
1153         if (r < 0)
1154                 return r;
1155
1156         if (link->iftype == ARPHRD_CAN) {
1157                 /* let's shortcut things for CAN which doesn't need most of what's done below. */
1158                 r = link_request_to_set_can(link);
1159                 if (r < 0)
1160                         return r;
1161
1162                 return link_request_to_activate(link);
1163         }
1164
1165         r = link_request_sr_iov_vfs(link);
1166         if (r < 0)
1167                 return r;
1168
1169         r = link_set_sysctl(link);
1170         if (r < 0)
1171                 return r;
1172
1173         r = link_request_to_set_mac(link, /* allow_retry = */ true);
1174         if (r < 0)
1175                 return r;
1176
1177         r = link_request_to_set_ipoib(link);
1178         if (r < 0)
1179                 return r;
1180
1181         r = link_request_to_set_flags(link);
1182         if (r < 0)
1183                 return r;
1184
1185         r = link_request_to_set_group(link);
1186         if (r < 0)
1187                 return r;
1188
1189         r = link_request_to_set_addrgen_mode(link);
1190         if (r < 0)
1191                 return r;
1192
1193         r = link_request_to_set_master(link);
1194         if (r < 0)
1195                 return r;
1196
1197         r = link_request_stacked_netdevs(link);
1198         if (r < 0)
1199                 return r;
1200
1201         r = link_request_to_set_bond(link);
1202         if (r < 0)
1203                 return r;
1204
1205         r = link_request_to_set_bridge(link);
1206         if (r < 0)
1207                 return r;
1208
1209         r = link_request_to_set_bridge_vlan(link);
1210         if (r < 0)
1211                 return r;
1212
1213         r = link_request_to_activate(link);
1214         if (r < 0)
1215                 return r;
1216
1217         r = ipv4ll_configure(link);
1218         if (r < 0)
1219                 return r;
1220
1221         r = link_request_dhcp4_client(link);
1222         if (r < 0)
1223                 return r;
1224
1225         r = link_request_dhcp6_client(link);
1226         if (r < 0)
1227                 return r;
1228
1229         r = link_request_ndisc(link);
1230         if (r < 0)
1231                 return r;
1232
1233         r = link_request_dhcp_server(link);
1234         if (r < 0)
1235                 return r;
1236
1237         r = link_request_radv(link);
1238         if (r < 0)
1239                 return r;
1240
1241         r = link_lldp_rx_configure(link);
1242         if (r < 0)
1243                 return r;
1244
1245         r = link_lldp_tx_configure(link);
1246         if (r < 0)
1247                 return r;
1248
1249         r = link_drop_foreign_config(link);
1250         if (r < 0)
1251                 return r;
1252
1253         r = link_request_static_configs(link);
1254         if (r < 0)
1255                 return r;
1256
1257         if (!link_has_carrier(link))
1258                 return 0;
1259
1260         return link_acquire_dynamic_conf(link);
1261 }
1262
1263 static int link_get_network(Link *link, Network **ret) {
1264         Network *network;
1265         int r;
1266
1267         assert(link);
1268         assert(link->manager);
1269         assert(ret);
1270
1271         ORDERED_HASHMAP_FOREACH(network, link->manager->networks) {
1272                 bool warn = false;
1273
1274                 r = net_match_config(
1275                                 &network->match,
1276                                 link->dev,
1277                                 &link->hw_addr,
1278                                 &link->permanent_hw_addr,
1279                                 link->driver,
1280                                 link->iftype,
1281                                 link->kind,
1282                                 link->ifname,
1283                                 link->alternative_names,
1284                                 link->wlan_iftype,
1285                                 link->ssid,
1286                                 &link->bssid);
1287                 if (r < 0)
1288                         return r;
1289                 if (r == 0)
1290                         continue;
1291
1292                 if (network->match.ifname && link->dev) {
1293                         uint8_t name_assign_type = NET_NAME_UNKNOWN;
1294                         const char *attr;
1295
1296                         if (sd_device_get_sysattr_value(link->dev, "name_assign_type", &attr) >= 0)
1297                                 (void) safe_atou8(attr, &name_assign_type);
1298
1299                         warn = name_assign_type == NET_NAME_ENUM;
1300                 }
1301
1302                 log_link_full(link, warn ? LOG_WARNING : LOG_DEBUG,
1303                               "found matching network '%s'%s.",
1304                               network->filename,
1305                               warn ? ", based on potentially unpredictable interface name" : "");
1306
1307                 if (network->unmanaged)
1308                         return -ENOENT;
1309
1310                 *ret = network;
1311                 return 0;
1312         }
1313
1314         return -ENOENT;
1315 }
1316
1317 int link_reconfigure_impl(Link *link, bool force) {
1318         Network *network = NULL;
1319         NetDev *netdev = NULL;
1320         int r;
1321
1322         assert(link);
1323
1324         if (IN_SET(link->state, LINK_STATE_PENDING, LINK_STATE_LINGER))
1325                 return 0;
1326
1327         r = netdev_get(link->manager, link->ifname, &netdev);
1328         if (r < 0 && r != -ENOENT)
1329                 return r;
1330
1331         r = link_get_network(link, &network);
1332         if (r < 0 && r != -ENOENT)
1333                 return r;
1334
1335         if (link->state != LINK_STATE_UNMANAGED && !network)
1336                 /* If link is in initialized state, then link->network is also NULL. */
1337                 force = true;
1338
1339         if (link->network == network && !force)
1340                 return 0;
1341
1342         if (network) {
1343                 _cleanup_free_ char *joined = strv_join(network->dropins, ", ");
1344
1345                 if (link->state == LINK_STATE_INITIALIZED)
1346                         log_link_info(link, "Configuring with %s%s%s%s.",
1347                                       network->filename,
1348                                       isempty(joined) ? "" : " (dropins: ",
1349                                       joined,
1350                                       isempty(joined) ? "" : ")");
1351                 else
1352                         log_link_info(link, "Reconfiguring with %s%s%s%s.",
1353                                       network->filename,
1354                                       isempty(joined) ? "" : " (dropins: ",
1355                                       joined,
1356                                       isempty(joined) ? "" : ")");
1357         } else
1358                 log_link_full(link, link->state == LINK_STATE_INITIALIZED ? LOG_DEBUG : LOG_INFO,
1359                               "Unmanaging interface.");
1360
1361         /* Dropping old .network file */
1362         r = link_stop_engines(link, false);
1363         if (r < 0)
1364                 return r;
1365
1366         r = link_drop_requests(link);
1367         if (r < 0)
1368                 return r;
1369
1370         if (network && !force && network->keep_configuration != KEEP_CONFIGURATION_YES)
1371                 /* When a new/updated .network file is assigned, first make all configs (addresses,
1372                  * routes, and so on) foreign, and then drop unnecessary configs later by
1373                  * link_drop_foreign_config() in link_configure().
1374                  * Note, when KeepConfiguration=yes, link_drop_foreign_config() does nothing. Hence,
1375                  * here we need to drop the configs such as addresses, routes, and so on configured by
1376                  * the previously assigned .network file. */
1377                 link_foreignize_config(link);
1378         else {
1379                 /* Remove all managed configs. Note, foreign configs are removed in later by
1380                  * link_configure() -> link_drop_foreign_config() if the link is managed by us. */
1381                 r = link_drop_managed_config(link);
1382                 if (r < 0)
1383                         return r;
1384         }
1385
1386         /* The bound_to map depends on .network file, hence it needs to be freed. But, do not free the
1387          * bound_by map. Otherwise, if a link enters unmanaged state below, then its carrier state will
1388          * not propagated to other interfaces anymore. Moreover, it is not necessary to recreate the
1389          * map here, as it depends on .network files assigned to other links. */
1390         link_free_bound_to_list(link);
1391
1392         link_free_engines(link);
1393         link->network = network_unref(link->network);
1394
1395         netdev_unref(link->netdev);
1396         link->netdev = netdev_ref(netdev);
1397
1398         if (!network) {
1399                 link_set_state(link, LINK_STATE_UNMANAGED);
1400                 return 0;
1401         }
1402
1403         /* Then, apply new .network file */
1404         link->network = network_ref(network);
1405         link_update_operstate(link, true);
1406         link_dirty(link);
1407
1408         link_set_state(link, LINK_STATE_INITIALIZED);
1409         link->activated = false;
1410
1411         r = link_configure(link);
1412         if (r < 0)
1413                 return r;
1414
1415         return 1;
1416 }
1417
1418 static int link_reconfigure_handler_internal(sd_netlink *rtnl, sd_netlink_message *m, Link *link, bool force) {
1419         int r;
1420
1421         assert(link);
1422
1423         r = link_getlink_handler_internal(rtnl, m, link, "Failed to update link state");
1424         if (r <= 0)
1425                 return r;
1426
1427         r = link_reconfigure_impl(link, force);
1428         if (r < 0) {
1429                 link_enter_failed(link);
1430                 return 0;
1431         }
1432
1433         return r;
1434 }
1435
1436 static int link_reconfigure_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
1437         return link_reconfigure_handler_internal(rtnl, m, link, /* force = */ false);
1438 }
1439
1440 static int link_force_reconfigure_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
1441         return link_reconfigure_handler_internal(rtnl, m, link, /* force = */ true);
1442 }
1443
1444 int link_reconfigure(Link *link, bool force) {
1445         int r;
1446
1447         assert(link);
1448
1449         /* When link in pending or initialized state, then link_configure() will be called. To prevent
1450          * the function from being called multiple times simultaneously, refuse to reconfigure the
1451          * interface in these cases. */
1452         if (IN_SET(link->state, LINK_STATE_PENDING, LINK_STATE_INITIALIZED, LINK_STATE_LINGER))
1453                 return 0; /* 0 means no-op. */
1454
1455         r = link_call_getlink(link, force ? link_force_reconfigure_handler : link_reconfigure_handler);
1456         if (r < 0)
1457                 return r;
1458
1459         return 1; /* 1 means the interface will be reconfigured. */
1460 }
1461
1462 typedef struct ReconfigureData {
1463         Link *link;
1464         Manager *manager;
1465         sd_bus_message *message;
1466 } ReconfigureData;
1467
1468 static void reconfigure_data_destroy_callback(ReconfigureData *data) {
1469         int r;
1470
1471         assert(data);
1472         assert(data->link);
1473         assert(data->manager);
1474         assert(data->manager->reloading > 0);
1475         assert(data->message);
1476
1477         link_unref(data->link);
1478
1479         data->manager->reloading--;
1480         if (data->manager->reloading <= 0) {
1481                 r = sd_bus_reply_method_return(data->message, NULL);
1482                 if (r < 0)
1483                         log_warning_errno(r, "Failed to send reply for 'Reload' DBus method, ignoring: %m");
1484         }
1485
1486         sd_bus_message_unref(data->message);
1487         free(data);
1488 }
1489
1490 static int reconfigure_handler_on_bus_method_reload(sd_netlink *rtnl, sd_netlink_message *m, ReconfigureData *data) {
1491         assert(data);
1492         assert(data->link);
1493         return link_reconfigure_handler_internal(rtnl, m, data->link, /* force = */ false);
1494 }
1495
1496 int link_reconfigure_on_bus_method_reload(Link *link, sd_bus_message *message) {
1497         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
1498         _cleanup_free_ ReconfigureData *data = NULL;
1499         int r;
1500
1501         assert(link);
1502         assert(link->manager);
1503         assert(link->manager->rtnl);
1504         assert(message);
1505
1506         /* See comments in link_reconfigure() above. */
1507         if (IN_SET(link->state, LINK_STATE_PENDING, LINK_STATE_INITIALIZED, LINK_STATE_LINGER))
1508                 return 0;
1509
1510         r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK, link->ifindex);
1511         if (r < 0)
1512                 return r;
1513
1514         data = new(ReconfigureData, 1);
1515         if (!data)
1516                 return -ENOMEM;
1517
1518         r = netlink_call_async(link->manager->rtnl, NULL, req,
1519                                reconfigure_handler_on_bus_method_reload,
1520                                reconfigure_data_destroy_callback, data);
1521         if (r < 0)
1522                 return r;
1523
1524         *data = (ReconfigureData) {
1525                 .link = link_ref(link),
1526                 .manager = link->manager,
1527                 .message = sd_bus_message_ref(message),
1528         };
1529
1530         link->manager->reloading++;
1531
1532         TAKE_PTR(data);
1533         return 0;
1534 }
1535
1536 static int link_initialized_and_synced(Link *link) {
1537         int r;
1538
1539         assert(link);
1540         assert(link->manager);
1541
1542         if (link->manager->test_mode) {
1543                 log_link_debug(link, "Running in test mode, refusing to enter initialized state.");
1544                 link_set_state(link, LINK_STATE_UNMANAGED);
1545                 return 0;
1546         }
1547
1548         if (link->state == LINK_STATE_PENDING) {
1549                 log_link_debug(link, "Link state is up-to-date");
1550                 link_set_state(link, LINK_STATE_INITIALIZED);
1551
1552                 r = link_new_bound_by_list(link);
1553                 if (r < 0)
1554                         return r;
1555
1556                 r = link_handle_bound_by_list(link);
1557                 if (r < 0)
1558                         return r;
1559         }
1560
1561         return link_reconfigure_impl(link, /* force = */ false);
1562 }
1563
1564 static int link_initialized_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
1565         int r;
1566
1567         r = link_getlink_handler_internal(rtnl, m, link, "Failed to wait for the interface to be initialized");
1568         if (r <= 0)
1569                 return r;
1570
1571         r = link_initialized_and_synced(link);
1572         if (r < 0)
1573                 link_enter_failed(link);
1574
1575         return 0;
1576 }
1577
1578 static int link_initialized(Link *link, sd_device *device) {
1579         int r;
1580
1581         assert(link);
1582         assert(device);
1583
1584         /* Always replace with the new sd_device object. As the sysname (and possibly other properties
1585          * or sysattrs) may be outdated. */
1586         device_unref_and_replace(link->dev, device);
1587
1588         if (link->dhcp_client) {
1589                 r = sd_dhcp_client_attach_device(link->dhcp_client, link->dev);
1590                 if (r < 0)
1591                         log_link_warning_errno(link, r, "Failed to attach device to DHCPv4 client, ignoring: %m");
1592         }
1593
1594         if (link->dhcp6_client) {
1595                 r = sd_dhcp6_client_attach_device(link->dhcp6_client, link->dev);
1596                 if (r < 0)
1597                         log_link_warning_errno(link, r, "Failed to attach device to DHCPv6 client, ignoring: %m");
1598         }
1599
1600         r = link_set_sr_iov_ifindices(link);
1601         if (r < 0)
1602                 log_link_warning_errno(link, r, "Failed to manage SR-IOV PF and VF ports, ignoring: %m");
1603
1604         if (link->state != LINK_STATE_PENDING)
1605                 return link_reconfigure(link, /* force = */ false);
1606
1607         log_link_debug(link, "udev initialized link");
1608
1609         /* udev has initialized the link, but we don't know if we have yet
1610          * processed the NEWLINK messages with the latest state. Do a GETLINK,
1611          * when it returns we know that the pending NEWLINKs have already been
1612          * processed and that we are up-to-date */
1613
1614         return link_call_getlink(link, link_initialized_handler);
1615 }
1616
1617 static int link_check_initialized(Link *link) {
1618         _cleanup_(sd_device_unrefp) sd_device *device = NULL;
1619         int r;
1620
1621         assert(link);
1622
1623         if (!udev_available())
1624                 return link_initialized_and_synced(link);
1625
1626         /* udev should be around */
1627         r = sd_device_new_from_ifindex(&device, link->ifindex);
1628         if (r < 0) {
1629                 log_link_debug_errno(link, r, "Could not find device, waiting for device initialization: %m");
1630                 return 0;
1631         }
1632
1633         r = device_is_processed(device);
1634         if (r < 0)
1635                 return log_link_warning_errno(link, r, "Could not determine whether the device is processed by udevd: %m");
1636         if (r == 0) {
1637                 /* not yet ready */
1638                 log_link_debug(link, "link pending udev initialization...");
1639                 return 0;
1640         }
1641
1642         r = device_is_renaming(device);
1643         if (r < 0)
1644                 return log_link_warning_errno(link, r, "Failed to determine the device is being renamed: %m");
1645         if (r > 0) {
1646                 log_link_debug(link, "Interface is being renamed, pending initialization.");
1647                 return 0;
1648         }
1649
1650         return link_initialized(link, device);
1651 }
1652
1653 int manager_udev_process_link(Manager *m, sd_device *device, sd_device_action_t action) {
1654         int r, ifindex;
1655         const char *s;
1656         Link *link;
1657
1658         assert(m);
1659         assert(device);
1660
1661         r = sd_device_get_ifindex(device, &ifindex);
1662         if (r < 0)
1663                 return log_device_debug_errno(device, r, "Failed to get ifindex: %m");
1664
1665         r = link_get_by_index(m, ifindex, &link);
1666         if (r < 0) {
1667                 /* This error is not critical, as the corresponding rtnl message may be received later. */
1668                 log_device_debug_errno(device, r, "Failed to get link from ifindex %i, ignoring: %m", ifindex);
1669                 return 0;
1670         }
1671
1672         /* Let's unref the sd-device object assigned to the corresponding Link object, but keep the Link
1673          * object here. It will be removed only when rtnetlink says so. */
1674         if (action == SD_DEVICE_REMOVE) {
1675                 link->dev = sd_device_unref(link->dev);
1676                 return 0;
1677         }
1678
1679         r = device_is_renaming(device);
1680         if (r < 0)
1681                 return log_device_debug_errno(device, r, "Failed to determine if the device is renaming or not: %m");
1682         if (r > 0) {
1683                 log_device_debug(device, "Device is renaming, waiting for the interface to be renamed.");
1684                 /* TODO:
1685                  * What happens when a device is initialized, then soon renamed after that? When we detect
1686                  * such, maybe we should cancel or postpone all queued requests for the interface. */
1687                 return 0;
1688         }
1689
1690         r = sd_device_get_property_value(device, "ID_NET_MANAGED_BY", &s);
1691         if (r < 0 && r != -ENOENT)
1692                 log_device_debug_errno(device, r, "Failed to get ID_NET_MANAGED_BY udev property, ignoring: %m");
1693         if (r >= 0 && !streq(s, "io.systemd.Network")) {
1694                 log_device_debug(device, "Interface is requested to be managed by '%s', not managing the interface.", s);
1695                 link_set_state(link, LINK_STATE_UNMANAGED);
1696                 return 0;
1697         }
1698
1699         r = link_initialized(link, device);
1700         if (r < 0)
1701                 link_enter_failed(link);
1702
1703         return 0;
1704 }
1705
1706 static int link_carrier_gained(Link *link) {
1707         bool force_reconfigure;
1708         int r;
1709
1710         assert(link);
1711
1712         r = event_source_disable(link->carrier_lost_timer);
1713         if (r < 0)
1714                 log_link_warning_errno(link, r, "Failed to disable carrier lost timer, ignoring: %m");
1715
1716         /* If a wireless interface was connected to an access point, and the SSID is changed (that is,
1717          * both previous_ssid and ssid are non-NULL), then the connected wireless network could be
1718          * changed. So, always reconfigure the link. Which means e.g. the DHCP client will be
1719          * restarted, and the correct network information will be gained.
1720          *
1721          * However, do not reconfigure the wireless interface forcibly if it was not connected to any
1722          * access points previously (previous_ssid is NULL in this case). As, a .network file may be
1723          * already assigned to the interface (in that case, the .network file does not have the SSID=
1724          * setting in the [Match] section), and the interface is already being configured. Of course,
1725          * there may exist another .network file with higher priority and a matching SSID= setting. But
1726          * in that case, link_reconfigure_impl() can handle that without the force_reconfigure flag.
1727          *
1728          * For non-wireless interfaces, we have no way to detect the connected network change. So,
1729          * setting force_reconfigure = false. Note, both ssid and previous_ssid are NULL in that case. */
1730         force_reconfigure = link->previous_ssid && !streq_ptr(link->previous_ssid, link->ssid);
1731         link->previous_ssid = mfree(link->previous_ssid);
1732
1733         /* AP and P2P-GO interfaces may have a new SSID - update the link properties in case a new .network
1734          * profile wants to match on it with SSID= in its [Match] section.
1735          */
1736         if (IN_SET(link->wlan_iftype, NL80211_IFTYPE_AP, NL80211_IFTYPE_P2P_GO)) {
1737                 r = link_get_wlan_interface(link);
1738                 if (r < 0)
1739                         return r;
1740         }
1741
1742         /* At this stage, both wlan and link information should be up-to-date. Hence, it is not necessary to
1743          * call RTM_GETLINK, NL80211_CMD_GET_INTERFACE, or NL80211_CMD_GET_STATION commands, and simply call
1744          * link_reconfigure_impl(). Note, link_reconfigure_impl() returns 1 when the link is reconfigured. */
1745         r = link_reconfigure_impl(link, force_reconfigure);
1746         if (r != 0)
1747                 return r;
1748
1749         r = link_handle_bound_by_list(link);
1750         if (r < 0)
1751                 return r;
1752
1753         if (link->iftype == ARPHRD_CAN)
1754                 /* let's shortcut things for CAN which doesn't need most of what's done below. */
1755                 return 0;
1756
1757         if (IN_SET(link->state, LINK_STATE_CONFIGURING, LINK_STATE_CONFIGURED)) {
1758                 r = link_acquire_dynamic_conf(link);
1759                 if (r < 0)
1760                         return r;
1761
1762                 r = link_request_static_configs(link);
1763                 if (r < 0)
1764                         return r;
1765         }
1766
1767         return 0;
1768 }
1769
1770 static int link_carrier_lost_impl(Link *link) {
1771         int r, ret = 0;
1772
1773         assert(link);
1774
1775         link->previous_ssid = mfree(link->previous_ssid);
1776
1777         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1778                 return 0;
1779
1780         if (!link->network)
1781                 return 0;
1782
1783         r = link_stop_engines(link, false);
1784         if (r < 0)
1785                 ret = r;
1786
1787         r = link_drop_managed_config(link);
1788         if (r < 0 && ret >= 0)
1789                 ret = r;
1790
1791         return ret;
1792 }
1793
1794 static int link_carrier_lost_handler(sd_event_source *s, uint64_t usec, void *userdata) {
1795         Link *link = ASSERT_PTR(userdata);
1796         int r;
1797
1798         r = link_carrier_lost_impl(link);
1799         if (r < 0) {
1800                 log_link_warning_errno(link, r, "Failed to process carrier lost event: %m");
1801                 link_enter_failed(link);
1802         }
1803
1804         return 0;
1805 }
1806
1807 static int link_carrier_lost(Link *link) {
1808         uint16_t dhcp_mtu;
1809         usec_t usec;
1810         int r;
1811
1812         assert(link);
1813
1814         r = link_handle_bound_by_list(link);
1815         if (r < 0)
1816                 return r;
1817
1818         if (link->iftype == ARPHRD_CAN)
1819                 /* let's shortcut things for CAN which doesn't need most of what's done below. */
1820                 return 0;
1821
1822         if (!link->network)
1823                 return 0;
1824
1825         if (link->network->ignore_carrier_loss_set)
1826                 /* If IgnoreCarrierLoss= is explicitly specified, then use the specified value. */
1827                 usec = link->network->ignore_carrier_loss_usec;
1828
1829         else if (link->network->bond && link->wlan_iftype > 0)
1830                 /* Enslaving wlan interface to a bond disconnects from the connected AP, and causes its
1831                  * carrier to be lost. See #19832. */
1832                 usec = 3 * USEC_PER_SEC;
1833
1834         else if (link->network->dhcp_use_mtu &&
1835                  link->dhcp_lease &&
1836                  sd_dhcp_lease_get_mtu(link->dhcp_lease, &dhcp_mtu) >= 0 &&
1837                  dhcp_mtu != link->original_mtu)
1838                 /* Some drivers reset interfaces when changing MTU. Resetting interfaces by the static
1839                  * MTU should not cause any issues, as MTU is changed only once. However, setting MTU
1840                  * through DHCP lease causes an infinite loop of resetting the interface. See #18738. */
1841                 usec = 5 * USEC_PER_SEC;
1842
1843         else
1844                 /* Otherwise, use the implied default value. */
1845                 usec = link->network->ignore_carrier_loss_usec;
1846
1847         if (usec == USEC_INFINITY)
1848                 return 0;
1849
1850         if (usec == 0)
1851                 return link_carrier_lost_impl(link);
1852
1853         return event_reset_time_relative(link->manager->event,
1854                                          &link->carrier_lost_timer,
1855                                          CLOCK_BOOTTIME,
1856                                          usec,
1857                                          0,
1858                                          link_carrier_lost_handler,
1859                                          link,
1860                                          0,
1861                                          "link-carrier-loss",
1862                                          true);
1863 }
1864
1865 static int link_admin_state_up(Link *link) {
1866         int r;
1867
1868         assert(link);
1869
1870         /* This is called every time an interface admin state changes to up;
1871          * specifically, when IFF_UP flag changes from unset to set. */
1872
1873         if (!link->network)
1874                 return 0;
1875
1876         if (link->activated && link->network->activation_policy == ACTIVATION_POLICY_ALWAYS_DOWN) {
1877                 log_link_info(link, "Activation policy is \"always-down\", forcing link down.");
1878                 return link_request_to_bring_up_or_down(link, /* up = */ false);
1879         }
1880
1881         /* We set the ipv6 mtu after the device mtu, but the kernel resets
1882          * ipv6 mtu on NETDEV_UP, so we need to reset it. */
1883         r = link_set_ipv6_mtu(link);
1884         if (r < 0)
1885                 log_link_warning_errno(link, r, "Cannot set IPv6 MTU, ignoring: %m");
1886
1887         return 0;
1888 }
1889
1890 static int link_admin_state_down(Link *link) {
1891         assert(link);
1892
1893         if (!link->network)
1894                 return 0;
1895
1896         if (link->activated && link->network->activation_policy == ACTIVATION_POLICY_ALWAYS_UP) {
1897                 log_link_info(link, "Activation policy is \"always-up\", forcing link up.");
1898                 return link_request_to_bring_up_or_down(link, /* up = */ true);
1899         }
1900
1901         return 0;
1902 }
1903
1904 static bool link_is_enslaved(Link *link) {
1905         if (link->flags & IFF_SLAVE)
1906                 return true;
1907
1908         if (link->master_ifindex > 0)
1909                 return true;
1910
1911         return false;
1912 }
1913
1914 void link_update_operstate(Link *link, bool also_update_master) {
1915         LinkOperationalState operstate;
1916         LinkCarrierState carrier_state;
1917         LinkAddressState ipv4_address_state, ipv6_address_state, address_state;
1918         LinkOnlineState online_state;
1919         _cleanup_strv_free_ char **p = NULL;
1920         bool changed = false;
1921
1922         assert(link);
1923
1924         if (link->kernel_operstate == IF_OPER_DORMANT)
1925                 carrier_state = LINK_CARRIER_STATE_DORMANT;
1926         else if (link_has_carrier(link)) {
1927                 if (link_is_enslaved(link))
1928                         carrier_state = LINK_CARRIER_STATE_ENSLAVED;
1929                 else
1930                         carrier_state = LINK_CARRIER_STATE_CARRIER;
1931         } else if (link->flags & IFF_UP)
1932                 carrier_state = LINK_CARRIER_STATE_NO_CARRIER;
1933         else
1934                 carrier_state = LINK_CARRIER_STATE_OFF;
1935
1936         if (carrier_state >= LINK_CARRIER_STATE_CARRIER) {
1937                 Link *slave;
1938
1939                 SET_FOREACH(slave, link->slaves) {
1940                         link_update_operstate(slave, false);
1941
1942                         if (slave->carrier_state < LINK_CARRIER_STATE_CARRIER)
1943                                 carrier_state = LINK_CARRIER_STATE_DEGRADED_CARRIER;
1944                 }
1945         }
1946
1947         link_get_address_states(link, &ipv4_address_state, &ipv6_address_state, &address_state);
1948
1949         /* Mapping of address and carrier state vs operational state
1950          *                                                     carrier state
1951          *                          | off | no-carrier | dormant | degraded-carrier | carrier  | enslaved
1952          *                 ------------------------------------------------------------------------------
1953          *                 off      | off | no-carrier | dormant | degraded-carrier | carrier  | enslaved
1954          * address_state   degraded | off | no-carrier | dormant | degraded         | degraded | enslaved
1955          *                 routable | off | no-carrier | dormant | routable         | routable | routable
1956          */
1957
1958         if (carrier_state == LINK_CARRIER_STATE_DEGRADED_CARRIER && address_state == LINK_ADDRESS_STATE_ROUTABLE)
1959                 operstate = LINK_OPERSTATE_ROUTABLE;
1960         else if (carrier_state == LINK_CARRIER_STATE_DEGRADED_CARRIER && address_state == LINK_ADDRESS_STATE_DEGRADED)
1961                 operstate = LINK_OPERSTATE_DEGRADED;
1962         else if (carrier_state < LINK_CARRIER_STATE_CARRIER || address_state == LINK_ADDRESS_STATE_OFF)
1963                 operstate = (LinkOperationalState) carrier_state;
1964         else if (address_state == LINK_ADDRESS_STATE_ROUTABLE)
1965                 operstate = LINK_OPERSTATE_ROUTABLE;
1966         else if (carrier_state == LINK_CARRIER_STATE_CARRIER)
1967                 operstate = LINK_OPERSTATE_DEGRADED;
1968         else
1969                 operstate = LINK_OPERSTATE_ENSLAVED;
1970
1971         LinkOperationalStateRange req;
1972         link_required_operstate_for_online(link, &req);
1973
1974         /* Only determine online state for managed links with RequiredForOnline=yes */
1975         if (!link->network || !link->network->required_for_online)
1976                 online_state = _LINK_ONLINE_STATE_INVALID;
1977
1978         else if (!operational_state_is_in_range(operstate, &req))
1979                 online_state = LINK_ONLINE_STATE_OFFLINE;
1980
1981         else {
1982                 AddressFamily required_family = link_required_family_for_online(link);
1983                 bool needs_ipv4 = required_family & ADDRESS_FAMILY_IPV4;
1984                 bool needs_ipv6 = required_family & ADDRESS_FAMILY_IPV6;
1985
1986                 /* The operational state is within the range required for online.
1987                  * If a particular address family is also required, we might revert
1988                  * to offline in the blocks below. */
1989                 online_state = LINK_ONLINE_STATE_ONLINE;
1990
1991                 if (req.min >= LINK_OPERSTATE_DEGRADED) {
1992                         if (needs_ipv4 && ipv4_address_state < LINK_ADDRESS_STATE_DEGRADED)
1993                                 online_state = LINK_ONLINE_STATE_OFFLINE;
1994                         if (needs_ipv6 && ipv6_address_state < LINK_ADDRESS_STATE_DEGRADED)
1995                                 online_state = LINK_ONLINE_STATE_OFFLINE;
1996                 }
1997
1998                 if (req.min >= LINK_OPERSTATE_ROUTABLE) {
1999                         if (needs_ipv4 && ipv4_address_state < LINK_ADDRESS_STATE_ROUTABLE)
2000                                 online_state = LINK_ONLINE_STATE_OFFLINE;
2001                         if (needs_ipv6 && ipv6_address_state < LINK_ADDRESS_STATE_ROUTABLE)
2002                                 online_state = LINK_ONLINE_STATE_OFFLINE;
2003                 }
2004         }
2005
2006         if (link->carrier_state != carrier_state) {
2007                 link->carrier_state = carrier_state;
2008                 changed = true;
2009                 if (strv_extend(&p, "CarrierState") < 0)
2010                         log_oom();
2011         }
2012
2013         if (link->address_state != address_state) {
2014                 link->address_state = address_state;
2015                 changed = true;
2016                 if (strv_extend(&p, "AddressState") < 0)
2017                         log_oom();
2018         }
2019
2020         if (link->ipv4_address_state != ipv4_address_state) {
2021                 link->ipv4_address_state = ipv4_address_state;
2022                 changed = true;
2023                 if (strv_extend(&p, "IPv4AddressState") < 0)
2024                         log_oom();
2025         }
2026
2027         if (link->ipv6_address_state != ipv6_address_state) {
2028                 link->ipv6_address_state = ipv6_address_state;
2029                 changed = true;
2030                 if (strv_extend(&p, "IPv6AddressState") < 0)
2031                         log_oom();
2032         }
2033
2034         if (link->operstate != operstate) {
2035                 link->operstate = operstate;
2036                 changed = true;
2037                 if (strv_extend(&p, "OperationalState") < 0)
2038                         log_oom();
2039         }
2040
2041         if (link->online_state != online_state) {
2042                 link->online_state = online_state;
2043                 changed = true;
2044                 if (strv_extend(&p, "OnlineState") < 0)
2045                         log_oom();
2046         }
2047
2048         if (p)
2049                 link_send_changed_strv(link, p);
2050         if (changed)
2051                 link_dirty(link);
2052
2053         if (also_update_master) {
2054                 Link *master;
2055
2056                 if (link_get_master(link, &master) >= 0)
2057                         link_update_operstate(master, true);
2058         }
2059 }
2060
2061 #define FLAG_STRING(string, flag, old, new)                      \
2062         (((old ^ new) & flag)                                    \
2063          ? ((old & flag) ? (" -" string) : (" +" string))        \
2064          : "")
2065
2066 static int link_update_flags(Link *link, sd_netlink_message *message) {
2067         bool link_was_admin_up, had_carrier;
2068         uint8_t operstate;
2069         unsigned flags;
2070         int r;
2071
2072         assert(link);
2073         assert(message);
2074
2075         r = sd_rtnl_message_link_get_flags(message, &flags);
2076         if (r < 0)
2077                 return log_link_debug_errno(link, r, "rtnl: failed to read link flags: %m");
2078
2079         r = sd_netlink_message_read_u8(message, IFLA_OPERSTATE, &operstate);
2080         if (r == -ENODATA)
2081                 /* If we got a message without operstate, assume the state was unchanged. */
2082                 operstate = link->kernel_operstate;
2083         else if (r < 0)
2084                 return log_link_debug_errno(link, r, "rtnl: failed to read operational state: %m");
2085
2086         if (link->flags == flags && link->kernel_operstate == operstate)
2087                 return 0;
2088
2089         if (link->flags != flags) {
2090                 unsigned unknown_flags, unknown_flags_added, unknown_flags_removed;
2091
2092                 log_link_debug(link, "Flags change:%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
2093                                FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
2094                                FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
2095                                FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
2096                                FLAG_STRING("UP", IFF_UP, link->flags, flags),
2097                                FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
2098                                FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
2099                                FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
2100                                FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
2101                                FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
2102                                FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
2103                                FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
2104                                FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
2105                                FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
2106                                FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
2107                                FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
2108                                FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
2109                                FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
2110                                FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
2111                                FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
2112
2113                 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
2114                                   IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
2115                                   IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
2116                                   IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
2117                                   IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
2118                                   IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
2119                 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
2120                 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
2121
2122                 if (unknown_flags_added)
2123                         log_link_debug(link, "Unknown link flags gained, ignoring: %#.5x", unknown_flags_added);
2124
2125                 if (unknown_flags_removed)
2126                         log_link_debug(link, "Unknown link flags lost, ignoring: %#.5x", unknown_flags_removed);
2127         }
2128
2129         link_was_admin_up = link->flags & IFF_UP;
2130         had_carrier = link_has_carrier(link);
2131
2132         link->flags = flags;
2133         link->kernel_operstate = operstate;
2134
2135         link_update_operstate(link, true);
2136
2137         if (!link_was_admin_up && (link->flags & IFF_UP)) {
2138                 log_link_info(link, "Link UP");
2139
2140                 r = link_admin_state_up(link);
2141                 if (r < 0)
2142                         return r;
2143         } else if (link_was_admin_up && !(link->flags & IFF_UP)) {
2144                 log_link_info(link, "Link DOWN");
2145
2146                 r = link_admin_state_down(link);
2147                 if (r < 0)
2148                         return r;
2149         }
2150
2151         if (!had_carrier && link_has_carrier(link)) {
2152                 log_link_info(link, "Gained carrier");
2153
2154                 r = link_carrier_gained(link);
2155                 if (r < 0)
2156                         return r;
2157         } else if (had_carrier && !link_has_carrier(link)) {
2158                 log_link_info(link, "Lost carrier");
2159
2160                 r = link_carrier_lost(link);
2161                 if (r < 0)
2162                         return r;
2163         }
2164
2165         return 0;
2166 }
2167
2168 static int link_update_master(Link *link, sd_netlink_message *message) {
2169         int master_ifindex, r;
2170
2171         assert(link);
2172         assert(message);
2173
2174         r = sd_netlink_message_read_u32(message, IFLA_MASTER, (uint32_t*) &master_ifindex);
2175         if (r == -ENODATA)
2176                 return 0;
2177         if (r < 0)
2178                 return log_link_debug_errno(link, r, "rtnl: failed to read master ifindex: %m");
2179
2180         if (master_ifindex == link->ifindex)
2181                 master_ifindex = 0;
2182
2183         if (master_ifindex != link->master_ifindex) {
2184                 if (link->master_ifindex == 0)
2185                         log_link_debug(link, "Attached to master interface: %i", master_ifindex);
2186                 else if (master_ifindex == 0)
2187                         log_link_debug(link, "Detached from master interface: %i", link->master_ifindex);
2188                 else
2189                         log_link_debug(link, "Master interface changed: %i %s %i", link->master_ifindex,
2190                                        special_glyph(SPECIAL_GLYPH_ARROW_RIGHT), master_ifindex);
2191
2192                 link_drop_from_master(link);
2193                 link->master_ifindex = master_ifindex;
2194         }
2195
2196         r = link_append_to_master(link);
2197         if (r < 0)
2198                 return log_link_debug_errno(link, r, "Failed to append link to master: %m");
2199
2200         return 0;
2201 }
2202
2203 static int link_update_driver(Link *link, sd_netlink_message *message) {
2204         int r;
2205
2206         assert(link);
2207         assert(link->manager);
2208         assert(message);
2209
2210         /* Driver is already read. Assuming the driver is never changed. */
2211         if (link->ethtool_driver_read)
2212                 return 0;
2213
2214         /* When udevd is running, read the driver after the interface is initialized by udevd.
2215          * Otherwise, ethtool may not work correctly. See issue #22538.
2216          * When udevd is not running, read the value when the interface is detected. */
2217         if (udev_available() && !link->dev)
2218                 return 0;
2219
2220         link->ethtool_driver_read = true;
2221
2222         r = ethtool_get_driver(&link->manager->ethtool_fd, link->ifname, &link->driver);
2223         if (r < 0) {
2224                 log_link_debug_errno(link, r, "Failed to get driver, continuing without: %m");
2225                 return 0;
2226         }
2227
2228         log_link_debug(link, "Found driver: %s", strna(link->driver));
2229
2230         if (streq_ptr(link->driver, "dsa")) {
2231                 uint32_t dsa_master_ifindex = 0;
2232
2233                 r = sd_netlink_message_read_u32(message, IFLA_LINK, &dsa_master_ifindex);
2234                 if (r < 0 && r != -ENODATA)
2235                         return log_link_debug_errno(link, r, "rtnl: failed to read ifindex of the DSA master interface: %m");
2236
2237                 if (dsa_master_ifindex > INT_MAX) {
2238                         log_link_debug(link, "rtnl: received too large DSA master ifindex (%"PRIu32" > INT_MAX), ignoring.",
2239                                        dsa_master_ifindex);
2240                         dsa_master_ifindex = 0;
2241                 }
2242
2243                 link->dsa_master_ifindex = (int) dsa_master_ifindex;
2244         }
2245
2246         return 1; /* needs reconfigure */
2247 }
2248
2249 static int link_update_permanent_hardware_address_from_ethtool(Link *link, sd_netlink_message *message) {
2250         int r;
2251
2252         assert(link);
2253         assert(link->manager);
2254         assert(message);
2255
2256         if (link->ethtool_permanent_hw_addr_read)
2257                 return 0;
2258
2259         /* When udevd is running, read the permanent hardware address after the interface is
2260          * initialized by udevd. Otherwise, ethtool may not work correctly. See issue #22538.
2261          * When udevd is not running, read the value when the interface is detected. */
2262         if (udev_available() && !link->dev)
2263                 return 0;
2264
2265         /* If the interface does not have a hardware address, then it will not have a permanent address either. */
2266         r = netlink_message_read_hw_addr(message, IFLA_ADDRESS, NULL);
2267         if (r == -ENODATA)
2268                 return 0;
2269         if (r < 0)
2270                 return log_link_debug_errno(link, r, "Failed to read IFLA_ADDRESS attribute: %m");
2271
2272         link->ethtool_permanent_hw_addr_read = true;
2273
2274         r = ethtool_get_permanent_hw_addr(&link->manager->ethtool_fd, link->ifname, &link->permanent_hw_addr);
2275         if (r < 0)
2276                 log_link_debug_errno(link, r, "Permanent hardware address not found, continuing without: %m");
2277
2278         return 0;
2279 }
2280
2281 static int link_update_permanent_hardware_address(Link *link, sd_netlink_message *message) {
2282         int r;
2283
2284         assert(link);
2285         assert(link->manager);
2286         assert(message);
2287
2288         if (link->permanent_hw_addr.length > 0)
2289                 return 0;
2290
2291         r = netlink_message_read_hw_addr(message, IFLA_PERM_ADDRESS, &link->permanent_hw_addr);
2292         if (r < 0) {
2293                 if (r != -ENODATA)
2294                         return log_link_debug_errno(link, r, "Failed to read IFLA_PERM_ADDRESS attribute: %m");
2295
2296                 /* Fallback to ethtool for older kernels. */
2297                 r = link_update_permanent_hardware_address_from_ethtool(link, message);
2298                 if (r < 0)
2299                         return r;
2300         }
2301
2302         if (link->permanent_hw_addr.length > 0)
2303                 log_link_debug(link, "Saved permanent hardware address: %s", HW_ADDR_TO_STR(&link->permanent_hw_addr));
2304
2305         return 1; /* needs reconfigure */
2306 }
2307
2308 static int link_update_hardware_address(Link *link, sd_netlink_message *message) {
2309         struct hw_addr_data addr;
2310         int r;
2311
2312         assert(link);
2313         assert(message);
2314
2315         r = netlink_message_read_hw_addr(message, IFLA_BROADCAST, &link->bcast_addr);
2316         if (r < 0 && r != -ENODATA)
2317                 return log_link_debug_errno(link, r, "rtnl: failed to read broadcast address: %m");
2318
2319         r = netlink_message_read_hw_addr(message, IFLA_ADDRESS, &addr);
2320         if (r == -ENODATA)
2321                 return 0;
2322         if (r < 0)
2323                 return log_link_debug_errno(link, r, "rtnl: failed to read hardware address: %m");
2324
2325         if (hw_addr_equal(&link->hw_addr, &addr))
2326                 return 0;
2327
2328         if (link->hw_addr.length == 0)
2329                 log_link_debug(link, "Saved hardware address: %s", HW_ADDR_TO_STR(&addr));
2330         else {
2331                 log_link_debug(link, "Hardware address is changed: %s %s %s",
2332                                HW_ADDR_TO_STR(&link->hw_addr),
2333                                special_glyph(SPECIAL_GLYPH_ARROW_RIGHT),
2334                                HW_ADDR_TO_STR(&addr));
2335
2336                 hashmap_remove_value(link->manager->links_by_hw_addr, &link->hw_addr, link);
2337         }
2338
2339         link->hw_addr = addr;
2340
2341         if (!hw_addr_is_null(&link->hw_addr)) {
2342                 r = hashmap_ensure_put(&link->manager->links_by_hw_addr, &hw_addr_hash_ops, &link->hw_addr, link);
2343                 if (r == -EEXIST && streq_ptr(link->kind, "bond"))
2344                         /* bonding master and its slaves have the same hardware address. */
2345                         r = hashmap_replace(link->manager->links_by_hw_addr, &link->hw_addr, link);
2346                 if (r < 0)
2347                         log_link_debug_errno(link, r, "Failed to manage link by its new hardware address, ignoring: %m");
2348         }
2349
2350         r = ipv4acd_update_mac(link);
2351         if (r < 0)
2352                 return log_link_debug_errno(link, r, "Could not update MAC address in IPv4 ACD client: %m");
2353
2354         r = ipv4ll_update_mac(link);
2355         if (r < 0)
2356                 return log_link_debug_errno(link, r, "Could not update MAC address in IPv4LL client: %m");
2357
2358         r = dhcp4_update_mac(link);
2359         if (r < 0)
2360                 return log_link_debug_errno(link, r, "Could not update MAC address in DHCP client: %m");
2361
2362         r = dhcp6_update_mac(link);
2363         if (r < 0)
2364                 return log_link_debug_errno(link, r, "Could not update MAC address in DHCPv6 client: %m");
2365
2366         r = radv_update_mac(link);
2367         if (r < 0)
2368                 return log_link_debug_errno(link, r, "Could not update MAC address for Router Advertisement: %m");
2369
2370         if (link->ndisc && link->hw_addr.length == ETH_ALEN) {
2371                 r = sd_ndisc_set_mac(link->ndisc, &link->hw_addr.ether);
2372                 if (r < 0)
2373                         return log_link_debug_errno(link, r, "Could not update MAC for NDisc: %m");
2374         }
2375
2376         if (link->lldp_rx) {
2377                 r = sd_lldp_rx_set_filter_address(link->lldp_rx, &link->hw_addr.ether);
2378                 if (r < 0)
2379                         return log_link_debug_errno(link, r, "Could not update MAC address for LLDP Rx: %m");
2380         }
2381
2382         if (link->lldp_tx) {
2383                 r = sd_lldp_tx_set_hwaddr(link->lldp_tx, &link->hw_addr.ether);
2384                 if (r < 0)
2385                         return log_link_debug_errno(link, r, "Could not update MAC address for LLDP Tx: %m");
2386         }
2387
2388         return 1; /* needs reconfigure */
2389 }
2390
2391 static int link_update_mtu(Link *link, sd_netlink_message *message) {
2392         uint32_t mtu, min_mtu = 0, max_mtu = UINT32_MAX;
2393         int r;
2394
2395         assert(link);
2396         assert(message);
2397
2398         r = sd_netlink_message_read_u32(message, IFLA_MTU, &mtu);
2399         if (r == -ENODATA)
2400                 return 0;
2401         if (r < 0)
2402                 return log_link_debug_errno(link, r, "rtnl: failed to read MTU in RTM_NEWLINK message: %m");
2403         if (mtu == 0)
2404                 return 0;
2405
2406         r = sd_netlink_message_read_u32(message, IFLA_MIN_MTU, &min_mtu);
2407         if (r < 0 && r != -ENODATA)
2408                 return log_link_debug_errno(link, r, "rtnl: failed to read minimum MTU in RTM_NEWLINK message: %m");
2409
2410         r = sd_netlink_message_read_u32(message, IFLA_MAX_MTU, &max_mtu);
2411         if (r < 0 && r != -ENODATA)
2412                 return log_link_debug_errno(link, r, "rtnl: failed to read maximum MTU in RTM_NEWLINK message: %m");
2413
2414         if (max_mtu == 0)
2415                 max_mtu = UINT32_MAX;
2416
2417         link->min_mtu = min_mtu;
2418         link->max_mtu = max_mtu;
2419
2420         if (link->original_mtu == 0) {
2421                 link->original_mtu = mtu;
2422                 log_link_debug(link, "Saved original MTU %" PRIu32" (min: %"PRIu32", max: %"PRIu32")",
2423                                link->original_mtu, link->min_mtu, link->max_mtu);
2424         }
2425
2426         if (link->mtu == mtu)
2427                 return 0;
2428
2429         if (link->mtu != 0)
2430                 log_link_debug(link, "MTU is changed: %"PRIu32" %s %"PRIu32" (min: %"PRIu32", max: %"PRIu32")",
2431                                link->mtu, special_glyph(SPECIAL_GLYPH_ARROW_RIGHT), mtu,
2432                                link->min_mtu, link->max_mtu);
2433
2434         link->mtu = mtu;
2435
2436         if (link->dhcp_client) {
2437                 r = sd_dhcp_client_set_mtu(link->dhcp_client, link->mtu);
2438                 if (r < 0)
2439                         return log_link_debug_errno(link, r, "Could not update MTU in DHCP client: %m");
2440         }
2441
2442         if (link->radv) {
2443                 r = sd_radv_set_mtu(link->radv, link->mtu);
2444                 if (r < 0)
2445                         return log_link_debug_errno(link, r, "Could not set MTU for Router Advertisement: %m");
2446         }
2447
2448         return 0;
2449 }
2450
2451 static int link_update_alternative_names(Link *link, sd_netlink_message *message) {
2452         _cleanup_strv_free_ char **altnames = NULL;
2453         int r;
2454
2455         assert(link);
2456         assert(message);
2457
2458         r = sd_netlink_message_read_strv(message, IFLA_PROP_LIST, IFLA_ALT_IFNAME, &altnames);
2459         if (r == -ENODATA)
2460                 /* The message does not have IFLA_PROP_LIST container attribute. It does not mean the
2461                  * interface has no alternative name. */
2462                 return 0;
2463         if (r < 0)
2464                 return log_link_debug_errno(link, r, "rtnl: failed to read alternative names: %m");
2465
2466         if (strv_equal(altnames, link->alternative_names))
2467                 return 0;
2468
2469         STRV_FOREACH(n, link->alternative_names)
2470                 hashmap_remove(link->manager->links_by_name, *n);
2471
2472         strv_free_and_replace(link->alternative_names, altnames);
2473
2474         STRV_FOREACH(n, link->alternative_names) {
2475                 r = hashmap_ensure_put(&link->manager->links_by_name, &string_hash_ops, *n, link);
2476                 if (r < 0)
2477                         return log_link_debug_errno(link, r, "Failed to manage link by its new alternative names: %m");
2478         }
2479
2480         return 1; /* needs reconfigure */
2481 }
2482
2483 static int link_update_name(Link *link, sd_netlink_message *message) {
2484         char ifname_from_index[IF_NAMESIZE];
2485         const char *ifname;
2486         int r;
2487
2488         assert(link);
2489         assert(message);
2490
2491         r = sd_netlink_message_read_string(message, IFLA_IFNAME, &ifname);
2492         if (r == -ENODATA)
2493                 /* Hmm?? But ok. */
2494                 return 0;
2495         if (r < 0)
2496                 return log_link_debug_errno(link, r, "Failed to read interface name in RTM_NEWLINK message: %m");
2497
2498         if (streq(ifname, link->ifname))
2499                 return 0;
2500
2501         r = format_ifname(link->ifindex, ifname_from_index);
2502         if (r < 0)
2503                 return log_link_debug_errno(link, r, "Could not get interface name for index %i.", link->ifindex);
2504
2505         if (!streq(ifname, ifname_from_index)) {
2506                 log_link_debug(link, "New interface name '%s' received from the kernel does not correspond "
2507                                "with the name currently configured on the actual interface '%s'. Ignoring.",
2508                                ifname, ifname_from_index);
2509                 return 0;
2510         }
2511
2512         log_link_info(link, "Interface name change detected, renamed to %s.", ifname);
2513
2514         hashmap_remove(link->manager->links_by_name, link->ifname);
2515
2516         r = free_and_strdup(&link->ifname, ifname);
2517         if (r < 0)
2518                 return log_oom_debug();
2519
2520         r = hashmap_ensure_put(&link->manager->links_by_name, &string_hash_ops, link->ifname, link);
2521         if (r < 0)
2522                 return log_link_debug_errno(link, r, "Failed to manage link by its new name: %m");
2523
2524         if (link->dhcp_client) {
2525                 r = sd_dhcp_client_set_ifname(link->dhcp_client, link->ifname);
2526                 if (r < 0)
2527                         return log_link_debug_errno(link, r, "Failed to update interface name in DHCP client: %m");
2528         }
2529
2530         if (link->dhcp6_client) {
2531                 r = sd_dhcp6_client_set_ifname(link->dhcp6_client, link->ifname);
2532                 if (r < 0)
2533                         return log_link_debug_errno(link, r, "Failed to update interface name in DHCP6 client: %m");
2534         }
2535
2536         if (link->ndisc) {
2537                 r = sd_ndisc_set_ifname(link->ndisc, link->ifname);
2538                 if (r < 0)
2539                         return log_link_debug_errno(link, r, "Failed to update interface name in NDisc: %m");
2540         }
2541
2542         if (link->dhcp_server) {
2543                 r = sd_dhcp_server_set_ifname(link->dhcp_server, link->ifname);
2544                 if (r < 0)
2545                         return log_link_debug_errno(link, r, "Failed to update interface name in DHCP server: %m");
2546         }
2547
2548         if (link->radv) {
2549                 r = sd_radv_set_ifname(link->radv, link->ifname);
2550                 if (r < 0)
2551                         return log_link_debug_errno(link, r, "Failed to update interface name in Router Advertisement: %m");
2552         }
2553
2554         if (link->lldp_rx) {
2555                 r = sd_lldp_rx_set_ifname(link->lldp_rx, link->ifname);
2556                 if (r < 0)
2557                         return log_link_debug_errno(link, r, "Failed to update interface name in LLDP Rx: %m");
2558         }
2559
2560         if (link->lldp_tx) {
2561                 r = sd_lldp_tx_set_ifname(link->lldp_tx, link->ifname);
2562                 if (r < 0)
2563                         return log_link_debug_errno(link, r, "Failed to update interface name in LLDP Tx: %m");
2564         }
2565
2566         if (link->ipv4ll) {
2567                 r = sd_ipv4ll_set_ifname(link->ipv4ll, link->ifname);
2568                 if (r < 0)
2569                         return log_link_debug_errno(link, r, "Failed to update interface name in IPv4LL client: %m");
2570         }
2571
2572         r = ipv4acd_set_ifname(link);
2573         if (r < 0)
2574                 return log_link_debug_errno(link, r, "Failed to update interface name in IPv4ACD client: %m");
2575
2576         return 1; /* needs reconfigure */
2577 }
2578
2579 static int link_update(Link *link, sd_netlink_message *message) {
2580         bool needs_reconfigure = false;
2581         int r;
2582
2583         assert(link);
2584         assert(message);
2585
2586         r = link_update_name(link, message);
2587         if (r < 0)
2588                 return r;
2589         needs_reconfigure = needs_reconfigure || r > 0;
2590
2591         r = link_update_alternative_names(link, message);
2592         if (r < 0)
2593                 return r;
2594         needs_reconfigure = needs_reconfigure || r > 0;
2595
2596         r = link_update_mtu(link, message);
2597         if (r < 0)
2598                 return r;
2599
2600         r = link_update_driver(link, message);
2601         if (r < 0)
2602                 return r;
2603         needs_reconfigure = needs_reconfigure || r > 0;
2604
2605         r = link_update_permanent_hardware_address(link, message);
2606         if (r < 0)
2607                 return r;
2608         needs_reconfigure = needs_reconfigure || r > 0;
2609
2610         r = link_update_hardware_address(link, message);
2611         if (r < 0)
2612                 return r;
2613         needs_reconfigure = needs_reconfigure || r > 0;
2614
2615         r = link_update_master(link, message);
2616         if (r < 0)
2617                 return r;
2618
2619         r = link_update_ipv6ll_addrgen_mode(link, message);
2620         if (r < 0)
2621                 return r;
2622
2623         r = link_update_flags(link, message);
2624         if (r < 0)
2625                 return r;
2626
2627         r = link_update_bridge_vlan(link, message);
2628         if (r < 0)
2629                 return r;
2630
2631         return needs_reconfigure;
2632 }
2633
2634 static Link *link_drop_or_unref(Link *link) {
2635         if (!link)
2636                 return NULL;
2637         if (!link->manager)
2638                 return link_unref(link);
2639         return link_drop(link);
2640 }
2641
2642 DEFINE_TRIVIAL_CLEANUP_FUNC(Link*, link_drop_or_unref);
2643
2644 static int link_new(Manager *manager, sd_netlink_message *message, Link **ret) {
2645         _cleanup_free_ char *ifname = NULL, *kind = NULL, *state_file = NULL, *lease_file = NULL;
2646         _cleanup_(link_drop_or_unrefp) Link *link = NULL;
2647         unsigned short iftype;
2648         int r, ifindex;
2649
2650         assert(manager);
2651         assert(message);
2652         assert(ret);
2653
2654         r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
2655         if (r < 0)
2656                 return log_debug_errno(r, "rtnl: failed to read ifindex from link message: %m");
2657         else if (ifindex <= 0)
2658                 return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "rtnl: received link message without valid ifindex.");
2659
2660         r = sd_rtnl_message_link_get_type(message, &iftype);
2661         if (r < 0)
2662                 return log_debug_errno(r, "rtnl: failed to read interface type from link message: %m");
2663
2664         r = sd_netlink_message_read_string_strdup(message, IFLA_IFNAME, &ifname);
2665         if (r < 0)
2666                 return log_debug_errno(r, "rtnl: failed to read interface name from link message: %m");
2667
2668         /* check for link kind */
2669         r = sd_netlink_message_enter_container(message, IFLA_LINKINFO);
2670         if (r >= 0) {
2671                 r = sd_netlink_message_read_string_strdup(message, IFLA_INFO_KIND, &kind);
2672                 if (r < 0 && r != -ENODATA)
2673                         return log_debug_errno(r, "rtnl: failed to read interface kind from link message: %m");
2674                 r = sd_netlink_message_exit_container(message);
2675                 if (r < 0)
2676                         return log_debug_errno(r, "rtnl: failed to exit IFLA_LINKINFO container: %m");
2677         }
2678
2679         if (!manager->test_mode) {
2680                 /* Do not update state files when running in test mode. */
2681                 if (asprintf(&state_file, "/run/systemd/netif/links/%d", ifindex) < 0)
2682                         return log_oom_debug();
2683
2684                 if (asprintf(&lease_file, "/run/systemd/netif/leases/%d", ifindex) < 0)
2685                         return log_oom_debug();
2686         }
2687
2688         link = new(Link, 1);
2689         if (!link)
2690                 return -ENOMEM;
2691
2692         *link = (Link) {
2693                 .n_ref = 1,
2694                 .state = LINK_STATE_PENDING,
2695                 .online_state = _LINK_ONLINE_STATE_INVALID,
2696                 .automatic_reconfigure_ratelimit = (const RateLimit) { .interval = 10 * USEC_PER_SEC, .burst = 5 },
2697                 .ifindex = ifindex,
2698                 .iftype = iftype,
2699                 .ifname = TAKE_PTR(ifname),
2700                 .kind = TAKE_PTR(kind),
2701
2702                 .bridge_vlan_pvid = UINT16_MAX,
2703
2704                 .ipv6ll_address_gen_mode = _IPV6_LINK_LOCAL_ADDRESS_GEN_MODE_INVALID,
2705
2706                 .state_file = TAKE_PTR(state_file),
2707                 .lease_file = TAKE_PTR(lease_file),
2708
2709                 .n_dns = UINT_MAX,
2710                 .dns_default_route = -1,
2711                 .llmnr = _RESOLVE_SUPPORT_INVALID,
2712                 .mdns = _RESOLVE_SUPPORT_INVALID,
2713                 .dnssec_mode = _DNSSEC_MODE_INVALID,
2714                 .dns_over_tls_mode = _DNS_OVER_TLS_MODE_INVALID,
2715         };
2716
2717         r = hashmap_ensure_put(&manager->links_by_index, NULL, INT_TO_PTR(link->ifindex), link);
2718         if (r < 0)
2719                 return log_link_debug_errno(link, r, "Failed to store link into manager: %m");
2720
2721         link->manager = manager;
2722
2723         r = hashmap_ensure_put(&manager->links_by_name, &string_hash_ops, link->ifname, link);
2724         if (r < 0)
2725                 return log_link_debug_errno(link, r, "Failed to manage link by its interface name: %m");
2726
2727         log_link_debug(link, "Saved new link: ifindex=%i, iftype=%s(%u), kind=%s",
2728                        link->ifindex, strna(arphrd_to_name(link->iftype)), link->iftype, strna(link->kind));
2729
2730         /* If contained in this set, the link is wireless and the corresponding NL80211_CMD_NEW_INTERFACE
2731          * message arrived too early. Request the wireless link information again.
2732          */
2733         if (set_remove(manager->new_wlan_ifindices, INT_TO_PTR(link->ifindex))) {
2734                 r = link_get_wlan_interface(link);
2735                 if (r < 0)
2736                         log_link_warning_errno(link, r, "Failed to get wireless interface, ignoring: %m");
2737         }
2738
2739         *ret = TAKE_PTR(link);
2740         return 0;
2741 }
2742
2743 int manager_rtnl_process_link(sd_netlink *rtnl, sd_netlink_message *message, Manager *manager) {
2744         Link *link = NULL;
2745         NetDev *netdev = NULL;
2746         uint16_t type;
2747         const char *name;
2748         int r, ifindex;
2749
2750         assert(rtnl);
2751         assert(message);
2752         assert(manager);
2753
2754         if (sd_netlink_message_is_error(message)) {
2755                 r = sd_netlink_message_get_errno(message);
2756                 if (r < 0)
2757                         log_message_warning_errno(message, r, "rtnl: Could not receive link message, ignoring");
2758
2759                 return 0;
2760         }
2761
2762         r = sd_netlink_message_get_type(message, &type);
2763         if (r < 0) {
2764                 log_warning_errno(r, "rtnl: Could not get message type, ignoring: %m");
2765                 return 0;
2766         } else if (!IN_SET(type, RTM_NEWLINK, RTM_DELLINK)) {
2767                 log_warning("rtnl: Received unexpected message type %u when processing link, ignoring.", type);
2768                 return 0;
2769         }
2770
2771         r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
2772         if (r < 0) {
2773                 log_warning_errno(r, "rtnl: Could not get ifindex from link message, ignoring: %m");
2774                 return 0;
2775         } else if (ifindex <= 0) {
2776                 log_warning("rtnl: received link message with invalid ifindex %d, ignoring.", ifindex);
2777                 return 0;
2778         }
2779
2780         r = sd_netlink_message_read_string(message, IFLA_IFNAME, &name);
2781         if (r < 0) {
2782                 log_warning_errno(r, "rtnl: Received link message without ifname, ignoring: %m");
2783                 return 0;
2784         }
2785
2786         (void) link_get_by_index(manager, ifindex, &link);
2787         (void) netdev_get(manager, name, &netdev);
2788
2789         switch (type) {
2790         case RTM_NEWLINK:
2791                 if (netdev) {
2792                         /* netdev exists, so make sure the ifindex matches */
2793                         r = netdev_set_ifindex(netdev, message);
2794                         if (r < 0) {
2795                                 log_netdev_warning_errno(netdev, r, "Could not process new link message for netdev, ignoring: %m");
2796                                 return 0;
2797                         }
2798                 }
2799
2800                 if (!link) {
2801                         /* link is new, so add it */
2802                         r = link_new(manager, message, &link);
2803                         if (r < 0) {
2804                                 log_warning_errno(r, "Could not process new link message: %m");
2805                                 return 0;
2806                         }
2807
2808                         r = link_update(link, message);
2809                         if (r < 0) {
2810                                 log_link_warning_errno(link, r, "Could not process link message: %m");
2811                                 link_enter_failed(link);
2812                                 return 0;
2813                         }
2814
2815                         r = link_check_initialized(link);
2816                         if (r < 0) {
2817                                 log_link_warning_errno(link, r, "Failed to check link is initialized: %m");
2818                                 link_enter_failed(link);
2819                                 return 0;
2820                         }
2821                 } else {
2822                         r = link_update(link, message);
2823                         if (r < 0) {
2824                                 log_link_warning_errno(link, r, "Could not process link message: %m");
2825                                 link_enter_failed(link);
2826                                 return 0;
2827                         }
2828                         if (r > 0) {
2829                                 r = link_reconfigure_impl(link, /* force = */ false);
2830                                 if (r < 0) {
2831                                         log_link_warning_errno(link, r, "Failed to reconfigure interface: %m");
2832                                         link_enter_failed(link);
2833                                         return 0;
2834                                 }
2835                         }
2836                 }
2837                 break;
2838
2839         case RTM_DELLINK:
2840                 link_drop(link);
2841                 netdev_drop(netdev);
2842                 break;
2843
2844         default:
2845                 assert_not_reached();
2846         }
2847
2848         return 1;
2849 }
2850
2851 int link_getlink_handler_internal(sd_netlink *rtnl, sd_netlink_message *m, Link *link, const char *error_msg) {
2852         uint16_t message_type;
2853         int r;
2854
2855         assert(m);
2856         assert(link);
2857         assert(error_msg);
2858
2859         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
2860                 return 0;
2861
2862         r = sd_netlink_message_get_errno(m);
2863         if (r < 0) {
2864                 log_link_message_warning_errno(link, m, r, error_msg);
2865                 link_enter_failed(link);
2866                 return 0;
2867         }
2868
2869         r = sd_netlink_message_get_type(m, &message_type);
2870         if (r < 0) {
2871                 log_link_debug_errno(link, r, "rtnl: failed to read link message type, ignoring: %m");
2872                 return 0;
2873         }
2874         if (message_type != RTM_NEWLINK) {
2875                 log_link_debug(link, "rtnl: received invalid link message type, ignoring.");
2876                 return 0;
2877         }
2878
2879         r = link_update(link, m);
2880         if (r < 0) {
2881                 link_enter_failed(link);
2882                 return 0;
2883         }
2884
2885         return 1;
2886 }
2887
2888 int link_call_getlink(Link *link, link_netlink_message_handler_t callback) {
2889         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
2890         int r;
2891
2892         assert(link);
2893         assert(link->manager);
2894         assert(link->manager->rtnl);
2895         assert(callback);
2896
2897         r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK, link->ifindex);
2898         if (r < 0)
2899                 return r;
2900
2901         r = netlink_call_async(link->manager->rtnl, NULL, req, callback,
2902                                link_netlink_destroy_callback, link);
2903         if (r < 0)
2904                 return r;
2905
2906         link_ref(link);
2907         return 0;
2908 }
2909
2910 static const char* const link_state_table[_LINK_STATE_MAX] = {
2911         [LINK_STATE_PENDING]     = "pending",
2912         [LINK_STATE_INITIALIZED] = "initialized",
2913         [LINK_STATE_CONFIGURING] = "configuring",
2914         [LINK_STATE_CONFIGURED]  = "configured",
2915         [LINK_STATE_UNMANAGED]   = "unmanaged",
2916         [LINK_STATE_FAILED]      = "failed",
2917         [LINK_STATE_LINGER]      = "linger",
2918 };
2919
2920 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
2921
2922 int link_flags_to_string_alloc(uint32_t flags, char **ret) {
2923         _cleanup_free_ char *str = NULL;
2924         static const char* map[] = {
2925                 [LOG2U(IFF_UP)]          = "up",             /* interface is up. */
2926                 [LOG2U(IFF_BROADCAST)]   = "broadcast",      /* broadcast address valid. */
2927                 [LOG2U(IFF_DEBUG)]       = "debug",          /* turn on debugging. */
2928                 [LOG2U(IFF_LOOPBACK)]    = "loopback",       /* interface is a loopback net. */
2929                 [LOG2U(IFF_POINTOPOINT)] = "point-to-point", /* interface has p-p link. */
2930                 [LOG2U(IFF_NOTRAILERS)]  = "no-trailers",    /* avoid use of trailers. */
2931                 [LOG2U(IFF_RUNNING)]     = "running",        /* interface RFC2863 OPER_UP. */
2932                 [LOG2U(IFF_NOARP)]       = "no-arp",         /* no ARP protocol. */
2933                 [LOG2U(IFF_PROMISC)]     = "promiscuous",    /* receive all packets. */
2934                 [LOG2U(IFF_ALLMULTI)]    = "all-multicast",  /* receive all multicast packets. */
2935                 [LOG2U(IFF_MASTER)]      = "master",         /* master of a load balancer. */
2936                 [LOG2U(IFF_SLAVE)]       = "slave",          /* slave of a load balancer. */
2937                 [LOG2U(IFF_MULTICAST)]   = "multicast",      /* supports multicast. */
2938                 [LOG2U(IFF_PORTSEL)]     = "portsel",        /* can set media type. */
2939                 [LOG2U(IFF_AUTOMEDIA)]   = "auto-media",     /* auto media select active. */
2940                 [LOG2U(IFF_DYNAMIC)]     = "dynamic",        /* dialup device with changing addresses. */
2941                 [LOG2U(IFF_LOWER_UP)]    = "lower-up",       /* driver signals L1 up. */
2942                 [LOG2U(IFF_DORMANT)]     = "dormant",        /* driver signals dormant. */
2943                 [LOG2U(IFF_ECHO)]        = "echo",           /* echo sent packets. */
2944         };
2945
2946         assert(ret);
2947
2948         for (size_t i = 0; i < ELEMENTSOF(map); i++)
2949                 if (FLAGS_SET(flags, 1 << i) && map[i])
2950                         if (!strextend_with_separator(&str, ",", map[i]))
2951                                 return -ENOMEM;
2952
2953         *ret = TAKE_PTR(str);
2954         return 0;
2955 }
2956
2957 static const char * const kernel_operstate_table[] = {
2958         [IF_OPER_UNKNOWN]        = "unknown",
2959         [IF_OPER_NOTPRESENT]     = "not-present",
2960         [IF_OPER_DOWN]           = "down",
2961         [IF_OPER_LOWERLAYERDOWN] = "lower-layer-down",
2962         [IF_OPER_TESTING]        = "testing",
2963         [IF_OPER_DORMANT]        = "dormant",
2964         [IF_OPER_UP]             = "up",
2965 };
2966
2967 DEFINE_STRING_TABLE_LOOKUP_TO_STRING(kernel_operstate, int);