src/network/networkd-link.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <netinet/in.h>
   4 #include <linux/if.h>
   5 #include <unistd.h>
   6
   7 #include "alloc-util.h"
   8 #include "bus-util.h"
   9 #include "dhcp-identifier.h"
  10 #include "dhcp-lease-internal.h"
  11 #include "env-file.h"
  12 #include "fd-util.h"
  13 #include "fileio.h"
  14 #include "missing_network.h"
  15 #include "netdev/bond.h"
  16 #include "netdev/bridge.h"
  17 #include "netdev/ipvlan.h"
  18 #include "netdev/vrf.h"
  19 #include "netlink-util.h"
  20 #include "network-internal.h"
  21 #include "networkd-can.h"
  22 #include "networkd-ipv6-proxy-ndp.h"
  23 #include "networkd-lldp-tx.h"
  24 #include "networkd-manager.h"
  25 #include "networkd-ndisc.h"
  26 #include "networkd-neighbor.h"
  27 #include "networkd-radv.h"
  28 #include "networkd-routing-policy-rule.h"
  29 #include "set.h"
  30 #include "socket-util.h"
  31 #include "stdio-util.h"
  32 #include "string-table.h"
  33 #include "strv.h"
  34 #include "sysctl-util.h"
  35 #include "tmpfile-util.h"
  36 #include "udev-util.h"
  37 #include "util.h"
  38 #include "virt.h"
  39
  40 uint32_t link_get_vrf_table(Link *link) {
  41         return link->network->vrf ? VRF(link->network->vrf)->table : RT_TABLE_MAIN;
  42 }
  43
  44 uint32_t link_get_dhcp_route_table(Link *link) {
  45         /* When the interface is part of an VRF use the VRFs routing table, unless
  46          * another table is explicitly specified. */
  47         if (link->network->dhcp_route_table_set)
  48                 return link->network->dhcp_route_table;
  49         return link_get_vrf_table(link);
  50 }
  51
  52 uint32_t link_get_ipv6_accept_ra_route_table(Link *link) {
  53         if (link->network->ipv6_accept_ra_route_table_set)
  54                 return link->network->ipv6_accept_ra_route_table;
  55         return link_get_vrf_table(link);
  56 }
  57
  58 DUID* link_get_duid(Link *link) {
  59         if (link->network->duid.type != _DUID_TYPE_INVALID)
  60                 return &link->network->duid;
  61         else
  62                 return &link->manager->duid;
  63 }
  64
  65 static bool link_dhcp6_enabled(Link *link) {
  66         assert(link);
  67
  68         if (!socket_ipv6_is_supported())
  69                 return false;
  70
  71         if (link->flags & IFF_LOOPBACK)
  72                 return false;
  73
  74         if (!link->network)
  75                 return false;
  76
  77         if (link->network->bond)
  78                 return false;
  79
  80         if (STRPTR_IN_SET(link->kind, "can", "vcan", "vxcan"))
  81                 return false;
  82
  83         if (manager_sysctl_ipv6_enabled(link->manager) == 0)
  84                 return false;
  85
  86         return link->network->dhcp & ADDRESS_FAMILY_IPV6;
  87 }
  88
  89 static bool link_dhcp4_enabled(Link *link) {
  90         assert(link);
  91
  92         if (link->flags & IFF_LOOPBACK)
  93                 return false;
  94
  95         if (!link->network)
  96                 return false;
  97
  98         if (link->network->bond)
  99                 return false;
 100
 101         if (STRPTR_IN_SET(link->kind, "can", "vcan", "vxcan"))
 102                 return false;
 103
 104         return link->network->dhcp & ADDRESS_FAMILY_IPV4;
 105 }
 106
 107 static bool link_dhcp4_server_enabled(Link *link) {
 108         assert(link);
 109
 110         if (link->flags & IFF_LOOPBACK)
 111                 return false;
 112
 113         if (!link->network)
 114                 return false;
 115
 116         if (link->network->bond)
 117                 return false;
 118
 119         if (STRPTR_IN_SET(link->kind, "can", "vcan", "vxcan"))
 120                 return false;
 121
 122         return link->network->dhcp_server;
 123 }
 124
 125 bool link_ipv4ll_enabled(Link *link, AddressFamilyBoolean mask) {
 126         assert(link);
 127         assert((mask & ~(ADDRESS_FAMILY_IPV4 | ADDRESS_FAMILY_FALLBACK_IPV4)) == 0);
 128
 129         if (link->flags & IFF_LOOPBACK)
 130                 return false;
 131
 132         if (!link->network)
 133                 return false;
 134
 135         if (STRPTR_IN_SET(link->kind, "vrf", "wireguard", "ipip", "gre", "ip6gre", "ip6tnl", "sit", "vti", "vti6", "can", "vcan", "vxcan", "nlmon"))
 136                 return false;
 137
 138         /* L3 or L3S mode do not support ARP. */
 139         if (IN_SET(link_get_ipvlan_mode(link), NETDEV_IPVLAN_MODE_L3, NETDEV_IPVLAN_MODE_L3S))
 140                 return false;
 141
 142         if (link->network->bond)
 143                 return false;
 144
 145         if (link->network->bond)
 146                 return false;
 147
 148         return link->network->link_local & mask;
 149 }
 150
 151 static bool link_ipv6ll_enabled(Link *link) {
 152         assert(link);
 153
 154         if (!socket_ipv6_is_supported())
 155                 return false;
 156
 157         if (link->flags & IFF_LOOPBACK)
 158                 return false;
 159
 160         if (!link->network)
 161                 return false;
 162
 163         if (STRPTR_IN_SET(link->kind, "vrf", "wireguard", "ipip", "gre", "sit", "vti", "can", "vcan", "vxcan", "nlmon"))
 164                 return false;
 165
 166         if (link->network->bond)
 167                 return false;
 168
 169         if (manager_sysctl_ipv6_enabled(link->manager) == 0)
 170                 return false;
 171
 172         return link->network->link_local & ADDRESS_FAMILY_IPV6;
 173 }
 174
 175 static bool link_ipv6_enabled(Link *link) {
 176         assert(link);
 177
 178         if (!socket_ipv6_is_supported())
 179                 return false;
 180
 181         if (link->network->bond)
 182                 return false;
 183
 184         if (manager_sysctl_ipv6_enabled(link->manager) == 0)
 185                 return false;
 186
 187         if (STRPTR_IN_SET(link->kind, "can", "vcan", "vxcan"))
 188                 return false;
 189
 190         /* DHCPv6 client will not be started if no IPv6 link-local address is configured. */
 191         return link_ipv6ll_enabled(link) || network_has_static_ipv6_addresses(link->network);
 192 }
 193
 194 static bool link_radv_enabled(Link *link) {
 195         assert(link);
 196
 197         if (!link_ipv6ll_enabled(link))
 198                 return false;
 199
 200         return link->network->router_prefix_delegation != RADV_PREFIX_DELEGATION_NONE;
 201 }
 202
 203 static bool link_ipv4_forward_enabled(Link *link) {
 204         assert(link);
 205
 206         if (link->flags & IFF_LOOPBACK)
 207                 return false;
 208
 209         if (!link->network)
 210                 return false;
 211
 212         if (link->network->ip_forward == _ADDRESS_FAMILY_BOOLEAN_INVALID)
 213                 return false;
 214
 215         return link->network->ip_forward & ADDRESS_FAMILY_IPV4;
 216 }
 217
 218 static bool link_ipv6_forward_enabled(Link *link) {
 219         assert(link);
 220
 221         if (!socket_ipv6_is_supported())
 222                 return false;
 223
 224         if (link->flags & IFF_LOOPBACK)
 225                 return false;
 226
 227         if (!link->network)
 228                 return false;
 229
 230         if (link->network->ip_forward == _ADDRESS_FAMILY_BOOLEAN_INVALID)
 231                 return false;
 232
 233         if (manager_sysctl_ipv6_enabled(link->manager) == 0)
 234                 return false;
 235
 236         return link->network->ip_forward & ADDRESS_FAMILY_IPV6;
 237 }
 238
 239 static bool link_proxy_arp_enabled(Link *link) {
 240         assert(link);
 241
 242         if (link->flags & IFF_LOOPBACK)
 243                 return false;
 244
 245         if (!link->network)
 246                 return false;
 247
 248         if (link->network->proxy_arp < 0)
 249                 return false;
 250
 251         return true;
 252 }
 253
 254 static bool link_ipv6_accept_ra_enabled(Link *link) {
 255         assert(link);
 256
 257         if (!socket_ipv6_is_supported())
 258                 return false;
 259
 260         if (link->flags & IFF_LOOPBACK)
 261                 return false;
 262
 263         if (!link->network)
 264                 return false;
 265
 266         if (!link_ipv6ll_enabled(link))
 267                 return false;
 268
 269         /* If unset use system default (enabled if local forwarding is disabled.
 270          * disabled if local forwarding is enabled).
 271          * If set, ignore or enforce RA independent of local forwarding state.
 272          */
 273         if (link->network->ipv6_accept_ra < 0)
 274                 /* default to accept RA if ip_forward is disabled and ignore RA if ip_forward is enabled */
 275                 return !link_ipv6_forward_enabled(link);
 276         else if (link->network->ipv6_accept_ra > 0)
 277                 /* accept RA even if ip_forward is enabled */
 278                 return true;
 279         else
 280                 /* ignore RA */
 281                 return false;
 282 }
 283
 284 static IPv6PrivacyExtensions link_ipv6_privacy_extensions(Link *link) {
 285         assert(link);
 286
 287         if (!socket_ipv6_is_supported())
 288                 return _IPV6_PRIVACY_EXTENSIONS_INVALID;
 289
 290         if (link->flags & IFF_LOOPBACK)
 291                 return _IPV6_PRIVACY_EXTENSIONS_INVALID;
 292
 293         if (!link->network)
 294                 return _IPV6_PRIVACY_EXTENSIONS_INVALID;
 295
 296         return link->network->ipv6_privacy_extensions;
 297 }
 298
 299 static int link_enable_ipv6(Link *link) {
 300         bool disabled;
 301         int r;
 302
 303         if (link->flags & IFF_LOOPBACK)
 304                 return 0;
 305
 306         disabled = !link_ipv6_enabled(link);
 307
 308         r = sysctl_write_ip_property_boolean(AF_INET6, link->ifname, "disable_ipv6", disabled);
 309         if (r < 0)
 310                 log_link_warning_errno(link, r, "Cannot %s IPv6: %m", enable_disable(!disabled));
 311         else
 312                 log_link_info(link, "IPv6 successfully %sd", enable_disable(!disabled));
 313
 314         return 0;
 315 }
 316
 317 static bool link_is_enslaved(Link *link) {
 318         if (link->flags & IFF_SLAVE)
 319                 /* Even if the link is not managed by networkd, honor IFF_SLAVE flag. */
 320                 return true;
 321
 322         if (!link->network)
 323                 return false;
 324
 325         if (link->master_ifindex > 0 && link->network->bridge)
 326                 return true;
 327
 328         /* TODO: add conditions for other netdevs. */
 329
 330         return false;
 331 }
 332
 333 static void link_update_master_operstate(Link *link, NetDev *netdev) {
 334         Link *master;
 335
 336         if (!netdev)
 337                 return;
 338
 339         if (link_get(link->manager, netdev->ifindex, &master) < 0)
 340                 return;
 341
 342         link_update_operstate(master, true);
 343 }
 344
 345 void link_update_operstate(Link *link, bool also_update_master) {
 346         LinkOperationalState operstate;
 347         Iterator i;
 348
 349         assert(link);
 350
 351         if (link->kernel_operstate == IF_OPER_DORMANT)
 352                 operstate = LINK_OPERSTATE_DORMANT;
 353         else if (link_has_carrier(link)) {
 354                 Address *address;
 355                 uint8_t scope = RT_SCOPE_NOWHERE;
 356
 357                 /* if we have carrier, check what addresses we have */
 358                 SET_FOREACH(address, link->addresses, i) {
 359                         if (!address_is_ready(address))
 360                                 continue;
 361
 362                         if (address->scope < scope)
 363                                 scope = address->scope;
 364                 }
 365
 366                 /* for operstate we also take foreign addresses into account */
 367                 SET_FOREACH(address, link->addresses_foreign, i) {
 368                         if (!address_is_ready(address))
 369                                 continue;
 370
 371                         if (address->scope < scope)
 372                                 scope = address->scope;
 373                 }
 374
 375                 if (scope < RT_SCOPE_SITE)
 376                         /* universally accessible addresses found */
 377                         operstate = LINK_OPERSTATE_ROUTABLE;
 378                 else if (scope < RT_SCOPE_HOST)
 379                         /* only link or site local addresses found */
 380                         operstate = LINK_OPERSTATE_DEGRADED;
 381                 else
 382                         /* no useful addresses found */
 383                         operstate = LINK_OPERSTATE_CARRIER;
 384         } else if (link->flags & IFF_UP)
 385                 operstate = LINK_OPERSTATE_NO_CARRIER;
 386         else
 387                 operstate = LINK_OPERSTATE_OFF;
 388
 389         if (IN_SET(operstate, LINK_OPERSTATE_DEGRADED, LINK_OPERSTATE_CARRIER) &&
 390             link_is_enslaved(link))
 391                 operstate = LINK_OPERSTATE_ENSLAVED;
 392
 393         if (operstate >= LINK_OPERSTATE_CARRIER) {
 394                 Link *slave;
 395
 396                 SET_FOREACH(slave, link->slaves, i) {
 397                         link_update_operstate(slave, false);
 398
 399                         if (slave->operstate < LINK_OPERSTATE_CARRIER)
 400                                 operstate = LINK_OPERSTATE_DEGRADED_CARRIER;
 401                 }
 402         }
 403
 404         if (link->operstate != operstate) {
 405                 link->operstate = operstate;
 406                 link_send_changed(link, "OperationalState", NULL);
 407                 link_dirty(link);
 408         }
 409
 410         if (also_update_master && link->network) {
 411                 link_update_master_operstate(link, link->network->bond);
 412                 link_update_master_operstate(link, link->network->bridge);
 413         }
 414 }
 415
 416 #define FLAG_STRING(string, flag, old, new) \
 417         (((old ^ new) & flag) \
 418                 ? ((old & flag) ? (" -" string) : (" +" string)) \
 419                 : "")
 420
 421 static int link_update_flags(Link *link, sd_netlink_message *m, bool force_update_operstate) {
 422         unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
 423         uint8_t operstate;
 424         int r;
 425
 426         assert(link);
 427
 428         r = sd_rtnl_message_link_get_flags(m, &flags);
 429         if (r < 0)
 430                 return log_link_warning_errno(link, r, "Could not get link flags: %m");
 431
 432         r = sd_netlink_message_read_u8(m, IFLA_OPERSTATE, &operstate);
 433         if (r < 0)
 434                 /* if we got a message without operstate, take it to mean
 435                    the state was unchanged */
 436                 operstate = link->kernel_operstate;
 437
 438         if (!force_update_operstate && (link->flags == flags) && (link->kernel_operstate == operstate))
 439                 return 0;
 440
 441         if (link->flags != flags) {
 442                 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",
 443                                FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
 444                                FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
 445                                FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
 446                                FLAG_STRING("UP", IFF_UP, link->flags, flags),
 447                                FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
 448                                FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
 449                                FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
 450                                FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
 451                                FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
 452                                FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
 453                                FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
 454                                FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
 455                                FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
 456                                FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
 457                                FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
 458                                FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
 459                                FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
 460                                FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
 461                                FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
 462
 463                 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
 464                                   IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
 465                                   IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
 466                                   IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
 467                                   IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
 468                                   IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
 469                 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
 470                 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
 471
 472                 /* link flags are currently at most 18 bits, let's align to
 473                  * printing 20 */
 474                 if (unknown_flags_added)
 475                         log_link_debug(link,
 476                                        "Unknown link flags gained: %#.5x (ignoring)",
 477                                        unknown_flags_added);
 478
 479                 if (unknown_flags_removed)
 480                         log_link_debug(link,
 481                                        "Unknown link flags lost: %#.5x (ignoring)",
 482                                        unknown_flags_removed);
 483         }
 484
 485         link->flags = flags;
 486         link->kernel_operstate = operstate;
 487
 488         link_update_operstate(link, true);
 489
 490         return 0;
 491 }
 492
 493 static int link_new(Manager *manager, sd_netlink_message *message, Link **ret) {
 494         _cleanup_(link_unrefp) Link *link = NULL;
 495         uint16_t type;
 496         const char *ifname, *kind = NULL;
 497         int r, ifindex;
 498         unsigned short iftype;
 499
 500         assert(manager);
 501         assert(message);
 502         assert(ret);
 503
 504         /* check for link kind */
 505         r = sd_netlink_message_enter_container(message, IFLA_LINKINFO);
 506         if (r == 0) {
 507                 (void) sd_netlink_message_read_string(message, IFLA_INFO_KIND, &kind);
 508                 r = sd_netlink_message_exit_container(message);
 509                 if (r < 0)
 510                         return r;
 511         }
 512
 513         r = sd_netlink_message_get_type(message, &type);
 514         if (r < 0)
 515                 return r;
 516         else if (type != RTM_NEWLINK)
 517                 return -EINVAL;
 518
 519         r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
 520         if (r < 0)
 521                 return r;
 522         else if (ifindex <= 0)
 523                 return -EINVAL;
 524
 525         r = sd_rtnl_message_link_get_type(message, &iftype);
 526         if (r < 0)
 527                 return r;
 528
 529         r = sd_netlink_message_read_string(message, IFLA_IFNAME, &ifname);
 530         if (r < 0)
 531                 return r;
 532
 533         link = new(Link, 1);
 534         if (!link)
 535                 return -ENOMEM;
 536
 537         *link = (Link) {
 538                 .n_ref = 1,
 539                 .manager = manager,
 540                 .state = LINK_STATE_PENDING,
 541                 .rtnl_extended_attrs = true,
 542                 .ifindex = ifindex,
 543                 .iftype = iftype,
 544         };
 545
 546         link->ifname = strdup(ifname);
 547         if (!link->ifname)
 548                 return -ENOMEM;
 549
 550         if (kind) {
 551                 link->kind = strdup(kind);
 552                 if (!link->kind)
 553                         return -ENOMEM;
 554         }
 555
 556         r = sd_netlink_message_read_u32(message, IFLA_MASTER, (uint32_t *)&link->master_ifindex);
 557         if (r < 0)
 558                 log_link_debug_errno(link, r, "New device has no master, continuing without");
 559
 560         r = sd_netlink_message_read_ether_addr(message, IFLA_ADDRESS, &link->mac);
 561         if (r < 0)
 562                 log_link_debug_errno(link, r, "MAC address not found for new device, continuing without");
 563
 564         if (asprintf(&link->state_file, "/run/systemd/netif/links/%d", link->ifindex) < 0)
 565                 return -ENOMEM;
 566
 567         if (asprintf(&link->lease_file, "/run/systemd/netif/leases/%d", link->ifindex) < 0)
 568                 return -ENOMEM;
 569
 570         if (asprintf(&link->lldp_file, "/run/systemd/netif/lldp/%d", link->ifindex) < 0)
 571                 return -ENOMEM;
 572
 573         r = hashmap_ensure_allocated(&manager->links, NULL);
 574         if (r < 0)
 575                 return r;
 576
 577         r = hashmap_put(manager->links, INT_TO_PTR(link->ifindex), link);
 578         if (r < 0)
 579                 return r;
 580
 581         r = link_update_flags(link, message, false);
 582         if (r < 0)
 583                 return r;
 584
 585         *ret = TAKE_PTR(link);
 586
 587         return 0;
 588 }
 589
 590 static Link *link_free(Link *link) {
 591         Address *address;
 592
 593         assert(link);
 594
 595         link->routes = set_free_with_destructor(link->routes, route_free);
 596         link->routes_foreign = set_free_with_destructor(link->routes_foreign, route_free);
 597
 598         link->addresses = set_free_with_destructor(link->addresses, address_free);
 599         link->addresses_foreign = set_free_with_destructor(link->addresses_foreign, address_free);
 600
 601         while ((address = link->pool_addresses)) {
 602                 LIST_REMOVE(addresses, link->pool_addresses, address);
 603                 address_free(address);
 604         }
 605
 606         sd_dhcp_server_unref(link->dhcp_server);
 607         sd_dhcp_client_unref(link->dhcp_client);
 608         sd_dhcp_lease_unref(link->dhcp_lease);
 609
 610         link_lldp_emit_stop(link);
 611
 612         free(link->lease_file);
 613
 614         sd_lldp_unref(link->lldp);
 615         free(link->lldp_file);
 616
 617         ndisc_flush(link);
 618
 619         sd_ipv4ll_unref(link->ipv4ll);
 620         sd_dhcp6_client_unref(link->dhcp6_client);
 621         sd_ndisc_unref(link->ndisc);
 622         sd_radv_unref(link->radv);
 623
 624         free(link->ifname);
 625         free(link->kind);
 626
 627         (void) unlink(link->state_file);
 628         free(link->state_file);
 629
 630         sd_device_unref(link->sd_device);
 631
 632         hashmap_free(link->bound_to_links);
 633         hashmap_free(link->bound_by_links);
 634
 635         set_free_with_destructor(link->slaves, link_unref);
 636
 637         network_unref(link->network);
 638
 639         return mfree(link);
 640 }
 641
 642 DEFINE_TRIVIAL_REF_UNREF_FUNC(Link, link, link_free);
 643
 644 int link_get(Manager *m, int ifindex, Link **ret) {
 645         Link *link;
 646
 647         assert(m);
 648         assert(ifindex);
 649         assert(ret);
 650
 651         link = hashmap_get(m->links, INT_TO_PTR(ifindex));
 652         if (!link)
 653                 return -ENODEV;
 654
 655         *ret = link;
 656
 657         return 0;
 658 }
 659
 660 void link_set_state(Link *link, LinkState state) {
 661         assert(link);
 662
 663         if (link->state == state)
 664                 return;
 665
 666         log_link_debug(link, "State changed: %s -> %s",
 667                        link_state_to_string(link->state),
 668                        link_state_to_string(state));
 669
 670         link->state = state;
 671
 672         link_send_changed(link, "AdministrativeState", NULL);
 673 }
 674
 675 static void link_enter_unmanaged(Link *link) {
 676         assert(link);
 677
 678         link_set_state(link, LINK_STATE_UNMANAGED);
 679
 680         link_dirty(link);
 681 }
 682
 683 int link_stop_clients(Link *link, bool may_keep_dhcp) {
 684         int r = 0, k;
 685
 686         assert(link);
 687         assert(link->manager);
 688         assert(link->manager->event);
 689
 690         if (link->dhcp_client && (!may_keep_dhcp || !link->network ||
 691                                   !FLAGS_SET(link->network->keep_configuration, KEEP_CONFIGURATION_DHCP_ON_STOP))) {
 692                 k = sd_dhcp_client_stop(link->dhcp_client);
 693                 if (k < 0)
 694                         r = log_link_warning_errno(link, k, "Could not stop DHCPv4 client: %m");
 695         }
 696
 697         if (link->ipv4ll) {
 698                 k = sd_ipv4ll_stop(link->ipv4ll);
 699                 if (k < 0)
 700                         r = log_link_warning_errno(link, k, "Could not stop IPv4 link-local: %m");
 701         }
 702
 703         if (link->dhcp6_client) {
 704                 k = sd_dhcp6_client_stop(link->dhcp6_client);
 705                 if (k < 0)
 706                         r = log_link_warning_errno(link, k, "Could not stop DHCPv6 client: %m");
 707         }
 708
 709         if (link->ndisc) {
 710                 k = sd_ndisc_stop(link->ndisc);
 711                 if (k < 0)
 712                         r = log_link_warning_errno(link, k, "Could not stop IPv6 Router Discovery: %m");
 713         }
 714
 715         if (link->radv) {
 716                 k = sd_radv_stop(link->radv);
 717                 if (k < 0)
 718                         r = log_link_warning_errno(link, k, "Could not stop IPv6 Router Advertisement: %m");
 719         }
 720
 721         link_lldp_emit_stop(link);
 722         return r;
 723 }
 724
 725 void link_enter_failed(Link *link) {
 726         assert(link);
 727
 728         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 729                 return;
 730
 731         log_link_warning(link, "Failed");
 732
 733         link_set_state(link, LINK_STATE_FAILED);
 734
 735         link_stop_clients(link, false);
 736
 737         link_dirty(link);
 738 }
 739
 740 static Address* link_find_dhcp_server_address(Link *link) {
 741         Address *address;
 742
 743         assert(link);
 744         assert(link->network);
 745
 746         /* The first statically configured address if there is any */
 747         LIST_FOREACH(addresses, address, link->network->static_addresses) {
 748
 749                 if (address->family != AF_INET)
 750                         continue;
 751
 752                 if (in_addr_is_null(address->family, &address->in_addr))
 753                         continue;
 754
 755                 return address;
 756         }
 757
 758         /* If that didn't work, find a suitable address we got from the pool */
 759         LIST_FOREACH(addresses, address, link->pool_addresses) {
 760                 if (address->family != AF_INET)
 761                         continue;
 762
 763                 return address;
 764         }
 765
 766         return NULL;
 767 }
 768
 769 static int link_join_netdevs_after_configured(Link *link) {
 770         NetDev *netdev;
 771         Iterator i;
 772         int r;
 773
 774         HASHMAP_FOREACH(netdev, link->network->stacked_netdevs, i) {
 775                 if (netdev->ifindex > 0)
 776                         /* Assume already enslaved. */
 777                         continue;
 778
 779                 if (netdev_get_create_type(netdev) != NETDEV_CREATE_AFTER_CONFIGURED)
 780                         continue;
 781
 782                 log_struct(LOG_DEBUG,
 783                            LOG_LINK_INTERFACE(link),
 784                            LOG_NETDEV_INTERFACE(netdev),
 785                            LOG_LINK_MESSAGE(link, "Enslaving by '%s'", netdev->ifname));
 786
 787                 r = netdev_join(netdev, link, NULL);
 788                 if (r < 0)
 789                         return log_struct_errno(LOG_WARNING, r,
 790                                                 LOG_LINK_INTERFACE(link),
 791                                                 LOG_NETDEV_INTERFACE(netdev),
 792                                                 LOG_LINK_MESSAGE(link, "Could not join netdev '%s': %m", netdev->ifname));
 793         }
 794
 795         return 0;
 796 }
 797
 798 static void link_enter_configured(Link *link) {
 799         assert(link);
 800         assert(link->network);
 801
 802         if (link->state != LINK_STATE_CONFIGURING)
 803                 return;
 804
 805         log_link_info(link, "Configured");
 806
 807         link_set_state(link, LINK_STATE_CONFIGURED);
 808
 809         (void) link_join_netdevs_after_configured(link);
 810
 811         link_dirty(link);
 812 }
 813
 814 static int link_request_set_routing_policy_rule(Link *link) {
 815         RoutingPolicyRule *rule, *rrule = NULL;
 816         int r;
 817
 818         assert(link);
 819         assert(link->network);
 820
 821         link_set_state(link, LINK_STATE_CONFIGURING);
 822         link->routing_policy_rules_configured = false;
 823
 824         LIST_FOREACH(rules, rule, link->network->rules) {
 825                 r = routing_policy_rule_get(link->manager, rule->family, &rule->from, rule->from_prefixlen, &rule->to,
 826                                             rule->to_prefixlen, rule->tos, rule->fwmark, rule->table, rule->iif, rule->oif,
 827                                             rule->protocol, &rule->sport, &rule->dport, &rrule);
 828                 if (r == 0) {
 829                         (void) routing_policy_rule_make_local(link->manager, rrule);
 830                         continue;
 831                 }
 832
 833                 r = routing_policy_rule_configure(rule, link, NULL, false);
 834                 if (r < 0) {
 835                         log_link_warning_errno(link, r, "Could not set routing policy rules: %m");
 836                         link_enter_failed(link);
 837                         return r;
 838                 }
 839
 840                 link->routing_policy_rule_messages++;
 841         }
 842
 843         routing_policy_rule_purge(link->manager, link);
 844         if (link->routing_policy_rule_messages == 0) {
 845                 link->routing_policy_rules_configured = true;
 846                 link_check_ready(link);
 847         } else
 848                 log_link_debug(link, "Setting routing policy rules");
 849
 850         return 0;
 851 }
 852
 853 static int route_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
 854         int r;
 855
 856         assert(link);
 857         assert(link->route_messages > 0);
 858         assert(IN_SET(link->state, LINK_STATE_CONFIGURING,
 859                       LINK_STATE_FAILED, LINK_STATE_LINGER));
 860
 861         link->route_messages--;
 862
 863         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 864                 return 1;
 865
 866         r = sd_netlink_message_get_errno(m);
 867         if (r < 0 && r != -EEXIST)
 868                 log_link_warning_errno(link, r, "Could not set route: %m");
 869
 870         if (link->route_messages == 0) {
 871                 log_link_debug(link, "Routes set");
 872                 link->static_routes_configured = true;
 873                 link_check_ready(link);
 874         }
 875
 876         return 1;
 877 }
 878
 879 int link_request_set_routes(Link *link) {
 880         enum {
 881                 PHASE_NON_GATEWAY, /* First phase: Routes without a gateway */
 882                 PHASE_GATEWAY,     /* Second phase: Routes with a gateway */
 883                 _PHASE_MAX
 884         } phase;
 885         Route *rt;
 886         int r;
 887
 888         assert(link);
 889         assert(link->network);
 890         assert(link->addresses_configured);
 891         assert(link->address_messages == 0);
 892         assert(link->state != _LINK_STATE_INVALID);
 893
 894         link_set_state(link, LINK_STATE_CONFIGURING);
 895         link->static_routes_configured = false;
 896
 897         r = link_request_set_routing_policy_rule(link);
 898         if (r < 0)
 899                 return r;
 900
 901         /* First add the routes that enable us to talk to gateways, then add in the others that need a gateway. */
 902         for (phase = 0; phase < _PHASE_MAX; phase++)
 903                 LIST_FOREACH(routes, rt, link->network->static_routes) {
 904
 905                         if (in_addr_is_null(rt->family, &rt->gw) != (phase == PHASE_NON_GATEWAY))
 906                                 continue;
 907
 908                         r = route_configure(rt, link, route_handler);
 909                         if (r < 0) {
 910                                 log_link_warning_errno(link, r, "Could not set routes: %m");
 911                                 link_enter_failed(link);
 912                                 return r;
 913                         }
 914
 915                         link->route_messages++;
 916                 }
 917
 918         if (link->route_messages == 0) {
 919                 link->static_routes_configured = true;
 920                 link_check_ready(link);
 921         } else
 922                 log_link_debug(link, "Setting routes");
 923
 924         return 0;
 925 }
 926
 927 void link_check_ready(Link *link) {
 928         Address *a;
 929         Iterator i;
 930
 931         assert(link);
 932
 933         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 934                 return;
 935
 936         if (!link->network)
 937                 return;
 938
 939         if (!link->addresses_configured)
 940                 return;
 941
 942         if (!link->neighbors_configured)
 943                 return;
 944
 945         SET_FOREACH(a, link->addresses, i)
 946                 if (!address_is_ready(a))
 947                         return;
 948
 949         if (!link->addresses_ready) {
 950                 link->addresses_ready = true;
 951                 link_request_set_routes(link);
 952                 return;
 953         }
 954
 955         if (!link->static_routes_configured)
 956                 return;
 957
 958         if (!link->routing_policy_rules_configured)
 959                 return;
 960
 961         if (link_ipv4ll_enabled(link, ADDRESS_FAMILY_IPV4) && !(link->ipv4ll_address && link->ipv4ll_route))
 962                 return;
 963
 964         if (link_ipv6ll_enabled(link) &&
 965             in_addr_is_null(AF_INET6, (const union in_addr_union*) &link->ipv6ll_address))
 966                 return;
 967
 968         if ((link_dhcp4_enabled(link) || link_dhcp6_enabled(link)) &&
 969             !link->dhcp4_configured &&
 970             !link->dhcp6_configured &&
 971             !(link_ipv4ll_enabled(link, ADDRESS_FAMILY_FALLBACK_IPV4) && link->ipv4ll_address && link->ipv4ll_route))
 972                 /* When DHCP is enabled, at least one protocol must provide an address, or
 973                  * an IPv4ll fallback address must be configured. */
 974                 return;
 975
 976         if (link_ipv6_accept_ra_enabled(link) && !link->ndisc_configured)
 977                 return;
 978
 979         if (link->state != LINK_STATE_CONFIGURED)
 980                 link_enter_configured(link);
 981
 982         return;
 983 }
 984
 985 static int link_request_set_neighbors(Link *link) {
 986         Neighbor *neighbor;
 987         int r;
 988
 989         assert(link);
 990         assert(link->network);
 991         assert(link->state != _LINK_STATE_INVALID);
 992
 993         link_set_state(link, LINK_STATE_CONFIGURING);
 994         link->neighbors_configured = false;
 995
 996         LIST_FOREACH(neighbors, neighbor, link->network->neighbors) {
 997                 r = neighbor_configure(neighbor, link, NULL);
 998                 if (r < 0) {
 999                         log_link_warning_errno(link, r, "Could not set neighbor: %m");
1000                         link_enter_failed(link);
1001                         return r;
1002                 }
1003         }
1004
1005         if (link->neighbor_messages == 0) {
1006                 link->neighbors_configured = true;
1007                 link_check_ready(link);
1008         } else
1009                 log_link_debug(link, "Setting neighbors");
1010
1011         return 0;
1012 }
1013
1014 static int address_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
1015         int r;
1016
1017         assert(rtnl);
1018         assert(m);
1019         assert(link);
1020         assert(link->ifname);
1021         assert(link->address_messages > 0);
1022         assert(IN_SET(link->state, LINK_STATE_CONFIGURING,
1023                LINK_STATE_FAILED, LINK_STATE_LINGER));
1024
1025         link->address_messages--;
1026
1027         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1028                 return 1;
1029
1030         r = sd_netlink_message_get_errno(m);
1031         if (r < 0 && r != -EEXIST)
1032                 log_link_warning_errno(link, r, "could not set address: %m");
1033         else if (r >= 0)
1034                 manager_rtnl_process_address(rtnl, m, link->manager);
1035
1036         if (link->address_messages == 0) {
1037                 log_link_debug(link, "Addresses set");
1038                 link->addresses_configured = true;
1039                 link_check_ready(link);
1040         }
1041
1042         return 1;
1043 }
1044
1045 static int link_push_uplink_dns_to_dhcp_server(Link *link, sd_dhcp_server *s) {
1046         _cleanup_free_ struct in_addr *addresses = NULL;
1047         size_t n_addresses = 0, n_allocated = 0;
1048         unsigned i;
1049
1050         log_debug("Copying DNS server information from %s", link->ifname);
1051
1052         if (!link->network)
1053                 return 0;
1054
1055         for (i = 0; i < link->network->n_dns; i++) {
1056                 struct in_addr ia;
1057
1058                 /* Only look for IPv4 addresses */
1059                 if (link->network->dns[i].family != AF_INET)
1060                         continue;
1061
1062                 ia = link->network->dns[i].address.in;
1063
1064                 /* Never propagate obviously borked data */
1065                 if (in4_addr_is_null(&ia) || in4_addr_is_localhost(&ia))
1066                         continue;
1067
1068                 if (!GREEDY_REALLOC(addresses, n_allocated, n_addresses + 1))
1069                         return log_oom();
1070
1071                 addresses[n_addresses++] = ia;
1072         }
1073
1074         if (link->network->dhcp_use_dns && link->dhcp_lease) {
1075                 const struct in_addr *da = NULL;
1076                 int j, n;
1077
1078                 n = sd_dhcp_lease_get_dns(link->dhcp_lease, &da);
1079                 if (n > 0) {
1080
1081                         if (!GREEDY_REALLOC(addresses, n_allocated, n_addresses + n))
1082                                 return log_oom();
1083
1084                         for (j = 0; j < n; j++)
1085                                 if (in4_addr_is_non_local(&da[j]))
1086                                         addresses[n_addresses++] = da[j];
1087                 }
1088         }
1089
1090         if (n_addresses <= 0)
1091                 return 0;
1092
1093         return sd_dhcp_server_set_dns(s, addresses, n_addresses);
1094 }
1095
1096 static int link_push_uplink_ntp_to_dhcp_server(Link *link, sd_dhcp_server *s) {
1097         _cleanup_free_ struct in_addr *addresses = NULL;
1098         size_t n_addresses = 0, n_allocated = 0;
1099         char **a;
1100
1101         if (!link->network)
1102                 return 0;
1103
1104         log_debug("Copying NTP server information from %s", link->ifname);
1105
1106         STRV_FOREACH(a, link->network->ntp) {
1107                 union in_addr_union ia;
1108
1109                 /* Only look for IPv4 addresses */
1110                 if (in_addr_from_string(AF_INET, *a, &ia) <= 0)
1111                         continue;
1112
1113                 /* Never propagate obviously borked data */
1114                 if (in4_addr_is_null(&ia.in) || in4_addr_is_localhost(&ia.in))
1115                         continue;
1116
1117                 if (!GREEDY_REALLOC(addresses, n_allocated, n_addresses + 1))
1118                         return log_oom();
1119
1120                 addresses[n_addresses++] = ia.in;
1121         }
1122
1123         if (link->network->dhcp_use_ntp && link->dhcp_lease) {
1124                 const struct in_addr *da = NULL;
1125                 int j, n;
1126
1127                 n = sd_dhcp_lease_get_ntp(link->dhcp_lease, &da);
1128                 if (n > 0) {
1129
1130                         if (!GREEDY_REALLOC(addresses, n_allocated, n_addresses + n))
1131                                 return log_oom();
1132
1133                         for (j = 0; j < n; j++)
1134                                 if (in4_addr_is_non_local(&da[j]))
1135                                         addresses[n_addresses++] = da[j];
1136                 }
1137         }
1138
1139         if (n_addresses <= 0)
1140                 return 0;
1141
1142         return sd_dhcp_server_set_ntp(s, addresses, n_addresses);
1143 }
1144
1145 static int link_set_bridge_fdb(Link *link) {
1146         FdbEntry *fdb_entry;
1147         int r;
1148
1149         LIST_FOREACH(static_fdb_entries, fdb_entry, link->network->static_fdb_entries) {
1150                 r = fdb_entry_configure(link, fdb_entry);
1151                 if (r < 0)
1152                         return log_link_error_errno(link, r, "Failed to add MAC entry to static MAC table: %m");
1153         }
1154
1155         return 0;
1156 }
1157
1158 static int link_request_set_addresses(Link *link) {
1159         AddressLabel *label;
1160         Address *ad;
1161         int r;
1162
1163         assert(link);
1164         assert(link->network);
1165         assert(link->state != _LINK_STATE_INVALID);
1166
1167         link_set_state(link, LINK_STATE_CONFIGURING);
1168
1169         /* Reset all *_configured flags we are configuring. */
1170         link->addresses_configured = false;
1171         link->addresses_ready = false;
1172         link->neighbors_configured = false;
1173         link->static_routes_configured = false;
1174         link->routing_policy_rules_configured = false;
1175
1176         r = link_set_bridge_fdb(link);
1177         if (r < 0)
1178                 return r;
1179
1180         r = link_request_set_neighbors(link);
1181         if (r < 0)
1182                 return r;
1183
1184         LIST_FOREACH(addresses, ad, link->network->static_addresses) {
1185                 bool update;
1186
1187                 update = address_get(link, ad->family, &ad->in_addr, ad->prefixlen, NULL) > 0;
1188
1189                 r = address_configure(ad, link, address_handler, update);
1190                 if (r < 0) {
1191                         log_link_warning_errno(link, r, "Could not set addresses: %m");
1192                         link_enter_failed(link);
1193                         return r;
1194                 }
1195
1196                 link->address_messages++;
1197         }
1198
1199         LIST_FOREACH(labels, label, link->network->address_labels) {
1200                 r = address_label_configure(label, link, NULL, false);
1201                 if (r < 0) {
1202                         log_link_warning_errno(link, r, "Could not set address label: %m");
1203                         link_enter_failed(link);
1204                         return r;
1205                 }
1206
1207                 link->address_label_messages++;
1208         }
1209
1210         /* now that we can figure out a default address for the dhcp server,
1211            start it */
1212         if (link_dhcp4_server_enabled(link) && (link->flags & IFF_UP)) {
1213                 Address *address;
1214                 Link *uplink = NULL;
1215                 bool acquired_uplink = false;
1216
1217                 address = link_find_dhcp_server_address(link);
1218                 if (!address) {
1219                         log_link_warning(link, "Failed to find suitable address for DHCPv4 server instance.");
1220                         link_enter_failed(link);
1221                         return 0;
1222                 }
1223
1224                 /* use the server address' subnet as the pool */
1225                 r = sd_dhcp_server_configure_pool(link->dhcp_server, &address->in_addr.in, address->prefixlen,
1226                                                   link->network->dhcp_server_pool_offset, link->network->dhcp_server_pool_size);
1227                 if (r < 0)
1228                         return r;
1229
1230                 /* TODO:
1231                 r = sd_dhcp_server_set_router(link->dhcp_server,
1232                                               &main_address->in_addr.in);
1233                 if (r < 0)
1234                         return r;
1235                 */
1236
1237                 if (link->network->dhcp_server_max_lease_time_usec > 0) {
1238                         r = sd_dhcp_server_set_max_lease_time(
1239                                         link->dhcp_server,
1240                                         DIV_ROUND_UP(link->network->dhcp_server_max_lease_time_usec, USEC_PER_SEC));
1241                         if (r < 0)
1242                                 return r;
1243                 }
1244
1245                 if (link->network->dhcp_server_default_lease_time_usec > 0) {
1246                         r = sd_dhcp_server_set_default_lease_time(
1247                                         link->dhcp_server,
1248                                         DIV_ROUND_UP(link->network->dhcp_server_default_lease_time_usec, USEC_PER_SEC));
1249                         if (r < 0)
1250                                 return r;
1251                 }
1252
1253                 if (link->network->dhcp_server_emit_dns) {
1254
1255                         if (link->network->n_dhcp_server_dns > 0)
1256                                 r = sd_dhcp_server_set_dns(link->dhcp_server, link->network->dhcp_server_dns, link->network->n_dhcp_server_dns);
1257                         else {
1258                                 uplink = manager_find_uplink(link->manager, link);
1259                                 acquired_uplink = true;
1260
1261                                 if (!uplink) {
1262                                         log_link_debug(link, "Not emitting DNS server information on link, couldn't find suitable uplink.");
1263                                         r = 0;
1264                                 } else
1265                                         r = link_push_uplink_dns_to_dhcp_server(uplink, link->dhcp_server);
1266                         }
1267                         if (r < 0)
1268                                 log_link_warning_errno(link, r, "Failed to set DNS server for DHCP server, ignoring: %m");
1269                 }
1270
1271                 if (link->network->dhcp_server_emit_ntp) {
1272
1273                         if (link->network->n_dhcp_server_ntp > 0)
1274                                 r = sd_dhcp_server_set_ntp(link->dhcp_server, link->network->dhcp_server_ntp, link->network->n_dhcp_server_ntp);
1275                         else {
1276                                 if (!acquired_uplink)
1277                                         uplink = manager_find_uplink(link->manager, link);
1278
1279                                 if (!uplink) {
1280                                         log_link_debug(link, "Not emitting NTP server information on link, couldn't find suitable uplink.");
1281                                         r = 0;
1282                                 } else
1283                                         r = link_push_uplink_ntp_to_dhcp_server(uplink, link->dhcp_server);
1284
1285                         }
1286                         if (r < 0)
1287                                 log_link_warning_errno(link, r, "Failed to set NTP server for DHCP server, ignoring: %m");
1288                 }
1289
1290                 r = sd_dhcp_server_set_emit_router(link->dhcp_server, link->network->dhcp_server_emit_router);
1291                 if (r < 0)
1292                         return log_link_warning_errno(link, r, "Failed to set router emission for DHCP server: %m");
1293
1294                 if (link->network->dhcp_server_emit_timezone) {
1295                         _cleanup_free_ char *buffer = NULL;
1296                         const char *tz = NULL;
1297
1298                         if (link->network->dhcp_server_timezone)
1299                                 tz = link->network->dhcp_server_timezone;
1300                         else {
1301                                 r = get_timezone(&buffer);
1302                                 if (r < 0)
1303                                         log_warning_errno(r, "Failed to determine timezone: %m");
1304                                 else
1305                                         tz = buffer;
1306                         }
1307
1308                         if (tz) {
1309                                 r = sd_dhcp_server_set_timezone(link->dhcp_server, tz);
1310                                 if (r < 0)
1311                                         return r;
1312                         }
1313                 }
1314                 if (!sd_dhcp_server_is_running(link->dhcp_server)) {
1315                         r = sd_dhcp_server_start(link->dhcp_server);
1316                         if (r < 0) {
1317                                 log_link_warning_errno(link, r, "Could not start DHCPv4 server instance: %m");
1318
1319                                 link_enter_failed(link);
1320
1321                                 return 0;
1322                         }
1323                 }
1324
1325                 log_link_debug(link, "Offering DHCPv4 leases");
1326         }
1327
1328         if (link->address_messages == 0) {
1329                 link->addresses_configured = true;
1330                 link_check_ready(link);
1331         } else
1332                 log_link_debug(link, "Setting addresses");
1333
1334         return 0;
1335 }
1336
1337 static int link_set_bridge_vlan(Link *link) {
1338         int r;
1339
1340         r = br_vlan_configure(link, link->network->pvid, link->network->br_vid_bitmap, link->network->br_untagged_bitmap);
1341         if (r < 0)
1342                 log_link_error_errno(link, r, "Failed to assign VLANs to bridge port: %m");
1343
1344         return r;
1345 }
1346
1347 static int link_set_proxy_arp(Link *link) {
1348         int r;
1349
1350         if (!link_proxy_arp_enabled(link))
1351                 return 0;
1352
1353         r = sysctl_write_ip_property_boolean(AF_INET, link->ifname, "proxy_arp", link->network->proxy_arp > 0);
1354         if (r < 0)
1355                 log_link_warning_errno(link, r, "Cannot configure proxy ARP for interface: %m");
1356
1357         return 0;
1358 }
1359
1360 static int link_configure_after_setting_mtu(Link *link);
1361
1362 static int set_mtu_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
1363         int r;
1364
1365         assert(m);
1366         assert(link);
1367         assert(link->ifname);
1368
1369         link->setting_mtu = false;
1370
1371         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1372                 return 1;
1373
1374         r = sd_netlink_message_get_errno(m);
1375         if (r < 0) {
1376                 log_link_warning_errno(link, r, "Could not set MTU: %m");
1377                 return 1;
1378         }
1379
1380         log_link_debug(link, "Setting MTU done.");
1381
1382         if (link->state == LINK_STATE_INITIALIZED)
1383                 (void) link_configure_after_setting_mtu(link);
1384
1385         return 1;
1386 }
1387
1388 int link_set_mtu(Link *link, uint32_t mtu) {
1389         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
1390         int r;
1391
1392         assert(link);
1393         assert(link->manager);
1394         assert(link->manager->rtnl);
1395
1396         if (mtu == 0 || link->setting_mtu)
1397                 return 0;
1398
1399         if (link->mtu == mtu)
1400                 return 0;
1401
1402         log_link_debug(link, "Setting MTU: %" PRIu32, mtu);
1403
1404         r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
1405         if (r < 0)
1406                 return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
1407
1408         /* If IPv6 not configured (no static IPv6 address and IPv6LL autoconfiguration is disabled)
1409          * for this interface, then disable IPv6 else enable it. */
1410         (void) link_enable_ipv6(link);
1411
1412         /* IPv6 protocol requires a minimum MTU of IPV6_MTU_MIN(1280) bytes
1413          * on the interface. Bump up MTU bytes to IPV6_MTU_MIN. */
1414         if (link_ipv6_enabled(link) && mtu < IPV6_MIN_MTU) {
1415
1416                 log_link_warning(link, "Bumping MTU to " STRINGIFY(IPV6_MIN_MTU) ", as "
1417                                  "IPv6 is requested and requires a minimum MTU of " STRINGIFY(IPV6_MIN_MTU) " bytes: %m");
1418
1419                 mtu = IPV6_MIN_MTU;
1420         }
1421
1422         r = sd_netlink_message_append_u32(req, IFLA_MTU, mtu);
1423         if (r < 0)
1424                 return log_link_error_errno(link, r, "Could not append MTU: %m");
1425
1426         r = netlink_call_async(link->manager->rtnl, NULL, req, set_mtu_handler,
1427                                link_netlink_destroy_callback, link);
1428         if (r < 0)
1429                 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
1430
1431         link_ref(link);
1432         link->setting_mtu = true;
1433
1434         return 0;
1435 }
1436
1437 static bool link_reduces_vlan_mtu(Link *link) {
1438         /* See netif_reduces_vlan_mtu() in kernel. */
1439         return streq_ptr(link->kind, "macsec");
1440 }
1441
1442 static uint32_t link_get_requested_mtu_by_stacked_netdevs(Link *link) {
1443         uint32_t mtu = 0;
1444         NetDev *dev;
1445         Iterator i;
1446
1447         HASHMAP_FOREACH(dev, link->network->stacked_netdevs, i)
1448                 if (dev->kind == NETDEV_KIND_VLAN && dev->mtu > 0)
1449                         /* See vlan_dev_change_mtu() in kernel. */
1450                         mtu = MAX(mtu, link_reduces_vlan_mtu(link) ? dev->mtu + 4 : dev->mtu);
1451
1452                 else if (dev->kind == NETDEV_KIND_MACVLAN && dev->mtu > mtu)
1453                         /* See macvlan_change_mtu() in kernel. */
1454                         mtu = dev->mtu;
1455
1456         return mtu;
1457 }
1458
1459 static int link_configure_mtu(Link *link) {
1460         uint32_t mtu;
1461
1462         assert(link);
1463         assert(link->network);
1464
1465         if (link->network->mtu > 0)
1466                 return link_set_mtu(link, link->network->mtu);
1467
1468         mtu = link_get_requested_mtu_by_stacked_netdevs(link);
1469         if (link->mtu >= mtu)
1470                 return 0;
1471
1472         log_link_notice(link, "Bumping MTU bytes from %"PRIu32" to %"PRIu32" because of stacked device. "
1473                         "If it is not desired, then please explicitly specify MTUBytes= setting.",
1474                         link->mtu, mtu);
1475
1476         return link_set_mtu(link, mtu);
1477 }
1478
1479 static int set_flags_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
1480         int r;
1481
1482         assert(m);
1483         assert(link);
1484         assert(link->ifname);
1485
1486         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1487                 return 1;
1488
1489         r = sd_netlink_message_get_errno(m);
1490         if (r < 0)
1491                 log_link_warning_errno(link, r, "Could not set link flags: %m");
1492
1493         return 1;
1494 }
1495
1496 static int link_set_flags(Link *link) {
1497         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
1498         unsigned ifi_change = 0;
1499         unsigned ifi_flags = 0;
1500         int r;
1501
1502         assert(link);
1503         assert(link->manager);
1504         assert(link->manager->rtnl);
1505
1506         if (link->flags & IFF_LOOPBACK)
1507                 return 0;
1508
1509         if (!link->network)
1510                 return 0;
1511
1512         if (link->network->arp < 0 && link->network->multicast < 0 && link->network->allmulticast < 0)
1513                 return 0;
1514
1515         r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
1516         if (r < 0)
1517                 return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
1518
1519         if (link->network->arp >= 0) {
1520                 ifi_change |= IFF_NOARP;
1521                 SET_FLAG(ifi_flags, IFF_NOARP, link->network->arp == 0);
1522         }
1523
1524         if (link->network->multicast >= 0) {
1525                 ifi_change |= IFF_MULTICAST;
1526                 SET_FLAG(ifi_flags, IFF_MULTICAST, link->network->multicast);
1527         }
1528
1529         if (link->network->allmulticast >= 0) {
1530                 ifi_change |= IFF_ALLMULTI;
1531                 SET_FLAG(ifi_flags, IFF_ALLMULTI, link->network->allmulticast);
1532         }
1533
1534         r = sd_rtnl_message_link_set_flags(req, ifi_flags, ifi_change);
1535         if (r < 0)
1536                 return log_link_error_errno(link, r, "Could not set link flags: %m");
1537
1538         r = netlink_call_async(link->manager->rtnl, NULL, req, set_flags_handler,
1539                                link_netlink_destroy_callback, link);
1540         if (r < 0)
1541                 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
1542
1543         link_ref(link);
1544
1545         return 0;
1546 }
1547
1548 static int link_acquire_ipv6_conf(Link *link) {
1549         int r;
1550
1551         assert(link);
1552
1553         if (link_ipv6_accept_ra_enabled(link)) {
1554                 assert(link->ndisc);
1555
1556                 log_link_debug(link, "Discovering IPv6 routers");
1557
1558                 r = sd_ndisc_start(link->ndisc);
1559                 if (r < 0 && r != -EBUSY)
1560                         return log_link_warning_errno(link, r, "Could not start IPv6 Router Discovery: %m");
1561         }
1562
1563         if (link_radv_enabled(link)) {
1564                 assert(link->radv);
1565                 assert(in_addr_is_link_local(AF_INET6, (const union in_addr_union*)&link->ipv6ll_address) > 0);
1566
1567                 log_link_debug(link, "Starting IPv6 Router Advertisements");
1568
1569                 r = sd_radv_start(link->radv);
1570                 if (r < 0 && r != -EBUSY)
1571                         return log_link_warning_errno(link, r, "Could not start IPv6 Router Advertisement: %m");
1572         }
1573
1574         (void) dhcp6_request_prefix_delegation(link);
1575
1576         return 0;
1577 }
1578
1579 static int link_acquire_ipv4_conf(Link *link) {
1580         int r;
1581
1582         assert(link);
1583         assert(link->manager);
1584         assert(link->manager->event);
1585
1586         if (link_ipv4ll_enabled(link, ADDRESS_FAMILY_IPV4)) {
1587                 assert(link->ipv4ll);
1588
1589                 log_link_debug(link, "Acquiring IPv4 link-local address");
1590
1591                 r = sd_ipv4ll_start(link->ipv4ll);
1592                 if (r < 0)
1593                         return log_link_warning_errno(link, r, "Could not acquire IPv4 link-local address: %m");
1594         }
1595
1596         if (link_dhcp4_enabled(link)) {
1597                 assert(link->dhcp_client);
1598
1599                 log_link_debug(link, "Acquiring DHCPv4 lease");
1600
1601                 r = sd_dhcp_client_start(link->dhcp_client);
1602                 if (r < 0)
1603                         return log_link_warning_errno(link, r, "Could not acquire DHCPv4 lease: %m");
1604         }
1605
1606         return 0;
1607 }
1608
1609 static int link_acquire_conf(Link *link) {
1610         int r;
1611
1612         assert(link);
1613
1614         r = link_acquire_ipv4_conf(link);
1615         if (r < 0)
1616                 return r;
1617
1618         if (!in_addr_is_null(AF_INET6, (const union in_addr_union*) &link->ipv6ll_address)) {
1619                 r = link_acquire_ipv6_conf(link);
1620                 if (r < 0)
1621                         return r;
1622         }
1623
1624         if (link_lldp_emit_enabled(link)) {
1625                 r = link_lldp_emit_start(link);
1626                 if (r < 0)
1627                         return log_link_warning_errno(link, r, "Failed to start LLDP transmission: %m");
1628         }
1629
1630         return 0;
1631 }
1632
1633 bool link_has_carrier(Link *link) {
1634         /* see Documentation/networking/operstates.txt in the kernel sources */
1635
1636         if (link->kernel_operstate == IF_OPER_UP)
1637                 return true;
1638
1639         if (link->kernel_operstate == IF_OPER_UNKNOWN)
1640                 /* operstate may not be implemented, so fall back to flags */
1641                 if (FLAGS_SET(link->flags, IFF_LOWER_UP | IFF_RUNNING) &&
1642                     !FLAGS_SET(link->flags, IFF_DORMANT))
1643                         return true;
1644
1645         return false;
1646 }
1647
1648 static int link_address_genmode_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
1649         int r;
1650
1651         assert(link);
1652
1653         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1654                 return 1;
1655
1656         r = sd_netlink_message_get_errno(m);
1657         if (r < 0)
1658                 log_link_warning_errno(link, r, "Could not set address genmode for interface: %m");
1659
1660         return 1;
1661 }
1662
1663 static int link_configure_addrgen_mode(Link *link) {
1664         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
1665         uint8_t ipv6ll_mode;
1666         int r;
1667
1668         assert(link);
1669         assert(link->network);
1670         assert(link->manager);
1671         assert(link->manager->rtnl);
1672
1673         if (!socket_ipv6_is_supported())
1674                 return 0;
1675
1676         log_link_debug(link, "Setting address genmode for link");
1677
1678         r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
1679         if (r < 0)
1680                 return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
1681
1682         r = sd_netlink_message_open_container(req, IFLA_AF_SPEC);
1683         if (r < 0)
1684                 return log_link_error_errno(link, r, "Could not open IFLA_AF_SPEC container: %m");
1685
1686         r = sd_netlink_message_open_container(req, AF_INET6);
1687         if (r < 0)
1688                 return log_link_error_errno(link, r, "Could not open AF_INET6 container: %m");
1689
1690         if (!link_ipv6ll_enabled(link))
1691                 ipv6ll_mode = IN6_ADDR_GEN_MODE_NONE;
1692         else if (sysctl_read_ip_property(AF_INET6, link->ifname, "stable_secret", NULL) < 0)
1693                 /* The file may not exist. And event if it exists, when stable_secret is unset,
1694                  * reading the file fails with EIO. */
1695                 ipv6ll_mode = IN6_ADDR_GEN_MODE_EUI64;
1696         else
1697                 ipv6ll_mode = IN6_ADDR_GEN_MODE_STABLE_PRIVACY;
1698
1699         r = sd_netlink_message_append_u8(req, IFLA_INET6_ADDR_GEN_MODE, ipv6ll_mode);
1700         if (r < 0)
1701                 return log_link_error_errno(link, r, "Could not append IFLA_INET6_ADDR_GEN_MODE: %m");
1702
1703         r = sd_netlink_message_close_container(req);
1704         if (r < 0)
1705                 return log_link_error_errno(link, r, "Could not close AF_INET6 container: %m");
1706
1707         r = sd_netlink_message_close_container(req);
1708         if (r < 0)
1709                 return log_link_error_errno(link, r, "Could not close IFLA_AF_SPEC container: %m");
1710
1711         r = netlink_call_async(link->manager->rtnl, NULL, req, link_address_genmode_handler,
1712                                link_netlink_destroy_callback, link);
1713         if (r < 0)
1714                 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
1715
1716         link_ref(link);
1717
1718         return 0;
1719 }
1720
1721 static int link_up_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
1722         int r;
1723
1724         assert(link);
1725
1726         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1727                 return 1;
1728
1729         r = sd_netlink_message_get_errno(m);
1730         if (r < 0)
1731                 /* we warn but don't fail the link, as it may be brought up later */
1732                 log_link_warning_errno(link, r, "Could not bring up interface: %m");
1733
1734         return 1;
1735 }
1736
1737 static int link_up(Link *link) {
1738         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
1739         int r;
1740
1741         assert(link);
1742         assert(link->network);
1743         assert(link->manager);
1744         assert(link->manager->rtnl);
1745
1746         log_link_debug(link, "Bringing link up");
1747
1748         r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
1749         if (r < 0)
1750                 return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
1751
1752         /* set it free if not enslaved with networkd */
1753         if (!link->network->bridge && !link->network->bond && !link->network->vrf) {
1754                 r = sd_netlink_message_append_u32(req, IFLA_MASTER, 0);
1755                 if (r < 0)
1756                         return log_link_error_errno(link, r, "Could not append IFLA_MASTER attribute: %m");
1757         }
1758
1759         r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1760         if (r < 0)
1761                 return log_link_error_errno(link, r, "Could not set link flags: %m");
1762
1763         if (link->network->mac) {
1764                 r = sd_netlink_message_append_ether_addr(req, IFLA_ADDRESS, link->network->mac);
1765                 if (r < 0)
1766                         return log_link_error_errno(link, r, "Could not set MAC address: %m");
1767         }
1768
1769         r = netlink_call_async(link->manager->rtnl, NULL, req, link_up_handler,
1770                                link_netlink_destroy_callback, link);
1771         if (r < 0)
1772                 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
1773
1774         link_ref(link);
1775
1776         return 0;
1777 }
1778
1779 static int link_down_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
1780         int r;
1781
1782         assert(link);
1783
1784         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1785                 return 1;
1786
1787         r = sd_netlink_message_get_errno(m);
1788         if (r < 0)
1789                 log_link_warning_errno(link, r, "Could not bring down interface: %m");
1790
1791         return 1;
1792 }
1793
1794 int link_down(Link *link, link_netlink_message_handler_t callback) {
1795         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
1796         int r;
1797
1798         assert(link);
1799         assert(link->manager);
1800         assert(link->manager->rtnl);
1801
1802         log_link_debug(link, "Bringing link down");
1803
1804         r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1805                                      RTM_SETLINK, link->ifindex);
1806         if (r < 0)
1807                 return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
1808
1809         r = sd_rtnl_message_link_set_flags(req, 0, IFF_UP);
1810         if (r < 0)
1811                 return log_link_error_errno(link, r, "Could not set link flags: %m");
1812
1813         r = netlink_call_async(link->manager->rtnl, NULL, req,
1814                                callback ?: link_down_handler,
1815                                link_netlink_destroy_callback, link);
1816         if (r < 0)
1817                 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
1818
1819         link_ref(link);
1820
1821         return 0;
1822 }
1823
1824 static int link_handle_bound_to_list(Link *link) {
1825         Link *l;
1826         Iterator i;
1827         int r;
1828         bool required_up = false;
1829         bool link_is_up = false;
1830
1831         assert(link);
1832
1833         if (hashmap_isempty(link->bound_to_links))
1834                 return 0;
1835
1836         if (link->flags & IFF_UP)
1837                 link_is_up = true;
1838
1839         HASHMAP_FOREACH (l, link->bound_to_links, i)
1840                 if (link_has_carrier(l)) {
1841                         required_up = true;
1842                         break;
1843                 }
1844
1845         if (!required_up && link_is_up) {
1846                 r = link_down(link, NULL);
1847                 if (r < 0)
1848                         return r;
1849         } else if (required_up && !link_is_up) {
1850                 r = link_up(link);
1851                 if (r < 0)
1852                         return r;
1853         }
1854
1855         return 0;
1856 }
1857
1858 static int link_handle_bound_by_list(Link *link) {
1859         Iterator i;
1860         Link *l;
1861         int r;
1862
1863         assert(link);
1864
1865         if (hashmap_isempty(link->bound_by_links))
1866                 return 0;
1867
1868         HASHMAP_FOREACH (l, link->bound_by_links, i) {
1869                 r = link_handle_bound_to_list(l);
1870                 if (r < 0)
1871                         return r;
1872         }
1873
1874         return 0;
1875 }
1876
1877 static int link_put_carrier(Link *link, Link *carrier, Hashmap **h) {
1878         int r;
1879
1880         assert(link);
1881         assert(carrier);
1882
1883         if (link == carrier)
1884                 return 0;
1885
1886         if (hashmap_get(*h, INT_TO_PTR(carrier->ifindex)))
1887                 return 0;
1888
1889         r = hashmap_ensure_allocated(h, NULL);
1890         if (r < 0)
1891                 return r;
1892
1893         r = hashmap_put(*h, INT_TO_PTR(carrier->ifindex), carrier);
1894         if (r < 0)
1895                 return r;
1896
1897         return 0;
1898 }
1899
1900 static int link_new_bound_by_list(Link *link) {
1901         Manager *m;
1902         Link *carrier;
1903         Iterator i;
1904         int r;
1905         bool list_updated = false;
1906
1907         assert(link);
1908         assert(link->manager);
1909
1910         m = link->manager;
1911
1912         HASHMAP_FOREACH(carrier, m->links, i) {
1913                 if (!carrier->network)
1914                         continue;
1915
1916                 if (strv_isempty(carrier->network->bind_carrier))
1917                         continue;
1918
1919                 if (strv_fnmatch(carrier->network->bind_carrier, link->ifname, 0)) {
1920                         r = link_put_carrier(link, carrier, &link->bound_by_links);
1921                         if (r < 0)
1922                                 return r;
1923
1924                         list_updated = true;
1925                 }
1926         }
1927
1928         if (list_updated)
1929                 link_dirty(link);
1930
1931         HASHMAP_FOREACH(carrier, link->bound_by_links, i) {
1932                 r = link_put_carrier(carrier, link, &carrier->bound_to_links);
1933                 if (r < 0)
1934                         return r;
1935
1936                 link_dirty(carrier);
1937         }
1938
1939         return 0;
1940 }
1941
1942 static int link_new_bound_to_list(Link *link) {
1943         Manager *m;
1944         Link *carrier;
1945         Iterator i;
1946         int r;
1947         bool list_updated = false;
1948
1949         assert(link);
1950         assert(link->manager);
1951
1952         if (!link->network)
1953                 return 0;
1954
1955         if (strv_isempty(link->network->bind_carrier))
1956                 return 0;
1957
1958         m = link->manager;
1959
1960         HASHMAP_FOREACH (carrier, m->links, i) {
1961                 if (strv_fnmatch(link->network->bind_carrier, carrier->ifname, 0)) {
1962                         r = link_put_carrier(link, carrier, &link->bound_to_links);
1963                         if (r < 0)
1964                                 return r;
1965
1966                         list_updated = true;
1967                 }
1968         }
1969
1970         if (list_updated)
1971                 link_dirty(link);
1972
1973         HASHMAP_FOREACH (carrier, link->bound_to_links, i) {
1974                 r = link_put_carrier(carrier, link, &carrier->bound_by_links);
1975                 if (r < 0)
1976                         return r;
1977
1978                 link_dirty(carrier);
1979         }
1980
1981         return 0;
1982 }
1983
1984 static int link_new_carrier_maps(Link *link) {
1985         int r;
1986
1987         r = link_new_bound_by_list(link);
1988         if (r < 0)
1989                 return r;
1990
1991         r = link_handle_bound_by_list(link);
1992         if (r < 0)
1993                 return r;
1994
1995         r = link_new_bound_to_list(link);
1996         if (r < 0)
1997                 return r;
1998
1999         r = link_handle_bound_to_list(link);
2000         if (r < 0)
2001                 return r;
2002
2003         return 0;
2004 }
2005
2006 static void link_free_bound_to_list(Link *link) {
2007         Link *bound_to;
2008         Iterator i;
2009
2010         HASHMAP_FOREACH (bound_to, link->bound_to_links, i) {
2011                 hashmap_remove(link->bound_to_links, INT_TO_PTR(bound_to->ifindex));
2012
2013                 if (hashmap_remove(bound_to->bound_by_links, INT_TO_PTR(link->ifindex)))
2014                         link_dirty(bound_to);
2015         }
2016
2017         return;
2018 }
2019
2020 static void link_free_bound_by_list(Link *link) {
2021         Link *bound_by;
2022         Iterator i;
2023
2024         HASHMAP_FOREACH (bound_by, link->bound_by_links, i) {
2025                 hashmap_remove(link->bound_by_links, INT_TO_PTR(bound_by->ifindex));
2026
2027                 if (hashmap_remove(bound_by->bound_to_links, INT_TO_PTR(link->ifindex))) {
2028                         link_dirty(bound_by);
2029                         link_handle_bound_to_list(bound_by);
2030                 }
2031         }
2032
2033         return;
2034 }
2035
2036 static void link_free_carrier_maps(Link *link) {
2037         bool list_updated = false;
2038
2039         assert(link);
2040
2041         if (!hashmap_isempty(link->bound_to_links)) {
2042                 link_free_bound_to_list(link);
2043                 list_updated = true;
2044         }
2045
2046         if (!hashmap_isempty(link->bound_by_links)) {
2047                 link_free_bound_by_list(link);
2048                 list_updated = true;
2049         }
2050
2051         if (list_updated)
2052                 link_dirty(link);
2053
2054         return;
2055 }
2056
2057 static int link_append_to_master(Link *link, NetDev *netdev) {
2058         Link *master;
2059         int r;
2060
2061         assert(link);
2062         assert(netdev);
2063
2064         r = link_get(link->manager, netdev->ifindex, &master);
2065         if (r < 0)
2066                 return r;
2067
2068         r = set_ensure_allocated(&master->slaves, NULL);
2069         if (r < 0)
2070                 return r;
2071
2072         r = set_put(master->slaves, link);
2073         if (r < 0)
2074                 return r;
2075
2076         link_ref(link);
2077         return 0;
2078 }
2079
2080 static void link_drop_from_master(Link *link, NetDev *netdev) {
2081         Link *master;
2082
2083         assert(link);
2084
2085         if (!link->manager || !netdev)
2086                 return;
2087
2088         if (link_get(link->manager, netdev->ifindex, &master) < 0)
2089                 return;
2090
2091         link_unref(set_remove(master->slaves, link));
2092 }
2093
2094 static void link_detach_from_manager(Link *link) {
2095         if (!link || !link->manager)
2096                 return;
2097
2098         link_unref(set_remove(link->manager->links_requesting_uuid, link));
2099         link_clean(link);
2100
2101         /* The following must be called at last. */
2102         assert_se(hashmap_remove(link->manager->links, INT_TO_PTR(link->ifindex)) == link);
2103         link_unref(link);
2104 }
2105
2106 void link_drop(Link *link) {
2107         if (!link || link->state == LINK_STATE_LINGER)
2108                 return;
2109
2110         link_set_state(link, LINK_STATE_LINGER);
2111
2112         link_free_carrier_maps(link);
2113
2114         if (link->network) {
2115                 link_drop_from_master(link, link->network->bridge);
2116                 link_drop_from_master(link, link->network->bond);
2117         }
2118
2119         log_link_debug(link, "Link removed");
2120
2121         (void) unlink(link->state_file);
2122         link_detach_from_manager(link);
2123 }
2124
2125 static int link_joined(Link *link) {
2126         int r;
2127
2128         assert(link);
2129         assert(link->network);
2130
2131         if (!hashmap_isempty(link->bound_to_links)) {
2132                 r = link_handle_bound_to_list(link);
2133                 if (r < 0)
2134                         return r;
2135         } else if (!(link->flags & IFF_UP)) {
2136                 r = link_up(link);
2137                 if (r < 0) {
2138                         link_enter_failed(link);
2139                         return r;
2140                 }
2141         }
2142
2143         if (link->network->bridge) {
2144                 r = link_set_bridge(link);
2145                 if (r < 0)
2146                         log_link_error_errno(link, r, "Could not set bridge message: %m");
2147
2148                 r = link_append_to_master(link, link->network->bridge);
2149                 if (r < 0)
2150                         log_link_error_errno(link, r, "Failed to add to bridge master's slave list: %m");
2151         }
2152
2153         if (link->network->bond) {
2154                 r = link_set_bond(link);
2155                 if (r < 0)
2156                         log_link_error_errno(link, r, "Could not set bond message: %m");
2157
2158                 r = link_append_to_master(link, link->network->bond);
2159                 if (r < 0)
2160                         log_link_error_errno(link, r, "Failed to add to bond master's slave list: %m");
2161         }
2162
2163         if (link->network->use_br_vlan &&
2164             (link->network->bridge || streq_ptr("bridge", link->kind))) {
2165                 r = link_set_bridge_vlan(link);
2166                 if (r < 0)
2167                         log_link_error_errno(link, r, "Could not set bridge vlan: %m");
2168         }
2169
2170         /* Skip setting up addresses until it gets carrier,
2171            or it would try to set addresses twice,
2172            which is bad for non-idempotent steps. */
2173         if (!link_has_carrier(link) && !link->network->configure_without_carrier)
2174                 return 0;
2175
2176         return link_request_set_addresses(link);
2177 }
2178
2179 static int netdev_join_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
2180         int r;
2181
2182         assert(link);
2183         assert(link->network);
2184         assert(link->enslaving > 0);
2185
2186         link->enslaving--;
2187
2188         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
2189                 return 1;
2190
2191         r = sd_netlink_message_get_errno(m);
2192         if (r < 0 && r != -EEXIST) {
2193                 log_link_error_errno(link, r, "Could not join netdev: %m");
2194                 link_enter_failed(link);
2195                 return 1;
2196         } else
2197                 log_link_debug(link, "Joined netdev");
2198
2199         if (link->enslaving == 0) {
2200                 link_joined(link);
2201         }
2202
2203         return 1;
2204 }
2205
2206 static int link_enter_join_netdev(Link *link) {
2207         NetDev *netdev;
2208         Iterator i;
2209         int r;
2210
2211         assert(link);
2212         assert(link->network);
2213         assert(link->state == LINK_STATE_INITIALIZED);
2214
2215         link_set_state(link, LINK_STATE_CONFIGURING);
2216
2217         link_dirty(link);
2218         link->enslaving = 0;
2219
2220         if (link->network->bond) {
2221                 if (link->network->bond->state == NETDEV_STATE_READY &&
2222                     link->network->bond->ifindex == link->master_ifindex)
2223                         return link_joined(link);
2224
2225                 log_struct(LOG_DEBUG,
2226                            LOG_LINK_INTERFACE(link),
2227                            LOG_NETDEV_INTERFACE(link->network->bond),
2228                            LOG_LINK_MESSAGE(link, "Enslaving by '%s'", link->network->bond->ifname));
2229
2230                 link->enslaving++;
2231
2232                 r = netdev_join(link->network->bond, link, netdev_join_handler);
2233                 if (r < 0) {
2234                         log_struct_errno(LOG_WARNING, r,
2235                                          LOG_LINK_INTERFACE(link),
2236                                          LOG_NETDEV_INTERFACE(link->network->bond),
2237                                          LOG_LINK_MESSAGE(link, "Could not join netdev '%s': %m", link->network->bond->ifname));
2238                         link_enter_failed(link);
2239                         return r;
2240                 }
2241         }
2242
2243         if (link->network->bridge) {
2244                 log_struct(LOG_DEBUG,
2245                            LOG_LINK_INTERFACE(link),
2246                            LOG_NETDEV_INTERFACE(link->network->bridge),
2247                            LOG_LINK_MESSAGE(link, "Enslaving by '%s'", link->network->bridge->ifname));
2248
2249                 link->enslaving++;
2250
2251                 r = netdev_join(link->network->bridge, link, netdev_join_handler);
2252                 if (r < 0) {
2253                         log_struct_errno(LOG_WARNING, r,
2254                                          LOG_LINK_INTERFACE(link),
2255                                          LOG_NETDEV_INTERFACE(link->network->bridge),
2256                                          LOG_LINK_MESSAGE(link, "Could not join netdev '%s': %m", link->network->bridge->ifname));
2257                         link_enter_failed(link);
2258                         return r;
2259                 }
2260         }
2261
2262         if (link->network->vrf) {
2263                 log_struct(LOG_DEBUG,
2264                            LOG_LINK_INTERFACE(link),
2265                            LOG_NETDEV_INTERFACE(link->network->vrf),
2266                            LOG_LINK_MESSAGE(link, "Enslaving by '%s'", link->network->vrf->ifname));
2267
2268                 link->enslaving++;
2269
2270                 r = netdev_join(link->network->vrf, link, netdev_join_handler);
2271                 if (r < 0) {
2272                         log_struct_errno(LOG_WARNING, r,
2273                                          LOG_LINK_INTERFACE(link),
2274                                          LOG_NETDEV_INTERFACE(link->network->vrf),
2275                                          LOG_LINK_MESSAGE(link, "Could not join netdev '%s': %m", link->network->vrf->ifname));
2276                         link_enter_failed(link);
2277                         return r;
2278                 }
2279         }
2280
2281         HASHMAP_FOREACH(netdev, link->network->stacked_netdevs, i) {
2282
2283                 if (netdev->ifindex > 0)
2284                         /* Assume already enslaved. */
2285                         continue;
2286
2287                 if (netdev_get_create_type(netdev) != NETDEV_CREATE_STACKED)
2288                         continue;
2289
2290                 log_struct(LOG_DEBUG,
2291                            LOG_LINK_INTERFACE(link),
2292                            LOG_NETDEV_INTERFACE(netdev),
2293                            LOG_LINK_MESSAGE(link, "Enslaving by '%s'", netdev->ifname));
2294
2295                 link->enslaving++;
2296
2297                 r = netdev_join(netdev, link, netdev_join_handler);
2298                 if (r < 0) {
2299                         log_struct_errno(LOG_WARNING, r,
2300                                          LOG_LINK_INTERFACE(link),
2301                                          LOG_NETDEV_INTERFACE(netdev),
2302                                          LOG_LINK_MESSAGE(link, "Could not join netdev '%s': %m", netdev->ifname));
2303                         link_enter_failed(link);
2304                         return r;
2305                 }
2306         }
2307
2308         if (link->enslaving == 0)
2309                 return link_joined(link);
2310
2311         return 0;
2312 }
2313
2314 static int link_set_ipv4_forward(Link *link) {
2315         int r;
2316
2317         if (!link_ipv4_forward_enabled(link))
2318                 return 0;
2319
2320         /* We propagate the forwarding flag from one interface to the
2321          * global setting one way. This means: as long as at least one
2322          * interface was configured at any time that had IP forwarding
2323          * enabled the setting will stay on for good. We do this
2324          * primarily to keep IPv4 and IPv6 packet forwarding behaviour
2325          * somewhat in sync (see below). */
2326
2327         r = sysctl_write_ip_property(AF_INET, NULL, "ip_forward", "1");
2328         if (r < 0)
2329                 log_link_warning_errno(link, r, "Cannot turn on IPv4 packet forwarding, ignoring: %m");
2330
2331         return 0;
2332 }
2333
2334 static int link_set_ipv6_forward(Link *link) {
2335         int r;
2336
2337         if (!link_ipv6_forward_enabled(link))
2338                 return 0;
2339
2340         /* On Linux, the IPv6 stack does not know a per-interface
2341          * packet forwarding setting: either packet forwarding is on
2342          * for all, or off for all. We hence don't bother with a
2343          * per-interface setting, but simply propagate the interface
2344          * flag, if it is set, to the global flag, one-way. Note that
2345          * while IPv4 would allow a per-interface flag, we expose the
2346          * same behaviour there and also propagate the setting from
2347          * one to all, to keep things simple (see above). */
2348
2349         r = sysctl_write_ip_property(AF_INET6, "all", "forwarding", "1");
2350         if (r < 0)
2351                 log_link_warning_errno(link, r, "Cannot configure IPv6 packet forwarding, ignoring: %m");
2352
2353         return 0;
2354 }
2355
2356 static int link_set_ipv6_privacy_extensions(Link *link) {
2357         IPv6PrivacyExtensions s;
2358         int r;
2359
2360         s = link_ipv6_privacy_extensions(link);
2361         if (s < 0)
2362                 return 0;
2363
2364         r = sysctl_write_ip_property_int(AF_INET6, link->ifname, "use_tempaddr", (int) link->network->ipv6_privacy_extensions);
2365         if (r < 0)
2366                 log_link_warning_errno(link, r, "Cannot configure IPv6 privacy extension for interface: %m");
2367
2368         return 0;
2369 }
2370
2371 static int link_set_ipv6_accept_ra(Link *link) {
2372         int r;
2373
2374         /* Make this a NOP if IPv6 is not available */
2375         if (!socket_ipv6_is_supported())
2376                 return 0;
2377
2378         if (link->flags & IFF_LOOPBACK)
2379                 return 0;
2380
2381         if (!link->network)
2382                 return 0;
2383
2384         r = sysctl_write_ip_property(AF_INET6, link->ifname, "accept_ra", "0");
2385         if (r < 0)
2386                 log_link_warning_errno(link, r, "Cannot disable kernel IPv6 accept_ra for interface: %m");
2387
2388         return 0;
2389 }
2390
2391 static int link_set_ipv6_dad_transmits(Link *link) {
2392         int r;
2393
2394         /* Make this a NOP if IPv6 is not available */
2395         if (!socket_ipv6_is_supported())
2396                 return 0;
2397
2398         if (link->flags & IFF_LOOPBACK)
2399                 return 0;
2400
2401         if (!link->network)
2402                 return 0;
2403
2404         if (link->network->ipv6_dad_transmits < 0)
2405                 return 0;
2406
2407         r = sysctl_write_ip_property_int(AF_INET6, link->ifname, "dad_transmits", link->network->ipv6_dad_transmits);
2408         if (r < 0)
2409                 log_link_warning_errno(link, r, "Cannot set IPv6 dad transmits for interface: %m");
2410
2411         return 0;
2412 }
2413
2414 static int link_set_ipv6_hop_limit(Link *link) {
2415         int r;
2416
2417         /* Make this a NOP if IPv6 is not available */
2418         if (!socket_ipv6_is_supported())
2419                 return 0;
2420
2421         if (link->flags & IFF_LOOPBACK)
2422                 return 0;
2423
2424         if (!link->network)
2425                 return 0;
2426
2427         if (link->network->ipv6_hop_limit < 0)
2428                 return 0;
2429
2430         r = sysctl_write_ip_property_int(AF_INET6, link->ifname, "hop_limit", link->network->ipv6_hop_limit);
2431         if (r < 0)
2432                 log_link_warning_errno(link, r, "Cannot set IPv6 hop limit for interface: %m");
2433
2434         return 0;
2435 }
2436
2437 static int link_set_ipv6_mtu(Link *link) {
2438         int r;
2439
2440         /* Make this a NOP if IPv6 is not available */
2441         if (!socket_ipv6_is_supported())
2442                 return 0;
2443
2444         if (link->flags & IFF_LOOPBACK)
2445                 return 0;
2446
2447         if (link->network->ipv6_mtu == 0)
2448                 return 0;
2449
2450         r = sysctl_write_ip_property_uint32(AF_INET6, link->ifname, "mtu", link->network->ipv6_mtu);
2451         if (r < 0)
2452                 log_link_warning_errno(link, r, "Cannot set IPv6 MTU for interface: %m");
2453
2454         return 0;
2455 }
2456
2457 static bool link_is_static_address_configured(Link *link, Address *address) {
2458         Address *net_address;
2459
2460         assert(link);
2461         assert(address);
2462
2463         if (!link->network)
2464                 return false;
2465
2466         LIST_FOREACH(addresses, net_address, link->network->static_addresses)
2467                 if (address_equal(net_address, address))
2468                         return true;
2469
2470         return false;
2471 }
2472
2473 static bool link_is_static_route_configured(Link *link, Route *route) {
2474         Route *net_route;
2475
2476         assert(link);
2477         assert(route);
2478
2479         if (!link->network)
2480                 return false;
2481
2482         LIST_FOREACH(routes, net_route, link->network->static_routes)
2483                 if (route_equal(net_route, route))
2484                         return true;
2485
2486         return false;
2487 }
2488
2489 static bool link_address_is_dynamic(Link *link, Address *address) {
2490         Route *route;
2491         Iterator i;
2492
2493         assert(link);
2494         assert(address);
2495
2496         if (address->cinfo.ifa_prefered != CACHE_INFO_INFINITY_LIFE_TIME)
2497                 return true;
2498
2499         /* Even when the address is leased from a DHCP server, networkd assign the address
2500          * without lifetime when KeepConfiguration=dhcp. So, let's check that we have
2501          * corresponding routes with RTPROT_DHCP. */
2502         SET_FOREACH(route, link->routes_foreign, i) {
2503                 if (route->protocol != RTPROT_DHCP)
2504                         continue;
2505
2506                 if (address->family != route->family)
2507                         continue;
2508
2509                 if (in_addr_equal(address->family, &address->in_addr, &route->prefsrc))
2510                         return true;
2511         }
2512
2513         return false;
2514 }
2515
2516 static int link_drop_foreign_config(Link *link) {
2517         Address *address;
2518         Route *route;
2519         Iterator i;
2520         int r;
2521
2522         SET_FOREACH(address, link->addresses_foreign, i) {
2523                 /* we consider IPv6LL addresses to be managed by the kernel */
2524                 if (address->family == AF_INET6 && in_addr_is_link_local(AF_INET6, &address->in_addr) == 1)
2525                         continue;
2526
2527                 if (link_address_is_dynamic(link, address)) {
2528                         if (FLAGS_SET(link->network->keep_configuration, KEEP_CONFIGURATION_DHCP))
2529                                 continue;
2530                 } else if (FLAGS_SET(link->network->keep_configuration, KEEP_CONFIGURATION_STATIC))
2531                         continue;
2532
2533                 if (link_is_static_address_configured(link, address)) {
2534                         r = address_add(link, address->family, &address->in_addr, address->prefixlen, NULL);
2535                         if (r < 0)
2536                                 return log_link_error_errno(link, r, "Failed to add address: %m");
2537                 } else {
2538                         r = address_remove(address, link, NULL);
2539                         if (r < 0)
2540                                 return r;
2541                 }
2542         }
2543
2544         SET_FOREACH(route, link->routes_foreign, i) {
2545                 /* do not touch routes managed by the kernel */
2546                 if (route->protocol == RTPROT_KERNEL)
2547                         continue;
2548
2549                 if (route->protocol == RTPROT_STATIC &&
2550                     FLAGS_SET(link->network->keep_configuration, KEEP_CONFIGURATION_STATIC))
2551                         continue;
2552
2553                 if (route->protocol == RTPROT_DHCP &&
2554                     FLAGS_SET(link->network->keep_configuration, KEEP_CONFIGURATION_DHCP))
2555                         continue;
2556
2557                 if (link_is_static_route_configured(link, route)) {
2558                         r = route_add(link, route->family, &route->dst, route->dst_prefixlen, route->tos, route->priority, route->table, NULL);
2559                         if (r < 0)
2560                                 return r;
2561                 } else {
2562                         r = route_remove(route, link, NULL);
2563                         if (r < 0)
2564                                 return r;
2565                 }
2566         }
2567
2568         return 0;
2569 }
2570
2571 static int link_drop_config(Link *link) {
2572         Address *address, *pool_address;
2573         Route *route;
2574         Iterator i;
2575         int r;
2576
2577         SET_FOREACH(address, link->addresses, i) {
2578                 /* we consider IPv6LL addresses to be managed by the kernel */
2579                 if (address->family == AF_INET6 && in_addr_is_link_local(AF_INET6, &address->in_addr) == 1)
2580                         continue;
2581
2582                 r = address_remove(address, link, NULL);
2583                 if (r < 0)
2584                         return r;
2585
2586                 /* If this address came from an address pool, clean up the pool */
2587                 LIST_FOREACH(addresses, pool_address, link->pool_addresses) {
2588                         if (address_equal(address, pool_address)) {
2589                                 LIST_REMOVE(addresses, link->pool_addresses, pool_address);
2590                                 address_free(pool_address);
2591                                 break;
2592                         }
2593                 }
2594         }
2595
2596         SET_FOREACH(route, link->routes, i) {
2597                 /* do not touch routes managed by the kernel */
2598                 if (route->protocol == RTPROT_KERNEL)
2599                         continue;
2600
2601                 r = route_remove(route, link, NULL);
2602                 if (r < 0)
2603                         return r;
2604         }
2605
2606         ndisc_flush(link);
2607
2608         return 0;
2609 }
2610
2611 static int link_configure(Link *link) {
2612         int r;
2613
2614         assert(link);
2615         assert(link->network);
2616         assert(link->state == LINK_STATE_INITIALIZED);
2617
2618         if (STRPTR_IN_SET(link->kind, "can", "vcan", "vxcan"))
2619                 return link_configure_can(link);
2620
2621         /* Drop foreign config, but ignore loopback or critical devices.
2622          * We do not want to remove loopback address or addresses used for root NFS. */
2623         if (!(link->flags & IFF_LOOPBACK) &&
2624             link->network->keep_configuration != KEEP_CONFIGURATION_YES) {
2625                 r = link_drop_foreign_config(link);
2626                 if (r < 0)
2627                         return r;
2628         }
2629
2630         r = link_set_proxy_arp(link);
2631         if (r < 0)
2632                return r;
2633
2634         r = ipv6_proxy_ndp_addresses_configure(link);
2635         if (r < 0)
2636                 return r;
2637
2638         r = link_set_ipv4_forward(link);
2639         if (r < 0)
2640                 return r;
2641
2642         r = link_set_ipv6_forward(link);
2643         if (r < 0)
2644                 return r;
2645
2646         r = link_set_ipv6_privacy_extensions(link);
2647         if (r < 0)
2648                 return r;
2649
2650         r = link_set_ipv6_accept_ra(link);
2651         if (r < 0)
2652                 return r;
2653
2654         r = link_set_ipv6_dad_transmits(link);
2655         if (r < 0)
2656                 return r;
2657
2658         r = link_set_ipv6_hop_limit(link);
2659         if (r < 0)
2660                 return r;
2661
2662         r = link_set_flags(link);
2663         if (r < 0)
2664                 return r;
2665
2666         r = link_set_ipv6_mtu(link);
2667         if (r < 0)
2668                 return r;
2669
2670         if (link_ipv4ll_enabled(link, ADDRESS_FAMILY_IPV4 | ADDRESS_FAMILY_FALLBACK_IPV4)) {
2671                 r = ipv4ll_configure(link);
2672                 if (r < 0)
2673                         return r;
2674         }
2675
2676         if (link_dhcp4_enabled(link)) {
2677                 r = dhcp4_set_promote_secondaries(link);
2678                 if (r < 0)
2679                         return r;
2680
2681                 r = dhcp4_configure(link);
2682                 if (r < 0)
2683                         return r;
2684         }
2685
2686         if (link_dhcp4_server_enabled(link)) {
2687                 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
2688                 if (r < 0)
2689                         return r;
2690
2691                 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
2692                 if (r < 0)
2693                         return r;
2694         }
2695
2696         if (link_dhcp6_enabled(link) ||
2697             link_ipv6_accept_ra_enabled(link)) {
2698                 r = dhcp6_configure(link);
2699                 if (r < 0)
2700                         return r;
2701         }
2702
2703         if (link_ipv6_accept_ra_enabled(link)) {
2704                 r = ndisc_configure(link);
2705                 if (r < 0)
2706                         return r;
2707         }
2708
2709         if (link_radv_enabled(link)) {
2710                 r = radv_configure(link);
2711                 if (r < 0)
2712                         return r;
2713         }
2714
2715         if (link_lldp_rx_enabled(link)) {
2716                 r = link_lldp_rx_configure(link);
2717                 if (r < 0)
2718                         return r;
2719         }
2720
2721         r = link_configure_mtu(link);
2722         if (r < 0)
2723                 return r;
2724
2725         r = link_configure_addrgen_mode(link);
2726         if (r < 0)
2727                 return r;
2728
2729         return link_configure_after_setting_mtu(link);
2730 }
2731
2732 static int link_configure_after_setting_mtu(Link *link) {
2733         int r;
2734
2735         assert(link);
2736         assert(link->network);
2737         assert(link->state == LINK_STATE_INITIALIZED);
2738
2739         if (link->setting_mtu)
2740                 return 0;
2741
2742         if (link_has_carrier(link) || link->network->configure_without_carrier) {
2743                 r = link_acquire_conf(link);
2744                 if (r < 0)
2745                         return r;
2746         }
2747
2748         return link_enter_join_netdev(link);
2749 }
2750
2751 static int duid_set_uuid(DUID *duid, sd_id128_t uuid) {
2752         assert(duid);
2753
2754         if (duid->raw_data_len > 0)
2755                 return 0;
2756
2757         if (duid->type != DUID_TYPE_UUID)
2758                 return -EINVAL;
2759
2760         memcpy(&duid->raw_data, &uuid, sizeof(sd_id128_t));
2761         duid->raw_data_len = sizeof(sd_id128_t);
2762
2763         return 1;
2764 }
2765
2766 int get_product_uuid_handler(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
2767         Manager *manager = userdata;
2768         const sd_bus_error *e;
2769         const void *a;
2770         size_t sz;
2771         DUID *duid;
2772         Link *link;
2773         int r;
2774
2775         assert(m);
2776         assert(manager);
2777
2778         e = sd_bus_message_get_error(m);
2779         if (e) {
2780                 log_error_errno(sd_bus_error_get_errno(e),
2781                                 "Could not get product UUID. Falling back to use machine-app-specific ID as DUID-UUID: %s",
2782                                 e->message);
2783                 goto configure;
2784         }
2785
2786         r = sd_bus_message_read_array(m, 'y', &a, &sz);
2787         if (r < 0)
2788                 goto configure;
2789
2790         if (sz != sizeof(sd_id128_t)) {
2791                 log_error("Invalid product UUID. Falling back to use machine-app-specific ID as DUID-UUID.");
2792                 goto configure;
2793         }
2794
2795         memcpy(&manager->product_uuid, a, sz);
2796         while ((duid = set_steal_first(manager->duids_requesting_uuid)))
2797                 (void) duid_set_uuid(duid, manager->product_uuid);
2798
2799         manager->duids_requesting_uuid = set_free(manager->duids_requesting_uuid);
2800
2801 configure:
2802         while ((link = set_steal_first(manager->links_requesting_uuid))) {
2803                 r = link_configure(link);
2804                 if (r < 0)
2805                         log_link_error_errno(link, r, "Failed to configure link: %m");
2806         }
2807
2808         manager->links_requesting_uuid = set_free(manager->links_requesting_uuid);
2809
2810         /* To avoid calling GetProductUUID() bus method so frequently, set the flag below
2811          * even if the method fails. */
2812         manager->has_product_uuid = true;
2813
2814         return 1;
2815 }
2816
2817 static bool link_requires_uuid(Link *link) {
2818         const DUID *duid;
2819
2820         assert(link);
2821         assert(link->manager);
2822         assert(link->network);
2823
2824         duid = link_get_duid(link);
2825         if (duid->type != DUID_TYPE_UUID || duid->raw_data_len != 0)
2826                 return false;
2827
2828         if (link_dhcp4_enabled(link) && IN_SET(link->network->dhcp_client_identifier, DHCP_CLIENT_ID_DUID, DHCP_CLIENT_ID_DUID_ONLY))
2829                 return true;
2830
2831         if (link_dhcp6_enabled(link) || link_ipv6_accept_ra_enabled(link))
2832                 return true;
2833
2834         return false;
2835 }
2836
2837 static int link_configure_duid(Link *link) {
2838         Manager *m;
2839         DUID *duid;
2840         int r;
2841
2842         assert(link);
2843         assert(link->manager);
2844         assert(link->network);
2845
2846         m = link->manager;
2847         duid = link_get_duid(link);
2848
2849         if (!link_requires_uuid(link))
2850                 return 1;
2851
2852         if (m->has_product_uuid) {
2853                 (void) duid_set_uuid(duid, m->product_uuid);
2854                 return 1;
2855         }
2856
2857         if (!m->links_requesting_uuid) {
2858                 r = manager_request_product_uuid(m, link);
2859                 if (r < 0) {
2860                         if (r == -ENOMEM)
2861                                 return r;
2862
2863                         log_link_warning_errno(link, r,
2864                                                "Failed to get product UUID. Falling back to use machine-app-specific ID as DUID-UUID: %m");
2865                         return 1;
2866                 }
2867         } else {
2868                 r = set_put(m->links_requesting_uuid, link);
2869                 if (r < 0)
2870                         return log_oom();
2871
2872                 r = set_put(m->duids_requesting_uuid, duid);
2873                 if (r < 0)
2874                         return log_oom();
2875         }
2876
2877         return 0;
2878 }
2879
2880 static int link_initialized_and_synced(Link *link) {
2881         Network *network;
2882         int r;
2883
2884         assert(link);
2885         assert(link->ifname);
2886         assert(link->manager);
2887
2888         /* We may get called either from the asynchronous netlink callback,
2889          * or directly for link_add() if running in a container. See link_add(). */
2890         if (!IN_SET(link->state, LINK_STATE_PENDING, LINK_STATE_INITIALIZED))
2891                 return 0;
2892
2893         log_link_debug(link, "Link state is up-to-date");
2894         link_set_state(link, LINK_STATE_INITIALIZED);
2895
2896         r = link_new_bound_by_list(link);
2897         if (r < 0)
2898                 return r;
2899
2900         r = link_handle_bound_by_list(link);
2901         if (r < 0)
2902                 return r;
2903
2904         if (!link->network) {
2905                 r = network_get(link->manager, link->sd_device, link->ifname,
2906                                 &link->mac, &network);
2907                 if (r == -ENOENT) {
2908                         link_enter_unmanaged(link);
2909                         return 0;
2910                 } else if (r == 0 && network->unmanaged) {
2911                         link_enter_unmanaged(link);
2912                         return 0;
2913                 } else if (r < 0)
2914                         return r;
2915
2916                 if (link->flags & IFF_LOOPBACK) {
2917                         if (network->link_local != ADDRESS_FAMILY_NO)
2918                                 log_link_debug(link, "Ignoring link-local autoconfiguration for loopback link");
2919
2920                         if (network->dhcp != ADDRESS_FAMILY_NO)
2921                                 log_link_debug(link, "Ignoring DHCP clients for loopback link");
2922
2923                         if (network->dhcp_server)
2924                                 log_link_debug(link, "Ignoring DHCP server for loopback link");
2925                 }
2926
2927                 r = network_apply(network, link);
2928                 if (r < 0)
2929                         return r;
2930         }
2931
2932         r = link_new_bound_to_list(link);
2933         if (r < 0)
2934                 return r;
2935
2936         /* link_configure_duid() returns 0 if it requests product UUID. In that case,
2937          * link_configure() is called later asynchronously. */
2938         r = link_configure_duid(link);
2939         if (r <= 0)
2940                 return r;
2941
2942         r = link_configure(link);
2943         if (r < 0)
2944                 return r;
2945
2946         return 0;
2947 }
2948
2949 static int link_initialized_handler(sd_netlink *rtnl, sd_netlink_message *m, Link *link) {
2950         (void) link_initialized_and_synced(link);
2951         return 1;
2952 }
2953
2954 int link_initialized(Link *link, sd_device *device) {
2955         _cleanup_(sd_netlink_message_unrefp) sd_netlink_message *req = NULL;
2956         int r;
2957
2958         assert(link);
2959         assert(link->manager);
2960         assert(link->manager->rtnl);
2961         assert(device);
2962
2963         if (link->state != LINK_STATE_PENDING)
2964                 return 0;
2965
2966         if (link->sd_device)
2967                 return 0;
2968
2969         log_link_debug(link, "udev initialized link");
2970         link_set_state(link, LINK_STATE_INITIALIZED);
2971
2972         link->sd_device = sd_device_ref(device);
2973
2974         /* udev has initialized the link, but we don't know if we have yet
2975          * processed the NEWLINK messages with the latest state. Do a GETLINK,
2976          * when it returns we know that the pending NEWLINKs have already been
2977          * processed and that we are up-to-date */
2978
2979         r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK,
2980                                      link->ifindex);
2981         if (r < 0)
2982                 return r;
2983
2984         r = netlink_call_async(link->manager->rtnl, NULL, req, link_initialized_handler,
2985                                link_netlink_destroy_callback, link);
2986         if (r < 0)
2987                 return r;
2988
2989         link_ref(link);
2990
2991         return 0;
2992 }
2993
2994 static int link_load(Link *link) {
2995         _cleanup_free_ char *network_file = NULL,
2996                             *addresses = NULL,
2997                             *routes = NULL,
2998                             *dhcp4_address = NULL,
2999                             *ipv4ll_address = NULL;
3000         union in_addr_union address;
3001         union in_addr_union route_dst;
3002         const char *p;
3003         int r;
3004
3005         assert(link);
3006
3007         r = parse_env_file(NULL, link->state_file,
3008                            "NETWORK_FILE", &network_file,
3009                            "ADDRESSES", &addresses,
3010                            "ROUTES", &routes,
3011                            "DHCP4_ADDRESS", &dhcp4_address,
3012                            "IPV4LL_ADDRESS", &ipv4ll_address);
3013         if (r < 0 && r != -ENOENT)
3014                 return log_link_error_errno(link, r, "Failed to read %s: %m", link->state_file);
3015
3016         if (network_file) {
3017                 Network *network;
3018                 char *suffix;
3019
3020                 /* drop suffix */
3021                 suffix = strrchr(network_file, '.');
3022                 if (!suffix) {
3023                         log_link_debug(link, "Failed to get network name from %s", network_file);
3024                         goto network_file_fail;
3025                 }
3026                 *suffix = '\0';
3027
3028                 r = network_get_by_name(link->manager, basename(network_file), &network);
3029                 if (r < 0) {
3030                         log_link_debug_errno(link, r, "Failed to get network %s: %m", basename(network_file));
3031                         goto network_file_fail;
3032                 }
3033
3034                 r = network_apply(network, link);
3035                 if (r < 0)
3036                         return log_link_error_errno(link, r, "Failed to apply network %s: %m", basename(network_file));
3037         }
3038
3039 network_file_fail:
3040
3041         if (addresses) {
3042                 p = addresses;
3043
3044                 for (;;) {
3045                         _cleanup_free_ char *address_str = NULL;
3046                         char *prefixlen_str;
3047                         int family;
3048                         unsigned char prefixlen;
3049
3050                         r = extract_first_word(&p, &address_str, NULL, 0);
3051                         if (r < 0) {
3052                                 log_link_debug_errno(link, r, "Failed to extract next address string: %m");
3053                                 continue;
3054                         }
3055                         if (r == 0)
3056                                 break;
3057
3058                         prefixlen_str = strchr(address_str, '/');
3059                         if (!prefixlen_str) {
3060                                 log_link_debug(link, "Failed to parse address and prefix length %s", address_str);
3061                                 continue;
3062                         }
3063
3064                         *prefixlen_str++ = '\0';
3065
3066                         r = sscanf(prefixlen_str, "%hhu", &prefixlen);
3067                         if (r != 1) {
3068                                 log_link_error(link, "Failed to parse prefixlen %s", prefixlen_str);
3069                                 continue;
3070                         }
3071
3072                         r = in_addr_from_string_auto(address_str, &family, &address);
3073                         if (r < 0) {
3074                                 log_link_debug_errno(link, r, "Failed to parse address %s: %m", address_str);
3075                                 continue;
3076                         }
3077
3078                         r = address_add(link, family, &address, prefixlen, NULL);
3079                         if (r < 0)
3080                                 return log_link_error_errno(link, r, "Failed to add address: %m");
3081                 }
3082         }
3083
3084         if (routes) {
3085                 p = routes;
3086
3087                 for (;;) {
3088                         Route *route;
3089                         _cleanup_free_ char *route_str = NULL;
3090                         _cleanup_(sd_event_source_unrefp) sd_event_source *expire = NULL;
3091                         usec_t lifetime;
3092                         char *prefixlen_str;
3093                         int family;
3094                         unsigned char prefixlen, tos, table;
3095                         uint32_t priority;
3096
3097                         r = extract_first_word(&p, &route_str, NULL, 0);
3098                         if (r < 0) {
3099                                 log_link_debug_errno(link, r, "Failed to extract next route string: %m");
3100                                 continue;
3101                         }
3102                         if (r == 0)
3103                                 break;
3104
3105                         prefixlen_str = strchr(route_str, '/');
3106                         if (!prefixlen_str) {
3107                                 log_link_debug(link, "Failed to parse route %s", route_str);
3108                                 continue;
3109                         }
3110
3111                         *prefixlen_str++ = '\0';
3112
3113                         r = sscanf(prefixlen_str, "%hhu/%hhu/%"SCNu32"/%hhu/"USEC_FMT, &prefixlen, &tos, &priority, &table, &lifetime);
3114                         if (r != 5) {
3115                                 log_link_debug(link,
3116                                                "Failed to parse destination prefix length, tos, priority, table or expiration %s",
3117                                                prefixlen_str);
3118                                 continue;
3119                         }
3120
3121                         r = in_addr_from_string_auto(route_str, &family, &route_dst);
3122                         if (r < 0) {
3123                                 log_link_debug_errno(link, r, "Failed to parse route destination %s: %m", route_str);
3124                                 continue;
3125                         }
3126
3127                         r = route_add(link, family, &route_dst, prefixlen, tos, priority, table, &route);
3128                         if (r < 0)
3129                                 return log_link_error_errno(link, r, "Failed to add route: %m");
3130
3131                         if (lifetime != USEC_INFINITY && !kernel_route_expiration_supported()) {
3132                                 r = sd_event_add_time(link->manager->event, &expire, clock_boottime_or_monotonic(), lifetime,
3133                                                       0, route_expire_handler, route);
3134                                 if (r < 0)
3135                                         log_link_warning_errno(link, r, "Could not arm route expiration handler: %m");
3136                         }
3137
3138                         route->lifetime = lifetime;
3139                         sd_event_source_unref(route->expire);
3140                         route->expire = TAKE_PTR(expire);
3141                 }
3142         }
3143
3144         if (dhcp4_address) {
3145                 r = in_addr_from_string(AF_INET, dhcp4_address, &address);
3146                 if (r < 0) {
3147                         log_link_debug_errno(link, r, "Failed to parse DHCPv4 address %s: %m", dhcp4_address);
3148                         goto dhcp4_address_fail;
3149                 }
3150
3151                 r = sd_dhcp_client_new(&link->dhcp_client, link->network ? link->network->dhcp_anonymize : 0);
3152                 if (r < 0)
3153                         return log_link_error_errno(link, r, "Failed to create DHCPv4 client: %m");
3154
3155                 r = sd_dhcp_client_set_request_address(link->dhcp_client, &address.in);
3156                 if (r < 0)
3157                         return log_link_error_errno(link, r, "Failed to set initial DHCPv4 address %s: %m", dhcp4_address);
3158         }
3159
3160 dhcp4_address_fail:
3161
3162         if (ipv4ll_address) {
3163                 r = in_addr_from_string(AF_INET, ipv4ll_address, &address);
3164                 if (r < 0) {
3165                         log_link_debug_errno(link, r, "Failed to parse IPv4LL address %s: %m", ipv4ll_address);
3166                         goto ipv4ll_address_fail;
3167                 }
3168
3169                 r = sd_ipv4ll_new(&link->ipv4ll);
3170                 if (r < 0)
3171                         return log_link_error_errno(link, r, "Failed to create IPv4LL client: %m");
3172
3173                 r = sd_ipv4ll_set_address(link->ipv4ll, &address.in);
3174                 if (r < 0)
3175                         return log_link_error_errno(link, r, "Failed to set initial IPv4LL address %s: %m", ipv4ll_address);
3176         }
3177
3178 ipv4ll_address_fail:
3179
3180         return 0;
3181 }
3182
3183 int link_add(Manager *m, sd_netlink_message *message, Link **ret) {
3184         _cleanup_(sd_device_unrefp) sd_device *device = NULL;
3185         char ifindex_str[2 + DECIMAL_STR_MAX(int)];
3186         Link *link;
3187         int r;
3188
3189         assert(m);
3190         assert(m->rtnl);
3191         assert(message);
3192         assert(ret);
3193
3194         r = link_new(m, message, ret);
3195         if (r < 0)
3196                 return r;
3197
3198         link = *ret;
3199
3200         log_link_debug(link, "Link %d added", link->ifindex);
3201
3202         r = link_load(link);
3203         if (r < 0)
3204                 return r;
3205
3206         if (detect_container() <= 0) {
3207                 /* not in a container, udev will be around */
3208                 sprintf(ifindex_str, "n%d", link->ifindex);
3209                 r = sd_device_new_from_device_id(&device, ifindex_str);
3210                 if (r < 0) {
3211                         log_link_warning_errno(link, r, "Could not find device: %m");
3212                         goto failed;
3213                 }
3214
3215                 r = sd_device_get_is_initialized(device);
3216                 if (r < 0) {
3217                         log_link_warning_errno(link, r, "Could not determine whether the device is initialized or not: %m");
3218                         goto failed;
3219                 }
3220                 if (r == 0) {
3221                         /* not yet ready */
3222                         log_link_debug(link, "link pending udev initialization...");
3223                         return 0;
3224                 }
3225
3226                 r = device_is_renaming(device);
3227                 if (r < 0) {
3228                         log_link_warning_errno(link, r, "Failed to determine the device is renamed or not: %m");
3229                         goto failed;
3230                 }
3231                 if (r > 0) {
3232                         log_link_debug(link, "Interface is under renaming, pending initialization.");
3233                         return 0;
3234                 }
3235
3236                 r = link_initialized(link, device);
3237                 if (r < 0)
3238                         goto failed;
3239         } else {
3240                 r = link_initialized_and_synced(link);
3241                 if (r < 0)
3242                         goto failed;
3243         }
3244
3245         return 0;
3246 failed:
3247         link_enter_failed(link);
3248         return r;
3249 }
3250
3251 int link_ipv6ll_gained(Link *link, const struct in6_addr *address) {
3252         int r;
3253
3254         assert(link);
3255
3256         log_link_info(link, "Gained IPv6LL");
3257
3258         link->ipv6ll_address = *address;
3259         link_check_ready(link);
3260
3261         if (IN_SET(link->state, LINK_STATE_CONFIGURING, LINK_STATE_CONFIGURED)) {
3262                 r = link_acquire_ipv6_conf(link);
3263                 if (r < 0) {
3264                         link_enter_failed(link);
3265                         return r;
3266                 }
3267         }
3268
3269         return 0;
3270 }
3271
3272 static int link_carrier_gained(Link *link) {
3273         int r;
3274
3275         assert(link);
3276
3277         if (IN_SET(link->state, LINK_STATE_CONFIGURING, LINK_STATE_CONFIGURED)) {
3278                 r = link_acquire_conf(link);
3279                 if (r < 0) {
3280                         link_enter_failed(link);
3281                         return r;
3282                 }
3283
3284                 r = link_request_set_addresses(link);
3285                 if (r < 0)
3286                         return r;
3287         }
3288
3289         r = link_handle_bound_by_list(link);
3290         if (r < 0)
3291                 return r;
3292
3293         return 0;
3294 }
3295
3296 static int link_carrier_lost(Link *link) {
3297         int r;
3298
3299         assert(link);
3300
3301         if (link->network && link->network->ignore_carrier_loss)
3302                 return 0;
3303
3304         /* Some devices reset itself while setting the MTU. This causes the DHCP client fall into a loop.
3305          * setting_mtu keep track whether the device got reset because of setting MTU and does not drop the
3306          * configuration and stop the clients as well. */
3307         if (link->setting_mtu)
3308                 return 0;
3309
3310         r = link_stop_clients(link, false);
3311         if (r < 0) {
3312                 link_enter_failed(link);
3313                 return r;
3314         }
3315
3316         if (link_dhcp4_server_enabled(link))
3317                 (void) sd_dhcp_server_stop(link->dhcp_server);
3318
3319         r = link_drop_config(link);
3320         if (r < 0)
3321                 return r;
3322
3323         if (!IN_SET(link->state, LINK_STATE_UNMANAGED, LINK_STATE_PENDING)) {
3324                 log_link_debug(link, "State is %s, dropping config", link_state_to_string(link->state));
3325                 r = link_drop_foreign_config(link);
3326                 if (r < 0)
3327                         return r;
3328         }
3329
3330         r = link_handle_bound_by_list(link);
3331         if (r < 0)
3332                 return r;
3333
3334         return 0;
3335 }
3336
3337 int link_carrier_reset(Link *link) {
3338         int r;
3339
3340         assert(link);
3341
3342         if (link_has_carrier(link)) {
3343                 r = link_carrier_lost(link);
3344                 if (r < 0)
3345                         return r;
3346
3347                 r = link_carrier_gained(link);
3348                 if (r < 0)
3349                         return r;
3350
3351                 log_link_info(link, "Reset carrier");
3352         }
3353
3354         return 0;
3355 }
3356
3357 int link_update(Link *link, sd_netlink_message *m) {
3358         struct ether_addr mac;
3359         const char *ifname;
3360         uint32_t mtu;
3361         bool had_carrier, carrier_gained, carrier_lost;
3362         int old_master, r;
3363
3364         assert(link);
3365         assert(link->ifname);
3366         assert(m);
3367
3368         if (link->state == LINK_STATE_LINGER) {
3369                 log_link_info(link, "Link re-added");
3370                 link_set_state(link, LINK_STATE_CONFIGURING);
3371
3372                 r = link_new_carrier_maps(link);
3373                 if (r < 0)
3374                         return r;
3375         }
3376
3377         r = sd_netlink_message_read_string(m, IFLA_IFNAME, &ifname);
3378         if (r >= 0 && !streq(ifname, link->ifname)) {
3379                 Manager *manager = link->manager;
3380
3381                 log_link_info(link, "Interface name change detected, %s has been renamed to %s.", link->ifname, ifname);
3382
3383                 link_drop(link);
3384                 r = link_add(manager, m, &link);
3385                 if (r < 0)
3386                         return r;
3387         }
3388
3389         r = sd_netlink_message_read_u32(m, IFLA_MTU, &mtu);
3390         if (r >= 0 && mtu > 0) {
3391                 link->mtu = mtu;
3392                 if (link->original_mtu == 0) {
3393                         link->original_mtu = mtu;
3394                         log_link_debug(link, "Saved original MTU: %" PRIu32, link->original_mtu);
3395                 }
3396
3397                 if (link->dhcp_client) {
3398                         r = sd_dhcp_client_set_mtu(link->dhcp_client,
3399                                                    link->mtu);
3400                         if (r < 0)
3401                                 return log_link_warning_errno(link, r, "Could not update MTU in DHCP client: %m");
3402                 }
3403
3404                 if (link->radv) {
3405                         r = sd_radv_set_mtu(link->radv, link->mtu);
3406                         if (r < 0)
3407                                 return log_link_warning_errno(link, r, "Could not set MTU for Router Advertisement: %m");
3408                 }
3409         }
3410
3411         /* The kernel may broadcast NEWLINK messages without the MAC address
3412            set, simply ignore them. */
3413         r = sd_netlink_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
3414         if (r >= 0) {
3415                 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet,
3416                            ETH_ALEN)) {
3417
3418                         memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet,
3419                                ETH_ALEN);
3420
3421                         log_link_debug(link, "MAC address: "
3422                                        "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
3423                                        mac.ether_addr_octet[0],
3424                                        mac.ether_addr_octet[1],
3425                                        mac.ether_addr_octet[2],
3426                                        mac.ether_addr_octet[3],
3427                                        mac.ether_addr_octet[4],
3428                                        mac.ether_addr_octet[5]);
3429
3430                         if (link->ipv4ll) {
3431                                 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
3432                                 if (r < 0)
3433                                         return log_link_warning_errno(link, r, "Could not update MAC address in IPv4LL client: %m");
3434                         }
3435
3436                         if (link->dhcp_client) {
3437                                 r = sd_dhcp_client_set_mac(link->dhcp_client,
3438                                                            (const uint8_t *) &link->mac,
3439                                                            sizeof (link->mac),
3440                                                            ARPHRD_ETHER);
3441                                 if (r < 0)
3442                                         return log_link_warning_errno(link, r, "Could not update MAC address in DHCP client: %m");
3443
3444                                 r = dhcp4_set_client_identifier(link);
3445                                 if (r < 0)
3446                                         return r;
3447                         }
3448
3449                         if (link->dhcp6_client) {
3450                                 const DUID* duid = link_get_duid(link);
3451
3452                                 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
3453                                                             (const uint8_t *) &link->mac,
3454                                                             sizeof (link->mac),
3455                                                             ARPHRD_ETHER);
3456                                 if (r < 0)
3457                                         return log_link_warning_errno(link, r, "Could not update MAC address in DHCPv6 client: %m");
3458
3459                                 if (link->network->iaid_set) {
3460                                         r = sd_dhcp6_client_set_iaid(link->dhcp6_client,
3461                                                                      link->network->iaid);
3462                                         if (r < 0)
3463                                                 return log_link_warning_errno(link, r, "Could not update DHCPv6 IAID: %m");
3464                                 }
3465
3466                                 r = sd_dhcp6_client_set_duid(link->dhcp6_client,
3467                                                              duid->type,
3468                                                              duid->raw_data_len > 0 ? duid->raw_data : NULL,
3469                                                              duid->raw_data_len);
3470                                 if (r < 0)
3471                                         return log_link_warning_errno(link, r, "Could not update DHCPv6 DUID: %m");
3472                         }
3473
3474                         if (link->radv) {
3475                                 r = sd_radv_set_mac(link->radv, &link->mac);
3476                                 if (r < 0)
3477                                         return log_link_warning_errno(link, r, "Could not update MAC for Router Advertisement: %m");
3478                         }
3479
3480                         if (link->ndisc) {
3481                                 r = sd_ndisc_set_mac(link->ndisc, &link->mac);
3482                                 if (r < 0)
3483                                         return log_link_warning_errno(link, r, "Could not update MAC for ndisc: %m");
3484                         }
3485                 }
3486         }
3487
3488         old_master = link->master_ifindex;
3489         (void) sd_netlink_message_read_u32(m, IFLA_MASTER, (uint32_t *) &link->master_ifindex);
3490
3491         had_carrier = link_has_carrier(link);
3492
3493         r = link_update_flags(link, m, old_master != link->master_ifindex);
3494         if (r < 0)
3495                 return r;
3496
3497         r = link_update_lldp(link);
3498         if (r < 0)
3499                 return r;
3500
3501         carrier_gained = !had_carrier && link_has_carrier(link);
3502         carrier_lost = had_carrier && !link_has_carrier(link);
3503
3504         if (carrier_gained) {
3505                 log_link_info(link, "Gained carrier");
3506
3507                 r = link_carrier_gained(link);
3508                 if (r < 0)
3509                         return r;
3510         } else if (carrier_lost) {
3511                 log_link_info(link, "Lost carrier");
3512
3513                 r = link_carrier_lost(link);
3514                 if (r < 0)
3515                         return r;
3516         }
3517
3518         return 0;
3519 }
3520
3521 static void print_link_hashmap(FILE *f, const char *prefix, Hashmap* h) {
3522         bool space = false;
3523         Iterator i;
3524         Link *link;
3525
3526         assert(f);
3527         assert(prefix);
3528
3529         if (hashmap_isempty(h))
3530                 return;
3531
3532         fputs(prefix, f);
3533         HASHMAP_FOREACH(link, h, i) {
3534                 if (space)
3535                         fputc(' ', f);
3536
3537                 fprintf(f, "%i", link->ifindex);
3538                 space = true;
3539         }
3540
3541         fputc('\n', f);
3542 }
3543
3544 int link_save(Link *link) {
3545         _cleanup_free_ char *temp_path = NULL;
3546         _cleanup_fclose_ FILE *f = NULL;
3547         const char *admin_state, *oper_state;
3548         Address *a;
3549         Route *route;
3550         Iterator i;
3551         int r;
3552
3553         assert(link);
3554         assert(link->state_file);
3555         assert(link->lease_file);
3556         assert(link->manager);
3557
3558         if (link->state == LINK_STATE_LINGER) {
3559                 (void) unlink(link->state_file);
3560                 return 0;
3561         }
3562
3563         link_lldp_save(link);
3564
3565         admin_state = link_state_to_string(link->state);
3566         assert(admin_state);
3567
3568         oper_state = link_operstate_to_string(link->operstate);
3569         assert(oper_state);
3570
3571         r = fopen_temporary(link->state_file, &f, &temp_path);
3572         if (r < 0)
3573                 goto fail;
3574
3575         (void) fchmod(fileno(f), 0644);
3576
3577         fprintf(f,
3578                 "# This is private data. Do not parse.\n"
3579                 "ADMIN_STATE=%s\n"
3580                 "OPER_STATE=%s\n",
3581                 admin_state, oper_state);
3582
3583         if (link->network) {
3584                 char **dhcp6_domains = NULL, **dhcp_domains = NULL;
3585                 const char *dhcp_domainname = NULL, *p;
3586                 sd_dhcp6_lease *dhcp6_lease = NULL;
3587                 unsigned j;
3588                 bool space;
3589
3590                 fprintf(f, "REQUIRED_FOR_ONLINE=%s\n",
3591                         yes_no(link->network->required_for_online));
3592
3593                 fprintf(f, "REQUIRED_OPER_STATE_FOR_ONLINE=%s\n",
3594                         strempty(link_operstate_to_string(link->network->required_operstate_for_online)));
3595
3596                 if (link->dhcp6_client) {
3597                         r = sd_dhcp6_client_get_lease(link->dhcp6_client, &dhcp6_lease);
3598                         if (r < 0 && r != -ENOMSG)
3599                                 log_link_debug(link, "No DHCPv6 lease");
3600                 }
3601
3602                 fprintf(f, "NETWORK_FILE=%s\n", link->network->filename);
3603
3604                 fputs("DNS=", f);
3605                 space = false;
3606
3607                 for (j = 0; j < link->network->n_dns; j++) {
3608                         _cleanup_free_ char *b = NULL;
3609
3610                         r = in_addr_to_string(link->network->dns[j].family,
3611                                               &link->network->dns[j].address,  &b);
3612                         if (r < 0) {
3613                                 log_debug_errno(r, "Failed to format address, ignoring: %m");
3614                                 continue;
3615                         }
3616
3617                         if (space)
3618                                 fputc(' ', f);
3619                         fputs(b, f);
3620                         space = true;
3621                 }
3622
3623                 if (link->network->dhcp_use_dns &&
3624                     link->dhcp_lease) {
3625                         const struct in_addr *addresses;
3626
3627                         r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
3628                         if (r > 0)
3629                                 if (serialize_in_addrs(f, addresses, r, space, in4_addr_is_non_local) > 0)
3630                                         space = true;
3631                 }
3632
3633                 if (link->network->dhcp_use_dns && dhcp6_lease) {
3634                         struct in6_addr *in6_addrs;
3635
3636                         r = sd_dhcp6_lease_get_dns(dhcp6_lease, &in6_addrs);
3637                         if (r > 0) {
3638                                 if (space)
3639                                         fputc(' ', f);
3640                                 serialize_in6_addrs(f, in6_addrs, r);
3641                                 space = true;
3642                         }
3643                 }
3644
3645                 /* Make sure to flush out old entries before we use the NDISC data */
3646                 ndisc_vacuum(link);
3647
3648                 if (link->network->ipv6_accept_ra_use_dns && link->ndisc_rdnss) {
3649                         NDiscRDNSS *dd;
3650
3651                         SET_FOREACH(dd, link->ndisc_rdnss, i) {
3652                                 if (space)
3653                                         fputc(' ', f);
3654
3655                                 serialize_in6_addrs(f, &dd->address, 1);
3656                                 space = true;
3657                         }
3658                 }
3659
3660                 fputc('\n', f);
3661
3662                 fputs("NTP=", f);
3663                 space = false;
3664                 fputstrv(f, link->network->ntp, NULL, &space);
3665
3666                 if (link->network->dhcp_use_ntp &&
3667                     link->dhcp_lease) {
3668                         const struct in_addr *addresses;
3669
3670                         r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
3671                         if (r > 0)
3672                                 if (serialize_in_addrs(f, addresses, r, space, in4_addr_is_non_local) > 0)
3673                                         space = true;
3674                 }
3675
3676                 if (link->network->dhcp_use_ntp && dhcp6_lease) {
3677                         struct in6_addr *in6_addrs;
3678                         char **hosts;
3679
3680                         r = sd_dhcp6_lease_get_ntp_addrs(dhcp6_lease,
3681                                                          &in6_addrs);
3682                         if (r > 0) {
3683                                 if (space)
3684                                         fputc(' ', f);
3685                                 serialize_in6_addrs(f, in6_addrs, r);
3686                                 space = true;
3687                         }
3688
3689                         r = sd_dhcp6_lease_get_ntp_fqdn(dhcp6_lease, &hosts);
3690                         if (r > 0)
3691                                 fputstrv(f, hosts, NULL, &space);
3692                 }
3693
3694                 fputc('\n', f);
3695
3696                 if (link->network->dhcp_use_domains != DHCP_USE_DOMAINS_NO) {
3697                         if (link->dhcp_lease) {
3698                                 (void) sd_dhcp_lease_get_domainname(link->dhcp_lease, &dhcp_domainname);
3699                                 (void) sd_dhcp_lease_get_search_domains(link->dhcp_lease, &dhcp_domains);
3700                         }
3701                         if (dhcp6_lease)
3702                                 (void) sd_dhcp6_lease_get_domains(dhcp6_lease, &dhcp6_domains);
3703                 }
3704
3705                 fputs("DOMAINS=", f);
3706                 space = false;
3707                 ORDERED_SET_FOREACH(p, link->network->search_domains, i)
3708                         fputs_with_space(f, p, NULL, &space);
3709
3710                 if (link->network->dhcp_use_domains == DHCP_USE_DOMAINS_YES) {
3711                         NDiscDNSSL *dd;
3712
3713                         if (dhcp_domainname)
3714                                 fputs_with_space(f, dhcp_domainname, NULL, &space);
3715                         if (dhcp_domains)
3716                                 fputstrv(f, dhcp_domains, NULL, &space);
3717                         if (dhcp6_domains)
3718                                 fputstrv(f, dhcp6_domains, NULL, &space);
3719
3720                         SET_FOREACH(dd, link->ndisc_dnssl, i)
3721                                 fputs_with_space(f, NDISC_DNSSL_DOMAIN(dd), NULL, &space);
3722                 }
3723
3724                 fputc('\n', f);
3725
3726                 fputs("ROUTE_DOMAINS=", f);
3727                 space = false;
3728                 ORDERED_SET_FOREACH(p, link->network->route_domains, i)
3729                         fputs_with_space(f, p, NULL, &space);
3730
3731                 if (link->network->dhcp_use_domains == DHCP_USE_DOMAINS_ROUTE) {
3732                         NDiscDNSSL *dd;
3733
3734                         if (dhcp_domainname)
3735                                 fputs_with_space(f, dhcp_domainname, NULL, &space);
3736                         if (dhcp_domains)
3737                                 fputstrv(f, dhcp_domains, NULL, &space);
3738                         if (dhcp6_domains)
3739                                 fputstrv(f, dhcp6_domains, NULL, &space);
3740
3741                         SET_FOREACH(dd, link->ndisc_dnssl, i)
3742                                 fputs_with_space(f, NDISC_DNSSL_DOMAIN(dd), NULL, &space);
3743                 }
3744
3745                 fputc('\n', f);
3746
3747                 fprintf(f, "LLMNR=%s\n",
3748                         resolve_support_to_string(link->network->llmnr));
3749                 fprintf(f, "MDNS=%s\n",
3750                         resolve_support_to_string(link->network->mdns));
3751                 if (link->network->dns_default_route >= 0)
3752                         fprintf(f, "DNS_DEFAULT_ROUTE=%s\n", yes_no(link->network->dns_default_route));
3753
3754                 if (link->network->dns_over_tls_mode != _DNS_OVER_TLS_MODE_INVALID)
3755                         fprintf(f, "DNS_OVER_TLS=%s\n",
3756                                 dns_over_tls_mode_to_string(link->network->dns_over_tls_mode));
3757
3758                 if (link->network->dnssec_mode != _DNSSEC_MODE_INVALID)
3759                         fprintf(f, "DNSSEC=%s\n",
3760                                 dnssec_mode_to_string(link->network->dnssec_mode));
3761
3762                 if (!set_isempty(link->network->dnssec_negative_trust_anchors)) {
3763                         const char *n;
3764
3765                         fputs("DNSSEC_NTA=", f);
3766                         space = false;
3767                         SET_FOREACH(n, link->network->dnssec_negative_trust_anchors, i)
3768                                 fputs_with_space(f, n, NULL, &space);
3769                         fputc('\n', f);
3770                 }
3771
3772                 fputs("ADDRESSES=", f);
3773                 space = false;
3774                 SET_FOREACH(a, link->addresses, i) {
3775                         _cleanup_free_ char *address_str = NULL;
3776
3777                         r = in_addr_to_string(a->family, &a->in_addr, &address_str);
3778                         if (r < 0)
3779                                 goto fail;
3780
3781                         fprintf(f, "%s%s/%u", space ? " " : "", address_str, a->prefixlen);
3782                         space = true;
3783                 }
3784                 fputc('\n', f);
3785
3786                 fputs("ROUTES=", f);
3787                 space = false;
3788                 SET_FOREACH(route, link->routes, i) {
3789                         _cleanup_free_ char *route_str = NULL;
3790
3791                         r = in_addr_to_string(route->family, &route->dst, &route_str);
3792                         if (r < 0)
3793                                 goto fail;
3794
3795                         fprintf(f, "%s%s/%hhu/%hhu/%"PRIu32"/%"PRIu32"/"USEC_FMT,
3796                                 space ? " " : "", route_str,
3797                                 route->dst_prefixlen, route->tos, route->priority, route->table, route->lifetime);
3798                         space = true;
3799                 }
3800
3801                 fputc('\n', f);
3802         }
3803
3804         print_link_hashmap(f, "CARRIER_BOUND_TO=", link->bound_to_links);
3805         print_link_hashmap(f, "CARRIER_BOUND_BY=", link->bound_by_links);
3806
3807         if (link->dhcp_lease) {
3808                 struct in_addr address;
3809                 const char *tz = NULL;
3810
3811                 assert(link->network);
3812
3813                 r = sd_dhcp_lease_get_timezone(link->dhcp_lease, &tz);
3814                 if (r >= 0)
3815                         fprintf(f, "TIMEZONE=%s\n", tz);
3816
3817                 r = sd_dhcp_lease_get_address(link->dhcp_lease, &address);
3818                 if (r >= 0) {
3819                         fputs("DHCP4_ADDRESS=", f);
3820                         serialize_in_addrs(f, &address, 1, false, NULL);
3821                         fputc('\n', f);
3822                 }
3823
3824                 r = dhcp_lease_save(link->dhcp_lease, link->lease_file);
3825                 if (r < 0)
3826                         goto fail;
3827
3828                 fprintf(f,
3829                         "DHCP_LEASE=%s\n",
3830                         link->lease_file);
3831         } else
3832                 (void) unlink(link->lease_file);
3833
3834         if (link->ipv4ll) {
3835                 struct in_addr address;
3836
3837                 r = sd_ipv4ll_get_address(link->ipv4ll, &address);
3838                 if (r >= 0) {
3839                         fputs("IPV4LL_ADDRESS=", f);
3840                         serialize_in_addrs(f, &address, 1, false, NULL);
3841                         fputc('\n', f);
3842                 }
3843         }
3844
3845         r = fflush_and_check(f);
3846         if (r < 0)
3847                 goto fail;
3848
3849         if (rename(temp_path, link->state_file) < 0) {
3850                 r = -errno;
3851                 goto fail;
3852         }
3853
3854         return 0;
3855
3856 fail:
3857         (void) unlink(link->state_file);
3858         if (temp_path)
3859                 (void) unlink(temp_path);
3860
3861         return log_link_error_errno(link, r, "Failed to save link data to %s: %m", link->state_file);
3862 }
3863
3864 /* The serialized state in /run is no longer up-to-date. */
3865 void link_dirty(Link *link) {
3866         int r;
3867
3868         assert(link);
3869
3870         /* mark manager dirty as link is dirty */
3871         manager_dirty(link->manager);
3872
3873         r = set_ensure_allocated(&link->manager->dirty_links, NULL);
3874         if (r < 0)
3875                 /* allocation errors are ignored */
3876                 return;
3877
3878         r = set_put(link->manager->dirty_links, link);
3879         if (r <= 0)
3880                 /* don't take another ref if the link was already dirty */
3881                 return;
3882
3883         link_ref(link);
3884 }
3885
3886 /* The serialized state in /run is up-to-date */
3887 void link_clean(Link *link) {
3888         assert(link);
3889         assert(link->manager);
3890
3891         link_unref(set_remove(link->manager->dirty_links, link));
3892 }
3893
3894 static const char* const link_state_table[_LINK_STATE_MAX] = {
3895         [LINK_STATE_PENDING] = "pending",
3896         [LINK_STATE_INITIALIZED] = "initialized",
3897         [LINK_STATE_CONFIGURING] = "configuring",
3898         [LINK_STATE_CONFIGURED] = "configured",
3899         [LINK_STATE_UNMANAGED] = "unmanaged",
3900         [LINK_STATE_FAILED] = "failed",
3901         [LINK_STATE_LINGER] = "linger",
3902 };
3903
3904 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);