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