src/network/networkd-link.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2013 Tom Gundersen <teg@jklm.no>
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <netinet/ether.h>
  23 #include <linux/if.h>
  24 #include <unistd.h>
  25
  26 #include "util.h"
  27 #include "virt.h"
  28 #include "fileio.h"
  29 #include "socket-util.h"
  30 #include "bus-util.h"
  31 #include "udev-util.h"
  32 #include "dhcp-lease-internal.h"
  33 #include "network-internal.h"
  34 #include "networkd-link.h"
  35 #include "networkd-netdev.h"
  36
  37 bool link_dhcp6_enabled(Link *link) {
  38         if (link->flags & IFF_LOOPBACK)
  39                 return false;
  40
  41         if (!link->network)
  42                 return false;
  43
  44         return link->network->dhcp & ADDRESS_FAMILY_IPV6;
  45 }
  46
  47 bool link_dhcp4_enabled(Link *link) {
  48         if (link->flags & IFF_LOOPBACK)
  49                 return false;
  50
  51         if (!link->network)
  52                 return false;
  53
  54         return link->network->dhcp & ADDRESS_FAMILY_IPV4;
  55 }
  56
  57 bool link_dhcp4_server_enabled(Link *link) {
  58         if (link->flags & IFF_LOOPBACK)
  59                 return false;
  60
  61         if (!link->network)
  62                 return false;
  63
  64         return link->network->dhcp_server;
  65 }
  66
  67 bool link_ipv4ll_enabled(Link *link) {
  68         if (link->flags & IFF_LOOPBACK)
  69                 return false;
  70
  71         if (!link->network)
  72                 return false;
  73
  74         return link->network->link_local & ADDRESS_FAMILY_IPV4;
  75 }
  76
  77 bool link_ipv6ll_enabled(Link *link) {
  78         if (link->flags & IFF_LOOPBACK)
  79                 return false;
  80
  81         if (!link->network)
  82                 return false;
  83
  84         return link->network->link_local & ADDRESS_FAMILY_IPV6;
  85 }
  86
  87 bool link_lldp_enabled(Link *link) {
  88         if (link->flags & IFF_LOOPBACK)
  89                 return false;
  90
  91         if (!link->network)
  92                 return false;
  93
  94         if (link->network->bridge)
  95                 return false;
  96
  97         return link->network->lldp;
  98 }
  99
 100 static bool link_ipv4_forward_enabled(Link *link) {
 101         if (link->flags & IFF_LOOPBACK)
 102                 return false;
 103
 104         if (!link->network)
 105                 return false;
 106
 107         return link->network->ip_forward & ADDRESS_FAMILY_IPV4;
 108 }
 109
 110 static bool link_ipv6_forward_enabled(Link *link) {
 111         if (link->flags & IFF_LOOPBACK)
 112                 return false;
 113
 114         if (!link->network)
 115                 return false;
 116
 117         return link->network->ip_forward & ADDRESS_FAMILY_IPV6;
 118 }
 119
 120 static IPv6PrivacyExtensions link_ipv6_privacy_extensions(Link *link) {
 121         if (link->flags & IFF_LOOPBACK)
 122                 return _IPV6_PRIVACY_EXTENSIONS_INVALID;
 123
 124         if (!link->network)
 125                 return _IPV6_PRIVACY_EXTENSIONS_INVALID;
 126
 127         return link->network->ipv6_privacy_extensions;
 128 }
 129
 130 #define FLAG_STRING(string, flag, old, new) \
 131         (((old ^ new) & flag) \
 132                 ? ((old & flag) ? (" -" string) : (" +" string)) \
 133                 : "")
 134
 135 static int link_update_flags(Link *link, sd_netlink_message *m) {
 136         unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
 137         uint8_t operstate;
 138         int r;
 139
 140         assert(link);
 141
 142         r = sd_rtnl_message_link_get_flags(m, &flags);
 143         if (r < 0)
 144                 return log_link_warning_errno(link, r, "Could not get link flags: %m");
 145
 146         r = sd_netlink_message_read_u8(m, IFLA_OPERSTATE, &operstate);
 147         if (r < 0)
 148                 /* if we got a message without operstate, take it to mean
 149                    the state was unchanged */
 150                 operstate = link->kernel_operstate;
 151
 152         if ((link->flags == flags) && (link->kernel_operstate == operstate))
 153                 return 0;
 154
 155         if (link->flags != flags) {
 156                 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",
 157                                FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
 158                                FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
 159                                FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
 160                                FLAG_STRING("UP", IFF_UP, link->flags, flags),
 161                                FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
 162                                FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
 163                                FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
 164                                FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
 165                                FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
 166                                FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
 167                                FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
 168                                FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
 169                                FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
 170                                FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
 171                                FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
 172                                FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
 173                                FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
 174                                FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
 175                                FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
 176
 177                 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
 178                                   IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
 179                                   IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
 180                                   IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
 181                                   IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
 182                                   IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
 183                 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
 184                 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
 185
 186                 /* link flags are currently at most 18 bits, let's align to
 187                  * printing 20 */
 188                 if (unknown_flags_added)
 189                         log_link_debug(link,
 190                                        "Unknown link flags gained: %#.5x (ignoring)",
 191                                        unknown_flags_added);
 192
 193                 if (unknown_flags_removed)
 194                         log_link_debug(link,
 195                                        "Unknown link flags lost: %#.5x (ignoring)",
 196                                        unknown_flags_removed);
 197         }
 198
 199         link->flags = flags;
 200         link->kernel_operstate = operstate;
 201
 202         link_save(link);
 203
 204         return 0;
 205 }
 206
 207 static int link_new(Manager *manager, sd_netlink_message *message, Link **ret) {
 208         _cleanup_link_unref_ Link *link = NULL;
 209         uint16_t type;
 210         const char *ifname;
 211         int r, ifindex;
 212
 213         assert(manager);
 214         assert(message);
 215         assert(ret);
 216
 217         r = sd_netlink_message_get_type(message, &type);
 218         if (r < 0)
 219                 return r;
 220         else if (type != RTM_NEWLINK)
 221                 return -EINVAL;
 222
 223         r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
 224         if (r < 0)
 225                 return r;
 226         else if (ifindex <= 0)
 227                 return -EINVAL;
 228
 229         r = sd_netlink_message_read_string(message, IFLA_IFNAME, &ifname);
 230         if (r < 0)
 231                 return r;
 232
 233         link = new0(Link, 1);
 234         if (!link)
 235                 return -ENOMEM;
 236
 237         link->n_ref = 1;
 238         link->manager = manager;
 239         link->state = LINK_STATE_PENDING;
 240         link->rtnl_extended_attrs = true;
 241         link->ifindex = ifindex;
 242         link->ifname = strdup(ifname);
 243         if (!link->ifname)
 244                 return -ENOMEM;
 245
 246         r = sd_netlink_message_read_ether_addr(message, IFLA_ADDRESS, &link->mac);
 247         if (r < 0)
 248                 log_link_debug(link, "MAC address not found for new device, continuing without");
 249
 250         r = asprintf(&link->state_file, "/run/systemd/netif/links/%d",
 251                      link->ifindex);
 252         if (r < 0)
 253                 return -ENOMEM;
 254
 255         r = asprintf(&link->lease_file, "/run/systemd/netif/leases/%d",
 256                      link->ifindex);
 257         if (r < 0)
 258                 return -ENOMEM;
 259
 260         r = asprintf(&link->lldp_file, "/run/systemd/netif/lldp/%d",
 261                      link->ifindex);
 262         if (r < 0)
 263                 return -ENOMEM;
 264
 265
 266         r = hashmap_ensure_allocated(&manager->links, NULL);
 267         if (r < 0)
 268                 return r;
 269
 270         r = hashmap_put(manager->links, INT_TO_PTR(link->ifindex), link);
 271         if (r < 0)
 272                 return r;
 273
 274         r = link_update_flags(link, message);
 275         if (r < 0)
 276                 return r;
 277
 278         *ret = link;
 279         link = NULL;
 280
 281         return 0;
 282 }
 283
 284 static void link_free(Link *link) {
 285         Address *address;
 286         Iterator i;
 287         Link *carrier;
 288
 289         if (!link)
 290                 return;
 291
 292         while ((address = link->addresses)) {
 293                 LIST_REMOVE(addresses, link->addresses, address);
 294                 address_free(address);
 295         }
 296
 297         while ((address = link->pool_addresses)) {
 298                 LIST_REMOVE(addresses, link->pool_addresses, address);
 299                 address_free(address);
 300         }
 301
 302         sd_dhcp_server_unref(link->dhcp_server);
 303         sd_dhcp_client_unref(link->dhcp_client);
 304         sd_dhcp_lease_unref(link->dhcp_lease);
 305
 306         free(link->lease_file);
 307
 308         sd_lldp_free(link->lldp);
 309
 310         free(link->lldp_file);
 311
 312         sd_ipv4ll_unref(link->ipv4ll);
 313         sd_dhcp6_client_unref(link->dhcp6_client);
 314         sd_icmp6_nd_unref(link->icmp6_router_discovery);
 315
 316         if (link->manager)
 317                 hashmap_remove(link->manager->links, INT_TO_PTR(link->ifindex));
 318
 319         free(link->ifname);
 320
 321         free(link->state_file);
 322
 323         udev_device_unref(link->udev_device);
 324
 325         HASHMAP_FOREACH (carrier, link->bound_to_links, i)
 326                 hashmap_remove(link->bound_to_links, INT_TO_PTR(carrier->ifindex));
 327         hashmap_free(link->bound_to_links);
 328
 329         HASHMAP_FOREACH (carrier, link->bound_by_links, i)
 330                 hashmap_remove(link->bound_by_links, INT_TO_PTR(carrier->ifindex));
 331         hashmap_free(link->bound_by_links);
 332
 333         free(link);
 334 }
 335
 336 Link *link_unref(Link *link) {
 337         if (link && (-- link->n_ref <= 0))
 338                 link_free(link);
 339
 340         return NULL;
 341 }
 342
 343 Link *link_ref(Link *link) {
 344         if (link)
 345                 assert_se(++ link->n_ref >= 2);
 346
 347         return link;
 348 }
 349
 350 int link_get(Manager *m, int ifindex, Link **ret) {
 351         Link *link;
 352
 353         assert(m);
 354         assert(ifindex);
 355         assert(ret);
 356
 357         link = hashmap_get(m->links, INT_TO_PTR(ifindex));
 358         if (!link)
 359                 return -ENODEV;
 360
 361         *ret = link;
 362
 363         return 0;
 364 }
 365
 366 static void link_set_state(Link *link, LinkState state) {
 367         assert(link);
 368
 369         if (link->state == state)
 370                 return;
 371
 372         link->state = state;
 373
 374         link_send_changed(link, "AdministrativeState", NULL);
 375
 376         return;
 377 }
 378
 379 static void link_enter_unmanaged(Link *link) {
 380         assert(link);
 381
 382         log_link_debug(link, "Unmanaged");
 383
 384         link_set_state(link, LINK_STATE_UNMANAGED);
 385
 386         link_save(link);
 387 }
 388
 389 static int link_stop_clients(Link *link) {
 390         int r = 0, k;
 391
 392         assert(link);
 393         assert(link->manager);
 394         assert(link->manager->event);
 395
 396         if (!link->network)
 397                 return 0;
 398
 399         if (link->dhcp_client) {
 400                 k = sd_dhcp_client_stop(link->dhcp_client);
 401                 if (k < 0)
 402                         r = log_link_warning_errno(link, r, "Could not stop DHCPv4 client: %m");
 403         }
 404
 405         if (link->ipv4ll) {
 406                 k = sd_ipv4ll_stop(link->ipv4ll);
 407                 if (k < 0)
 408                         r = log_link_warning_errno(link, r, "Could not stop IPv4 link-local: %m");
 409         }
 410
 411         if(link->icmp6_router_discovery) {
 412                 if (link->dhcp6_client) {
 413                         k = sd_dhcp6_client_stop(link->dhcp6_client);
 414                         if (k < 0)
 415                                 r = log_link_warning_errno(link, r, "Could not stop DHCPv6 client: %m");
 416                 }
 417
 418                 k = sd_icmp6_nd_stop(link->icmp6_router_discovery);
 419                 if (k < 0)
 420                         r = log_link_warning_errno(link, r, "Could not stop ICMPv6 router discovery: %m");
 421         }
 422
 423         if (link->lldp) {
 424                 k = sd_lldp_stop(link->lldp);
 425                 if (k < 0)
 426                         r = log_link_warning_errno(link, r, "Could not stop LLDP: %m");
 427         }
 428
 429         return r;
 430 }
 431
 432 void link_enter_failed(Link *link) {
 433         assert(link);
 434
 435         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 436                 return;
 437
 438         log_link_warning(link, "Failed");
 439
 440         link_set_state(link, LINK_STATE_FAILED);
 441
 442         link_stop_clients(link);
 443
 444         link_save(link);
 445 }
 446
 447 static Address* link_find_dhcp_server_address(Link *link) {
 448         Address *address;
 449
 450         assert(link);
 451         assert(link->network);
 452
 453         /* The first statically configured address if there is any */
 454         LIST_FOREACH(addresses, address, link->network->static_addresses) {
 455
 456                 if (address->family != AF_INET)
 457                         continue;
 458
 459                 if (in_addr_is_null(address->family, &address->in_addr))
 460                         continue;
 461
 462                 return address;
 463         }
 464
 465         /* If that didn't work, find a suitable address we got from the pool */
 466         LIST_FOREACH(addresses, address, link->pool_addresses) {
 467                 if (address->family != AF_INET)
 468                         continue;
 469
 470                 return address;
 471         }
 472
 473         return NULL;
 474 }
 475
 476 static int link_enter_configured(Link *link) {
 477         assert(link);
 478         assert(link->network);
 479         assert(link->state == LINK_STATE_SETTING_ROUTES);
 480
 481         log_link_info(link, "Configured");
 482
 483         link_set_state(link, LINK_STATE_CONFIGURED);
 484
 485         link_save(link);
 486
 487         return 0;
 488 }
 489
 490 void link_client_handler(Link *link) {
 491         assert(link);
 492         assert(link->network);
 493
 494         if (!link->static_configured)
 495                 return;
 496
 497         if (link_ipv4ll_enabled(link))
 498                 if (!link->ipv4ll_address ||
 499                     !link->ipv4ll_route)
 500                         return;
 501
 502         if (link_dhcp4_enabled(link) && !link->dhcp4_configured)
 503                         return;
 504
 505         if (link->state != LINK_STATE_CONFIGURED)
 506                 link_enter_configured(link);
 507
 508         return;
 509 }
 510
 511 static int route_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
 512         _cleanup_link_unref_ Link *link = userdata;
 513         int r;
 514
 515         assert(link->link_messages > 0);
 516         assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
 517                       LINK_STATE_SETTING_ROUTES, LINK_STATE_FAILED,
 518                       LINK_STATE_LINGER));
 519
 520         link->link_messages --;
 521
 522         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 523                 return 1;
 524
 525         r = sd_netlink_message_get_errno(m);
 526         if (r < 0 && r != -EEXIST)
 527                 log_link_warning_errno(link, r, "%-*s: could not set route: %m", IFNAMSIZ, link->ifname);
 528
 529         if (link->link_messages == 0) {
 530                 log_link_debug(link, "Routes set");
 531                 link->static_configured = true;
 532                 link_client_handler(link);
 533         }
 534
 535         return 1;
 536 }
 537
 538 static int link_enter_set_routes(Link *link) {
 539         Route *rt;
 540         int r;
 541
 542         assert(link);
 543         assert(link->network);
 544         assert(link->state == LINK_STATE_SETTING_ADDRESSES);
 545
 546         link_set_state(link, LINK_STATE_SETTING_ROUTES);
 547
 548         LIST_FOREACH(routes, rt, link->network->static_routes) {
 549                 r = route_configure(rt, link, &route_handler);
 550                 if (r < 0) {
 551                         log_link_warning_errno(link, r, "Could not set routes: %m");
 552                         link_enter_failed(link);
 553                         return r;
 554                 }
 555
 556                 link->link_messages ++;
 557         }
 558
 559         if (link->link_messages == 0) {
 560                 link->static_configured = true;
 561                 link_client_handler(link);
 562         } else
 563                 log_link_debug(link, "Setting routes");
 564
 565         return 0;
 566 }
 567
 568 int link_route_drop_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
 569         _cleanup_link_unref_ Link *link = userdata;
 570         int r;
 571
 572         assert(m);
 573         assert(link);
 574         assert(link->ifname);
 575
 576         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 577                 return 1;
 578
 579         r = sd_netlink_message_get_errno(m);
 580         if (r < 0 && r != -ESRCH)
 581                 log_link_warning_errno(link, r, "%-*s: could not drop route: %m", IFNAMSIZ, link->ifname);
 582
 583         return 1;
 584 }
 585
 586 static int address_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
 587         _cleanup_link_unref_ Link *link = userdata;
 588         int r;
 589
 590         assert(rtnl);
 591         assert(m);
 592         assert(link);
 593         assert(link->ifname);
 594         assert(link->link_messages > 0);
 595         assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
 596                LINK_STATE_FAILED, LINK_STATE_LINGER));
 597
 598         link->link_messages --;
 599
 600         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 601                 return 1;
 602
 603         r = sd_netlink_message_get_errno(m);
 604         if (r < 0 && r != -EEXIST)
 605                 log_link_warning_errno(link, r, "%-*s: could not set address: %m", IFNAMSIZ, link->ifname);
 606         else if (r >= 0)
 607                 link_rtnl_process_address(rtnl, m, link->manager);
 608
 609         if (link->link_messages == 0) {
 610                 log_link_debug(link, "Addresses set");
 611                 link_enter_set_routes(link);
 612         }
 613
 614         return 1;
 615 }
 616
 617 static int link_enter_set_addresses(Link *link) {
 618         Address *ad;
 619         int r;
 620
 621         assert(link);
 622         assert(link->network);
 623         assert(link->state != _LINK_STATE_INVALID);
 624
 625         link_set_state(link, LINK_STATE_SETTING_ADDRESSES);
 626
 627         LIST_FOREACH(addresses, ad, link->network->static_addresses) {
 628                 r = address_configure(ad, link, &address_handler);
 629                 if (r < 0) {
 630                         log_link_warning_errno(link, r, "Could not set addresses: %m");
 631                         link_enter_failed(link);
 632                         return r;
 633                 }
 634
 635                 link->link_messages ++;
 636         }
 637
 638         /* now that we can figure out a default address for the dhcp server,
 639            start it */
 640         if (link_dhcp4_server_enabled(link)) {
 641                 struct in_addr pool_start;
 642                 Address *address;
 643
 644                 address = link_find_dhcp_server_address(link);
 645                 if (!address) {
 646                         log_link_warning(link, "Failed to find suitable address for DHCPv4 server instance.");
 647                         link_enter_failed(link);
 648                         return 0;
 649                 }
 650
 651                 r = sd_dhcp_server_set_address(link->dhcp_server,
 652                                                &address->in_addr.in,
 653                                                address->prefixlen);
 654                 if (r < 0)
 655                         return r;
 656
 657                 /* offer 32 addresses starting from the address following the server address */
 658                 pool_start.s_addr = htobe32(be32toh(address->in_addr.in.s_addr) + 1);
 659                 r = sd_dhcp_server_set_lease_pool(link->dhcp_server,
 660                                                   &pool_start, 32);
 661                 if (r < 0)
 662                         return r;
 663
 664                 /* TODO:
 665                 r = sd_dhcp_server_set_router(link->dhcp_server,
 666                                               &main_address->in_addr.in);
 667                 if (r < 0)
 668                         return r;
 669
 670                 r = sd_dhcp_server_set_prefixlen(link->dhcp_server,
 671                                                  main_address->prefixlen);
 672                 if (r < 0)
 673                         return r;
 674                 */
 675
 676                 if (link->network->dhcp_server_max_lease_time_usec > 0) {
 677                         r = sd_dhcp_server_set_max_lease_time(
 678                                         link->dhcp_server,
 679                                         DIV_ROUND_UP(link->network->dhcp_server_max_lease_time_usec, USEC_PER_SEC));
 680                         if (r < 0)
 681                                 return r;
 682                 }
 683
 684                 if (link->network->dhcp_server_default_lease_time_usec > 0) {
 685                         r = sd_dhcp_server_set_default_lease_time(
 686                                         link->dhcp_server,
 687                                         DIV_ROUND_UP(link->network->dhcp_server_default_lease_time_usec, USEC_PER_SEC));
 688                         if (r < 0)
 689                                 return r;
 690                 }
 691
 692                 if (link->network->dhcp_server_emit_timezone) {
 693                         _cleanup_free_ char *buffer = NULL;
 694                         const char *tz;
 695
 696                         if (link->network->dhcp_server_timezone)
 697                                 tz = link->network->dhcp_server_timezone;
 698                         else {
 699                                 r = get_timezone(&buffer);
 700                                 if (r < 0)
 701                                         log_warning_errno(r, "Failed to determine timezone: %m");
 702                                 else
 703                                         tz = buffer;
 704                         }
 705
 706                         if (tz) {
 707                                 r = sd_dhcp_server_set_timezone(link->dhcp_server, tz);
 708                                 if (r < 0)
 709                                         return r;
 710                         }
 711                 }
 712
 713                 r = sd_dhcp_server_start(link->dhcp_server);
 714                 if (r < 0) {
 715                         log_link_warning_errno(link, r, "Could not start DHCPv4 server instance: %m");
 716
 717                         link_enter_failed(link);
 718
 719                         return 0;
 720                 }
 721
 722                 log_link_debug(link, "Offering DHCPv4 leases");
 723         }
 724
 725         if (link->link_messages == 0)
 726                 link_enter_set_routes(link);
 727         else
 728                 log_link_debug(link, "Setting addresses");
 729
 730         return 0;
 731 }
 732
 733 int link_address_drop_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
 734         _cleanup_link_unref_ Link *link = userdata;
 735         int r;
 736
 737         assert(m);
 738         assert(link);
 739         assert(link->ifname);
 740
 741         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 742                 return 1;
 743
 744         r = sd_netlink_message_get_errno(m);
 745         if (r < 0 && r != -EADDRNOTAVAIL)
 746                 log_link_warning_errno(link, r, "%-*s: could not drop address: %m", IFNAMSIZ, link->ifname);
 747
 748         return 1;
 749 }
 750
 751 static int link_set_bridge_fdb(Link *const link) {
 752         FdbEntry *fdb_entry;
 753         int r = 0;
 754
 755         LIST_FOREACH(static_fdb_entries, fdb_entry, link->network->static_fdb_entries) {
 756                 r = fdb_entry_configure(link, fdb_entry);
 757                 if(r < 0) {
 758                         log_link_error_errno(link, r, "Failed to add MAC entry to static MAC table: %m");
 759                         break;
 760                 }
 761         }
 762
 763         return r;
 764 }
 765
 766 static int link_set_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
 767         _cleanup_link_unref_ Link *link = userdata;
 768         int r;
 769
 770         log_link_debug(link, "Set link");
 771
 772         r = sd_netlink_message_get_errno(m);
 773         if (r < 0 && r != -EEXIST) {
 774                 log_link_error_errno(link, r, "Could not join netdev: %m");
 775                 link_enter_failed(link);
 776                 return 1;
 777         }
 778
 779         return 0;
 780 }
 781
 782 static int set_hostname_handler(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
 783         _cleanup_link_unref_ Link *link = userdata;
 784         int r;
 785
 786         assert(m);
 787         assert(link);
 788
 789         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 790                 return 1;
 791
 792         r = sd_bus_message_get_errno(m);
 793         if (r > 0)
 794                 log_link_warning_errno(link, r, "Could not set hostname: %m");
 795
 796         return 1;
 797 }
 798
 799 int link_set_hostname(Link *link, const char *hostname) {
 800         int r = 0;
 801
 802         assert(link);
 803         assert(link->manager);
 804         assert(hostname);
 805
 806         log_link_debug(link, "Setting transient hostname: '%s'", hostname);
 807
 808         if (!link->manager->bus) {
 809                 /* TODO: replace by assert when we can rely on kdbus */
 810                 log_link_info(link, "Not connected to system bus, ignoring transient hostname.");
 811                 return 0;
 812         }
 813
 814         r = sd_bus_call_method_async(
 815                         link->manager->bus,
 816                         NULL,
 817                         "org.freedesktop.hostname1",
 818                         "/org/freedesktop/hostname1",
 819                         "org.freedesktop.hostname1",
 820                         "SetHostname",
 821                         set_hostname_handler,
 822                         link,
 823                         "sb",
 824                         hostname,
 825                         false);
 826
 827         if (r < 0)
 828                 return log_link_error_errno(link, r, "Could not set transient hostname: %m");
 829
 830         link_ref(link);
 831
 832         return 0;
 833 }
 834
 835 static int set_mtu_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
 836         _cleanup_link_unref_ Link *link = userdata;
 837         int r;
 838
 839         assert(m);
 840         assert(link);
 841         assert(link->ifname);
 842
 843         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 844                 return 1;
 845
 846         r = sd_netlink_message_get_errno(m);
 847         if (r < 0)
 848                 log_link_warning_errno(link, r, "%-*s: could not set MTU: %m", IFNAMSIZ, link->ifname);
 849
 850         return 1;
 851 }
 852
 853 int link_set_mtu(Link *link, uint32_t mtu) {
 854         _cleanup_netlink_message_unref_ sd_netlink_message *req = NULL;
 855         int r;
 856
 857         assert(link);
 858         assert(link->manager);
 859         assert(link->manager->rtnl);
 860
 861         log_link_debug(link, "Setting MTU: %" PRIu32, mtu);
 862
 863         r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
 864         if (r < 0)
 865                 return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
 866
 867         r = sd_netlink_message_append_u32(req, IFLA_MTU, mtu);
 868         if (r < 0)
 869                 return log_link_error_errno(link, r, "Could not append MTU: %m");
 870
 871         r = sd_netlink_call_async(link->manager->rtnl, req, set_mtu_handler, link, 0, NULL);
 872         if (r < 0)
 873                 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
 874
 875         link_ref(link);
 876
 877         return 0;
 878 }
 879
 880 static int link_set_bridge(Link *link) {
 881         _cleanup_netlink_message_unref_ sd_netlink_message *req = NULL;
 882         int r;
 883
 884         assert(link);
 885         assert(link->network);
 886
 887         r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
 888         if (r < 0)
 889                 return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
 890
 891         r = sd_rtnl_message_link_set_family(req, PF_BRIDGE);
 892         if (r < 0)
 893                 return log_link_error_errno(link, r, "Could not set message family: %m");
 894
 895         r = sd_netlink_message_open_container(req, IFLA_PROTINFO);
 896         if (r < 0)
 897                 return log_link_error_errno(link, r, "Could not append IFLA_PROTINFO attribute: %m");
 898
 899         r = sd_netlink_message_append_u8(req, IFLA_BRPORT_GUARD, !link->network->use_bpdu);
 900         if (r < 0)
 901                 return log_link_error_errno(link, r, "Could not append IFLA_BRPORT_GUARD attribute: %m");
 902
 903         r = sd_netlink_message_append_u8(req, IFLA_BRPORT_MODE, link->network->hairpin);
 904         if (r < 0)
 905                 return log_link_error_errno(link, r, "Could not append IFLA_BRPORT_MODE attribute: %m");
 906
 907         r = sd_netlink_message_append_u8(req, IFLA_BRPORT_FAST_LEAVE, link->network->fast_leave);
 908         if (r < 0)
 909                 return log_link_error_errno(link, r, "Could not append IFLA_BRPORT_FAST_LEAVE attribute: %m");
 910
 911         r = sd_netlink_message_append_u8(req, IFLA_BRPORT_PROTECT, !link->network->allow_port_to_be_root);
 912         if (r < 0)
 913                 return log_link_error_errno(link, r, "Could not append IFLA_BRPORT_PROTECT attribute: %m");
 914
 915         r = sd_netlink_message_append_u8(req, IFLA_BRPORT_UNICAST_FLOOD, link->network->unicast_flood);
 916         if (r < 0)
 917                 return log_link_error_errno(link, r, "Could not append IFLA_BRPORT_UNICAST_FLOOD attribute: %m");
 918
 919         if(link->network->cost != 0) {
 920                 r = sd_netlink_message_append_u32(req, IFLA_BRPORT_COST, link->network->cost);
 921                 if (r < 0)
 922                         return log_link_error_errno(link, r, "Could not append IFLA_BRPORT_COST attribute: %m");
 923         }
 924
 925         r = sd_netlink_message_close_container(req);
 926         if (r < 0)
 927                 return log_link_error_errno(link, r, "Could not append IFLA_LINKINFO attribute: %m");
 928
 929         r = sd_netlink_call_async(link->manager->rtnl, req, link_set_handler, link, 0, NULL);
 930         if (r < 0)
 931                 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
 932
 933         link_ref(link);
 934
 935         return r;
 936 }
 937
 938 static void lldp_handler(sd_lldp *lldp, int event, void *userdata) {
 939         Link *link = userdata;
 940         int r;
 941
 942         assert(link);
 943         assert(link->network);
 944         assert(link->manager);
 945
 946         if (event != UPDATE_INFO)
 947                 return;
 948
 949         r = sd_lldp_save(link->lldp, link->lldp_file);
 950         if (r < 0)
 951                 log_link_warning_errno(link, r, "Could not save LLDP: %m");
 952
 953 }
 954
 955 static int link_acquire_conf(Link *link) {
 956         int r;
 957
 958         assert(link);
 959         assert(link->network);
 960         assert(link->manager);
 961         assert(link->manager->event);
 962
 963         if (link_ipv4ll_enabled(link)) {
 964                 assert(link->ipv4ll);
 965
 966                 log_link_debug(link, "Acquiring IPv4 link-local address");
 967
 968                 r = sd_ipv4ll_start(link->ipv4ll);
 969                 if (r < 0)
 970                         return log_link_warning_errno(link, r, "Could not acquire IPv4 link-local address: %m");
 971         }
 972
 973         if (link_dhcp4_enabled(link)) {
 974                 assert(link->dhcp_client);
 975
 976                 log_link_debug(link, "Acquiring DHCPv4 lease");
 977
 978                 r = sd_dhcp_client_start(link->dhcp_client);
 979                 if (r < 0)
 980                         return log_link_warning_errno(link, r, "Could not acquire DHCPv4 lease: %m");
 981         }
 982
 983         if (link_dhcp6_enabled(link)) {
 984                 assert(link->icmp6_router_discovery);
 985
 986                 log_link_debug(link, "Discovering IPv6 routers");
 987
 988                 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
 989                 if (r < 0)
 990                         return log_link_warning_errno(link, r, "Could not start IPv6 router discovery: %m");
 991         }
 992
 993         if (link_lldp_enabled(link)) {
 994                 assert(link->lldp);
 995
 996                 log_link_debug(link, "Starting LLDP");
 997
 998                 r = sd_lldp_start(link->lldp);
 999                 if (r < 0)
1000                         return log_link_warning_errno(link, r, "Could not start LLDP: %m");
1001         }
1002
1003         return 0;
1004 }
1005
1006 bool link_has_carrier(Link *link) {
1007         /* see Documentation/networking/operstates.txt in the kernel sources */
1008
1009         if (link->kernel_operstate == IF_OPER_UP)
1010                 return true;
1011
1012         if (link->kernel_operstate == IF_OPER_UNKNOWN)
1013                 /* operstate may not be implemented, so fall back to flags */
1014                 if ((link->flags & IFF_LOWER_UP) && !(link->flags & IFF_DORMANT))
1015                         return true;
1016
1017         return false;
1018 }
1019
1020 static int link_up_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
1021         _cleanup_link_unref_ Link *link = userdata;
1022         int r;
1023
1024         assert(link);
1025
1026         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1027                 return 1;
1028
1029         r = sd_netlink_message_get_errno(m);
1030         if (r < 0)
1031                 /* we warn but don't fail the link, as it may be
1032                    brought up later */
1033                 log_link_warning_errno(link, r, "%-*s: could not bring up interface: %m", IFNAMSIZ, link->ifname);
1034
1035         return 1;
1036 }
1037
1038 static int link_up(Link *link) {
1039         _cleanup_netlink_message_unref_ sd_netlink_message *req = NULL;
1040         uint8_t ipv6ll_mode;
1041         int r;
1042
1043         assert(link);
1044         assert(link->network);
1045         assert(link->manager);
1046         assert(link->manager->rtnl);
1047
1048         log_link_debug(link, "Bringing link up");
1049
1050         r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_SETLINK, link->ifindex);
1051         if (r < 0)
1052                 return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
1053
1054         r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1055         if (r < 0)
1056                 return log_link_error_errno(link, r, "Could not set link flags: %m");
1057
1058         if (link->network->mac) {
1059                 r = sd_netlink_message_append_ether_addr(req, IFLA_ADDRESS, link->network->mac);
1060                 if (r < 0)
1061                         return log_link_error_errno(link, r, "Could not set MAC address: %m");
1062         }
1063
1064         if (link->network->mtu) {
1065                 r = sd_netlink_message_append_u32(req, IFLA_MTU, link->network->mtu);
1066                 if (r < 0)
1067                         return log_link_error_errno(link, r, "Could not set MTU: %m");
1068         }
1069
1070         r = sd_netlink_message_open_container(req, IFLA_AF_SPEC);
1071         if (r < 0)
1072                 return log_link_error_errno(link, r, "Could not open IFLA_AF_SPEC container: %m");
1073
1074         if (socket_ipv6_is_supported()) {
1075                 /* if the kernel lacks ipv6 support setting IFF_UP fails if any ipv6 options are passed */
1076                 r = sd_netlink_message_open_container(req, AF_INET6);
1077                 if (r < 0)
1078                         return log_link_error_errno(link, r, "Could not open AF_INET6 container: %m");
1079
1080                 ipv6ll_mode = link_ipv6ll_enabled(link) ? IN6_ADDR_GEN_MODE_EUI64 : IN6_ADDR_GEN_MODE_NONE;
1081                 r = sd_netlink_message_append_u8(req, IFLA_INET6_ADDR_GEN_MODE, ipv6ll_mode);
1082                 if (r < 0)
1083                         return log_link_error_errno(link, r, "Could not append IFLA_INET6_ADDR_GEN_MODE: %m");
1084
1085                 if (!in_addr_is_null(AF_INET6, &link->network->ipv6_token)) {
1086                         r = sd_netlink_message_append_in6_addr(req, IFLA_INET6_TOKEN, &link->network->ipv6_token.in6);
1087                         if (r < 0)
1088                                 return log_link_error_errno(link, r, "Could not append IFLA_INET6_TOKEN: %m");
1089                 }
1090
1091                 r = sd_netlink_message_close_container(req);
1092                 if (r < 0)
1093                         return log_link_error_errno(link, r, "Could not close AF_INET6 container: %m");
1094         }
1095
1096         r = sd_netlink_message_close_container(req);
1097         if (r < 0)
1098                 return log_link_error_errno(link, r, "Could not close IFLA_AF_SPEC container: %m");
1099
1100         r = sd_netlink_call_async(link->manager->rtnl, req, link_up_handler, link, 0, NULL);
1101         if (r < 0)
1102                 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
1103
1104         link_ref(link);
1105
1106         return 0;
1107 }
1108
1109 static int link_down_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
1110         _cleanup_link_unref_ Link *link = userdata;
1111         int r;
1112
1113         assert(link);
1114
1115         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1116                 return 1;
1117
1118         r = sd_netlink_message_get_errno(m);
1119         if (r < 0)
1120                 log_link_warning_errno(link, r, "%-*s: could not bring down interface: %m", IFNAMSIZ, link->ifname);
1121
1122         return 1;
1123 }
1124
1125 static int link_down(Link *link) {
1126         _cleanup_netlink_message_unref_ sd_netlink_message *req = NULL;
1127         int r;
1128
1129         assert(link);
1130         assert(link->manager);
1131         assert(link->manager->rtnl);
1132
1133         log_link_debug(link, "Bringing link down");
1134
1135         r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1136                                      RTM_SETLINK, link->ifindex);
1137         if (r < 0)
1138                 return log_link_error_errno(link, r, "Could not allocate RTM_SETLINK message: %m");
1139
1140         r = sd_rtnl_message_link_set_flags(req, 0, IFF_UP);
1141         if (r < 0)
1142                 return log_link_error_errno(link, r, "Could not set link flags: %m");
1143
1144         r = sd_netlink_call_async(link->manager->rtnl, req, link_down_handler, link,  0, NULL);
1145         if (r < 0)
1146                 return log_link_error_errno(link, r, "Could not send rtnetlink message: %m");
1147
1148         link_ref(link);
1149
1150         return 0;
1151 }
1152
1153 static int link_handle_bound_to_list(Link *link) {
1154         Link *l;
1155         Iterator i;
1156         int r;
1157         bool required_up = false;
1158         bool link_is_up = false;
1159
1160         assert(link);
1161
1162         if (hashmap_isempty(link->bound_to_links))
1163                 return 0;
1164
1165         if (link->flags & IFF_UP)
1166                 link_is_up = true;
1167
1168         HASHMAP_FOREACH (l, link->bound_to_links, i)
1169                 if (link_has_carrier(l)) {
1170                         required_up = true;
1171                         break;
1172                 }
1173
1174         if (!required_up && link_is_up) {
1175                 r = link_down(link);
1176                 if (r < 0)
1177                         return r;
1178         } else if (required_up && !link_is_up) {
1179                 r = link_up(link);
1180                 if (r < 0)
1181                         return r;
1182         }
1183
1184         return 0;
1185 }
1186
1187 static int link_handle_bound_by_list(Link *link) {
1188         Iterator i;
1189         Link *l;
1190         int r;
1191
1192         assert(link);
1193
1194         if (hashmap_isempty(link->bound_by_links))
1195                 return 0;
1196
1197         HASHMAP_FOREACH (l, link->bound_by_links, i) {
1198                 r = link_handle_bound_to_list(l);
1199                 if (r < 0)
1200                         return r;
1201         }
1202
1203         return 0;
1204 }
1205
1206 static int link_put_carrier(Link *link, Link *carrier, Hashmap **h) {
1207         int r;
1208
1209         assert(link);
1210         assert(carrier);
1211
1212         if (link == carrier)
1213                 return 0;
1214
1215         if (hashmap_get(*h, INT_TO_PTR(carrier->ifindex)))
1216                 return 0;
1217
1218         r = hashmap_ensure_allocated(h, NULL);
1219         if (r < 0)
1220                 return r;
1221
1222         r = hashmap_put(*h, INT_TO_PTR(carrier->ifindex), carrier);
1223         if (r < 0)
1224                 return r;
1225
1226         return 0;
1227 }
1228
1229 static int link_new_bound_by_list(Link *link) {
1230         Manager *m;
1231         Link *carrier;
1232         Iterator i;
1233         int r;
1234         bool list_updated = false;
1235
1236         assert(link);
1237         assert(link->manager);
1238
1239         m = link->manager;
1240
1241         HASHMAP_FOREACH (carrier, m->links, i) {
1242                 if (!carrier->network)
1243                         continue;
1244
1245                 if (strv_isempty(carrier->network->bind_carrier))
1246                         continue;
1247
1248                 if (strv_fnmatch(carrier->network->bind_carrier, link->ifname, 0)) {
1249                         r = link_put_carrier(link, carrier, &link->bound_by_links);
1250                         if (r < 0)
1251                                 return r;
1252
1253                         list_updated = true;
1254                 }
1255         }
1256
1257         if (list_updated)
1258                 link_save(link);
1259
1260         HASHMAP_FOREACH (carrier, link->bound_by_links, i) {
1261                 r = link_put_carrier(carrier, link, &carrier->bound_to_links);
1262                 if (r < 0)
1263                         return r;
1264
1265                 link_save(carrier);
1266         }
1267
1268         return 0;
1269 }
1270
1271 static int link_new_bound_to_list(Link *link) {
1272         Manager *m;
1273         Link *carrier;
1274         Iterator i;
1275         int r;
1276         bool list_updated = false;
1277
1278         assert(link);
1279         assert(link->manager);
1280
1281         if (!link->network)
1282                 return 0;
1283
1284         if (strv_isempty(link->network->bind_carrier))
1285                 return 0;
1286
1287         m = link->manager;
1288
1289         HASHMAP_FOREACH (carrier, m->links, i) {
1290                 if (strv_fnmatch(link->network->bind_carrier, carrier->ifname, 0)) {
1291                         r = link_put_carrier(link, carrier, &link->bound_to_links);
1292                         if (r < 0)
1293                                 return r;
1294
1295                         list_updated = true;
1296                 }
1297         }
1298
1299         if (list_updated)
1300                 link_save(link);
1301
1302         HASHMAP_FOREACH (carrier, link->bound_to_links, i) {
1303                 r = link_put_carrier(carrier, link, &carrier->bound_by_links);
1304                 if (r < 0)
1305                         return r;
1306
1307                 link_save(carrier);
1308         }
1309
1310         return 0;
1311 }
1312
1313 static int link_new_carrier_maps(Link *link) {
1314         int r;
1315
1316         r = link_new_bound_by_list(link);
1317         if (r < 0)
1318                 return r;
1319
1320         r = link_handle_bound_by_list(link);
1321         if (r < 0)
1322                 return r;
1323
1324         r = link_new_bound_to_list(link);
1325         if (r < 0)
1326                 return r;
1327
1328         r = link_handle_bound_to_list(link);
1329         if (r < 0)
1330                 return r;
1331
1332         return 0;
1333 }
1334
1335 static void link_free_bound_to_list(Link *link) {
1336         Link *bound_to;
1337         Iterator i;
1338
1339         HASHMAP_FOREACH (bound_to, link->bound_to_links, i) {
1340                 hashmap_remove(link->bound_to_links, INT_TO_PTR(bound_to->ifindex));
1341
1342                 if (hashmap_remove(bound_to->bound_by_links, INT_TO_PTR(link->ifindex)))
1343                         link_save(bound_to);
1344         }
1345
1346         return;
1347 }
1348
1349 static void link_free_bound_by_list(Link *link) {
1350         Link *bound_by;
1351         Iterator i;
1352
1353         HASHMAP_FOREACH (bound_by, link->bound_by_links, i) {
1354                 hashmap_remove(link->bound_by_links, INT_TO_PTR(bound_by->ifindex));
1355
1356                 if (hashmap_remove(bound_by->bound_to_links, INT_TO_PTR(link->ifindex))) {
1357                         link_save(bound_by);
1358                         link_handle_bound_to_list(bound_by);
1359                 }
1360         }
1361
1362         return;
1363 }
1364
1365 static void link_free_carrier_maps(Link *link) {
1366         bool list_updated = false;
1367
1368         assert(link);
1369
1370         if (!hashmap_isempty(link->bound_to_links)) {
1371                 link_free_bound_to_list(link);
1372                 list_updated = true;
1373         }
1374
1375         if (!hashmap_isempty(link->bound_by_links)) {
1376                 link_free_bound_by_list(link);
1377                 list_updated = true;
1378         }
1379
1380         if (list_updated)
1381                 link_save(link);
1382
1383         return;
1384 }
1385
1386 void link_drop(Link *link) {
1387         if (!link || link->state == LINK_STATE_LINGER)
1388                 return;
1389
1390         link_set_state(link, LINK_STATE_LINGER);
1391
1392         link_free_carrier_maps(link);
1393
1394         log_link_debug(link, "Link removed");
1395
1396         link_unref(link);
1397
1398         return;
1399 }
1400
1401 static int link_joined(Link *link) {
1402         int r;
1403
1404         assert(link);
1405         assert(link->network);
1406
1407         if (!hashmap_isempty(link->bound_to_links)) {
1408                 r = link_handle_bound_to_list(link);
1409                 if (r < 0)
1410                         return r;
1411         } else if (!(link->flags & IFF_UP)) {
1412                 r = link_up(link);
1413                 if (r < 0) {
1414                         link_enter_failed(link);
1415                         return r;
1416                 }
1417         }
1418
1419         if(link->network->bridge) {
1420                 r = link_set_bridge(link);
1421                 if (r < 0)
1422                         log_link_error_errno(link, r, "Could not set bridge message: %m");
1423         }
1424
1425         return link_enter_set_addresses(link);
1426 }
1427
1428 static int netdev_join_handler(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {
1429         _cleanup_link_unref_ Link *link = userdata;
1430         int r;
1431
1432         assert(link);
1433         assert(link->network);
1434
1435         link->enslaving --;
1436
1437         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1438                 return 1;
1439
1440         r = sd_netlink_message_get_errno(m);
1441         if (r < 0 && r != -EEXIST) {
1442                 log_link_error_errno(link, r, "%-*s: could not join netdev: %m", IFNAMSIZ, link->ifname);
1443                 link_enter_failed(link);
1444                 return 1;
1445         } else
1446                 log_link_debug(link, "Joined netdev");
1447
1448         if (link->enslaving <= 0)
1449                 link_joined(link);
1450
1451         return 1;
1452 }
1453
1454 static int link_enter_join_netdev(Link *link) {
1455         NetDev *netdev;
1456         Iterator i;
1457         int r;
1458
1459         assert(link);
1460         assert(link->network);
1461         assert(link->state == LINK_STATE_PENDING);
1462
1463         link_set_state(link, LINK_STATE_ENSLAVING);
1464
1465         link_save(link);
1466
1467         if (!link->network->bridge &&
1468             !link->network->bond &&
1469             hashmap_isempty(link->network->stacked_netdevs))
1470                 return link_joined(link);
1471
1472         if (link->network->bond) {
1473                 log_struct(LOG_DEBUG,
1474                            LOG_LINK_INTERFACE(link),
1475                            LOG_NETDEV_INTERFACE(link->network->bond),
1476                            LOG_LINK_MESSAGE(link, "Enslaving by '%s'", link->network->bond->ifname),
1477                            NULL);
1478
1479                 r = netdev_join(link->network->bond, link, netdev_join_handler);
1480                 if (r < 0) {
1481                         log_struct_errno(LOG_WARNING, r,
1482                                          LOG_LINK_INTERFACE(link),
1483                                          LOG_NETDEV_INTERFACE(link->network->bond),
1484                                          LOG_LINK_MESSAGE(link, "Could not join netdev '%s': %m", link->network->bond->ifname),
1485                                          NULL);
1486
1487                         link_enter_failed(link);
1488                         return r;
1489                 }
1490
1491                 link->enslaving ++;
1492         }
1493
1494         if (link->network->bridge) {
1495                 log_struct(LOG_DEBUG,
1496                            LOG_LINK_INTERFACE(link),
1497                            LOG_NETDEV_INTERFACE(link->network->bridge),
1498                            LOG_LINK_MESSAGE(link, "Enslaving by '%s'", link->network->bridge->ifname),
1499                            NULL);
1500
1501                 r = netdev_join(link->network->bridge, link, netdev_join_handler);
1502                 if (r < 0) {
1503                         log_struct_errno(LOG_WARNING, r,
1504                                          LOG_LINK_INTERFACE(link),
1505                                          LOG_NETDEV_INTERFACE(link->network->bridge),
1506                                          LOG_LINK_MESSAGE(link, "Could not join netdev '%s': %m", link->network->bridge->ifname),
1507                                          NULL),
1508                         link_enter_failed(link);
1509                         return r;
1510                 }
1511
1512                 link->enslaving ++;
1513         }
1514
1515         HASHMAP_FOREACH(netdev, link->network->stacked_netdevs, i) {
1516
1517                 log_struct(LOG_DEBUG,
1518                            LOG_LINK_INTERFACE(link),
1519                            LOG_NETDEV_INTERFACE(netdev),
1520                            LOG_LINK_MESSAGE(link, "Enslaving by '%s'", netdev->ifname),
1521                            NULL);
1522
1523                 r = netdev_join(netdev, link, netdev_join_handler);
1524                 if (r < 0) {
1525                         log_struct_errno(LOG_WARNING, r,
1526                                          LOG_LINK_INTERFACE(link),
1527                                          LOG_NETDEV_INTERFACE(netdev),
1528                                          LOG_LINK_MESSAGE(link, "Could not join netdev '%s': %m", netdev->ifname),
1529                                          NULL);
1530                         link_enter_failed(link);
1531                         return r;
1532                 }
1533
1534                 link->enslaving ++;
1535         }
1536
1537         return 0;
1538 }
1539
1540 static int link_set_ipv4_forward(Link *link) {
1541         const char *p = NULL, *v;
1542         int r;
1543
1544         if (link->flags & IFF_LOOPBACK)
1545                 return 0;
1546
1547         if (link->network->ip_forward == _ADDRESS_FAMILY_BOOLEAN_INVALID)
1548                 return 0;
1549
1550         p = strjoina("/proc/sys/net/ipv4/conf/", link->ifname, "/forwarding");
1551         v = one_zero(link_ipv4_forward_enabled(link));
1552
1553         r = write_string_file(p, v, 0);
1554         if (r < 0) {
1555                 /* If the right value is set anyway, don't complain */
1556                 if (verify_one_line_file(p, v) > 0)
1557                         return 0;
1558
1559                 log_link_warning_errno(link, r, "Cannot configure IPv4 forwarding for interface %s: %m", link->ifname);
1560         }
1561
1562         return 0;
1563 }
1564
1565 static int link_set_ipv6_forward(Link *link) {
1566         const char *p = NULL, *v = NULL;
1567         int r;
1568
1569         /* Make this a NOP if IPv6 is not available */
1570         if (!socket_ipv6_is_supported())
1571                 return 0;
1572
1573         if (link->flags & IFF_LOOPBACK)
1574                 return 0;
1575
1576         if (link->network->ip_forward == _ADDRESS_FAMILY_BOOLEAN_INVALID)
1577                 return 0;
1578
1579         p = strjoina("/proc/sys/net/ipv6/conf/", link->ifname, "/forwarding");
1580         v = one_zero(link_ipv6_forward_enabled(link));
1581
1582         r = write_string_file(p, v, 0);
1583         if (r < 0) {
1584                 /* If the right value is set anyway, don't complain */
1585                 if (verify_one_line_file(p, v) > 0)
1586                         return 0;
1587
1588                 log_link_warning_errno(link, r, "Cannot configure IPv6 forwarding for interface: %m");
1589         }
1590
1591         return 0;
1592 }
1593
1594 static int link_set_ipv6_privacy_extensions(Link *link) {
1595         char buf[DECIMAL_STR_MAX(unsigned) + 1];
1596         IPv6PrivacyExtensions s;
1597         const char *p = NULL;
1598         int r;
1599
1600         /* Make this a NOP if IPv6 is not available */
1601         if (!socket_ipv6_is_supported())
1602                 return 0;
1603
1604         s = link_ipv6_privacy_extensions(link);
1605         if (s == _IPV6_PRIVACY_EXTENSIONS_INVALID)
1606                 return 0;
1607
1608         p = strjoina("/proc/sys/net/ipv6/conf/", link->ifname, "/use_tempaddr");
1609         xsprintf(buf, "%u", link->network->ipv6_privacy_extensions);
1610
1611         r = write_string_file(p, buf, 0);
1612         if (r < 0) {
1613                 /* If the right value is set anyway, don't complain */
1614                 if (verify_one_line_file(p, buf) > 0)
1615                         return 0;
1616
1617                 log_link_warning_errno(link, r, "Cannot configure IPv6 privacy extension for interface: %m");
1618         }
1619
1620         return 0;
1621 }
1622
1623 static int link_configure(Link *link) {
1624         int r;
1625
1626         assert(link);
1627         assert(link->network);
1628         assert(link->state == LINK_STATE_PENDING);
1629
1630         r = link_set_bridge_fdb(link);
1631         if (r < 0)
1632                 return r;
1633
1634         r = link_set_ipv4_forward(link);
1635         if (r < 0)
1636                 return r;
1637
1638         r = link_set_ipv6_forward(link);
1639         if (r < 0)
1640                 return r;
1641
1642         r = link_set_ipv6_privacy_extensions(link);
1643         if (r < 0)
1644                 return r;
1645
1646         if (link_ipv4ll_enabled(link)) {
1647                 r = ipv4ll_configure(link);
1648                 if (r < 0)
1649                         return r;
1650         }
1651
1652         if (link_dhcp4_enabled(link)) {
1653                 r = dhcp4_configure(link);
1654                 if (r < 0)
1655                         return r;
1656         }
1657
1658         if (link_dhcp4_server_enabled(link)) {
1659                 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
1660                 if (r < 0)
1661                         return r;
1662
1663                 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
1664                 if (r < 0)
1665                         return r;
1666         }
1667
1668         if (link_dhcp6_enabled(link)) {
1669                 r = icmp6_configure(link);
1670                 if (r < 0)
1671                         return r;
1672         }
1673
1674         if (link_lldp_enabled(link)) {
1675                 r = sd_lldp_new(link->ifindex, link->ifname, &link->mac, &link->lldp);
1676                 if (r < 0)
1677                         return r;
1678
1679                 r = sd_lldp_attach_event(link->lldp, NULL, 0);
1680                 if (r < 0)
1681                         return r;
1682
1683                 r = sd_lldp_set_callback(link->lldp,
1684                                          lldp_handler, link);
1685                 if (r < 0)
1686                         return r;
1687         }
1688
1689         if (link_has_carrier(link)) {
1690                 r = link_acquire_conf(link);
1691                 if (r < 0)
1692                         return r;
1693         }
1694
1695         return link_enter_join_netdev(link);
1696 }
1697
1698 static int link_initialized_and_synced(sd_netlink *rtnl, sd_netlink_message *m,
1699                                        void *userdata) {
1700         _cleanup_link_unref_ Link *link = userdata;
1701         Network *network;
1702         int r;
1703
1704         assert(link);
1705         assert(link->ifname);
1706         assert(link->manager);
1707
1708         if (link->state != LINK_STATE_PENDING)
1709                 return 1;
1710
1711         log_link_debug(link, "Link state is up-to-date");
1712
1713         r = link_new_bound_by_list(link);
1714         if (r < 0)
1715                 return r;
1716
1717         r = link_handle_bound_by_list(link);
1718         if (r < 0)
1719                 return r;
1720
1721         r = network_get(link->manager, link->udev_device, link->ifname,
1722                         &link->mac, &network);
1723         if (r == -ENOENT) {
1724                 link_enter_unmanaged(link);
1725                 return 1;
1726         } else if (r < 0)
1727                 return r;
1728
1729         if (link->flags & IFF_LOOPBACK) {
1730                 if (network->link_local != ADDRESS_FAMILY_NO)
1731                         log_link_debug(link, "Ignoring link-local autoconfiguration for loopback link");
1732
1733                 if (network->dhcp != ADDRESS_FAMILY_NO)
1734                         log_link_debug(link, "Ignoring DHCP clients for loopback link");
1735
1736                 if (network->dhcp_server)
1737                         log_link_debug(link, "Ignoring DHCP server for loopback link");
1738         }
1739
1740         r = network_apply(link->manager, network, link);
1741         if (r < 0)
1742                 return r;
1743
1744         r = link_new_bound_to_list(link);
1745         if (r < 0)
1746                 return r;
1747
1748         r = link_configure(link);
1749         if (r < 0)
1750                 return r;
1751
1752         return 1;
1753 }
1754
1755 int link_initialized(Link *link, struct udev_device *device) {
1756         _cleanup_netlink_message_unref_ sd_netlink_message *req = NULL;
1757         int r;
1758
1759         assert(link);
1760         assert(link->manager);
1761         assert(link->manager->rtnl);
1762         assert(device);
1763
1764         if (link->state != LINK_STATE_PENDING)
1765                 return 0;
1766
1767         if (link->udev_device)
1768                 return 0;
1769
1770         log_link_debug(link, "udev initialized link");
1771
1772         link->udev_device = udev_device_ref(device);
1773
1774         /* udev has initialized the link, but we don't know if we have yet
1775          * processed the NEWLINK messages with the latest state. Do a GETLINK,
1776          * when it returns we know that the pending NEWLINKs have already been
1777          * processed and that we are up-to-date */
1778
1779         r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK,
1780                                      link->ifindex);
1781         if (r < 0)
1782                 return r;
1783
1784         r = sd_netlink_call_async(link->manager->rtnl, req,
1785                                link_initialized_and_synced, link, 0, NULL);
1786         if (r < 0)
1787                 return r;
1788
1789         link_ref(link);
1790
1791         return 0;
1792 }
1793
1794 static Address* link_get_equal_address(Link *link, Address *needle) {
1795         Address *i;
1796
1797         assert(link);
1798         assert(needle);
1799
1800         LIST_FOREACH(addresses, i, link->addresses)
1801                 if (address_equal(i, needle))
1802                         return i;
1803
1804         return NULL;
1805 }
1806
1807 int link_rtnl_process_address(sd_netlink *rtnl, sd_netlink_message *message, void *userdata) {
1808         Manager *m = userdata;
1809         Link *link = NULL;
1810         uint16_t type;
1811         _cleanup_address_free_ Address *address = NULL;
1812         unsigned char flags;
1813         Address *existing;
1814         char buf[INET6_ADDRSTRLEN], valid_buf[FORMAT_TIMESPAN_MAX];
1815         const char *valid_str = NULL;
1816         int r, ifindex;
1817
1818         assert(rtnl);
1819         assert(message);
1820         assert(m);
1821
1822         if (sd_netlink_message_is_error(message)) {
1823                 r = sd_netlink_message_get_errno(message);
1824                 if (r < 0)
1825                         log_warning_errno(r, "rtnl: failed to receive address: %m");
1826
1827                 return 0;
1828         }
1829
1830         r = sd_netlink_message_get_type(message, &type);
1831         if (r < 0) {
1832                 log_warning_errno(r, "rtnl: could not get message type: %m");
1833                 return 0;
1834         } else if (type != RTM_NEWADDR && type != RTM_DELADDR) {
1835                 log_warning("rtnl: received unexpected message type when processing address");
1836                 return 0;
1837         }
1838
1839         r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
1840         if (r < 0) {
1841                 log_warning_errno(r, "rtnl: could not get ifindex from address: %m");
1842                 return 0;
1843         } else if (ifindex <= 0) {
1844                 log_warning("rtnl: received address message with invalid ifindex: %d", ifindex);
1845                 return 0;
1846         } else {
1847                 r = link_get(m, ifindex, &link);
1848                 if (r < 0 || !link) {
1849                         /* when enumerating we might be out of sync, but we will
1850                          * get the address again, so just ignore it */
1851                         if (!m->enumerating)
1852                                 log_warning("rtnl: received address for nonexistent link (%d), ignoring", ifindex);
1853                         return 0;
1854                 }
1855         }
1856
1857         r = address_new_dynamic(&address);
1858         if (r < 0)
1859                 return r;
1860
1861         r = sd_rtnl_message_addr_get_family(message, &address->family);
1862         if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
1863                 log_link_warning(link, "rtnl: received address with invalid family, ignoring.");
1864                 return 0;
1865         }
1866
1867         r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
1868         if (r < 0) {
1869                 log_link_warning_errno(link, r, "rtnl: received address with invalid prefixlen, ignoring: %m");
1870                 return 0;
1871         }
1872
1873         r = sd_rtnl_message_addr_get_scope(message, &address->scope);
1874         if (r < 0) {
1875                 log_link_warning_errno(link, r, "rtnl: received address with invalid scope, ignoring: %m");
1876                 return 0;
1877         }
1878
1879         r = sd_rtnl_message_addr_get_flags(message, &flags);
1880         if (r < 0) {
1881                 log_link_warning_errno(link, r, "rtnl: received address with invalid flags, ignoring: %m");
1882                 return 0;
1883         }
1884         address->flags = flags;
1885
1886         switch (address->family) {
1887         case AF_INET:
1888                 r = sd_netlink_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
1889                 if (r < 0) {
1890                         log_link_warning_errno(link, r, "rtnl: received address without valid address, ignoring: %m");
1891                         return 0;
1892                 }
1893
1894                 break;
1895
1896         case AF_INET6:
1897                 r = sd_netlink_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
1898                 if (r < 0) {
1899                         log_link_warning_errno(link, r, "rtnl: received address without valid address, ignoring: %m");
1900                         return 0;
1901                 }
1902
1903                 break;
1904
1905         default:
1906                 assert_not_reached("invalid address family");
1907         }
1908
1909         if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
1910                 log_link_warning(link, "Could not print address");
1911                 return 0;
1912         }
1913
1914         r = sd_netlink_message_read_cache_info(message, IFA_CACHEINFO, &address->cinfo);
1915         if (r >= 0) {
1916                 if (address->cinfo.ifa_valid == CACHE_INFO_INFINITY_LIFE_TIME)
1917                         valid_str = "ever";
1918                 else
1919                         valid_str = format_timespan(valid_buf, FORMAT_TIMESPAN_MAX,
1920                                                     address->cinfo.ifa_valid * USEC_PER_SEC,
1921                                                     USEC_PER_SEC);
1922         }
1923
1924         existing = link_get_equal_address(link, address);
1925
1926         switch (type) {
1927         case RTM_NEWADDR:
1928                 if (existing) {
1929                         log_link_debug(link, "Updating address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1930
1931
1932                         existing->scope = address->scope;
1933                         existing->flags = address->flags;
1934                         existing->cinfo = address->cinfo;
1935
1936                 } else {
1937                         log_link_debug(link, "Adding address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1938
1939                         LIST_PREPEND(addresses, link->addresses, address);
1940                         address_establish(address, link);
1941
1942                         address = NULL;
1943
1944                         link_save(link);
1945                 }
1946
1947                 break;
1948
1949         case RTM_DELADDR:
1950
1951                 if (existing) {
1952                         log_link_debug(link, "Removing address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1953                         address_release(existing, link);
1954                         LIST_REMOVE(addresses, link->addresses, existing);
1955                         address_free(existing);
1956                 } else
1957                         log_link_warning(link, "Removing non-existent address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1958
1959                 break;
1960         default:
1961                 assert_not_reached("Received invalid RTNL message type");
1962         }
1963
1964         return 1;
1965 }
1966
1967 int link_add(Manager *m, sd_netlink_message *message, Link **ret) {
1968         Link *link;
1969         _cleanup_udev_device_unref_ struct udev_device *device = NULL;
1970         char ifindex_str[2 + DECIMAL_STR_MAX(int)];
1971         int r;
1972
1973         assert(m);
1974         assert(m->rtnl);
1975         assert(message);
1976         assert(ret);
1977
1978         r = link_new(m, message, ret);
1979         if (r < 0)
1980                 return r;
1981
1982         link = *ret;
1983
1984         log_link_debug(link, "Link %d added", link->ifindex);
1985
1986         if (detect_container(NULL) <= 0) {
1987                 /* not in a container, udev will be around */
1988                 sprintf(ifindex_str, "n%d", link->ifindex);
1989                 device = udev_device_new_from_device_id(m->udev, ifindex_str);
1990                 if (!device)
1991                         return log_link_warning_errno(link, errno, "Could not find udev device: %m");
1992
1993                 if (udev_device_get_is_initialized(device) <= 0) {
1994                         /* not yet ready */
1995                         log_link_debug(link, "link pending udev initialization...");
1996                         return 0;
1997                 }
1998
1999                 r = link_initialized(link, device);
2000                 if (r < 0)
2001                         return r;
2002         } else {
2003                 /* we are calling a callback directly, so must take a ref */
2004                 link_ref(link);
2005
2006                 r = link_initialized_and_synced(m->rtnl, NULL, link);
2007                 if (r < 0)
2008                         return r;
2009         }
2010
2011         return 0;
2012 }
2013
2014 static int link_carrier_gained(Link *link) {
2015         int r;
2016
2017         assert(link);
2018
2019         if (link->network) {
2020                 r = link_acquire_conf(link);
2021                 if (r < 0) {
2022                         link_enter_failed(link);
2023                         return r;
2024                 }
2025         }
2026
2027         r = link_handle_bound_by_list(link);
2028         if (r < 0)
2029                 return r;
2030
2031         return 0;
2032 }
2033
2034 static int link_carrier_lost(Link *link) {
2035         int r;
2036
2037         assert(link);
2038
2039         r = link_stop_clients(link);
2040         if (r < 0) {
2041                 link_enter_failed(link);
2042                 return r;
2043         }
2044
2045         r = link_handle_bound_by_list(link);
2046         if (r < 0)
2047                 return r;
2048
2049         return 0;
2050 }
2051
2052 int link_carrier_reset(Link *link) {
2053         int r;
2054
2055         assert(link);
2056
2057         if (link_has_carrier(link)) {
2058                 r = link_carrier_lost(link);
2059                 if (r < 0)
2060                         return r;
2061
2062                 r = link_carrier_gained(link);
2063                 if (r < 0)
2064                         return r;
2065
2066                 log_link_info(link, "Reset carrier");
2067         }
2068
2069         return 0;
2070 }
2071
2072
2073 int link_update(Link *link, sd_netlink_message *m) {
2074         struct ether_addr mac;
2075         const char *ifname;
2076         uint32_t mtu;
2077         bool had_carrier, carrier_gained, carrier_lost;
2078         int r;
2079
2080         assert(link);
2081         assert(link->ifname);
2082         assert(m);
2083
2084         if (link->state == LINK_STATE_LINGER) {
2085                 link_ref(link);
2086                 log_link_info(link, "Link readded");
2087                 link_set_state(link, LINK_STATE_ENSLAVING);
2088
2089                 r = link_new_carrier_maps(link);
2090                 if (r < 0)
2091                         return r;
2092         }
2093
2094         r = sd_netlink_message_read_string(m, IFLA_IFNAME, &ifname);
2095         if (r >= 0 && !streq(ifname, link->ifname)) {
2096                 log_link_info(link, "Renamed to %s", ifname);
2097
2098                 link_free_carrier_maps(link);
2099
2100                 r = free_and_strdup(&link->ifname, ifname);
2101                 if (r < 0)
2102                         return r;
2103
2104                 r = link_new_carrier_maps(link);
2105                 if (r < 0)
2106                         return r;
2107         }
2108
2109         r = sd_netlink_message_read_u32(m, IFLA_MTU, &mtu);
2110         if (r >= 0 && mtu > 0) {
2111                 link->mtu = mtu;
2112                 if (!link->original_mtu) {
2113                         link->original_mtu = mtu;
2114                         log_link_debug(link, "Saved original MTU: %" PRIu32, link->original_mtu);
2115                 }
2116
2117                 if (link->dhcp_client) {
2118                         r = sd_dhcp_client_set_mtu(link->dhcp_client,
2119                                                    link->mtu);
2120                         if (r < 0) {
2121                                 log_link_warning_errno(link, r, "Could not update MTU in DHCP client: %m");
2122                                 return r;
2123                         }
2124                 }
2125         }
2126
2127         /* The kernel may broadcast NEWLINK messages without the MAC address
2128            set, simply ignore them. */
2129         r = sd_netlink_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
2130         if (r >= 0) {
2131                 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet,
2132                            ETH_ALEN)) {
2133
2134                         memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet,
2135                                ETH_ALEN);
2136
2137                         log_link_debug(link, "MAC address: "
2138                                        "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2139                                        mac.ether_addr_octet[0],
2140                                        mac.ether_addr_octet[1],
2141                                        mac.ether_addr_octet[2],
2142                                        mac.ether_addr_octet[3],
2143                                        mac.ether_addr_octet[4],
2144                                        mac.ether_addr_octet[5]);
2145
2146                         if (link->ipv4ll) {
2147                                 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
2148                                 if (r < 0)
2149                                         return log_link_warning_errno(link, r, "Could not update MAC address in IPv4LL client: %m");
2150                         }
2151
2152                         if (link->dhcp_client) {
2153                                 r = sd_dhcp_client_set_mac(link->dhcp_client,
2154                                                            (const uint8_t *) &link->mac,
2155                                                            sizeof (link->mac),
2156                                                            ARPHRD_ETHER);
2157                                 if (r < 0)
2158                                         return log_link_warning_errno(link, r, "Could not update MAC address in DHCP client: %m");
2159                         }
2160
2161                         if (link->dhcp6_client) {
2162                                 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
2163                                                             (const uint8_t *) &link->mac,
2164                                                             sizeof (link->mac),
2165                                                             ARPHRD_ETHER);
2166                                 if (r < 0)
2167                                         return log_link_warning_errno(link, r, "Could not update MAC address in DHCPv6 client: %m");
2168                         }
2169                 }
2170         }
2171
2172         had_carrier = link_has_carrier(link);
2173
2174         r = link_update_flags(link, m);
2175         if (r < 0)
2176                 return r;
2177
2178         carrier_gained = !had_carrier && link_has_carrier(link);
2179         carrier_lost = had_carrier && !link_has_carrier(link);
2180
2181         if (carrier_gained) {
2182                 log_link_info(link, "Gained carrier");
2183
2184                 r = link_carrier_gained(link);
2185                 if (r < 0)
2186                         return r;
2187         } else if (carrier_lost) {
2188                 log_link_info(link, "Lost carrier");
2189
2190                 r = link_carrier_lost(link);
2191                 if (r < 0)
2192                         return r;
2193
2194         }
2195
2196         return 0;
2197 }
2198
2199 static void link_update_operstate(Link *link) {
2200         LinkOperationalState operstate;
2201         assert(link);
2202
2203         if (link->kernel_operstate == IF_OPER_DORMANT)
2204                 operstate = LINK_OPERSTATE_DORMANT;
2205         else if (link_has_carrier(link)) {
2206                 Address *address;
2207                 uint8_t scope = RT_SCOPE_NOWHERE;
2208
2209                 /* if we have carrier, check what addresses we have */
2210                 LIST_FOREACH(addresses, address, link->addresses) {
2211                         if (address->flags & (IFA_F_TENTATIVE | IFA_F_DEPRECATED))
2212                                 continue;
2213
2214                         if (address->scope < scope)
2215                                 scope = address->scope;
2216                 }
2217
2218                 if (scope < RT_SCOPE_SITE)
2219                         /* universally accessible addresses found */
2220                         operstate = LINK_OPERSTATE_ROUTABLE;
2221                 else if (scope < RT_SCOPE_HOST)
2222                         /* only link or site local addresses found */
2223                         operstate = LINK_OPERSTATE_DEGRADED;
2224                 else
2225                         /* no useful addresses found */
2226                         operstate = LINK_OPERSTATE_CARRIER;
2227         } else if (link->flags & IFF_UP)
2228                 operstate = LINK_OPERSTATE_NO_CARRIER;
2229         else
2230                 operstate = LINK_OPERSTATE_OFF;
2231
2232         if (link->operstate != operstate) {
2233                 link->operstate = operstate;
2234                 link_send_changed(link, "OperationalState", NULL);
2235         }
2236 }
2237
2238 int link_save(Link *link) {
2239         _cleanup_free_ char *temp_path = NULL;
2240         _cleanup_fclose_ FILE *f = NULL;
2241         const char *admin_state, *oper_state;
2242         int r;
2243
2244         assert(link);
2245         assert(link->state_file);
2246         assert(link->lease_file);
2247         assert(link->manager);
2248
2249         link_update_operstate(link);
2250
2251         r = manager_save(link->manager);
2252         if (r < 0)
2253                 return r;
2254
2255         if (link->state == LINK_STATE_LINGER) {
2256                 unlink(link->state_file);
2257                 return 0;
2258         }
2259
2260         admin_state = link_state_to_string(link->state);
2261         assert(admin_state);
2262
2263         oper_state = link_operstate_to_string(link->operstate);
2264         assert(oper_state);
2265
2266         r = fopen_temporary(link->state_file, &f, &temp_path);
2267         if (r < 0)
2268                 goto fail;
2269
2270         fchmod(fileno(f), 0644);
2271
2272         fprintf(f,
2273                 "# This is private data. Do not parse.\n"
2274                 "ADMIN_STATE=%s\n"
2275                 "OPER_STATE=%s\n",
2276                 admin_state, oper_state);
2277
2278         if (link->network) {
2279                 char **address, **domain;
2280                 bool space;
2281                 sd_dhcp6_lease *dhcp6_lease = NULL;
2282
2283                 if (link->dhcp6_client) {
2284                         r = sd_dhcp6_client_get_lease(link->dhcp6_client,
2285                                                       &dhcp6_lease);
2286                         if (r < 0)
2287                                 log_link_debug(link, "No DHCPv6 lease");
2288                 }
2289
2290                 fprintf(f, "NETWORK_FILE=%s\n", link->network->filename);
2291
2292                 fputs("DNS=", f);
2293                 space = false;
2294                 STRV_FOREACH(address, link->network->dns) {
2295                         if (space)
2296                                 fputc(' ', f);
2297                         fputs(*address, f);
2298                         space = true;
2299                 }
2300
2301                 if (link->network->dhcp_dns &&
2302                     link->dhcp_lease) {
2303                         const struct in_addr *addresses;
2304
2305                         r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
2306                         if (r > 0) {
2307                                 if (space)
2308                                         fputc(' ', f);
2309                                 serialize_in_addrs(f, addresses, r);
2310                                 space = true;
2311                         }
2312                 }
2313
2314                 if (link->network->dhcp_dns && dhcp6_lease) {
2315                         struct in6_addr *in6_addrs;
2316
2317                         r = sd_dhcp6_lease_get_dns(dhcp6_lease, &in6_addrs);
2318                         if (r > 0) {
2319                                 if (space)
2320                                         fputc(' ', f);
2321                                 serialize_in6_addrs(f, in6_addrs, r);
2322                                 space = true;
2323                         }
2324                 }
2325
2326                 fputs("\n", f);
2327
2328                 fprintf(f, "NTP=");
2329                 space = false;
2330                 STRV_FOREACH(address, link->network->ntp) {
2331                         if (space)
2332                                 fputc(' ', f);
2333                         fputs(*address, f);
2334                         space = true;
2335                 }
2336
2337                 if (link->network->dhcp_ntp &&
2338                     link->dhcp_lease) {
2339                         const struct in_addr *addresses;
2340
2341                         r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
2342                         if (r > 0) {
2343                                 if (space)
2344                                         fputc(' ', f);
2345                                 serialize_in_addrs(f, addresses, r);
2346                                 space = true;
2347                         }
2348                 }
2349
2350                 if (link->network->dhcp_ntp && dhcp6_lease) {
2351                         struct in6_addr *in6_addrs;
2352                         char **hosts;
2353                         char **hostname;
2354
2355                         r = sd_dhcp6_lease_get_ntp_addrs(dhcp6_lease,
2356                                                          &in6_addrs);
2357                         if (r > 0) {
2358                                 if (space)
2359                                         fputc(' ', f);
2360                                 serialize_in6_addrs(f, in6_addrs, r);
2361                                 space = true;
2362                         }
2363
2364                         r = sd_dhcp6_lease_get_ntp_fqdn(dhcp6_lease, &hosts);
2365                         if (r > 0) {
2366                                 STRV_FOREACH(hostname, hosts) {
2367                                         if (space)
2368                                                 fputc(' ', f);
2369                                         fputs(*hostname, f);
2370                                         space = true;
2371                                 }
2372                         }
2373                 }
2374
2375                 fputs("\n", f);
2376
2377                 fprintf(f, "DOMAINS=");
2378                 space = false;
2379                 STRV_FOREACH(domain, link->network->domains) {
2380                         if (space)
2381                                 fputc(' ', f);
2382                         fputs(*domain, f);
2383                         space = true;
2384                 }
2385
2386                 if (link->network->dhcp_domains &&
2387                     link->dhcp_lease) {
2388                         const char *domainname;
2389
2390                         r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
2391                         if (r >= 0) {
2392                                 if (space)
2393                                         fputc(' ', f);
2394                                 fputs(domainname, f);
2395                                 space = true;
2396                         }
2397                 }
2398
2399                 if (link->network->dhcp_domains && dhcp6_lease) {
2400                         char **domains;
2401
2402                         r = sd_dhcp6_lease_get_domains(dhcp6_lease, &domains);
2403                         if (r >= 0) {
2404                                 STRV_FOREACH(domain, domains) {
2405                                         if (space)
2406                                                 fputc(' ', f);
2407                                         fputs(*domain, f);
2408                                         space = true;
2409                                 }
2410                         }
2411                 }
2412
2413                 fputs("\n", f);
2414
2415                 fprintf(f, "WILDCARD_DOMAIN=%s\n",
2416                         yes_no(link->network->wildcard_domain));
2417
2418                 fprintf(f, "LLMNR=%s\n",
2419                         resolve_support_to_string(link->network->llmnr));
2420         }
2421
2422         if (!hashmap_isempty(link->bound_to_links)) {
2423                 Link *carrier;
2424                 Iterator i;
2425                 bool space = false;
2426
2427                 fputs("CARRIER_BOUND_TO=", f);
2428                 HASHMAP_FOREACH(carrier, link->bound_to_links, i) {
2429                         if (space)
2430                                 fputc(' ', f);
2431                         fputs(carrier->ifname, f);
2432                         space = true;
2433                 }
2434
2435                 fputs("\n", f);
2436         }
2437
2438         if (!hashmap_isempty(link->bound_by_links)) {
2439                 Link *carrier;
2440                 Iterator i;
2441                 bool space = false;
2442
2443                 fputs("CARRIER_BOUND_BY=", f);
2444                 HASHMAP_FOREACH(carrier, link->bound_by_links, i) {
2445                         if (space)
2446                                 fputc(' ', f);
2447                         fputs(carrier->ifname, f);
2448                         space = true;
2449                 }
2450
2451                 fputs("\n", f);
2452         }
2453
2454         if (link->dhcp_lease) {
2455                 const char *tz = NULL;
2456
2457                 r = sd_dhcp_lease_get_timezone(link->dhcp_lease, &tz);
2458                 if (r >= 0)
2459                         fprintf(f, "TIMEZONE=%s\n", tz);
2460         }
2461
2462         if (link->dhcp_lease) {
2463                 assert(link->network);
2464
2465                 r = dhcp_lease_save(link->dhcp_lease, link->lease_file);
2466                 if (r < 0)
2467                         goto fail;
2468
2469                 fprintf(f,
2470                         "DHCP_LEASE=%s\n",
2471                         link->lease_file);
2472         } else
2473                 unlink(link->lease_file);
2474
2475         if (link->lldp) {
2476                 assert(link->network);
2477
2478                 r = sd_lldp_save(link->lldp, link->lldp_file);
2479                 if (r < 0)
2480                         goto fail;
2481
2482                 fprintf(f,
2483                         "LLDP_FILE=%s\n",
2484                         link->lldp_file);
2485         } else
2486                 unlink(link->lldp_file);
2487
2488         r = fflush_and_check(f);
2489         if (r < 0)
2490                 goto fail;
2491
2492         if (rename(temp_path, link->state_file) < 0) {
2493                 r = -errno;
2494                 goto fail;
2495         }
2496
2497         return 0;
2498
2499 fail:
2500         (void) unlink(link->state_file);
2501         if (temp_path)
2502                 (void) unlink(temp_path);
2503
2504         return log_link_error_errno(link, r, "Failed to save link data to %s: %m", link->state_file);
2505 }
2506
2507 static const char* const link_state_table[_LINK_STATE_MAX] = {
2508         [LINK_STATE_PENDING] = "pending",
2509         [LINK_STATE_ENSLAVING] = "configuring",
2510         [LINK_STATE_SETTING_ADDRESSES] = "configuring",
2511         [LINK_STATE_SETTING_ROUTES] = "configuring",
2512         [LINK_STATE_CONFIGURED] = "configured",
2513         [LINK_STATE_UNMANAGED] = "unmanaged",
2514         [LINK_STATE_FAILED] = "failed",
2515         [LINK_STATE_LINGER] = "linger",
2516 };
2517
2518 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
2519
2520 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
2521         [LINK_OPERSTATE_OFF] = "off",
2522         [LINK_OPERSTATE_NO_CARRIER] = "no-carrier",
2523         [LINK_OPERSTATE_DORMANT] = "dormant",
2524         [LINK_OPERSTATE_CARRIER] = "carrier",
2525         [LINK_OPERSTATE_DEGRADED] = "degraded",
2526         [LINK_OPERSTATE_ROUTABLE] = "routable",
2527 };
2528
2529 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);