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