src/network/networkd-link.c

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