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_info_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 int link_update_flags(Link *link, unsigned flags) {
1102         unsigned flags_added, flags_removed, generic_flags;
1103         bool carrier_gained, carrier_lost;
1104         int r;
1105
1106         assert(link);
1107
1108         if (link->state == LINK_STATE_FAILED)
1109                 return 0;
1110
1111         if (link->flags == flags)
1112                 return 0;
1113
1114         flags_added = (link->flags ^ flags) & flags;
1115         flags_removed = (link->flags ^ flags) & link->flags;
1116         generic_flags = ~(IFF_UP | IFF_LOWER_UP | IFF_DORMANT | IFF_DEBUG |
1117                           IFF_MULTICAST | IFF_BROADCAST | IFF_PROMISC |
1118                           IFF_NOARP | IFF_MASTER | IFF_SLAVE);
1119
1120         /* consider link to have carrier when LOWER_UP and !DORMANT
1121
1122            TODO: use proper operstates once we start supporting 802.1X
1123
1124            see Documentation/networking/operstates.txt in the kernel sources
1125          */
1126         carrier_gained = (((flags_added & IFF_LOWER_UP) && !(flags & IFF_DORMANT)) ||
1127                           ((flags_removed & IFF_DORMANT) && (flags & IFF_LOWER_UP)));
1128         carrier_lost = ((link->flags & IFF_LOWER_UP) && !(link->flags & IFF_DORMANT)) &&
1129                        ((flags_removed & IFF_LOWER_UP) || (flags_added & IFF_DORMANT));
1130
1131         link->flags = flags;
1132
1133         if (!link->network)
1134                 /* not currently managing this link
1135                    we track state changes, but don't log them
1136                    they will be logged if and when a network is
1137                    applied */
1138                 return 0;
1139
1140         if (flags_added & IFF_UP)
1141                 log_info_link(link, "link is up");
1142         else if (flags_removed & IFF_UP)
1143                 log_info_link(link, "link is down");
1144
1145         if (flags_added & IFF_LOWER_UP)
1146                 log_debug_link(link, "link is lower up");
1147         else if (flags_removed & IFF_LOWER_UP)
1148                 log_debug_link(link, "link is lower down");
1149
1150         if (flags_added & IFF_DORMANT)
1151                 log_debug_link(link, "link is dormant");
1152         else if (flags_removed & IFF_DORMANT)
1153                 log_debug_link(link, "link is not dormant");
1154
1155         if (flags_added & IFF_DEBUG)
1156                 log_debug_link(link, "debugging enabled in the kernel");
1157         else if (flags_removed & IFF_DEBUG)
1158                 log_debug_link(link, "debugging disabled in the kernel");
1159
1160         if (flags_added & IFF_MULTICAST)
1161                 log_debug_link(link, "multicast enabled");
1162         else if (flags_removed & IFF_MULTICAST)
1163                 log_debug_link(link, "multicast disabled");
1164
1165         if (flags_added & IFF_BROADCAST)
1166                 log_debug_link(link, "broadcast enabled");
1167         else if (flags_removed & IFF_BROADCAST)
1168                 log_debug_link(link, "broadcast disabled");
1169
1170         if (flags_added & IFF_PROMISC)
1171                 log_debug_link(link, "promiscuous mode enabled");
1172         else if (flags_removed & IFF_PROMISC)
1173                 log_debug_link(link, "promiscuous mode disabled");
1174
1175         if (flags_added & IFF_NOARP)
1176                 log_debug_link(link, "ARP protocol disabled");
1177         else if (flags_removed & IFF_NOARP)
1178                 log_debug_link(link, "ARP protocol enabled");
1179
1180         if (flags_added & IFF_MASTER)
1181                 log_debug_link(link, "link is master");
1182         else if (flags_removed & IFF_MASTER)
1183                 log_debug_link(link, "link is no longer master");
1184
1185         if (flags_added & IFF_SLAVE)
1186                 log_debug_link(link, "link is slave");
1187         else if (flags_removed & IFF_SLAVE)
1188                 log_debug_link(link, "link is no longer slave");
1189
1190         /* link flags are currently at most 18 bits, let's default to printing 20 */
1191         if (flags_added & generic_flags)
1192                 log_debug_link(link, "unknown link flags gained: %#.5x (ignoring)",
1193                                flags_added & generic_flags);
1194
1195         if (flags_removed & generic_flags)
1196                 log_debug_link(link, "unknown link flags lost: %#.5x (ignoring)",
1197                                flags_removed & generic_flags);
1198
1199         if (carrier_gained) {
1200                 log_info_link(link, "gained carrier");
1201
1202                 if (link->network->dhcp || link->network->ipv4ll) {
1203                         r = link_acquire_conf(link);
1204                         if (r < 0) {
1205                                 log_warning_link(link, "Could not acquire configuration: %s", strerror(-r));
1206                                 link_enter_failed(link);
1207                                 return r;
1208                         }
1209                 }
1210         } else if (carrier_lost) {
1211                 log_info_link(link, "lost carrier");
1212
1213                 if (link->network->dhcp) {
1214                         r = sd_dhcp_client_stop(link->dhcp_client);
1215                         if (r < 0) {
1216                                 log_warning_link(link, "Could not stop DHCPv4 client: %s", strerror(-r));
1217                                 link_enter_failed(link);
1218                                 return r;
1219                         }
1220                 }
1221
1222                 if (link->network->ipv4ll) {
1223                         r = sd_ipv4ll_stop(link->ipv4ll);
1224                         if (r < 0) {
1225                                 log_warning_link(link, "Could not stop IPv4 link-local: %s", strerror(-r));
1226                                 link_enter_failed(link);
1227                                 return r;
1228                         }
1229                 }
1230         }
1231
1232         return 0;
1233 }
1234
1235 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1236         Link *link = userdata;
1237         int r;
1238
1239         assert(link);
1240
1241         if (link->state == LINK_STATE_FAILED)
1242                 return 1;
1243
1244         r = sd_rtnl_message_get_errno(m);
1245         if (r >= 0)
1246                 link_update_flags(link, link->flags | IFF_UP);
1247         else
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         return 1;
1254 }
1255
1256 static int link_up(Link *link) {
1257         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1258         int r;
1259
1260         assert(link);
1261         assert(link->manager);
1262         assert(link->manager->rtnl);
1263
1264         log_debug_link(link, "bringing link up");
1265
1266         r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1267                                      RTM_SETLINK, link->ifindex);
1268         if (r < 0) {
1269                 log_error_link(link, "Could not allocate RTM_SETLINK message");
1270                 return r;
1271         }
1272
1273         r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1274         if (r < 0) {
1275                 log_error_link(link, "Could not set link flags: %s", strerror(-r));
1276                 return r;
1277         }
1278
1279         r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link, 0, NULL);
1280         if (r < 0) {
1281                 log_error_link(link,
1282                                "Could not send rtnetlink message: %s", strerror(-r));
1283                 return r;
1284         }
1285
1286         return 0;
1287 }
1288
1289 static int link_enslaved(Link *link) {
1290         int r;
1291
1292         assert(link);
1293         assert(link->state == LINK_STATE_ENSLAVING);
1294         assert(link->network);
1295
1296         if (!(link->flags & IFF_UP)) {
1297                 r = link_up(link);
1298                 if (r < 0) {
1299                         link_enter_failed(link);
1300                         return r;
1301                 }
1302         }
1303
1304         if (!link->network->dhcp && !link->network->ipv4ll)
1305                 return link_enter_set_addresses(link);
1306
1307         return 0;
1308 }
1309
1310 static int enslave_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1311         Link *link = userdata;
1312         int r;
1313
1314         assert(link);
1315         assert(link->state == LINK_STATE_ENSLAVING || link->state == LINK_STATE_FAILED);
1316         assert(link->network);
1317
1318         link->enslaving --;
1319
1320         if (link->state == LINK_STATE_FAILED)
1321                 return 1;
1322
1323         r = sd_rtnl_message_get_errno(m);
1324         if (r < 0) {
1325                 log_struct_link(LOG_ERR, link,
1326                                 "MESSAGE=%s: could not enslave: %s",
1327                                 link->ifname, strerror(-r),
1328                                 "ERRNO=%d", -r,
1329                                 NULL);
1330                 link_enter_failed(link);
1331                 return 1;
1332         }
1333
1334         log_debug_link(link, "enslaved");
1335
1336         if (link->enslaving == 0)
1337                 link_enslaved(link);
1338
1339         return 1;
1340 }
1341
1342 static int link_enter_enslave(Link *link) {
1343         NetDev *vlan, *macvlan;
1344         Iterator i;
1345         int r;
1346
1347         assert(link);
1348         assert(link->network);
1349         assert(link->state == LINK_STATE_INITIALIZING);
1350
1351         link->state = LINK_STATE_ENSLAVING;
1352
1353         link_save(link);
1354
1355         if (!link->network->bridge && !link->network->bond &&
1356             hashmap_isempty(link->network->vlans) &&
1357             hashmap_isempty(link->network->macvlans))
1358                 return link_enslaved(link);
1359
1360         if (link->network->bridge) {
1361                 log_struct_link(LOG_DEBUG, link,
1362                                 "MESSAGE=%s: enslaving by '%s'",
1363                                 link->ifname, link->network->bridge->name,
1364                                 NETDEV(link->network->bridge),
1365                                 NULL);
1366
1367                 r = netdev_enslave(link->network->bridge, link, &enslave_handler);
1368                 if (r < 0) {
1369                         log_struct_link(LOG_WARNING, link,
1370                                         "MESSAGE=%s: could not enslave by '%s': %s",
1371                                         link->ifname, link->network->bridge->name, strerror(-r),
1372                                         NETDEV(link->network->bridge),
1373                                         NULL);
1374                         link_enter_failed(link);
1375                         return r;
1376                 }
1377
1378                 link->enslaving ++;
1379         }
1380
1381         if (link->network->bond) {
1382                 log_struct_link(LOG_DEBUG, link,
1383                                 "MESSAGE=%s: enslaving by '%s'",
1384                                 link->ifname, link->network->bond->name,
1385                                 NETDEV(link->network->bond),
1386                                 NULL);
1387
1388                 r = netdev_enslave(link->network->bond, link, &enslave_handler);
1389                 if (r < 0) {
1390                         log_struct_link(LOG_WARNING, link,
1391                                         "MESSAGE=%s: could not enslave by '%s': %s",
1392                                         link->ifname, link->network->bond->name, strerror(-r),
1393                                         NETDEV(link->network->bond),
1394                                         NULL);
1395                         link_enter_failed(link);
1396                         return r;
1397                 }
1398
1399                 link->enslaving ++;
1400         }
1401
1402         HASHMAP_FOREACH(vlan, link->network->vlans, i) {
1403                 log_struct_link(LOG_DEBUG, link,
1404                                 "MESSAGE=%s: enslaving by '%s'",
1405                                 link->ifname, vlan->name, NETDEV(vlan), NULL);
1406
1407                 r = netdev_enslave(vlan, link, &enslave_handler);
1408                 if (r < 0) {
1409                         log_struct_link(LOG_WARNING, link,
1410                                         "MESSAGE=%s: could not enslave by '%s': %s",
1411                                         link->ifname, vlan->name, strerror(-r),
1412                                         NETDEV(vlan), NULL);
1413                         link_enter_failed(link);
1414                         return r;
1415                 }
1416
1417                 link->enslaving ++;
1418         }
1419
1420         HASHMAP_FOREACH(macvlan, link->network->macvlans, i) {
1421                 log_struct_link(LOG_DEBUG, link,
1422                                 "MESSAGE=%s: enslaving by '%s'",
1423                                 link->ifname, macvlan->name, NETDEV(macvlan), NULL);
1424
1425                 r = netdev_enslave(macvlan, link, &enslave_handler);
1426                 if (r < 0) {
1427                         log_struct_link(LOG_WARNING, link,
1428                                         "MESSAGE=%s: could not enslave by '%s': %s",
1429                                         link->ifname, macvlan->name, strerror(-r),
1430                                         NETDEV(macvlan), NULL);
1431                         link_enter_failed(link);
1432                         return r;
1433                 }
1434
1435                 link->enslaving ++;
1436         }
1437
1438         return 0;
1439 }
1440
1441 static int link_configure(Link *link) {
1442         int r;
1443
1444         assert(link);
1445         assert(link->state == LINK_STATE_INITIALIZING);
1446
1447         if (link->network->ipv4ll) {
1448                 uint8_t seed[8];
1449                 r = sd_ipv4ll_new(&link->ipv4ll);
1450                 if (r < 0)
1451                         return r;
1452
1453                 if (link->udev_device) {
1454                         r = net_get_unique_predictable_data(link->udev_device, seed);
1455                         if (r >= 0) {
1456                                 r = sd_ipv4ll_set_address_seed(link->ipv4ll, seed);
1457                                 if (r < 0)
1458                                         return r;
1459                         }
1460                 }
1461
1462                 r = sd_ipv4ll_attach_event(link->ipv4ll, NULL, 0);
1463                 if (r < 0)
1464                         return r;
1465
1466                 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1467                 if (r < 0)
1468                         return r;
1469
1470                 r = sd_ipv4ll_set_index(link->ipv4ll, link->ifindex);
1471                 if (r < 0)
1472                         return r;
1473
1474                 r = sd_ipv4ll_set_callback(link->ipv4ll, ipv4ll_handler, link);
1475                 if (r < 0)
1476                         return r;
1477         }
1478
1479         if (link->network->dhcp) {
1480                 r = sd_dhcp_client_new(&link->dhcp_client);
1481                 if (r < 0)
1482                         return r;
1483
1484                 r = sd_dhcp_client_attach_event(link->dhcp_client, NULL, 0);
1485                 if (r < 0)
1486                         return r;
1487
1488                 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
1489                 if (r < 0)
1490                         return r;
1491
1492                 r = sd_dhcp_client_set_index(link->dhcp_client, link->ifindex);
1493                 if (r < 0)
1494                         return r;
1495
1496                 r = sd_dhcp_client_set_callback(link->dhcp_client, dhcp_handler, link);
1497                 if (r < 0)
1498                         return r;
1499
1500                 if (link->network->dhcp_mtu) {
1501                         r = sd_dhcp_client_set_request_option(link->dhcp_client, 26);
1502                         if (r < 0)
1503                                 return r;
1504                 }
1505         }
1506
1507         return link_enter_enslave(link);
1508 }
1509
1510 int link_initialized(Link *link, struct udev_device *device) {
1511         Network *network;
1512         unsigned flags;
1513         int r;
1514
1515         assert(link);
1516         assert(link->ifname);
1517         assert(link->manager);
1518
1519         if (link->state != LINK_STATE_INITIALIZING)
1520                 return 0;
1521
1522         if (device)
1523                 link->udev_device = udev_device_ref(device);
1524
1525         log_debug_link(link, "link initialized");
1526
1527         r = network_get(link->manager, device, link->ifname, &link->mac, &network);
1528         if (r == -ENOENT) {
1529                 link_enter_unmanaged(link);
1530                 return 0;
1531         } else if (r < 0)
1532                 return r;
1533
1534         r = network_apply(link->manager, network, link);
1535         if (r < 0)
1536                 return r;
1537
1538         r = link_configure(link);
1539         if (r < 0)
1540                 return r;
1541
1542         /* re-trigger all state updates */
1543         flags = link->flags;
1544         link->flags = 0;
1545         r = link_update_flags(link, flags);
1546         if (r < 0)
1547                 return r;
1548
1549         return 0;
1550 }
1551
1552 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
1553         Link *link;
1554         _cleanup_udev_device_unref_ struct udev_device *device = NULL;
1555         char ifindex_str[2 + DECIMAL_STR_MAX(int)];
1556         int r;
1557
1558         assert(m);
1559         assert(message);
1560         assert(ret);
1561
1562         r = link_new(m, message, ret);
1563         if (r < 0)
1564                 return r;
1565
1566         link = *ret;
1567
1568         log_info_link(link, "link added");
1569
1570         if (detect_container(NULL) <= 0) {
1571                 /* not in a container, udev will be around */
1572                 sprintf(ifindex_str, "n%"PRIu64, link->ifindex);
1573                 device = udev_device_new_from_device_id(m->udev, ifindex_str);
1574                 if (!device) {
1575                         log_warning_link(link, "could not find udev device");
1576                         return -errno;
1577                 }
1578
1579                 if (udev_device_get_is_initialized(device) <= 0)
1580                         /* not yet ready */
1581                         return 0;
1582         }
1583
1584         r = link_initialized(link, device);
1585         if (r < 0)
1586                 return r;
1587
1588         return 0;
1589 }
1590
1591 int link_update(Link *link, sd_rtnl_message *m) {
1592         unsigned flags;
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         r = sd_rtnl_message_link_get_flags(m, &flags);
1661         if (r < 0) {
1662                 log_warning_link(link, "Could not get link flags");
1663                 return r;
1664         }
1665
1666         return link_update_flags(link, flags);
1667 }
1668
1669 int link_save(Link *link) {
1670         _cleanup_free_ char *temp_path = NULL;
1671         _cleanup_fclose_ FILE *f = NULL;
1672         const char *state;
1673         int r;
1674
1675         assert(link);
1676         assert(link->state_file);
1677
1678         state = link_state_to_string(link->state);
1679         assert(state);
1680
1681         r = fopen_temporary(link->state_file, &f, &temp_path);
1682         if (r < 0)
1683                 goto finish;
1684
1685         fchmod(fileno(f), 0644);
1686
1687         fprintf(f,
1688                 "# This is private data. Do not parse.\n"
1689                 "STATE=%s\n", state);
1690
1691         if (link->dhcp_lease) {
1692                 _cleanup_free_ char *lease_file = NULL;
1693
1694                 r = asprintf(&lease_file, "/run/systemd/network/leases/%"PRIu64,
1695                              link->ifindex);
1696                 if (r < 0)
1697                         return -ENOMEM;
1698
1699                 r = dhcp_lease_save(link->dhcp_lease, lease_file);
1700                 if (r < 0)
1701                         goto finish;
1702
1703                 fprintf(f, "DHCP_LEASE=%s\n", lease_file);
1704         }
1705
1706         fflush(f);
1707
1708         if (ferror(f) || rename(temp_path, link->state_file) < 0) {
1709                 r = -errno;
1710                 unlink(link->state_file);
1711                 unlink(temp_path);
1712         }
1713
1714 finish:
1715         if (r < 0)
1716                 log_error("Failed to save link data %s: %s", link->state_file, strerror(-r));
1717
1718         return r;
1719 }
1720
1721 static const char* const link_state_table[_LINK_STATE_MAX] = {
1722         [LINK_STATE_INITIALIZING] = "configuring",
1723         [LINK_STATE_ENSLAVING] = "configuring",
1724         [LINK_STATE_SETTING_ADDRESSES] = "configuring",
1725         [LINK_STATE_SETTING_ROUTES] = "configuring",
1726         [LINK_STATE_CONFIGURED] = "configured",
1727         [LINK_STATE_UNMANAGED] = "unmanaged",
1728         [LINK_STATE_FAILED] = "failed",
1729 };
1730
1731 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);