src/network/networkd-link.c

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