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