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