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