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