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