src/network/networkd-link.c

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