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