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