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