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