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