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