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_udev_device_unref_ struct udev_device *device = NULL;
1561         char ifindex_str[2 + DECIMAL_STR_MAX(int)];
1562         int r;
1563
1564         assert(m);
1565         assert(m->rtnl);
1566         assert(message);
1567         assert(ret);
1568
1569         r = link_new(m, message, ret);
1570         if (r < 0)
1571                 return r;
1572
1573         link = *ret;
1574
1575         log_link_debug(link, "link %d added", link->ifindex);
1576
1577         if (detect_container(NULL) <= 0) {
1578                 /* not in a container, udev will be around */
1579                 sprintf(ifindex_str, "n%d", link->ifindex);
1580                 device = udev_device_new_from_device_id(m->udev, ifindex_str);
1581                 if (!device) {
1582                         log_link_warning(link,
1583                                          "could not find udev device: %m");
1584                         return -errno;
1585                 }
1586
1587                 if (udev_device_get_is_initialized(device) <= 0) {
1588                         /* not yet ready */
1589                         log_link_debug(link, "link pending udev initialization...");
1590                         return 0;
1591                 }
1592
1593                 r = link_initialized(link, device);
1594                 if (r < 0)
1595                         return r;
1596         } else {
1597                 /* we are calling a callback directly, so must take a ref */
1598                 link_ref(link);
1599
1600                 r = link_initialized_and_synced(m->rtnl, NULL, link);
1601                 if (r < 0)
1602                         return r;
1603         }
1604
1605         return 0;
1606 }
1607
1608 int link_update(Link *link, sd_rtnl_message *m) {
1609         struct ether_addr mac;
1610         const char *ifname;
1611         uint32_t mtu;
1612         bool had_carrier, carrier_gained, carrier_lost;
1613         int r;
1614
1615         assert(link);
1616         assert(link->ifname);
1617         assert(m);
1618
1619         if (link->state == LINK_STATE_LINGER) {
1620                 link_ref(link);
1621                 log_link_info(link, "link readded");
1622                 link->state = LINK_STATE_ENSLAVING;
1623         }
1624
1625         r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
1626         if (r >= 0 && !streq(ifname, link->ifname)) {
1627                 log_link_info(link, "renamed to %s", ifname);
1628
1629                 free(link->ifname);
1630                 link->ifname = strdup(ifname);
1631                 if (!link->ifname)
1632                         return -ENOMEM;
1633         }
1634
1635         r = sd_rtnl_message_read_u32(m, IFLA_MTU, &mtu);
1636         if (r >= 0 && mtu > 0) {
1637                 link->mtu = mtu;
1638                 if (!link->original_mtu) {
1639                         link->original_mtu = mtu;
1640                         log_link_debug(link, "saved original MTU: %"
1641                                        PRIu32, link->original_mtu);
1642                 }
1643
1644                 if (link->dhcp_client) {
1645                         r = sd_dhcp_client_set_mtu(link->dhcp_client,
1646                                                    link->mtu);
1647                         if (r < 0) {
1648                                 log_link_warning(link,
1649                                                  "Could not update MTU in DHCP client: %s",
1650                                                  strerror(-r));
1651                                 return r;
1652                         }
1653                 }
1654         }
1655
1656         /* The kernel may broadcast NEWLINK messages without the MAC address
1657            set, simply ignore them. */
1658         r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
1659         if (r >= 0) {
1660                 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet,
1661                            ETH_ALEN)) {
1662
1663                         memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet,
1664                                ETH_ALEN);
1665
1666                         log_link_debug(link, "MAC address: "
1667                                        "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1668                                        mac.ether_addr_octet[0],
1669                                        mac.ether_addr_octet[1],
1670                                        mac.ether_addr_octet[2],
1671                                        mac.ether_addr_octet[3],
1672                                        mac.ether_addr_octet[4],
1673                                        mac.ether_addr_octet[5]);
1674
1675                         if (link->ipv4ll) {
1676                                 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1677                                 if (r < 0) {
1678                                         log_link_warning(link,
1679                                                          "Could not update MAC address in IPv4LL client: %s",
1680                                                          strerror(-r));
1681                                         return r;
1682                                 }
1683                         }
1684
1685                         if (link->dhcp_client) {
1686                                 r = sd_dhcp_client_set_mac(link->dhcp_client,
1687                                                            (const uint8_t *) &link->mac,
1688                                                            sizeof (link->mac),
1689                                                            ARPHRD_ETHER);
1690                                 if (r < 0) {
1691                                         log_link_warning(link,
1692                                                          "Could not update MAC address in DHCP client: %s",
1693                                                          strerror(-r));
1694                                         return r;
1695                                 }
1696                         }
1697
1698                         if (link->dhcp6_client) {
1699                                 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
1700                                                             (const uint8_t *) &link->mac,
1701                                                             sizeof (link->mac),
1702                                                             ARPHRD_ETHER);
1703                                 if (r < 0) {
1704                                         log_link_warning(link,
1705                                                          "Could not update MAC address in DHCPv6 client: %s",
1706                                                          strerror(-r));
1707                                         return r;
1708                                 }
1709                         }
1710                 }
1711         }
1712
1713         had_carrier = link_has_carrier(link);
1714
1715         r = link_update_flags(link, m);
1716         if (r < 0)
1717                 return r;
1718
1719         carrier_gained = !had_carrier && link_has_carrier(link);
1720         carrier_lost = had_carrier && !link_has_carrier(link);
1721
1722         if (carrier_gained) {
1723                 log_link_info(link, "gained carrier");
1724
1725                 if (link->network) {
1726                         r = link_acquire_conf(link);
1727                         if (r < 0) {
1728                                 link_enter_failed(link);
1729                                 return r;
1730                         }
1731                 }
1732         } else if (carrier_lost) {
1733                 log_link_info(link, "lost carrier");
1734
1735                 r = link_stop_clients(link);
1736                 if (r < 0) {
1737                         link_enter_failed(link);
1738                         return r;
1739                 }
1740         }
1741
1742         return 0;
1743 }
1744
1745 static void link_update_operstate(Link *link) {
1746
1747         assert(link);
1748
1749         if (link->kernel_operstate == IF_OPER_DORMANT)
1750                 link->operstate = LINK_OPERSTATE_DORMANT;
1751         else if (link_has_carrier(link)) {
1752                 Address *address;
1753                 uint8_t scope = RT_SCOPE_NOWHERE;
1754
1755                 /* if we have carrier, check what addresses we have */
1756                 LIST_FOREACH(addresses, address, link->addresses) {
1757                         if (address->flags & (IFA_F_TENTATIVE | IFA_F_DEPRECATED))
1758                                 continue;
1759
1760                         if (address->scope < scope)
1761                                 scope = address->scope;
1762                 }
1763
1764                 if (scope < RT_SCOPE_SITE)
1765                         /* universally accessible addresses found */
1766                         link->operstate = LINK_OPERSTATE_ROUTABLE;
1767                 else if (scope < RT_SCOPE_HOST)
1768                         /* only link or site local addresses found */
1769                         link->operstate = LINK_OPERSTATE_DEGRADED;
1770                 else
1771                         /* no useful addresses found */
1772                         link->operstate = LINK_OPERSTATE_CARRIER;
1773         } else if (link->flags & IFF_UP)
1774                 link->operstate = LINK_OPERSTATE_NO_CARRIER;
1775         else
1776                 link->operstate = LINK_OPERSTATE_OFF;
1777 }
1778
1779 int link_save(Link *link) {
1780         _cleanup_free_ char *temp_path = NULL;
1781         _cleanup_fclose_ FILE *f = NULL;
1782         const char *admin_state, *oper_state;
1783         int r;
1784
1785         assert(link);
1786         assert(link->state_file);
1787         assert(link->lease_file);
1788         assert(link->manager);
1789
1790         link_update_operstate(link);
1791
1792         r = manager_save(link->manager);
1793         if (r < 0)
1794                 return r;
1795
1796         if (link->state == LINK_STATE_LINGER) {
1797                 unlink(link->state_file);
1798                 return 0;
1799         }
1800
1801         admin_state = link_state_to_string(link->state);
1802         assert(admin_state);
1803
1804         oper_state = link_operstate_to_string(link->operstate);
1805         assert(oper_state);
1806
1807         r = fopen_temporary(link->state_file, &f, &temp_path);
1808         if (r < 0)
1809                 return r;
1810
1811         fchmod(fileno(f), 0644);
1812
1813         fprintf(f,
1814                 "# This is private data. Do not parse.\n"
1815                 "ADMIN_STATE=%s\n"
1816                 "OPER_STATE=%s\n",
1817                 admin_state, oper_state);
1818
1819         if (link->network) {
1820                 char **address, **domain;
1821                 bool space;
1822
1823                 fprintf(f, "NETWORK_FILE=%s\n", link->network->filename);
1824
1825                 fputs("DNS=", f);
1826                 space = false;
1827                 STRV_FOREACH(address, link->network->dns) {
1828                         if (space)
1829                                 fputc(' ', f);
1830                         fputs(*address, f);
1831                         space = true;
1832                 }
1833
1834                 if (link->network->dhcp_dns &&
1835                     link->dhcp_lease) {
1836                         const struct in_addr *addresses;
1837
1838                         r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
1839                         if (r > 0) {
1840                                 if (space)
1841                                         fputc(' ', f);
1842                                 serialize_in_addrs(f, addresses, r);
1843                         }
1844                 }
1845
1846                 fputs("\n", f);
1847
1848                 fprintf(f, "NTP=");
1849                 space = false;
1850                 STRV_FOREACH(address, link->network->ntp) {
1851                         if (space)
1852                                 fputc(' ', f);
1853                         fputs(*address, f);
1854                         space = true;
1855                 }
1856
1857                 if (link->network->dhcp_ntp &&
1858                     link->dhcp_lease) {
1859                         const struct in_addr *addresses;
1860
1861                         r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
1862                         if (r > 0) {
1863                                 if (space)
1864                                         fputc(' ', f);
1865                                 serialize_in_addrs(f, addresses, r);
1866                         }
1867                 }
1868
1869                 fputs("\n", f);
1870
1871                 fprintf(f, "DOMAINS=");
1872                 space = false;
1873                 STRV_FOREACH(domain, link->network->domains) {
1874                         if (space)
1875                                 fputc(' ', f);
1876                         fputs(*domain, f);
1877                         space = true;
1878                 }
1879
1880                 if (link->network->dhcp_domains &&
1881                     link->dhcp_lease) {
1882                         const char *domainname;
1883
1884                         r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
1885                         if (r >= 0) {
1886                                 if (space)
1887                                         fputc(' ', f);
1888                                 fputs(domainname, f);
1889                         }
1890                 }
1891
1892                 fputs("\n", f);
1893
1894                 fprintf(f, "WILDCARD_DOMAIN=%s\n",
1895                         yes_no(link->network->wildcard_domain));
1896
1897                 fprintf(f, "LLMNR=%s\n",
1898                         llmnr_support_to_string(link->network->llmnr));
1899         }
1900
1901         if (link->dhcp_lease) {
1902                 assert(link->network);
1903
1904                 r = sd_dhcp_lease_save(link->dhcp_lease, link->lease_file);
1905                 if (r < 0)
1906                         goto fail;
1907
1908                 fprintf(f,
1909                         "DHCP_LEASE=%s\n",
1910                         link->lease_file);
1911         } else
1912                 unlink(link->lease_file);
1913
1914         r = fflush_and_check(f);
1915         if (r < 0)
1916                 goto fail;
1917
1918         if (rename(temp_path, link->state_file) < 0) {
1919                 r = -errno;
1920                 goto fail;
1921         }
1922
1923         return 0;
1924 fail:
1925         log_link_error(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
1926         unlink(link->state_file);
1927         unlink(temp_path);
1928         return r;
1929 }
1930
1931 static const char* const link_state_table[_LINK_STATE_MAX] = {
1932         [LINK_STATE_PENDING] = "pending",
1933         [LINK_STATE_ENSLAVING] = "configuring",
1934         [LINK_STATE_SETTING_ADDRESSES] = "configuring",
1935         [LINK_STATE_SETTING_ROUTES] = "configuring",
1936         [LINK_STATE_CONFIGURED] = "configured",
1937         [LINK_STATE_UNMANAGED] = "unmanaged",
1938         [LINK_STATE_FAILED] = "failed",
1939         [LINK_STATE_LINGER] = "linger",
1940 };
1941
1942 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
1943
1944 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
1945         [LINK_OPERSTATE_OFF] = "off",
1946         [LINK_OPERSTATE_NO_CARRIER] = "no-carrier",
1947         [LINK_OPERSTATE_DORMANT] = "dormant",
1948         [LINK_OPERSTATE_CARRIER] = "carrier",
1949         [LINK_OPERSTATE_DEGRADED] = "degraded",
1950         [LINK_OPERSTATE_ROUTABLE] = "routable",
1951 };
1952
1953 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);