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