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_DORMANT);
1063
1064         /* consider link to have carrier when LOWER_UP and !DORMANT
1065
1066            TODO: use proper operstates once we start supporting 802.1X
1067
1068            see Documentation/networking/operstates.txt in the kernel sources
1069          */
1070         carrier_gained = (((flags_added & IFF_LOWER_UP) && !(flags & IFF_DORMANT)) ||
1071                           ((flags_removed & IFF_DORMANT) && (flags & IFF_LOWER_UP)));
1072         carrier_lost = ((link->flags & IFF_LOWER_UP) && !(link->flags & IFF_DORMANT)) &&
1073                        ((flags_removed & IFF_LOWER_UP) || (flags_added & IFF_DORMANT));
1074
1075         link->flags = flags;
1076
1077         if (!link->network)
1078                 /* not currently managing this link
1079                    we track state changes, but don't log them
1080                    they will be logged if and when a network is
1081                    applied */
1082                 return 0;
1083
1084         if (flags_added & IFF_UP)
1085                 log_info_link(link, "link is up");
1086         else if (flags_removed & IFF_UP)
1087                 log_info_link(link, "link is down");
1088
1089         if (flags_added & IFF_LOWER_UP)
1090                 log_debug_link(link, "link is lower up");
1091         else if (flags_removed & IFF_LOWER_UP)
1092                 log_debug_link(link, "link is lower down");
1093
1094         if (flags_added & IFF_DORMANT)
1095                 log_debug_link(link, "link is dormant");
1096         else if (flags_removed & IFF_DORMANT)
1097                 log_debug_link(link, "link is not dormant");
1098
1099         /* link flags are currently at most 18 bits, let's default to printing 20 */
1100         if (flags_added & generic_flags)
1101                 log_debug_link(link, "unknown link flags gained: %#.5x (ignoring)",
1102                                flags_added & generic_flags);
1103
1104         if (flags_removed & generic_flags)
1105                 log_debug_link(link, "unknown link flags lost: %#.5x (ignoring)",
1106                                flags_removed & generic_flags);
1107
1108         if (carrier_gained) {
1109                 log_info_link(link, "gained carrier");
1110
1111                 if (link->network->dhcp || link->network->ipv4ll) {
1112                         r = link_acquire_conf(link);
1113                         if (r < 0) {
1114                                 log_warning_link(link, "Could not acquire configuration: %s", strerror(-r));
1115                                 link_enter_failed(link);
1116                                 return r;
1117                         }
1118                 }
1119         } else if (carrier_lost) {
1120                 log_info_link(link, "lost carrier");
1121
1122                 if (link->network->dhcp) {
1123                         r = sd_dhcp_client_stop(link->dhcp_client);
1124                         if (r < 0) {
1125                                 log_warning_link(link, "Could not stop DHCPv4 client: %s", strerror(-r));
1126                                 link_enter_failed(link);
1127                                 return r;
1128                         }
1129                 }
1130
1131                 if (link->network->ipv4ll) {
1132                         r = sd_ipv4ll_stop(link->ipv4ll);
1133                         if (r < 0) {
1134                                 log_warning_link(link, "Could not stop IPv4 link-local: %s", strerror(-r));
1135                                 link_enter_failed(link);
1136                                 return r;
1137                         }
1138                 }
1139         }
1140
1141         return 0;
1142 }
1143
1144 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1145         Link *link = userdata;
1146         int r;
1147
1148         assert(link);
1149
1150         if (link->state == LINK_STATE_FAILED)
1151                 return 1;
1152
1153         r = sd_rtnl_message_get_errno(m);
1154         if (r >= 0)
1155                 link_update_flags(link, link->flags | IFF_UP);
1156         else
1157                 log_struct_link(LOG_WARNING, link,
1158                                 "MESSAGE=%s: could not bring up interface: %s",
1159                                 link->ifname, strerror(-r),
1160                                 "ERRNO=%d", -r,
1161                                 NULL);
1162         return 1;
1163 }
1164
1165 static int link_up(Link *link) {
1166         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1167         int r;
1168
1169         assert(link);
1170         assert(link->manager);
1171         assert(link->manager->rtnl);
1172
1173         log_debug_link(link, "bringing link up");
1174
1175         r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1176                                      RTM_SETLINK, link->ifindex);
1177         if (r < 0) {
1178                 log_error_link(link, "Could not allocate RTM_SETLINK message");
1179                 return r;
1180         }
1181
1182         r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1183         if (r < 0) {
1184                 log_error_link(link, "Could not set link flags: %s", strerror(-r));
1185                 return r;
1186         }
1187
1188         r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link, 0, NULL);
1189         if (r < 0) {
1190                 log_error_link(link,
1191                                "Could not send rtnetlink message: %s", strerror(-r));
1192                 return r;
1193         }
1194
1195         return 0;
1196 }
1197
1198 static int link_enslaved(Link *link) {
1199         int r;
1200
1201         assert(link);
1202         assert(link->state == LINK_STATE_ENSLAVING);
1203         assert(link->network);
1204
1205         if (!(link->flags & IFF_UP)) {
1206                 r = link_up(link);
1207                 if (r < 0) {
1208                         link_enter_failed(link);
1209                         return r;
1210                 }
1211         }
1212
1213         if (!link->network->dhcp && !link->network->ipv4ll)
1214                 return link_enter_set_addresses(link);
1215
1216         return 0;
1217 }
1218
1219 static int enslave_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1220         Link *link = userdata;
1221         int r;
1222
1223         assert(link);
1224         assert(link->state == LINK_STATE_ENSLAVING || link->state == LINK_STATE_FAILED);
1225         assert(link->network);
1226
1227         link->enslaving --;
1228
1229         if (link->state == LINK_STATE_FAILED)
1230                 return 1;
1231
1232         r = sd_rtnl_message_get_errno(m);
1233         if (r < 0) {
1234                 log_struct_link(LOG_ERR, link,
1235                                 "MESSAGE=%s: could not enslave: %s",
1236                                 link->ifname, strerror(-r),
1237                                 "ERRNO=%d", -r,
1238                                 NULL);
1239                 link_enter_failed(link);
1240                 return 1;
1241         }
1242
1243         log_debug_link(link, "enslaved");
1244
1245         if (link->enslaving == 0)
1246                 link_enslaved(link);
1247
1248         return 1;
1249 }
1250
1251 static int link_enter_enslave(Link *link) {
1252         NetDev *vlan, *macvlan;
1253         Iterator i;
1254         int r;
1255
1256         assert(link);
1257         assert(link->network);
1258         assert(link->state == LINK_STATE_INITIALIZING);
1259
1260         link->state = LINK_STATE_ENSLAVING;
1261
1262         link_save(link);
1263
1264         if (!link->network->bridge && !link->network->bond &&
1265             hashmap_isempty(link->network->vlans) &&
1266             hashmap_isempty(link->network->macvlans))
1267                 return link_enslaved(link);
1268
1269         if (link->network->bridge) {
1270                 log_struct_link(LOG_DEBUG, link,
1271                                 "MESSAGE=%s: enslaving by '%s'",
1272                                 link->ifname, link->network->bridge->name,
1273                                 NETDEV(link->network->bridge),
1274                                 NULL);
1275
1276                 r = netdev_enslave(link->network->bridge, link, &enslave_handler);
1277                 if (r < 0) {
1278                         log_struct_link(LOG_WARNING, link,
1279                                         "MESSAGE=%s: could not enslave by '%s': %s",
1280                                         link->ifname, link->network->bridge->name, strerror(-r),
1281                                         NETDEV(link->network->bridge),
1282                                         NULL);
1283                         link_enter_failed(link);
1284                         return r;
1285                 }
1286
1287                 link->enslaving ++;
1288         }
1289
1290         if (link->network->bond) {
1291                 log_struct_link(LOG_DEBUG, link,
1292                                 "MESSAGE=%s: enslaving by '%s'",
1293                                 link->ifname, link->network->bond->name,
1294                                 NETDEV(link->network->bond),
1295                                 NULL);
1296
1297                 r = netdev_enslave(link->network->bond, link, &enslave_handler);
1298                 if (r < 0) {
1299                         log_struct_link(LOG_WARNING, link,
1300                                         "MESSAGE=%s: could not enslave by '%s': %s",
1301                                         link->ifname, link->network->bond->name, strerror(-r),
1302                                         NETDEV(link->network->bond),
1303                                         NULL);
1304                         link_enter_failed(link);
1305                         return r;
1306                 }
1307
1308                 link->enslaving ++;
1309         }
1310
1311         HASHMAP_FOREACH(vlan, link->network->vlans, i) {
1312                 log_struct_link(LOG_DEBUG, link,
1313                                 "MESSAGE=%s: enslaving by '%s'",
1314                                 link->ifname, vlan->name, NETDEV(vlan), NULL);
1315
1316                 r = netdev_enslave(vlan, link, &enslave_handler);
1317                 if (r < 0) {
1318                         log_struct_link(LOG_WARNING, link,
1319                                         "MESSAGE=%s: could not enslave by '%s': %s",
1320                                         link->ifname, vlan->name, strerror(-r),
1321                                         NETDEV(vlan), NULL);
1322                         link_enter_failed(link);
1323                         return r;
1324                 }
1325
1326                 link->enslaving ++;
1327         }
1328
1329         HASHMAP_FOREACH(macvlan, link->network->macvlans, i) {
1330                 log_struct_link(LOG_DEBUG, link,
1331                                 "MESSAGE=%s: enslaving by '%s'",
1332                                 link->ifname, macvlan->name, NETDEV(macvlan), NULL);
1333
1334                 r = netdev_enslave(macvlan, link, &enslave_handler);
1335                 if (r < 0) {
1336                         log_struct_link(LOG_WARNING, link,
1337                                         "MESSAGE=%s: could not enslave by '%s': %s",
1338                                         link->ifname, macvlan->name, strerror(-r),
1339                                         NETDEV(macvlan), NULL);
1340                         link_enter_failed(link);
1341                         return r;
1342                 }
1343
1344                 link->enslaving ++;
1345         }
1346
1347         return 0;
1348 }
1349
1350 static int link_configure(Link *link) {
1351         int r;
1352
1353         assert(link);
1354         assert(link->state == LINK_STATE_INITIALIZING);
1355
1356         if (link->network->ipv4ll) {
1357                 uint8_t seed[8];
1358                 r = sd_ipv4ll_new(&link->ipv4ll);
1359                 if (r < 0)
1360                         return r;
1361
1362                 if (link->udev_device) {
1363                         r = net_get_unique_predictable_data(link->udev_device, seed);
1364                         if (r >= 0) {
1365                                 r = sd_ipv4ll_set_address_seed(link->ipv4ll, seed);
1366                                 if (r < 0)
1367                                         return r;
1368                         }
1369                 }
1370
1371                 r = sd_ipv4ll_attach_event(link->ipv4ll, NULL, 0);
1372                 if (r < 0)
1373                         return r;
1374
1375                 r = sd_ipv4ll_set_index(link->ipv4ll, link->ifindex);
1376                 if (r < 0)
1377                         return r;
1378
1379                 r = sd_ipv4ll_set_callback(link->ipv4ll, ipv4ll_handler, link);
1380                 if (r < 0)
1381                         return r;
1382         }
1383
1384         if (link->network->dhcp) {
1385                 r = sd_dhcp_client_new(&link->dhcp_client);
1386                 if (r < 0)
1387                         return r;
1388
1389                 r = sd_dhcp_client_attach_event(link->dhcp_client, NULL, 0);
1390                 if (r < 0)
1391                         return r;
1392
1393                 r = sd_dhcp_client_set_index(link->dhcp_client, link->ifindex);
1394                 if (r < 0)
1395                         return r;
1396
1397                 r = sd_dhcp_client_set_callback(link->dhcp_client, dhcp_handler, link);
1398                 if (r < 0)
1399                         return r;
1400
1401                 if (link->network->dhcp_mtu) {
1402                         r = sd_dhcp_client_set_request_option(link->dhcp_client, 26);
1403                         if (r < 0)
1404                                 return r;
1405                 }
1406         }
1407
1408         return link_enter_enslave(link);
1409 }
1410
1411 int link_initialized(Link *link, struct udev_device *device) {
1412         Network *network;
1413         unsigned flags;
1414         int r;
1415
1416         assert(link);
1417         assert(link->ifname);
1418         assert(link->manager);
1419
1420         if (link->state != LINK_STATE_INITIALIZING)
1421                 return 0;
1422
1423         if (device)
1424                 link->udev_device = udev_device_ref(device);
1425
1426         log_debug_link(link, "link initialized");
1427
1428         r = network_get(link->manager, device, link->ifname, &link->mac, &network);
1429         if (r < 0)
1430                 return r == -ENOENT ? 0 : r;
1431
1432         r = network_apply(link->manager, network, link);
1433         if (r < 0)
1434                 return r;
1435
1436         r = link_configure(link);
1437         if (r < 0)
1438                 return r;
1439
1440         /* re-trigger all state updates */
1441         flags = link->flags;
1442         link->flags = 0;
1443         r = link_update_flags(link, flags);
1444         if (r < 0)
1445                 return r;
1446
1447         return 0;
1448 }
1449
1450 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
1451         Link *link;
1452         _cleanup_udev_device_unref_ struct udev_device *device = NULL;
1453         char ifindex_str[2 + DECIMAL_STR_MAX(int)];
1454         int r;
1455
1456         assert(m);
1457         assert(message);
1458         assert(ret);
1459
1460         r = link_new(m, message, ret);
1461         if (r < 0)
1462                 return r;
1463
1464         link = *ret;
1465
1466         log_info_link(link, "link added");
1467
1468         if (detect_container(NULL) <= 0) {
1469                 /* not in a container, udev will be around */
1470                 sprintf(ifindex_str, "n%"PRIu64, link->ifindex);
1471                 device = udev_device_new_from_device_id(m->udev, ifindex_str);
1472                 if (!device) {
1473                         log_warning_link(link, "could not find udev device");
1474                         return -errno;
1475                 }
1476
1477                 if (udev_device_get_is_initialized(device) <= 0)
1478                         /* not yet ready */
1479                         return 0;
1480         }
1481
1482         r = link_initialized(link, device);
1483         if (r < 0)
1484                 return r;
1485
1486         return 0;
1487 }
1488
1489 int link_update(Link *link, sd_rtnl_message *m) {
1490         unsigned flags;
1491         struct ether_addr mac;
1492         char *ifname;
1493         int r;
1494
1495         assert(link);
1496         assert(link->ifname);
1497         assert(m);
1498
1499         if (link->state == LINK_STATE_FAILED)
1500                 return 0;
1501
1502         r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
1503         if (r >= 0 && !streq(ifname, link->ifname)) {
1504                 log_info_link(link, "renamed to %s", ifname);
1505
1506                 free(link->ifname);
1507                 link->ifname = strdup(ifname);
1508                 if (!link->ifname)
1509                         return -ENOMEM;
1510         }
1511
1512         if (!link->original_mtu) {
1513                 r = sd_rtnl_message_read_u16(m, IFLA_MTU, &link->original_mtu);
1514                 if (r >= 0)
1515                         log_debug_link(link, "saved original MTU: %"
1516                                        PRIu16, link->original_mtu);
1517         }
1518
1519         /* The kernel may broadcast NEWLINK messages without the MAC address
1520            set, simply ignore them. */
1521         r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
1522         if (r >= 0) {
1523                 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN)) {
1524
1525                         memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN);
1526
1527                         log_debug_link(link, "MAC address: "
1528                                        "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1529                                        mac.ether_addr_octet[0],
1530                                        mac.ether_addr_octet[1],
1531                                        mac.ether_addr_octet[2],
1532                                        mac.ether_addr_octet[3],
1533                                        mac.ether_addr_octet[4],
1534                                        mac.ether_addr_octet[5]);
1535
1536                         if (link->ipv4ll) {
1537                                 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1538                                 if (r < 0) {
1539                                         log_warning_link(link, "Could not update MAC "
1540                                                          "address in IPv4LL client: %s",
1541                                                          strerror(-r));
1542                                         return r;
1543                                 }
1544                         }
1545
1546                         if (link->dhcp_client) {
1547                                 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
1548                                 if (r < 0) {
1549                                         log_warning_link(link, "Could not update MAC "
1550                                                          "address in DHCP client: %s",
1551                                                          strerror(-r));
1552                                         return r;
1553                                 }
1554                         }
1555                 }
1556         }
1557
1558         r = sd_rtnl_message_link_get_flags(m, &flags);
1559         if (r < 0) {
1560                 log_warning_link(link, "Could not get link flags");
1561                 return r;
1562         }
1563
1564         return link_update_flags(link, flags);
1565 }
1566
1567 int link_save(Link *link) {
1568         _cleanup_free_ char *temp_path = NULL;
1569         _cleanup_fclose_ FILE *f = NULL;
1570         const char *state;
1571         int r;
1572
1573         assert(link);
1574         assert(link->state_file);
1575
1576         state = link_state_to_string(link->state);
1577         assert(state);
1578
1579         r = fopen_temporary(link->state_file, &f, &temp_path);
1580         if (r < 0)
1581                 goto finish;
1582
1583         fchmod(fileno(f), 0644);
1584
1585         fprintf(f,
1586                 "# This is private data. Do not parse.\n"
1587                 "STATE=%s\n", state);
1588
1589         if (link->dhcp_lease) {
1590                 _cleanup_free_ char *lease_file = NULL;
1591
1592                 r = asprintf(&lease_file, "/run/systemd/network/leases/%"PRIu64,
1593                              link->ifindex);
1594                 if (r < 0)
1595                         return -ENOMEM;
1596
1597                 r = dhcp_lease_save(link->dhcp_lease, lease_file);
1598                 if (r < 0)
1599                         goto finish;
1600
1601                 fprintf(f, "DHCP_LEASE=%s\n", lease_file);
1602         }
1603
1604         fflush(f);
1605
1606         if (ferror(f) || rename(temp_path, link->state_file) < 0) {
1607                 r = -errno;
1608                 unlink(link->state_file);
1609                 unlink(temp_path);
1610         }
1611
1612 finish:
1613         if (r < 0)
1614                 log_error("Failed to save link data %s: %s", link->state_file, strerror(-r));
1615
1616         return r;
1617 }
1618
1619 static const char* const link_state_table[_LINK_STATE_MAX] = {
1620         [LINK_STATE_INITIALIZING] = "configuring",
1621         [LINK_STATE_ENSLAVING] = "configuring",
1622         [LINK_STATE_SETTING_ADDRESSES] = "configuring",
1623         [LINK_STATE_SETTING_ROUTES] = "configuring",
1624         [LINK_STATE_CONFIGURED] = "configured",
1625         [LINK_STATE_FAILED] = "failed",
1626 };
1627
1628 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);