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         if (link->network->ip_forward == ADDRESS_FAMILY_KERNEL)
1485                 return 0;
1486
1487         p = strjoina("/proc/sys/net/ipv4/conf/", link->ifname, "/forwarding");
1488         r = write_string_file_no_create(p, one_zero(link_ipv4_forward_enabled(link)));
1489         if (r < 0)
1490                 log_link_warning_errno(link, r, "Cannot configure IPv4 forwarding for interface %s: %m", link->ifname);
1491
1492         return 0;
1493 }
1494
1495 static int link_set_ipv6_forward(Link *link) {
1496         const char *p = NULL;
1497         int r;
1498
1499         /* Make this a NOP if IPv6 is not available */
1500         if (!socket_ipv6_is_supported())
1501                 return 0;
1502
1503         if (link->network->ip_forward == ADDRESS_FAMILY_KERNEL)
1504                 return 0;
1505
1506         p = strjoina("/proc/sys/net/ipv6/conf/", link->ifname, "/forwarding");
1507         r = write_string_file_no_create(p, one_zero(link_ipv6_forward_enabled(link)));
1508         if (r < 0)
1509                 log_link_warning_errno(link, r, "Cannot configure IPv6 forwarding for interface: %m");
1510
1511         return 0;
1512 }
1513
1514 static int link_configure(Link *link) {
1515         int r;
1516
1517         assert(link);
1518         assert(link->network);
1519         assert(link->state == LINK_STATE_PENDING);
1520
1521         r = link_set_bridge_fdb(link);
1522         if (r < 0)
1523                 return r;
1524
1525         r = link_set_ipv4_forward(link);
1526         if (r < 0)
1527                 return r;
1528
1529         r = link_set_ipv6_forward(link);
1530         if (r < 0)
1531                 return r;
1532
1533         if (link_ipv4ll_enabled(link)) {
1534                 r = ipv4ll_configure(link);
1535                 if (r < 0)
1536                         return r;
1537         }
1538
1539         if (link_dhcp4_enabled(link)) {
1540                 r = dhcp4_configure(link);
1541                 if (r < 0)
1542                         return r;
1543         }
1544
1545         if (link_dhcp4_server_enabled(link)) {
1546                 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
1547                 if (r < 0)
1548                         return r;
1549
1550                 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
1551                 if (r < 0)
1552                         return r;
1553         }
1554
1555         if (link_dhcp6_enabled(link)) {
1556                 r = icmp6_configure(link);
1557                 if (r < 0)
1558                         return r;
1559         }
1560
1561         if (link_lldp_enabled(link)) {
1562                 r = sd_lldp_new(link->ifindex, link->ifname, &link->mac, &link->lldp);
1563                 if (r < 0)
1564                         return r;
1565
1566                 r = sd_lldp_attach_event(link->lldp, NULL, 0);
1567                 if (r < 0)
1568                         return r;
1569
1570                 r = sd_lldp_set_callback(link->lldp,
1571                                          lldp_handler, link);
1572                 if (r < 0)
1573                         return r;
1574         }
1575
1576         if (link_has_carrier(link)) {
1577                 r = link_acquire_conf(link);
1578                 if (r < 0)
1579                         return r;
1580         }
1581
1582         return link_enter_join_netdev(link);
1583 }
1584
1585 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m,
1586                                        void *userdata) {
1587         _cleanup_link_unref_ Link *link = userdata;
1588         Network *network;
1589         int r;
1590
1591         assert(link);
1592         assert(link->ifname);
1593         assert(link->manager);
1594
1595         if (link->state != LINK_STATE_PENDING)
1596                 return 1;
1597
1598         log_link_debug(link, "Link state is up-to-date");
1599
1600         r = link_new_bound_by_list(link);
1601         if (r < 0)
1602                 return r;
1603
1604         r = link_handle_bound_by_list(link);
1605         if (r < 0)
1606                 return r;
1607
1608         r = network_get(link->manager, link->udev_device, link->ifname,
1609                         &link->mac, &network);
1610         if (r == -ENOENT) {
1611                 link_enter_unmanaged(link);
1612                 return 1;
1613         } else if (r < 0)
1614                 return r;
1615
1616         if (link->flags & IFF_LOOPBACK) {
1617                 if (network->link_local != ADDRESS_FAMILY_NO)
1618                         log_link_debug(link, "Ignoring link-local autoconfiguration for loopback link");
1619
1620                 if (network->dhcp != ADDRESS_FAMILY_NO)
1621                         log_link_debug(link, "Ignoring DHCP clients for loopback link");
1622
1623                 if (network->dhcp_server)
1624                         log_link_debug(link, "Ignoring DHCP server for loopback link");
1625         }
1626
1627         r = network_apply(link->manager, network, link);
1628         if (r < 0)
1629                 return r;
1630
1631         r = link_new_bound_to_list(link);
1632         if (r < 0)
1633                 return r;
1634
1635         r = link_configure(link);
1636         if (r < 0)
1637                 return r;
1638
1639         return 1;
1640 }
1641
1642 int link_initialized(Link *link, struct udev_device *device) {
1643         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1644         int r;
1645
1646         assert(link);
1647         assert(link->manager);
1648         assert(link->manager->rtnl);
1649         assert(device);
1650
1651         if (link->state != LINK_STATE_PENDING)
1652                 return 0;
1653
1654         if (link->udev_device)
1655                 return 0;
1656
1657         log_link_debug(link, "udev initialized link");
1658
1659         link->udev_device = udev_device_ref(device);
1660
1661         /* udev has initialized the link, but we don't know if we have yet
1662          * processed the NEWLINK messages with the latest state. Do a GETLINK,
1663          * when it returns we know that the pending NEWLINKs have already been
1664          * processed and that we are up-to-date */
1665
1666         r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK,
1667                                      link->ifindex);
1668         if (r < 0)
1669                 return r;
1670
1671         r = sd_rtnl_call_async(link->manager->rtnl, req,
1672                                link_initialized_and_synced, link, 0, NULL);
1673         if (r < 0)
1674                 return r;
1675
1676         link_ref(link);
1677
1678         return 0;
1679 }
1680
1681 static Address* link_get_equal_address(Link *link, Address *needle) {
1682         Address *i;
1683
1684         assert(link);
1685         assert(needle);
1686
1687         LIST_FOREACH(addresses, i, link->addresses)
1688                 if (address_equal(i, needle))
1689                         return i;
1690
1691         return NULL;
1692 }
1693
1694 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
1695         Manager *m = userdata;
1696         Link *link = NULL;
1697         uint16_t type;
1698         _cleanup_address_free_ Address *address = NULL;
1699         unsigned char flags;
1700         Address *existing;
1701         char buf[INET6_ADDRSTRLEN], valid_buf[FORMAT_TIMESPAN_MAX];
1702         const char *valid_str = NULL;
1703         int r, ifindex;
1704
1705         assert(rtnl);
1706         assert(message);
1707         assert(m);
1708
1709         if (sd_rtnl_message_is_error(message)) {
1710                 r = sd_rtnl_message_get_errno(message);
1711                 if (r < 0)
1712                         log_warning_errno(r, "rtnl: failed to receive address: %m");
1713
1714                 return 0;
1715         }
1716
1717         r = sd_rtnl_message_get_type(message, &type);
1718         if (r < 0) {
1719                 log_warning_errno(r, "rtnl: could not get message type: %m");
1720                 return 0;
1721         } else if (type != RTM_NEWADDR && type != RTM_DELADDR) {
1722                 log_warning("rtnl: received unexpected message type when processing address");
1723                 return 0;
1724         }
1725
1726         r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
1727         if (r < 0) {
1728                 log_warning_errno(r, "rtnl: could not get ifindex from address: %m");
1729                 return 0;
1730         } else if (ifindex <= 0) {
1731                 log_warning("rtnl: received address message with invalid ifindex: %d", ifindex);
1732                 return 0;
1733         } else {
1734                 r = link_get(m, ifindex, &link);
1735                 if (r < 0 || !link) {
1736                         /* when enumerating we might be out of sync, but we will
1737                          * get the address again, so just ignore it */
1738                         if (!m->enumerating)
1739                                 log_warning("rtnl: received address for nonexistent link (%d), ignoring", ifindex);
1740                         return 0;
1741                 }
1742         }
1743
1744         r = address_new_dynamic(&address);
1745         if (r < 0)
1746                 return r;
1747
1748         r = sd_rtnl_message_addr_get_family(message, &address->family);
1749         if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
1750                 log_link_warning(link, "rtnl: received address with invalid family, ignoring.");
1751                 return 0;
1752         }
1753
1754         r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
1755         if (r < 0) {
1756                 log_link_warning_errno(link, r, "rtnl: received address with invalid prefixlen, ignoring: %m");
1757                 return 0;
1758         }
1759
1760         r = sd_rtnl_message_addr_get_scope(message, &address->scope);
1761         if (r < 0) {
1762                 log_link_warning_errno(link, r, "rtnl: received address with invalid scope, ignoring: %m");
1763                 return 0;
1764         }
1765
1766         r = sd_rtnl_message_addr_get_flags(message, &flags);
1767         if (r < 0) {
1768                 log_link_warning_errno(link, r, "rtnl: received address with invalid flags, ignoring: %m");
1769                 return 0;
1770         }
1771         address->flags = flags;
1772
1773         switch (address->family) {
1774         case AF_INET:
1775                 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
1776                 if (r < 0) {
1777                         log_link_warning_errno(link, r, "rtnl: received address without valid address, ignoring: %m");
1778                         return 0;
1779                 }
1780
1781                 break;
1782
1783         case AF_INET6:
1784                 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
1785                 if (r < 0) {
1786                         log_link_warning_errno(link, r, "rtnl: received address without valid address, ignoring: %m");
1787                         return 0;
1788                 }
1789
1790                 break;
1791
1792         default:
1793                 assert_not_reached("invalid address family");
1794         }
1795
1796         if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
1797                 log_link_warning(link, "Could not print address");
1798                 return 0;
1799         }
1800
1801         r = sd_rtnl_message_read_cache_info(message, IFA_CACHEINFO, &address->cinfo);
1802         if (r >= 0) {
1803                 if (address->cinfo.ifa_valid == CACHE_INFO_INFINITY_LIFE_TIME)
1804                         valid_str = "ever";
1805                 else
1806                         valid_str = format_timespan(valid_buf, FORMAT_TIMESPAN_MAX,
1807                                                     address->cinfo.ifa_valid * USEC_PER_SEC,
1808                                                     USEC_PER_SEC);
1809         }
1810
1811         existing = link_get_equal_address(link, address);
1812
1813         switch (type) {
1814         case RTM_NEWADDR:
1815                 if (existing) {
1816                         log_link_debug(link, "Updating address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1817
1818
1819                         existing->scope = address->scope;
1820                         existing->flags = address->flags;
1821                         existing->cinfo = address->cinfo;
1822
1823                 } else {
1824                         log_link_debug(link, "Adding address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1825
1826                         LIST_PREPEND(addresses, link->addresses, address);
1827                         address_establish(address, link);
1828
1829                         address = NULL;
1830
1831                         link_save(link);
1832                 }
1833
1834                 break;
1835
1836         case RTM_DELADDR:
1837
1838                 if (existing) {
1839                         log_link_debug(link, "Removing address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1840                         address_release(existing, link);
1841                         LIST_REMOVE(addresses, link->addresses, existing);
1842                         address_free(existing);
1843                 } else
1844                         log_link_warning(link, "Removing non-existent address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1845
1846                 break;
1847         default:
1848                 assert_not_reached("Received invalid RTNL message type");
1849         }
1850
1851         return 1;
1852 }
1853
1854 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
1855         Link *link;
1856         _cleanup_udev_device_unref_ struct udev_device *device = NULL;
1857         char ifindex_str[2 + DECIMAL_STR_MAX(int)];
1858         int r;
1859
1860         assert(m);
1861         assert(m->rtnl);
1862         assert(message);
1863         assert(ret);
1864
1865         r = link_new(m, message, ret);
1866         if (r < 0)
1867                 return r;
1868
1869         link = *ret;
1870
1871         log_link_debug(link, "Link %d added", link->ifindex);
1872
1873         if (detect_container(NULL) <= 0) {
1874                 /* not in a container, udev will be around */
1875                 sprintf(ifindex_str, "n%d", link->ifindex);
1876                 device = udev_device_new_from_device_id(m->udev, ifindex_str);
1877                 if (!device)
1878                         return log_link_warning_errno(link, errno, "Could not find udev device: %m");
1879
1880                 if (udev_device_get_is_initialized(device) <= 0) {
1881                         /* not yet ready */
1882                         log_link_debug(link, "link pending udev initialization...");
1883                         return 0;
1884                 }
1885
1886                 r = link_initialized(link, device);
1887                 if (r < 0)
1888                         return r;
1889         } else {
1890                 /* we are calling a callback directly, so must take a ref */
1891                 link_ref(link);
1892
1893                 r = link_initialized_and_synced(m->rtnl, NULL, link);
1894                 if (r < 0)
1895                         return r;
1896         }
1897
1898         return 0;
1899 }
1900
1901 static int link_carrier_gained(Link *link) {
1902         int r;
1903
1904         assert(link);
1905
1906         if (link->network) {
1907                 r = link_acquire_conf(link);
1908                 if (r < 0) {
1909                         link_enter_failed(link);
1910                         return r;
1911                 }
1912         }
1913
1914         r = link_handle_bound_by_list(link);
1915         if (r < 0)
1916                 return r;
1917
1918         return 0;
1919 }
1920
1921 static int link_carrier_lost(Link *link) {
1922         int r;
1923
1924         assert(link);
1925
1926         r = link_stop_clients(link);
1927         if (r < 0) {
1928                 link_enter_failed(link);
1929                 return r;
1930         }
1931
1932         r = link_handle_bound_by_list(link);
1933         if (r < 0)
1934                 return r;
1935
1936         return 0;
1937 }
1938
1939 int link_carrier_reset(Link *link) {
1940         int r;
1941
1942         assert(link);
1943
1944         if (link_has_carrier(link)) {
1945                 r = link_carrier_lost(link);
1946                 if (r < 0)
1947                         return r;
1948
1949                 r = link_carrier_gained(link);
1950                 if (r < 0)
1951                         return r;
1952
1953                 log_link_info(link, "Reset carrier");
1954         }
1955
1956         return 0;
1957 }
1958
1959
1960 int link_update(Link *link, sd_rtnl_message *m) {
1961         struct ether_addr mac;
1962         const char *ifname;
1963         uint32_t mtu;
1964         bool had_carrier, carrier_gained, carrier_lost;
1965         int r;
1966
1967         assert(link);
1968         assert(link->ifname);
1969         assert(m);
1970
1971         if (link->state == LINK_STATE_LINGER) {
1972                 link_ref(link);
1973                 log_link_info(link, "Link readded");
1974                 link_set_state(link, LINK_STATE_ENSLAVING);
1975
1976                 r = link_new_carrier_maps(link);
1977                 if (r < 0)
1978                         return r;
1979         }
1980
1981         r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
1982         if (r >= 0 && !streq(ifname, link->ifname)) {
1983                 log_link_info(link, "Renamed to %s", ifname);
1984
1985                 link_free_carrier_maps(link);
1986
1987                 free(link->ifname);
1988                 link->ifname = strdup(ifname);
1989                 if (!link->ifname)
1990                         return -ENOMEM;
1991
1992                 r = link_new_carrier_maps(link);
1993                 if (r < 0)
1994                         return r;
1995         }
1996
1997         r = sd_rtnl_message_read_u32(m, IFLA_MTU, &mtu);
1998         if (r >= 0 && mtu > 0) {
1999                 link->mtu = mtu;
2000                 if (!link->original_mtu) {
2001                         link->original_mtu = mtu;
2002                         log_link_debug(link, "Saved original MTU: %" PRIu32, link->original_mtu);
2003                 }
2004
2005                 if (link->dhcp_client) {
2006                         r = sd_dhcp_client_set_mtu(link->dhcp_client,
2007                                                    link->mtu);
2008                         if (r < 0) {
2009                                 log_link_warning_errno(link, r, "Could not update MTU in DHCP client: %m");
2010                                 return r;
2011                         }
2012                 }
2013         }
2014
2015         /* The kernel may broadcast NEWLINK messages without the MAC address
2016            set, simply ignore them. */
2017         r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
2018         if (r >= 0) {
2019                 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet,
2020                            ETH_ALEN)) {
2021
2022                         memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet,
2023                                ETH_ALEN);
2024
2025                         log_link_debug(link, "MAC address: "
2026                                        "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2027                                        mac.ether_addr_octet[0],
2028                                        mac.ether_addr_octet[1],
2029                                        mac.ether_addr_octet[2],
2030                                        mac.ether_addr_octet[3],
2031                                        mac.ether_addr_octet[4],
2032                                        mac.ether_addr_octet[5]);
2033
2034                         if (link->ipv4ll) {
2035                                 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
2036                                 if (r < 0)
2037                                         return log_link_warning_errno(link, r, "Could not update MAC address in IPv4LL client: %m");
2038                         }
2039
2040                         if (link->dhcp_client) {
2041                                 r = sd_dhcp_client_set_mac(link->dhcp_client,
2042                                                            (const uint8_t *) &link->mac,
2043                                                            sizeof (link->mac),
2044                                                            ARPHRD_ETHER);
2045                                 if (r < 0)
2046                                         return log_link_warning_errno(link, r, "Could not update MAC address in DHCP client: %m");
2047                         }
2048
2049                         if (link->dhcp6_client) {
2050                                 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
2051                                                             (const uint8_t *) &link->mac,
2052                                                             sizeof (link->mac),
2053                                                             ARPHRD_ETHER);
2054                                 if (r < 0)
2055                                         return log_link_warning_errno(link, r, "Could not update MAC address in DHCPv6 client: %m");
2056                         }
2057                 }
2058         }
2059
2060         had_carrier = link_has_carrier(link);
2061
2062         r = link_update_flags(link, m);
2063         if (r < 0)
2064                 return r;
2065
2066         carrier_gained = !had_carrier && link_has_carrier(link);
2067         carrier_lost = had_carrier && !link_has_carrier(link);
2068
2069         if (carrier_gained) {
2070                 log_link_info(link, "Gained carrier");
2071
2072                 r = link_carrier_gained(link);
2073                 if (r < 0)
2074                         return r;
2075         } else if (carrier_lost) {
2076                 log_link_info(link, "Lost carrier");
2077
2078                 r = link_carrier_lost(link);
2079                 if (r < 0)
2080                         return r;
2081
2082         }
2083
2084         return 0;
2085 }
2086
2087 static void link_update_operstate(Link *link) {
2088         LinkOperationalState operstate;
2089         assert(link);
2090
2091         if (link->kernel_operstate == IF_OPER_DORMANT)
2092                 operstate = LINK_OPERSTATE_DORMANT;
2093         else if (link_has_carrier(link)) {
2094                 Address *address;
2095                 uint8_t scope = RT_SCOPE_NOWHERE;
2096
2097                 /* if we have carrier, check what addresses we have */
2098                 LIST_FOREACH(addresses, address, link->addresses) {
2099                         if (address->flags & (IFA_F_TENTATIVE | IFA_F_DEPRECATED))
2100                                 continue;
2101
2102                         if (address->scope < scope)
2103                                 scope = address->scope;
2104                 }
2105
2106                 if (scope < RT_SCOPE_SITE)
2107                         /* universally accessible addresses found */
2108                         operstate = LINK_OPERSTATE_ROUTABLE;
2109                 else if (scope < RT_SCOPE_HOST)
2110                         /* only link or site local addresses found */
2111                         operstate = LINK_OPERSTATE_DEGRADED;
2112                 else
2113                         /* no useful addresses found */
2114                         operstate = LINK_OPERSTATE_CARRIER;
2115         } else if (link->flags & IFF_UP)
2116                 operstate = LINK_OPERSTATE_NO_CARRIER;
2117         else
2118                 operstate = LINK_OPERSTATE_OFF;
2119
2120         if (link->operstate != operstate) {
2121                 link->operstate = operstate;
2122                 link_send_changed(link, "OperationalState", NULL);
2123         }
2124 }
2125
2126 int link_save(Link *link) {
2127         _cleanup_free_ char *temp_path = NULL;
2128         _cleanup_fclose_ FILE *f = NULL;
2129         const char *admin_state, *oper_state;
2130         int r;
2131
2132         assert(link);
2133         assert(link->state_file);
2134         assert(link->lease_file);
2135         assert(link->manager);
2136
2137         link_update_operstate(link);
2138
2139         r = manager_save(link->manager);
2140         if (r < 0)
2141                 return r;
2142
2143         if (link->state == LINK_STATE_LINGER) {
2144                 unlink(link->state_file);
2145                 return 0;
2146         }
2147
2148         admin_state = link_state_to_string(link->state);
2149         assert(admin_state);
2150
2151         oper_state = link_operstate_to_string(link->operstate);
2152         assert(oper_state);
2153
2154         r = fopen_temporary(link->state_file, &f, &temp_path);
2155         if (r < 0)
2156                 goto fail;
2157
2158         fchmod(fileno(f), 0644);
2159
2160         fprintf(f,
2161                 "# This is private data. Do not parse.\n"
2162                 "ADMIN_STATE=%s\n"
2163                 "OPER_STATE=%s\n",
2164                 admin_state, oper_state);
2165
2166         if (link->network) {
2167                 char **address, **domain;
2168                 bool space;
2169
2170                 fprintf(f, "NETWORK_FILE=%s\n", link->network->filename);
2171
2172                 fputs("DNS=", f);
2173                 space = false;
2174                 STRV_FOREACH(address, link->network->dns) {
2175                         if (space)
2176                                 fputc(' ', f);
2177                         fputs(*address, f);
2178                         space = true;
2179                 }
2180
2181                 if (link->network->dhcp_dns &&
2182                     link->dhcp_lease) {
2183                         const struct in_addr *addresses;
2184
2185                         r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
2186                         if (r > 0) {
2187                                 if (space)
2188                                         fputc(' ', f);
2189                                 serialize_in_addrs(f, addresses, r);
2190                         }
2191                 }
2192
2193                 fputs("\n", f);
2194
2195                 fprintf(f, "NTP=");
2196                 space = false;
2197                 STRV_FOREACH(address, link->network->ntp) {
2198                         if (space)
2199                                 fputc(' ', f);
2200                         fputs(*address, f);
2201                         space = true;
2202                 }
2203
2204                 if (link->network->dhcp_ntp &&
2205                     link->dhcp_lease) {
2206                         const struct in_addr *addresses;
2207
2208                         r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
2209                         if (r > 0) {
2210                                 if (space)
2211                                         fputc(' ', f);
2212                                 serialize_in_addrs(f, addresses, r);
2213                         }
2214                 }
2215
2216                 fputs("\n", f);
2217
2218                 fprintf(f, "DOMAINS=");
2219                 space = false;
2220                 STRV_FOREACH(domain, link->network->domains) {
2221                         if (space)
2222                                 fputc(' ', f);
2223                         fputs(*domain, f);
2224                         space = true;
2225                 }
2226
2227                 if (link->network->dhcp_domains &&
2228                     link->dhcp_lease) {
2229                         const char *domainname;
2230
2231                         r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
2232                         if (r >= 0) {
2233                                 if (space)
2234                                         fputc(' ', f);
2235                                 fputs(domainname, f);
2236                         }
2237                 }
2238
2239                 fputs("\n", f);
2240
2241                 fprintf(f, "WILDCARD_DOMAIN=%s\n",
2242                         yes_no(link->network->wildcard_domain));
2243
2244                 fprintf(f, "LLMNR=%s\n",
2245                         llmnr_support_to_string(link->network->llmnr));
2246         }
2247
2248         if (!hashmap_isempty(link->bound_to_links)) {
2249                 Link *carrier;
2250                 Iterator i;
2251                 bool space = false;
2252
2253                 fputs("CARRIER_BOUND_TO=", f);
2254                 HASHMAP_FOREACH(carrier, link->bound_to_links, i) {
2255                         if (space)
2256                                 fputc(' ', f);
2257                         fputs(carrier->ifname, f);
2258                         space = true;
2259                 }
2260
2261                 fputs("\n", f);
2262         }
2263
2264         if (!hashmap_isempty(link->bound_by_links)) {
2265                 Link *carrier;
2266                 Iterator i;
2267                 bool space = false;
2268
2269                 fputs("CARRIER_BOUND_BY=", f);
2270                 HASHMAP_FOREACH(carrier, link->bound_by_links, i) {
2271                         if (space)
2272                                 fputc(' ', f);
2273                         fputs(carrier->ifname, f);
2274                         space = true;
2275                 }
2276
2277                 fputs("\n", f);
2278         }
2279
2280         if (link->dhcp_lease) {
2281                 assert(link->network);
2282
2283                 r = sd_dhcp_lease_save(link->dhcp_lease, link->lease_file);
2284                 if (r < 0)
2285                         goto fail;
2286
2287                 fprintf(f,
2288                         "DHCP_LEASE=%s\n",
2289                         link->lease_file);
2290         } else
2291                 unlink(link->lease_file);
2292
2293         if (link->lldp) {
2294                 assert(link->network);
2295
2296                 r = sd_lldp_save(link->lldp, link->lldp_file);
2297                 if (r < 0)
2298                         goto fail;
2299
2300                 fprintf(f,
2301                         "LLDP_FILE=%s\n",
2302                         link->lldp_file);
2303         } else
2304                 unlink(link->lldp_file);
2305
2306         r = fflush_and_check(f);
2307         if (r < 0)
2308                 goto fail;
2309
2310         if (rename(temp_path, link->state_file) < 0) {
2311                 r = -errno;
2312                 goto fail;
2313         }
2314
2315         return 0;
2316 fail:
2317         log_link_error_errno(link, r, "Failed to save link data to %s: %m", link->state_file);
2318         (void) unlink(link->state_file);
2319
2320         if (temp_path)
2321                 (void) unlink(temp_path);
2322
2323         return r;
2324 }
2325
2326 static const char* const link_state_table[_LINK_STATE_MAX] = {
2327         [LINK_STATE_PENDING] = "pending",
2328         [LINK_STATE_ENSLAVING] = "configuring",
2329         [LINK_STATE_SETTING_ADDRESSES] = "configuring",
2330         [LINK_STATE_SETTING_ROUTES] = "configuring",
2331         [LINK_STATE_CONFIGURED] = "configured",
2332         [LINK_STATE_UNMANAGED] = "unmanaged",
2333         [LINK_STATE_FAILED] = "failed",
2334         [LINK_STATE_LINGER] = "linger",
2335 };
2336
2337 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
2338
2339 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
2340         [LINK_OPERSTATE_OFF] = "off",
2341         [LINK_OPERSTATE_NO_CARRIER] = "no-carrier",
2342         [LINK_OPERSTATE_DORMANT] = "dormant",
2343         [LINK_OPERSTATE_CARRIER] = "carrier",
2344         [LINK_OPERSTATE_DEGRADED] = "degraded",
2345         [LINK_OPERSTATE_ROUTABLE] = "routable",
2346 };
2347
2348 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);