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 #include <unistd.h>
  25
  26 #include "networkd.h"
  27 #include "libudev-private.h"
  28 #include "udev-util.h"
  29 #include "util.h"
  30 #include "virt.h"
  31 #include "bus-util.h"
  32 #include "network-internal.h"
  33 #include "conf-parser.h"
  34
  35 #include "network-util.h"
  36 #include "dhcp-lease-internal.h"
  37
  38 static int ipv4ll_address_update(Link *link, bool deprecate);
  39 static bool ipv4ll_is_bound(sd_ipv4ll *ll);
  40
  41 static int link_new(Manager *manager, sd_rtnl_message *message, Link **ret) {
  42         _cleanup_link_unref_ Link *link = NULL;
  43         uint16_t type;
  44         char *ifname;
  45         int r, ifindex;
  46
  47         assert(manager);
  48         assert(manager->links);
  49         assert(message);
  50         assert(ret);
  51
  52         r = sd_rtnl_message_get_type(message, &type);
  53         if (r < 0)
  54                 return r;
  55         else if (type != RTM_NEWLINK)
  56                 return -EINVAL;
  57
  58         r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
  59         if (r < 0)
  60                 return r;
  61         else if (ifindex <= 0)
  62                 return -EINVAL;
  63
  64         r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &ifname);
  65         if (r < 0)
  66                 return r;
  67
  68         link = new0(Link, 1);
  69         if (!link)
  70                 return -ENOMEM;
  71
  72         link->n_ref = 1;
  73         link->manager = manager;
  74         link->state = LINK_STATE_INITIALIZING;
  75         link->ifindex = ifindex;
  76         link->ifname = strdup(ifname);
  77         if (!link->ifname)
  78                 return -ENOMEM;
  79
  80         r = sd_rtnl_message_read_ether_addr(message, IFLA_ADDRESS, &link->mac);
  81         if (r < 0)
  82                 log_debug_link(link, "MAC address not found for new device, continuing without");
  83
  84         r = asprintf(&link->state_file, "/run/systemd/netif/links/%"PRIu64,
  85                      link->ifindex);
  86         if (r < 0)
  87                 return -ENOMEM;
  88
  89         r = asprintf(&link->lease_file, "/run/systemd/netif/leases/%"PRIu64,
  90                      link->ifindex);
  91         if (r < 0)
  92                 return -ENOMEM;
  93
  94         r = hashmap_put(manager->links, &link->ifindex, link);
  95         if (r < 0)
  96                 return r;
  97
  98         *ret = link;
  99         link = NULL;
 100
 101         return 0;
 102 }
 103
 104 static void link_free(Link *link) {
 105         Address *address;
 106
 107         if (!link)
 108                 return;
 109
 110         while ((address = link->addresses)) {
 111                 LIST_REMOVE(addresses, link->addresses, address);
 112                 address_free(address);
 113         }
 114
 115         while ((address = link->pool_addresses)) {
 116                 LIST_REMOVE(addresses, link->pool_addresses, address);
 117                 address_free(address);
 118         }
 119
 120         sd_dhcp_client_unref(link->dhcp_client);
 121         sd_dhcp_lease_unref(link->dhcp_lease);
 122
 123         unlink(link->lease_file);
 124         free(link->lease_file);
 125
 126         sd_ipv4ll_unref(link->ipv4ll);
 127         sd_dhcp6_client_unref(link->dhcp6_client);
 128         sd_icmp6_nd_unref(link->icmp6_router_discovery);
 129
 130         if (link->manager)
 131                 hashmap_remove(link->manager->links, &link->ifindex);
 132
 133         free(link->ifname);
 134
 135         unlink(link->state_file);
 136         free(link->state_file);
 137
 138         udev_device_unref(link->udev_device);
 139
 140         free(link);
 141 }
 142
 143 Link *link_unref(Link *link) {
 144         if (link && (-- link->n_ref <= 0))
 145                 link_free(link);
 146
 147         return NULL;
 148 }
 149
 150 Link *link_ref(Link *link) {
 151         if (link)
 152                 assert_se(++ link->n_ref >= 2);
 153
 154         return link;
 155 }
 156
 157 int link_get(Manager *m, int ifindex, Link **ret) {
 158         Link *link;
 159         uint64_t ifindex_64;
 160
 161         assert(m);
 162         assert(m->links);
 163         assert(ifindex);
 164         assert(ret);
 165
 166         ifindex_64 = ifindex;
 167         link = hashmap_get(m->links, &ifindex_64);
 168         if (!link)
 169                 return -ENODEV;
 170
 171         *ret = link;
 172
 173         return 0;
 174 }
 175
 176 void link_drop(Link *link) {
 177         if (!link || link->state == LINK_STATE_LINGER)
 178                 return;
 179
 180         link->state = LINK_STATE_LINGER;
 181
 182         log_debug_link(link, "link removed");
 183
 184         link_unref(link);
 185
 186         return;
 187 }
 188
 189 static void link_enter_unmanaged(Link *link) {
 190         assert(link);
 191
 192         log_debug_link(link, "unmanaged");
 193
 194         link->state = LINK_STATE_UNMANAGED;
 195
 196         link_save(link);
 197 }
 198
 199 static int link_stop_clients(Link *link) {
 200         int r = 0, k;
 201
 202         assert(link);
 203         assert(link->manager);
 204         assert(link->manager->event);
 205
 206         if (!link->network)
 207                 return 0;
 208
 209         if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
 210                 assert(link->dhcp_client);
 211
 212                 k = sd_dhcp_client_stop(link->dhcp_client);
 213                 if (k < 0) {
 214                         log_warning_link(link, "Could not stop DHCPv4 client: %s", strerror(-r));
 215                         r = k;
 216                 }
 217         }
 218
 219         if (link->network->ipv4ll) {
 220                 assert(link->ipv4ll);
 221
 222                 k = sd_ipv4ll_stop(link->ipv4ll);
 223                 if (k < 0) {
 224                         log_warning_link(link, "Could not stop IPv4 link-local: %s", strerror(-r));
 225                         r = k;
 226                 }
 227         }
 228
 229         if (link->network->dhcp_server) {
 230                 assert(link->dhcp_server);
 231
 232                 k = sd_dhcp_server_stop(link->dhcp_server);
 233                 if (k < 0) {
 234                         log_warning_link(link, "Could not stop DHCPv4 server: %s", strerror(-r));
 235                         r = k;
 236                 }
 237         }
 238
 239         if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
 240                 assert(link->icmp6_router_discovery);
 241
 242                 if (link->dhcp6_client) {
 243                         k = sd_dhcp6_client_stop(link->dhcp6_client);
 244                         if (k < 0) {
 245                                 log_warning_link(link, "Could not stop DHCPv6 client: %s", strerror(-r));
 246                                 r = k;
 247                         }
 248                 }
 249
 250                 k = sd_icmp6_nd_stop(link->icmp6_router_discovery);
 251                 if (k < 0) {
 252                         log_warning_link(link, "Could not stop ICMPv6 router discovery: %s", strerror(-r));
 253                         r = k;
 254                 }
 255         }
 256
 257         return r;
 258 }
 259
 260 static void link_enter_failed(Link *link) {
 261         assert(link);
 262
 263         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 264                 return;
 265
 266         log_warning_link(link, "failed");
 267
 268         link->state = LINK_STATE_FAILED;
 269
 270         link_stop_clients(link);
 271
 272         link_save(link);
 273 }
 274
 275 static Address* link_find_dhcp_server_address(Link *link) {
 276         Address *address;
 277
 278         assert(link);
 279         assert(link->network);
 280
 281         /* The the first statically configured address if there is any */
 282         LIST_FOREACH(addresses, address, link->network->static_addresses) {
 283
 284                 if (address->family != AF_INET)
 285                         continue;
 286
 287                 if (in_addr_null(address->family, &address->in_addr))
 288                         continue;
 289
 290                 return address;
 291         }
 292
 293         /* If that didn't work, find a suitable address we got from the pool */
 294         LIST_FOREACH(addresses, address, link->pool_addresses) {
 295                 if (address->family != AF_INET)
 296                         continue;
 297
 298                 return address;
 299         }
 300
 301         return NULL;
 302 }
 303
 304 static int link_enter_configured(Link *link) {
 305         int r;
 306
 307         assert(link);
 308         assert(link->network);
 309         assert(link->state == LINK_STATE_SETTING_ROUTES);
 310
 311         if (link->network->dhcp_server &&
 312             !sd_dhcp_server_is_running(link->dhcp_server)) {
 313                 struct in_addr pool_start;
 314                 Address *address;
 315
 316                 address = link_find_dhcp_server_address(link);
 317                 if (!address) {
 318                         log_warning_link(link, "Failed to find suitable address for DHCPv4 server instance.");
 319                         link_enter_failed(link);
 320                         return 0;
 321                 }
 322
 323                 log_debug_link(link, "offering DHCPv4 leases");
 324
 325                 r = sd_dhcp_server_set_address(link->dhcp_server, &address->in_addr.in);
 326                 if (r < 0)
 327                         return r;
 328
 329                 /* offer 32 addresses starting from the address following the server address */
 330                 pool_start.s_addr = htobe32(be32toh(address->in_addr.in.s_addr) + 1);
 331                 r = sd_dhcp_server_set_lease_pool(link->dhcp_server,
 332                                                   &pool_start, 32);
 333                 if (r < 0)
 334                         return r;
 335
 336                 /* TODO:
 337                 r = sd_dhcp_server_set_router(link->dhcp_server,
 338                                               &main_address->in_addr.in);
 339                 if (r < 0)
 340                         return r;
 341
 342                 r = sd_dhcp_server_set_prefixlen(link->dhcp_server,
 343                                                  main_address->prefixlen);
 344                 if (r < 0)
 345                         return r;
 346                 */
 347
 348                 r = sd_dhcp_server_start(link->dhcp_server);
 349                 if (r < 0) {
 350                         log_warning_link(link, "could not start DHCPv4 server "
 351                                          "instance: %s", strerror(-r));
 352
 353                         link_enter_failed(link);
 354
 355                         return 0;
 356                 }
 357         }
 358
 359         log_info_link(link, "link configured");
 360
 361         link->state = LINK_STATE_CONFIGURED;
 362
 363         link_save(link);
 364
 365         return 0;
 366 }
 367
 368 static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
 369         _cleanup_link_unref_ Link *link = userdata;
 370         int r;
 371
 372         assert(link->route_messages > 0);
 373         assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
 374                       LINK_STATE_SETTING_ROUTES, LINK_STATE_FAILED,
 375                       LINK_STATE_LINGER));
 376
 377         link->route_messages --;
 378
 379         if (IN_SET(LINK_STATE_FAILED, LINK_STATE_LINGER))
 380                 return 1;
 381
 382         r = sd_rtnl_message_get_errno(m);
 383         if (r < 0 && r != -EEXIST)
 384                 log_struct_link(LOG_WARNING, link,
 385                                 "MESSAGE=%-*s: could not set route: %s",
 386                                 IFNAMSIZ,
 387                                 link->ifname, strerror(-r),
 388                                 "ERRNO=%d", -r,
 389                                 NULL);
 390
 391         /* we might have received an old reply after moving back to SETTING_ADDRESSES,
 392          * ignore it */
 393         if (link->route_messages == 0 && link->state == LINK_STATE_SETTING_ROUTES) {
 394                 log_debug_link(link, "routes set");
 395                 link_enter_configured(link);
 396         }
 397
 398         return 1;
 399 }
 400
 401 static int link_set_dhcp_routes(Link *link) {
 402         struct sd_dhcp_route *static_routes;
 403         size_t static_routes_size;
 404         int r;
 405         unsigned i;
 406
 407         assert(link);
 408
 409         r = sd_dhcp_lease_get_routes(link->dhcp_lease, &static_routes, &static_routes_size);
 410         if (r < 0) {
 411                 if (r != -ENOENT)
 412                         log_warning_link(link, "DHCP error: could not get routes: %s", strerror(-r));
 413                 return r;
 414         }
 415
 416         for (i = 0; i < static_routes_size; i++) {
 417                 _cleanup_route_free_ Route *route = NULL;
 418
 419                 r = route_new_dynamic(&route);
 420                 if (r < 0) {
 421                         log_error_link(link, "Could not allocate route: %s",
 422                                        strerror(-r));
 423                         return r;
 424                 }
 425
 426                 route->family = AF_INET;
 427                 route->in_addr.in = static_routes[i].gw_addr;
 428                 route->dst_addr.in = static_routes[i].dst_addr;
 429                 route->dst_prefixlen = static_routes[i].dst_prefixlen;
 430                 route->metrics = DHCP_ROUTE_METRIC;
 431
 432                 r = route_configure(route, link, &route_handler);
 433                 if (r < 0) {
 434                         log_warning_link(link,
 435                                          "could not set host route: %s", strerror(-r));
 436                         return r;
 437                 }
 438
 439                 link->route_messages ++;
 440         }
 441
 442         return 0;
 443 }
 444
 445 static int link_enter_set_routes(Link *link) {
 446         Route *rt;
 447         int r;
 448
 449         assert(link);
 450         assert(link->network);
 451         assert(link->state == LINK_STATE_SETTING_ADDRESSES);
 452
 453         link->state = LINK_STATE_SETTING_ROUTES;
 454
 455         if (!link->network->static_routes && !link->dhcp_lease &&
 456             (!link->ipv4ll || ipv4ll_is_bound(link->ipv4ll) == false))
 457                 return link_enter_configured(link);
 458
 459         log_debug_link(link, "setting routes");
 460
 461         LIST_FOREACH(routes, rt, link->network->static_routes) {
 462                 r = route_configure(rt, link, &route_handler);
 463                 if (r < 0) {
 464                         log_warning_link(link,
 465                                          "could not set routes: %s", strerror(-r));
 466                         link_enter_failed(link);
 467                         return r;
 468                 }
 469
 470                 link->route_messages ++;
 471         }
 472
 473         if (link->ipv4ll && !link->dhcp_lease) {
 474                 _cleanup_route_free_ Route *route = NULL;
 475                 struct in_addr addr;
 476
 477                 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
 478                 if (r < 0 && r != -ENOENT) {
 479                         log_warning_link(link, "IPV4LL error: no address: %s",
 480                                         strerror(-r));
 481                         return r;
 482                 }
 483
 484                 if (r != -ENOENT) {
 485                         r = route_new_dynamic(&route);
 486                         if (r < 0) {
 487                                 log_error_link(link, "Could not allocate route: %s",
 488                                                strerror(-r));
 489                                 return r;
 490                         }
 491
 492                         route->family = AF_INET;
 493                         route->scope = RT_SCOPE_LINK;
 494                         route->metrics = IPV4LL_ROUTE_METRIC;
 495
 496                         r = route_configure(route, link, &route_handler);
 497                         if (r < 0) {
 498                                 log_warning_link(link,
 499                                                  "could not set routes: %s", strerror(-r));
 500                                 link_enter_failed(link);
 501                                 return r;
 502                         }
 503
 504                         link->route_messages ++;
 505                 }
 506         }
 507
 508         if (link->dhcp_lease) {
 509                 _cleanup_route_free_ Route *route = NULL;
 510                 _cleanup_route_free_ Route *route_gw = NULL;
 511                 struct in_addr gateway;
 512
 513                 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
 514                 if (r < 0 && r != -ENOENT) {
 515                         log_warning_link(link, "DHCP error: could not get gateway: %s",
 516                                          strerror(-r));
 517                         return r;
 518                 }
 519
 520                 if (r >= 0) {
 521                         r = route_new_dynamic(&route);
 522                         if (r < 0) {
 523                                 log_error_link(link, "Could not allocate route: %s",
 524                                                strerror(-r));
 525                                 return r;
 526                         }
 527
 528                         r = route_new_dynamic(&route_gw);
 529                         if (r < 0) {
 530                                 log_error_link(link, "Could not allocate route: %s",
 531                                                strerror(-r));
 532                                 return r;
 533                         }
 534
 535                         /* The dhcp netmask may mask out the gateway. Add an explicit
 536                          * route for the gw host so that we can route no matter the
 537                          * netmask or existing kernel route tables. */
 538                         route_gw->family = AF_INET;
 539                         route_gw->dst_addr.in = gateway;
 540                         route_gw->dst_prefixlen = 32;
 541                         route_gw->scope = RT_SCOPE_LINK;
 542                         route_gw->metrics = DHCP_ROUTE_METRIC;
 543
 544                         r = route_configure(route_gw, link, &route_handler);
 545                         if (r < 0) {
 546                                 log_warning_link(link,
 547                                                  "could not set host route: %s", strerror(-r));
 548                                 return r;
 549                         }
 550
 551                         link->route_messages ++;
 552
 553                         route->family = AF_INET;
 554                         route->in_addr.in = gateway;
 555                         route->metrics = DHCP_ROUTE_METRIC;
 556
 557                         r = route_configure(route, link, &route_handler);
 558                         if (r < 0) {
 559                                 log_warning_link(link,
 560                                                  "could not set routes: %s", strerror(-r));
 561                                 link_enter_failed(link);
 562                                 return r;
 563                         }
 564
 565                         link->route_messages ++;
 566                 }
 567
 568                 if (link->network->dhcp_routes)
 569                         link_set_dhcp_routes(link);
 570         }
 571
 572         if (link->route_messages == 0) {
 573                 link_enter_configured(link);
 574         }
 575
 576         return 0;
 577 }
 578
 579 static int route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
 580         _cleanup_link_unref_ Link *link = userdata;
 581         int r;
 582
 583         assert(m);
 584         assert(link);
 585         assert(link->ifname);
 586
 587         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 588                 return 1;
 589
 590         r = sd_rtnl_message_get_errno(m);
 591         if (r < 0 && r != -ESRCH)
 592                 log_struct_link(LOG_WARNING, link,
 593                                 "MESSAGE=%-*s: could not drop route: %s",
 594                                 IFNAMSIZ,
 595                                 link->ifname, strerror(-r),
 596                                 "ERRNO=%d", -r,
 597                                 NULL);
 598
 599         return 1;
 600 }
 601
 602 static int link_get_address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
 603         _cleanup_link_unref_ Link *link = userdata;
 604         int r;
 605
 606         assert(rtnl);
 607         assert(m);
 608         assert(link);
 609         assert(link->manager);
 610
 611         for (; m; m = sd_rtnl_message_next(m)) {
 612                 r = sd_rtnl_message_get_errno(m);
 613                 if (r < 0) {
 614                         log_debug_link(link, "getting address failed: %s", strerror(-r));
 615                         continue;
 616                 }
 617
 618                 r = link_rtnl_process_address(rtnl, m, link->manager);
 619                 if (r < 0)
 620                         log_warning_link(link, "could not process address: %s", strerror(-r));
 621         }
 622
 623         return 1;
 624 }
 625
 626 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
 627         _cleanup_link_unref_ Link *link = userdata;
 628         int r;
 629
 630         assert(rtnl);
 631         assert(m);
 632         assert(link);
 633         assert(link->ifname);
 634         assert(link->addr_messages > 0);
 635         assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
 636                LINK_STATE_FAILED, LINK_STATE_LINGER));
 637
 638         link->addr_messages --;
 639
 640         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 641                 return 1;
 642
 643         r = sd_rtnl_message_get_errno(m);
 644         if (r < 0 && r != -EEXIST)
 645                 log_struct_link(LOG_WARNING, link,
 646                                 "MESSAGE=%-*s: could not set address: %s",
 647                                 IFNAMSIZ,
 648                                 link->ifname, strerror(-r),
 649                                 "ERRNO=%d", -r,
 650                                 NULL);
 651         else if (r >= 0) {
 652                 /* calling handler directly so take a ref */
 653                 link_ref(link);
 654                 link_get_address_handler(rtnl, m, link);
 655         }
 656
 657         if (link->addr_messages == 0) {
 658                 log_debug_link(link, "addresses set");
 659                 link_enter_set_routes(link);
 660         }
 661
 662         return 1;
 663 }
 664
 665 static int link_enter_set_addresses(Link *link) {
 666         Address *ad;
 667         int r;
 668         uint32_t lifetime = CACHE_INFO_INFINITY_LIFE_TIME;
 669
 670         assert(link);
 671         assert(link->network);
 672         assert(link->state != _LINK_STATE_INVALID);
 673
 674         link->state = LINK_STATE_SETTING_ADDRESSES;
 675
 676         if (!link->network->static_addresses && !link->dhcp_lease &&
 677                 (!link->ipv4ll || ipv4ll_is_bound(link->ipv4ll) == false))
 678                 return link_enter_set_routes(link);
 679
 680         log_debug_link(link, "setting addresses");
 681
 682         LIST_FOREACH(addresses, ad, link->network->static_addresses) {
 683                 r = address_configure(ad, link, &address_handler);
 684                 if (r < 0) {
 685                         log_warning_link(link,
 686                                          "could not set addresses: %s", strerror(-r));
 687                         link_enter_failed(link);
 688                         return r;
 689                 }
 690
 691                 link->addr_messages ++;
 692         }
 693
 694         if (link->ipv4ll && !link->dhcp_lease) {
 695                 _cleanup_address_free_ Address *ll_addr = NULL;
 696                 struct in_addr addr;
 697
 698                 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
 699                 if (r < 0 && r != -ENOENT) {
 700                         log_warning_link(link, "IPV4LL error: no address: %s",
 701                                         strerror(-r));
 702                         return r;
 703                 }
 704
 705                 if (r != -ENOENT) {
 706                         r = address_new_dynamic(&ll_addr);
 707                         if (r < 0) {
 708                                 log_error_link(link, "Could not allocate address: %s", strerror(-r));
 709                                 return r;
 710                         }
 711
 712                         ll_addr->family = AF_INET;
 713                         ll_addr->in_addr.in = addr;
 714                         ll_addr->prefixlen = 16;
 715                         ll_addr->broadcast.s_addr = ll_addr->in_addr.in.s_addr | htonl(0xfffffffflu >> ll_addr->prefixlen);
 716                         ll_addr->scope = RT_SCOPE_LINK;
 717
 718                         r = address_configure(ll_addr, link, &address_handler);
 719                         if (r < 0) {
 720                                 log_warning_link(link,
 721                                          "could not set addresses: %s", strerror(-r));
 722                                 link_enter_failed(link);
 723                                 return r;
 724                         }
 725
 726                         link->addr_messages ++;
 727                 }
 728         }
 729
 730         if (link->dhcp_lease) {
 731                 _cleanup_address_free_ Address *address = NULL;
 732                 struct in_addr addr;
 733                 struct in_addr netmask;
 734                 unsigned prefixlen;
 735
 736                 r = sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
 737                 if (r < 0) {
 738                         log_warning_link(link, "DHCP error: no address: %s",
 739                                          strerror(-r));
 740                         return r;
 741                 }
 742
 743                 if (!link->network->dhcp_critical) {
 744                         r = sd_dhcp_lease_get_lifetime(link->dhcp_lease,
 745                                                        &lifetime);
 746                         if (r < 0) {
 747                                 log_warning_link(link, "DHCP error: no lifetime: %s",
 748                                                  strerror(-r));
 749                                 return r;
 750                         }
 751                 }
 752
 753                 r = sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
 754                 if (r < 0) {
 755                         log_warning_link(link, "DHCP error: no netmask: %s",
 756                                          strerror(-r));
 757                         return r;
 758                 }
 759
 760                 prefixlen = net_netmask_to_prefixlen(&netmask);
 761
 762                 r = address_new_dynamic(&address);
 763                 if (r < 0) {
 764                         log_error_link(link, "Could not allocate address: %s",
 765                                        strerror(-r));
 766                         return r;
 767                 }
 768
 769                 address->family = AF_INET;
 770                 address->in_addr.in = addr;
 771                 address->cinfo.ifa_prefered = lifetime;
 772                 address->cinfo.ifa_valid = lifetime;
 773                 address->prefixlen = prefixlen;
 774                 address->broadcast.s_addr = addr.s_addr | ~netmask.s_addr;
 775
 776                 /* use update rather than configure so that we will update the lifetime
 777                    of an existing address if it has already been configured */
 778                 r = address_update(address, link, &address_handler);
 779                 if (r < 0) {
 780                         log_warning_link(link,
 781                                          "could not set addresses: %s", strerror(-r));
 782                         link_enter_failed(link);
 783                         return r;
 784                 }
 785
 786                 link->addr_messages ++;
 787         }
 788
 789         return 0;
 790 }
 791
 792 static int address_update_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
 793         _cleanup_link_unref_ Link *link = userdata;
 794         int r;
 795
 796         assert(m);
 797         assert(link);
 798         assert(link->ifname);
 799
 800         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 801                 return 1;
 802
 803         r = sd_rtnl_message_get_errno(m);
 804         if (r < 0 && r != -ENOENT)
 805                 log_struct_link(LOG_WARNING, link,
 806                                 "MESSAGE=%-*s: could not update address: %s",
 807                                 IFNAMSIZ,
 808                                 link->ifname, strerror(-r),
 809                                 "ERRNO=%d", -r,
 810                                 NULL);
 811
 812         return 1;
 813 }
 814
 815 static int address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
 816         _cleanup_link_unref_ Link *link = userdata;
 817         int r;
 818
 819         assert(m);
 820         assert(link);
 821         assert(link->ifname);
 822
 823         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 824                 return 1;
 825
 826         r = sd_rtnl_message_get_errno(m);
 827         if (r < 0 && r != -EADDRNOTAVAIL)
 828                 log_struct_link(LOG_WARNING, link,
 829                                 "MESSAGE=%-*s: could not drop address: %s",
 830                                 IFNAMSIZ,
 831                                 link->ifname, strerror(-r),
 832                                 "ERRNO=%d", -r,
 833                                 NULL);
 834
 835         return 1;
 836 }
 837
 838 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
 839         _cleanup_link_unref_ Link *link = userdata;
 840         int r;
 841
 842         assert(link);
 843
 844         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 845                 return 1;
 846
 847         r = sd_bus_message_get_errno(m);
 848         if (r < 0)
 849                 log_warning_link(link, "Could not set hostname: %s", strerror(-r));
 850
 851         return 1;
 852 }
 853
 854 static int link_set_hostname(Link *link, const char *hostname) {
 855         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
 856         int r = 0;
 857
 858         assert(link);
 859         assert(link->manager);
 860         assert(hostname);
 861
 862         log_debug_link(link, "Setting transient hostname: '%s'", hostname);
 863
 864         if (!link->manager->bus) { /* TODO: replace by assert when we can rely on kdbus */
 865                 log_info_link(link, "Not connected to system bus, ignoring transient hostname.");
 866                 return 0;
 867         }
 868
 869         r = sd_bus_message_new_method_call(
 870                         link->manager->bus,
 871                         &m,
 872                         "org.freedesktop.hostname1",
 873                         "/org/freedesktop/hostname1",
 874                         "org.freedesktop.hostname1",
 875                         "SetHostname");
 876         if (r < 0)
 877                 return r;
 878
 879         r = sd_bus_message_append(m, "sb", hostname, false);
 880         if (r < 0)
 881                 return r;
 882
 883         r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler, link, 0);
 884         if (r < 0) {
 885                 log_error_link(link, "Could not set transient hostname: %s", strerror(-r));
 886                 return r;
 887         }
 888
 889         link_ref(link);
 890
 891         return 0;
 892 }
 893
 894 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
 895         _cleanup_link_unref_ Link *link = userdata;
 896         int r;
 897
 898         assert(m);
 899         assert(link);
 900         assert(link->ifname);
 901
 902         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 903                 return 1;
 904
 905         r = sd_rtnl_message_get_errno(m);
 906         if (r < 0)
 907                 log_struct_link(LOG_WARNING, link,
 908                                 "MESSAGE=%-*s: could not set MTU: %s",
 909                                 IFNAMSIZ, link->ifname, strerror(-r),
 910                                 "ERRNO=%d", -r,
 911                                 NULL);
 912
 913         return 1;
 914 }
 915
 916 static int link_set_mtu(Link *link, uint32_t mtu) {
 917         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
 918         int r;
 919
 920         assert(link);
 921         assert(link->manager);
 922         assert(link->manager->rtnl);
 923
 924         log_debug_link(link, "setting MTU: %" PRIu32, mtu);
 925
 926         r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
 927                                      RTM_SETLINK, link->ifindex);
 928         if (r < 0) {
 929                 log_error_link(link, "Could not allocate RTM_SETLINK message");
 930                 return r;
 931         }
 932
 933         r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
 934         if (r < 0) {
 935                 log_error_link(link, "Could not append MTU: %s", strerror(-r));
 936                 return r;
 937         }
 938
 939         r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link, 0, NULL);
 940         if (r < 0) {
 941                 log_error_link(link,
 942                                "Could not send rtnetlink message: %s", strerror(-r));
 943                 return r;
 944         }
 945
 946         link_ref(link);
 947
 948         return 0;
 949 }
 950
 951 static int dhcp_lease_lost(Link *link) {
 952         _cleanup_address_free_ Address *address = NULL;
 953         struct in_addr addr;
 954         struct in_addr netmask;
 955         struct in_addr gateway;
 956         unsigned prefixlen;
 957         unsigned i;
 958         int r;
 959
 960         assert(link);
 961         assert(link->dhcp_lease);
 962
 963         log_warning_link(link, "DHCP lease lost");
 964
 965         if (link->network->dhcp_routes) {
 966                 struct sd_dhcp_route *routes;
 967                 size_t routes_size;
 968
 969                 r = sd_dhcp_lease_get_routes(link->dhcp_lease, &routes, &routes_size);
 970                 if (r >= 0) {
 971                         for (i = 0; i < routes_size; i++) {
 972                                 _cleanup_route_free_ Route *route = NULL;
 973
 974                                 r = route_new_dynamic(&route);
 975                                 if (r >= 0) {
 976                                         route->family = AF_INET;
 977                                         route->in_addr.in = routes[i].gw_addr;
 978                                         route->dst_addr.in = routes[i].dst_addr;
 979                                         route->dst_prefixlen = routes[i].dst_prefixlen;
 980
 981                                         route_drop(route, link, &route_drop_handler);
 982                                 }
 983                         }
 984                 }
 985         }
 986
 987         r = address_new_dynamic(&address);
 988         if (r >= 0) {
 989                 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
 990                 if (r >= 0) {
 991                         _cleanup_route_free_ Route *route_gw = NULL;
 992                         _cleanup_route_free_ Route *route = NULL;
 993
 994                         r = route_new_dynamic(&route_gw);
 995                         if (r >= 0) {
 996                                 route_gw->family = AF_INET;
 997                                 route_gw->dst_addr.in = gateway;
 998                                 route_gw->dst_prefixlen = 32;
 999                                 route_gw->scope = RT_SCOPE_LINK;
1000
1001                                 route_drop(route_gw, link, &route_drop_handler);
1002                         }
1003
1004                         r = route_new_dynamic(&route);
1005                         if (r >= 0) {
1006                                 route->family = AF_INET;
1007                                 route->in_addr.in = gateway;
1008
1009                                 route_drop(route, link, &route_drop_handler);
1010                         }
1011                 }
1012
1013                 sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
1014                 sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
1015                 prefixlen = net_netmask_to_prefixlen(&netmask);
1016
1017                 address->family = AF_INET;
1018                 address->in_addr.in = addr;
1019                 address->prefixlen = prefixlen;
1020
1021                 address_drop(address, link, &address_drop_handler);
1022         }
1023
1024         if (link->network->dhcp_mtu) {
1025                 uint16_t mtu;
1026
1027                 r = sd_dhcp_lease_get_mtu(link->dhcp_lease, &mtu);
1028                 if (r >= 0 && link->original_mtu != mtu) {
1029                         r = link_set_mtu(link, link->original_mtu);
1030                         if (r < 0) {
1031                                 log_warning_link(link, "DHCP error: could not reset MTU");
1032                                 link_enter_failed(link);
1033                                 return r;
1034                         }
1035                 }
1036         }
1037
1038         if (link->network->dhcp_hostname) {
1039                 const char *hostname = NULL;
1040
1041                 r = sd_dhcp_lease_get_hostname(link->dhcp_lease, &hostname);
1042                 if (r >= 0 && hostname) {
1043                         r = link_set_hostname(link, "");
1044                         if (r < 0)
1045                                 log_error_link(link, "Failed to reset transient hostname");
1046                 }
1047         }
1048
1049         link->dhcp_lease = sd_dhcp_lease_unref(link->dhcp_lease);
1050
1051         return 0;
1052 }
1053
1054 static int dhcp_lease_renew(sd_dhcp_client *client, Link *link) {
1055         sd_dhcp_lease *lease;
1056         int r;
1057
1058         r = sd_dhcp_client_get_lease(client, &lease);
1059         if (r < 0) {
1060                 log_warning_link(link, "DHCP error: no lease %s",
1061                                  strerror(-r));
1062                 return r;
1063         }
1064
1065         sd_dhcp_lease_unref(link->dhcp_lease);
1066         link->dhcp_lease = lease;
1067
1068         link_enter_set_addresses(link);
1069
1070         return 0;
1071 }
1072
1073 static int dhcp_lease_acquired(sd_dhcp_client *client, Link *link) {
1074         sd_dhcp_lease *lease;
1075         struct in_addr address;
1076         struct in_addr netmask;
1077         struct in_addr gateway;
1078         unsigned prefixlen;
1079         int r;
1080
1081         assert(client);
1082         assert(link);
1083
1084         r = sd_dhcp_client_get_lease(client, &lease);
1085         if (r < 0) {
1086                 log_warning_link(link, "DHCP error: no lease: %s",
1087                                  strerror(-r));
1088                 return r;
1089         }
1090
1091         r = sd_dhcp_lease_get_address(lease, &address);
1092         if (r < 0) {
1093                 log_warning_link(link, "DHCP error: no address: %s",
1094                                  strerror(-r));
1095                 return r;
1096         }
1097
1098         r = sd_dhcp_lease_get_netmask(lease, &netmask);
1099         if (r < 0) {
1100                 log_warning_link(link, "DHCP error: no netmask: %s",
1101                                  strerror(-r));
1102                 return r;
1103         }
1104
1105         prefixlen = net_netmask_to_prefixlen(&netmask);
1106
1107         r = sd_dhcp_lease_get_router(lease, &gateway);
1108         if (r < 0 && r != -ENOENT) {
1109                 log_warning_link(link, "DHCP error: could not get gateway: %s",
1110                                  strerror(-r));
1111                 return r;
1112         }
1113
1114         if (r >= 0)
1115                 log_struct_link(LOG_INFO, link,
1116                                 "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u via %u.%u.%u.%u",
1117                                  IFNAMSIZ,
1118                                  link->ifname,
1119                                  ADDRESS_FMT_VAL(address),
1120                                  prefixlen,
1121                                  ADDRESS_FMT_VAL(gateway),
1122                                  "ADDRESS=%u.%u.%u.%u",
1123                                  ADDRESS_FMT_VAL(address),
1124                                  "PREFIXLEN=%u",
1125                                  prefixlen,
1126                                  "GATEWAY=%u.%u.%u.%u",
1127                                  ADDRESS_FMT_VAL(gateway),
1128                                  NULL);
1129         else
1130                 log_struct_link(LOG_INFO, link,
1131                                 "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u",
1132                                  IFNAMSIZ,
1133                                  link->ifname,
1134                                  ADDRESS_FMT_VAL(address),
1135                                  prefixlen,
1136                                  "ADDRESS=%u.%u.%u.%u",
1137                                  ADDRESS_FMT_VAL(address),
1138                                  "PREFIXLEN=%u",
1139                                  prefixlen,
1140                                  NULL);
1141
1142         link->dhcp_lease = lease;
1143
1144         if (link->network->dhcp_mtu) {
1145                 uint16_t mtu;
1146
1147                 r = sd_dhcp_lease_get_mtu(lease, &mtu);
1148                 if (r >= 0) {
1149                         r = link_set_mtu(link, mtu);
1150                         if (r < 0)
1151                                 log_error_link(link, "Failed to set MTU "
1152                                                "to %" PRIu16, mtu);
1153                 }
1154         }
1155
1156         if (link->network->dhcp_hostname) {
1157                 const char *hostname;
1158
1159                 r = sd_dhcp_lease_get_hostname(lease, &hostname);
1160                 if (r >= 0) {
1161                         r = link_set_hostname(link, hostname);
1162                         if (r < 0)
1163                                 log_error_link(link, "Failed to set transient hostname "
1164                                           "to '%s'", hostname);
1165                 }
1166         }
1167
1168         link_enter_set_addresses(link);
1169
1170         return 0;
1171 }
1172
1173 static void dhcp_handler(sd_dhcp_client *client, int event, void *userdata) {
1174         Link *link = userdata;
1175         int r = 0;
1176
1177         assert(link);
1178         assert(link->network);
1179         assert(link->manager);
1180
1181         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1182                 return;
1183
1184         switch (event) {
1185                 case DHCP_EVENT_NO_LEASE:
1186                         log_debug_link(link, "IP address in use.");
1187                         break;
1188                 case DHCP_EVENT_EXPIRED:
1189                 case DHCP_EVENT_STOP:
1190                 case DHCP_EVENT_IP_CHANGE:
1191                         if (link->network->dhcp_critical) {
1192                                 log_error_link(link, "DHCPv4 connection considered system critical, "
1193                                                "ignoring request to reconfigure it.");
1194                                 return;
1195                         }
1196
1197                         if (link->dhcp_lease) {
1198                                 r = dhcp_lease_lost(link);
1199                                 if (r < 0) {
1200                                         link_enter_failed(link);
1201                                         return;
1202                                 }
1203                         }
1204
1205                         if (event == DHCP_EVENT_IP_CHANGE) {
1206                                 r = dhcp_lease_acquired(client, link);
1207                                 if (r < 0) {
1208                                         link_enter_failed(link);
1209                                         return;
1210                                 }
1211                         }
1212
1213                         if (event == DHCP_EVENT_EXPIRED && link->network->ipv4ll) {
1214                                 if (!sd_ipv4ll_is_running(link->ipv4ll))
1215                                         r = sd_ipv4ll_start(link->ipv4ll);
1216                                 else if (ipv4ll_is_bound(link->ipv4ll))
1217                                         r = ipv4ll_address_update(link, false);
1218                                 if (r < 0) {
1219                                         link_enter_failed(link);
1220                                         return;
1221                                 }
1222                         }
1223
1224                         break;
1225                 case DHCP_EVENT_RENEW:
1226                         r = dhcp_lease_renew(client, link);
1227                         if (r < 0) {
1228                                 link_enter_failed(link);
1229                                 return;
1230                         }
1231                         break;
1232                 case DHCP_EVENT_IP_ACQUIRE:
1233                         r = dhcp_lease_acquired(client, link);
1234                         if (r < 0) {
1235                                 link_enter_failed(link);
1236                                 return;
1237                         }
1238                         if (link->ipv4ll) {
1239                                 if (ipv4ll_is_bound(link->ipv4ll))
1240                                         r = ipv4ll_address_update(link, true);
1241                                 else
1242                                         r = sd_ipv4ll_stop(link->ipv4ll);
1243                                 if (r < 0) {
1244                                         link_enter_failed(link);
1245                                         return;
1246                                 }
1247                         }
1248                         break;
1249                 default:
1250                         if (event < 0)
1251                                 log_warning_link(link, "DHCP error: client failed: %s", strerror(-event));
1252                         else
1253                                 log_warning_link(link, "DHCP unknown event: %d", event);
1254                         break;
1255         }
1256
1257         return;
1258 }
1259
1260 static int ipv4ll_address_update(Link *link, bool deprecate) {
1261         int r;
1262         struct in_addr addr;
1263
1264         assert(link);
1265
1266         r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1267         if (r >= 0) {
1268                 _cleanup_address_free_ Address *address = NULL;
1269
1270                 log_debug_link(link, "IPv4 link-local %s %u.%u.%u.%u",
1271                                deprecate ? "deprecate" : "approve",
1272                                ADDRESS_FMT_VAL(addr));
1273
1274                 r = address_new_dynamic(&address);
1275                 if (r < 0) {
1276                         log_error_link(link, "Could not allocate address: %s", strerror(-r));
1277                         return r;
1278                 }
1279
1280                 address->family = AF_INET;
1281                 address->in_addr.in = addr;
1282                 address->prefixlen = 16;
1283                 address->scope = RT_SCOPE_LINK;
1284                 address->cinfo.ifa_prefered = deprecate ? 0 : CACHE_INFO_INFINITY_LIFE_TIME;
1285                 address->broadcast.s_addr = address->in_addr.in.s_addr | htonl(0xfffffffflu >> address->prefixlen);
1286
1287                 address_update(address, link, &address_update_handler);
1288         }
1289
1290         return 0;
1291
1292 }
1293
1294 static int ipv4ll_address_lost(Link *link) {
1295         int r;
1296         struct in_addr addr;
1297
1298         assert(link);
1299
1300         r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1301         if (r >= 0) {
1302                 _cleanup_address_free_ Address *address = NULL;
1303                 _cleanup_route_free_ Route *route = NULL;
1304
1305                 log_debug_link(link, "IPv4 link-local release %u.%u.%u.%u",
1306                                 ADDRESS_FMT_VAL(addr));
1307
1308                 r = address_new_dynamic(&address);
1309                 if (r < 0) {
1310                         log_error_link(link, "Could not allocate address: %s", strerror(-r));
1311                         return r;
1312                 }
1313
1314                 address->family = AF_INET;
1315                 address->in_addr.in = addr;
1316                 address->prefixlen = 16;
1317                 address->scope = RT_SCOPE_LINK;
1318
1319                 address_drop(address, link, &address_drop_handler);
1320
1321                 r = route_new_dynamic(&route);
1322                 if (r < 0) {
1323                         log_error_link(link, "Could not allocate route: %s",
1324                                        strerror(-r));
1325                         return r;
1326                 }
1327
1328                 route->family = AF_INET;
1329                 route->scope = RT_SCOPE_LINK;
1330                 route->metrics = 99;
1331
1332                 route_drop(route, link, &route_drop_handler);
1333         }
1334
1335         return 0;
1336 }
1337
1338 static bool ipv4ll_is_bound(sd_ipv4ll *ll) {
1339         int r;
1340         struct in_addr addr;
1341
1342         assert(ll);
1343
1344         r = sd_ipv4ll_get_address(ll, &addr);
1345         if (r < 0)
1346                 return false;
1347         return true;
1348 }
1349
1350 static int ipv4ll_address_claimed(sd_ipv4ll *ll, Link *link) {
1351         struct in_addr address;
1352         int r;
1353
1354         assert(ll);
1355         assert(link);
1356
1357         r = sd_ipv4ll_get_address(ll, &address);
1358         if (r < 0)
1359                 return r;
1360
1361         log_struct_link(LOG_INFO, link,
1362                         "MESSAGE=%-*s: IPv4 link-local address %u.%u.%u.%u",
1363                         IFNAMSIZ,
1364                         link->ifname,
1365                         ADDRESS_FMT_VAL(address),
1366                         NULL);
1367
1368        link_enter_set_addresses(link);
1369
1370        return 0;
1371 }
1372
1373 static void ipv4ll_handler(sd_ipv4ll *ll, int event, void *userdata){
1374         Link *link = userdata;
1375         int r;
1376
1377         assert(link);
1378         assert(link->network);
1379         assert(link->manager);
1380
1381         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1382                 return;
1383
1384         switch(event) {
1385                 case IPV4LL_EVENT_STOP:
1386                 case IPV4LL_EVENT_CONFLICT:
1387                         r = ipv4ll_address_lost(link);
1388                         if (r < 0) {
1389                                 link_enter_failed(link);
1390                                 return;
1391                         }
1392                         break;
1393                 case IPV4LL_EVENT_BIND:
1394                         r = ipv4ll_address_claimed(ll, link);
1395                         if (r < 0) {
1396                                 link_enter_failed(link);
1397                                 return;
1398                         }
1399                         break;
1400                 default:
1401                         if (event < 0)
1402                                 log_warning_link(link, "IPv4 link-local error: %s", strerror(-event));
1403                         else
1404                                 log_warning_link(link, "IPv4 link-local unknown event: %d", event);
1405                         break;
1406         }
1407 }
1408
1409 static void dhcp6_handler(sd_dhcp6_client *client, int event, void *userdata) {
1410         Link *link = userdata;
1411
1412         assert(link);
1413         assert(link->network);
1414         assert(link->manager);
1415
1416         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1417                 return;
1418
1419         switch(event) {
1420         case DHCP6_EVENT_STOP:
1421         case DHCP6_EVENT_RESEND_EXPIRE:
1422         case DHCP6_EVENT_RETRANS_MAX:
1423         case DHCP6_EVENT_IP_ACQUIRE:
1424                 log_debug_link(link, "DHCPv6 event %d", event);
1425
1426                 break;
1427
1428         default:
1429                 if (event < 0)
1430                         log_warning_link(link, "DHCPv6 error: %s",
1431                                          strerror(-event));
1432                 else
1433                         log_warning_link(link, "DHCPv6 unknown event: %d",
1434                                          event);
1435                 return;
1436         }
1437 }
1438
1439 static void icmp6_router_handler(sd_icmp6_nd *nd, int event, void *userdata) {
1440         Link *link = userdata;
1441         int r;
1442
1443         assert(link);
1444         assert(link->network);
1445         assert(link->manager);
1446
1447         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1448                 return;
1449
1450         switch(event) {
1451         case ICMP6_EVENT_ROUTER_ADVERTISMENT_NONE:
1452         case ICMP6_EVENT_ROUTER_ADVERTISMENT_OTHER:
1453                 return;
1454
1455         case ICMP6_EVENT_ROUTER_ADVERTISMENT_TIMEOUT:
1456         case ICMP6_EVENT_ROUTER_ADVERTISMENT_MANAGED:
1457                 break;
1458
1459         default:
1460                 if (event < 0)
1461                         log_warning_link(link, "ICMPv6 error: %s",
1462                                          strerror(-event));
1463                 else
1464                         log_warning_link(link, "ICMPv6 unknown event: %d",
1465                                          event);
1466
1467                 return;
1468         }
1469
1470         if (link->dhcp6_client)
1471                 return;
1472
1473         r = sd_dhcp6_client_new(&link->dhcp6_client);
1474         if (r < 0)
1475                 return;
1476
1477         r = sd_dhcp6_client_attach_event(link->dhcp6_client, NULL, 0);
1478         if (r < 0) {
1479                 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1480                 return;
1481         }
1482
1483         r = sd_dhcp6_client_set_mac(link->dhcp6_client, &link->mac);
1484         if (r < 0) {
1485                 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1486                 return;
1487         }
1488
1489         r = sd_dhcp6_client_set_index(link->dhcp6_client, link->ifindex);
1490         if (r < 0) {
1491                 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1492                 return;
1493         }
1494
1495         r = sd_dhcp6_client_set_callback(link->dhcp6_client, dhcp6_handler,
1496                                          link);
1497         if (r < 0) {
1498                 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1499                 return;
1500         }
1501
1502         r = sd_dhcp6_client_start(link->dhcp6_client);
1503         if (r < 0)
1504                 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1505 }
1506
1507 static int link_acquire_conf(Link *link) {
1508         int r;
1509
1510         assert(link);
1511         assert(link->network);
1512         assert(link->manager);
1513         assert(link->manager->event);
1514
1515         if (link->network->ipv4ll) {
1516                 assert(link->ipv4ll);
1517
1518                 log_debug_link(link, "acquiring IPv4 link-local address");
1519
1520                 r = sd_ipv4ll_start(link->ipv4ll);
1521                 if (r < 0) {
1522                         log_warning_link(link, "could not acquire IPv4 "
1523                                          "link-local address");
1524                         return r;
1525                 }
1526         }
1527
1528         if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V4)) {
1529                 assert(link->dhcp_client);
1530
1531                 log_debug_link(link, "acquiring DHCPv4 lease");
1532
1533                 r = sd_dhcp_client_start(link->dhcp_client);
1534                 if (r < 0) {
1535                         log_warning_link(link, "could not acquire DHCPv4 "
1536                                          "lease");
1537                         return r;
1538                 }
1539         }
1540
1541         if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
1542                 assert(link->icmp6_router_discovery);
1543
1544                 log_debug_link(link, "discovering IPv6 routers");
1545
1546                 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
1547                 if (r < 0) {
1548                         log_warning_link(link, "could not start IPv6 router discovery");
1549                         return r;
1550                 }
1551         }
1552
1553         return 0;
1554 }
1555
1556 bool link_has_carrier(unsigned flags, uint8_t operstate) {
1557         /* see Documentation/networking/operstates.txt in the kernel sources */
1558
1559         if (operstate == IF_OPER_UP)
1560                 return true;
1561
1562         if (operstate == IF_OPER_UNKNOWN)
1563                 /* operstate may not be implemented, so fall back to flags */
1564                 if ((flags & IFF_LOWER_UP) && !(flags & IFF_DORMANT))
1565                         return true;
1566
1567         return false;
1568 }
1569
1570 #define FLAG_STRING(string, flag, old, new) \
1571         (((old ^ new) & flag) \
1572                 ? ((old & flag) ? (" -" string) : (" +" string)) \
1573                 : "")
1574
1575 static int link_update_flags(Link *link, sd_rtnl_message *m) {
1576         unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
1577         uint8_t operstate;
1578         bool carrier_gained = false, carrier_lost = false;
1579         int r;
1580
1581         assert(link);
1582
1583         r = sd_rtnl_message_link_get_flags(m, &flags);
1584         if (r < 0) {
1585                 log_warning_link(link, "Could not get link flags");
1586                 return r;
1587         }
1588
1589         r = sd_rtnl_message_read_u8(m, IFLA_OPERSTATE, &operstate);
1590         if (r < 0)
1591                 /* if we got a message without operstate, take it to mean
1592                    the state was unchanged */
1593                 operstate = link->kernel_operstate;
1594
1595         if ((link->flags == flags) && (link->kernel_operstate == operstate))
1596                 return 0;
1597
1598         if (link->flags != flags) {
1599                 log_debug_link(link, "flags change:%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
1600                                FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
1601                                FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
1602                                FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
1603                                FLAG_STRING("UP", IFF_UP, link->flags, flags),
1604                                FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
1605                                FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
1606                                FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
1607                                FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
1608                                FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
1609                                FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
1610                                FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
1611                                FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
1612                                FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
1613                                FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
1614                                FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
1615                                FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
1616                                FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
1617                                FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
1618                                FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
1619
1620                 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
1621                                   IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
1622                                   IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
1623                                   IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
1624                                   IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
1625                                   IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
1626                 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
1627                 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
1628
1629                 /* link flags are currently at most 18 bits, let's align to printing 20 */
1630                 if (unknown_flags_added)
1631                         log_debug_link(link, "unknown link flags gained: %#.5x (ignoring)",
1632                                        unknown_flags_added);
1633
1634                 if (unknown_flags_removed)
1635                         log_debug_link(link, "unknown link flags lost: %#.5x (ignoring)",
1636                                        unknown_flags_removed);
1637         }
1638
1639         carrier_gained = !link_has_carrier(link->flags, link->kernel_operstate) &&
1640                        link_has_carrier(flags, operstate);
1641         carrier_lost = link_has_carrier(link->flags, link->kernel_operstate) &&
1642                          !link_has_carrier(flags, operstate);
1643
1644         link->flags = flags;
1645         link->kernel_operstate = operstate;
1646
1647         link_save(link);
1648
1649         if (link->state == LINK_STATE_FAILED ||
1650             link->state == LINK_STATE_UNMANAGED)
1651                 return 0;
1652
1653         if (carrier_gained) {
1654                 log_info_link(link, "gained carrier");
1655
1656                 if (link->network) {
1657                         r = link_acquire_conf(link);
1658                         if (r < 0) {
1659                                 link_enter_failed(link);
1660                                 return r;
1661                         }
1662                 }
1663         } else if (carrier_lost) {
1664                 log_info_link(link, "lost carrier");
1665
1666                 r = link_stop_clients(link);
1667                 if (r < 0) {
1668                         link_enter_failed(link);
1669                         return r;
1670                 }
1671         }
1672
1673         return 0;
1674 }
1675
1676 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1677         _cleanup_link_unref_ Link *link = userdata;
1678         int r;
1679
1680         assert(link);
1681
1682         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1683                 return 1;
1684
1685         r = sd_rtnl_message_get_errno(m);
1686         if (r < 0) {
1687                 /* we warn but don't fail the link, as it may
1688                    be brought up later */
1689                 log_struct_link(LOG_WARNING, link,
1690                                 "MESSAGE=%-*s: could not bring up interface: %s",
1691                                 IFNAMSIZ,
1692                                 link->ifname, strerror(-r),
1693                                 "ERRNO=%d", -r,
1694                                 NULL);
1695         }
1696
1697         return 1;
1698 }
1699
1700 static int link_up(Link *link) {
1701         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1702         int r;
1703
1704         assert(link);
1705         assert(link->manager);
1706         assert(link->manager->rtnl);
1707
1708         log_debug_link(link, "bringing link up");
1709
1710         r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1711                                      RTM_SETLINK, link->ifindex);
1712         if (r < 0) {
1713                 log_error_link(link, "Could not allocate RTM_SETLINK message");
1714                 return r;
1715         }
1716
1717         r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1718         if (r < 0) {
1719                 log_error_link(link, "Could not set link flags: %s", strerror(-r));
1720                 return r;
1721         }
1722
1723         r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link, 0, NULL);
1724         if (r < 0) {
1725                 log_error_link(link,
1726                                "Could not send rtnetlink message: %s", strerror(-r));
1727                 return r;
1728         }
1729
1730         link_ref(link);
1731
1732         return 0;
1733 }
1734
1735 static int link_joined(Link *link) {
1736         int r;
1737
1738         assert(link);
1739         assert(link->state == LINK_STATE_ENSLAVING);
1740         assert(link->network);
1741
1742         log_debug_link(link, "joined netdev");
1743
1744         if (!(link->flags & IFF_UP)) {
1745                 r = link_up(link);
1746                 if (r < 0) {
1747                         link_enter_failed(link);
1748                         return r;
1749                 }
1750         }
1751
1752         return link_enter_set_addresses(link);
1753 }
1754
1755 static int netdev_join_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1756         _cleanup_link_unref_ Link *link = userdata;
1757         int r;
1758
1759         assert(link);
1760         assert(IN_SET(link->state, LINK_STATE_ENSLAVING, LINK_STATE_FAILED,
1761                       LINK_STATE_LINGER));
1762         assert(link->network);
1763
1764         link->enslaving --;
1765
1766         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1767                 return 1;
1768
1769         r = sd_rtnl_message_get_errno(m);
1770         if (r < 0 && r != -EEXIST) {
1771                 log_struct_link(LOG_ERR, link,
1772                                 "MESSAGE=%-*s: could not join netdev: %s",
1773                                 IFNAMSIZ,
1774                                 link->ifname, strerror(-r),
1775                                 "ERRNO=%d", -r,
1776                                 NULL);
1777                 link_enter_failed(link);
1778                 return 1;
1779         }
1780
1781         if (link->enslaving <= 0)
1782                 link_joined(link);
1783
1784         return 1;
1785 }
1786
1787 static int link_enter_join_netdev(Link *link) {
1788         NetDev *vlan, *macvlan, *vxlan;
1789         Iterator i;
1790         int r;
1791
1792         assert(link);
1793         assert(link->network);
1794         assert(link->state == LINK_STATE_INITIALIZING);
1795
1796         link->state = LINK_STATE_ENSLAVING;
1797
1798         link_save(link);
1799
1800         if (!link->network->bridge &&
1801             !link->network->bond &&
1802             !link->network->tunnel &&
1803             hashmap_isempty(link->network->vlans) &&
1804             hashmap_isempty(link->network->macvlans) &&
1805             hashmap_isempty(link->network->vxlans))
1806                 return link_joined(link);
1807
1808         if (link->network->bond) {
1809                 log_struct_link(LOG_DEBUG, link,
1810                                 "MESSAGE=%-*s: enslaving by '%s'",
1811                                 IFNAMSIZ,
1812                                 link->ifname, link->network->bond->ifname,
1813                                 NETDEV(link->network->bond),
1814                                 NULL);
1815
1816                 r = netdev_join(link->network->bond, link, &netdev_join_handler);
1817                 if (r < 0) {
1818                         log_struct_link(LOG_WARNING, link,
1819                                         "MESSAGE=%-*s: could not join netdev '%s': %s",
1820                                         IFNAMSIZ,
1821                                         link->ifname, link->network->bond->ifname, strerror(-r),
1822                                         NETDEV(link->network->bond),
1823                                         NULL);
1824                         link_enter_failed(link);
1825                         return r;
1826                 }
1827
1828                 link->enslaving ++;
1829         }
1830
1831         if (link->network->bridge) {
1832                 log_struct_link(LOG_DEBUG, link,
1833                                 "MESSAGE=%-*s: enslaving by '%s'",
1834                                 IFNAMSIZ,
1835                                 link->ifname, link->network->bridge->ifname,
1836                                 NETDEV(link->network->bridge),
1837                                 NULL);
1838
1839                 r = netdev_join(link->network->bridge, link, &netdev_join_handler);
1840                 if (r < 0) {
1841                         log_struct_link(LOG_WARNING, link,
1842                                         "MESSAGE=%-*s: could not join netdev '%s': %s",
1843                                         IFNAMSIZ,
1844                                         link->ifname, link->network->bridge->ifname, strerror(-r),
1845                                         NETDEV(link->network->bridge),
1846                                         NULL);
1847                         link_enter_failed(link);
1848                         return r;
1849                 }
1850
1851                 link->enslaving ++;
1852         }
1853
1854         if (link->network->tunnel) {
1855                 log_struct_link(LOG_DEBUG, link,
1856                                 "MESSAGE=%-*s: enslaving by '%s'",
1857                                 IFNAMSIZ,
1858                                 link->ifname, link->network->tunnel->ifname,
1859                                 NETDEV(link->network->tunnel),
1860                                 NULL);
1861
1862                 r = netdev_join(link->network->tunnel, link, &netdev_join_handler);
1863                 if (r < 0) {
1864                         log_struct_link(LOG_WARNING, link,
1865                                         "MESSAGE=%-*s: could not join netdev '%s': %s",
1866                                         IFNAMSIZ,
1867                                         link->ifname, link->network->tunnel->ifname, strerror(-r),
1868                                         NETDEV(link->network->tunnel),
1869                                         NULL);
1870                         link_enter_failed(link);
1871                         return r;
1872                 }
1873
1874                 link->enslaving ++;
1875         }
1876
1877         HASHMAP_FOREACH(vlan, link->network->vlans, i) {
1878                 log_struct_link(LOG_DEBUG, link,
1879                                 "MESSAGE=%-*s: enslaving by '%s'",
1880                                 IFNAMSIZ,
1881                                 link->ifname, vlan->ifname, NETDEV(vlan), NULL);
1882
1883                 r = netdev_join(vlan, link, &netdev_join_handler);
1884                 if (r < 0) {
1885                         log_struct_link(LOG_WARNING, link,
1886                                         "MESSAGE=%-*s: could not join netdev '%s': %s",
1887                                         IFNAMSIZ,
1888                                         link->ifname, vlan->ifname, strerror(-r),
1889                                         NETDEV(vlan), NULL);
1890                         link_enter_failed(link);
1891                         return r;
1892                 }
1893
1894                 link->enslaving ++;
1895         }
1896
1897         HASHMAP_FOREACH(macvlan, link->network->macvlans, i) {
1898                 log_struct_link(LOG_DEBUG, link,
1899                                 "MESSAGE=%-*s: enslaving by '%s'",
1900                                 IFNAMSIZ,
1901                                 link->ifname, macvlan->ifname, NETDEV(macvlan), NULL);
1902
1903                 r = netdev_join(macvlan, link, &netdev_join_handler);
1904                 if (r < 0) {
1905                         log_struct_link(LOG_WARNING, link,
1906                                         "MESSAGE=%-*s: could not join netdev '%s': %s",
1907                                         IFNAMSIZ,
1908                                         link->ifname, macvlan->ifname, strerror(-r),
1909                                         NETDEV(macvlan), NULL);
1910                         link_enter_failed(link);
1911                         return r;
1912                 }
1913
1914                 link->enslaving ++;
1915         }
1916
1917         HASHMAP_FOREACH(vxlan, link->network->vxlans, i) {
1918                 log_struct_link(LOG_DEBUG, link,
1919                                 "MESSAGE=%*s: enslaving by '%s'",
1920                                 IFNAMSIZ,
1921                                 link->ifname, vxlan->ifname, NETDEV(vxlan), NULL);
1922
1923                 r = netdev_join(vxlan, link, &netdev_join_handler);
1924                 if (r < 0) {
1925                         log_struct_link(LOG_WARNING, link,
1926                                         "MESSAGE=%*s: could not join netdev '%s': %s",
1927                                         IFNAMSIZ,
1928                                         link->ifname, vxlan->ifname, strerror(-r),
1929                                         NETDEV(vxlan), NULL);
1930                         link_enter_failed(link);
1931                         return r;
1932                 }
1933
1934                 link->enslaving ++;
1935         }
1936
1937         return 0;
1938 }
1939
1940 static int link_configure(Link *link) {
1941         int r;
1942
1943         assert(link);
1944         assert(link->state == LINK_STATE_INITIALIZING);
1945
1946         if (link->network->ipv4ll) {
1947                 uint8_t seed[8];
1948
1949                 r = sd_ipv4ll_new(&link->ipv4ll);
1950                 if (r < 0)
1951                         return r;
1952
1953                 if (link->udev_device) {
1954                         r = net_get_unique_predictable_data(link->udev_device, seed);
1955                         if (r >= 0) {
1956                                 r = sd_ipv4ll_set_address_seed(link->ipv4ll, seed);
1957                                 if (r < 0)
1958                                         return r;
1959                         }
1960                 }
1961
1962                 r = sd_ipv4ll_attach_event(link->ipv4ll, NULL, 0);
1963                 if (r < 0)
1964                         return r;
1965
1966                 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1967                 if (r < 0)
1968                         return r;
1969
1970                 r = sd_ipv4ll_set_index(link->ipv4ll, link->ifindex);
1971                 if (r < 0)
1972                         return r;
1973
1974                 r = sd_ipv4ll_set_callback(link->ipv4ll, ipv4ll_handler, link);
1975                 if (r < 0)
1976                         return r;
1977         }
1978
1979         if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V4)) {
1980                 r = sd_dhcp_client_new(&link->dhcp_client);
1981                 if (r < 0)
1982                         return r;
1983
1984                 r = sd_dhcp_client_attach_event(link->dhcp_client, NULL, 0);
1985                 if (r < 0)
1986                         return r;
1987
1988                 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
1989                 if (r < 0)
1990                         return r;
1991
1992                 r = sd_dhcp_client_set_index(link->dhcp_client, link->ifindex);
1993                 if (r < 0)
1994                         return r;
1995
1996                 r = sd_dhcp_client_set_callback(link->dhcp_client, dhcp_handler, link);
1997                 if (r < 0)
1998                         return r;
1999
2000                 if (link->network->dhcp_mtu) {
2001                         r = sd_dhcp_client_set_request_option(link->dhcp_client, 26);
2002                         if (r < 0)
2003                                 return r;
2004                 }
2005
2006                 if (link->network->dhcp_routes) {
2007                         r = sd_dhcp_client_set_request_option(link->dhcp_client, DHCP_OPTION_STATIC_ROUTE);
2008                         if (r < 0)
2009                                 return r;
2010                         r = sd_dhcp_client_set_request_option(link->dhcp_client, DHCP_OPTION_CLASSLESS_STATIC_ROUTE);
2011                         if (r < 0)
2012                                 return r;
2013                 }
2014
2015                 if (link->network->dhcp_sendhost) {
2016                         _cleanup_free_ char *hostname = gethostname_malloc();
2017                         if (!hostname)
2018                                 return -ENOMEM;
2019
2020                         if (!is_localhost(hostname)) {
2021                                 r = sd_dhcp_client_set_hostname(link->dhcp_client, hostname);
2022                                 if (r < 0)
2023                                         return r;
2024                         }
2025                 }
2026
2027                 if (link->network->dhcp_vendor_class_identifier) {
2028                         r = sd_dhcp_client_set_vendor_class_identifier(link->dhcp_client,
2029                                                                        link->network->dhcp_vendor_class_identifier);
2030                         if (r < 0)
2031                                 return r;
2032                 }
2033         }
2034
2035         if (link->network->dhcp_server) {
2036                 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
2037                 if (r < 0)
2038                         return r;
2039
2040                 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
2041                 if (r < 0)
2042                         return r;
2043         }
2044
2045         if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
2046                 r = sd_icmp6_nd_new(&link->icmp6_router_discovery);
2047                 if (r < 0)
2048                         return r;
2049
2050                 r = sd_icmp6_nd_attach_event(link->icmp6_router_discovery,
2051                                              NULL, 0);
2052                 if (r < 0)
2053                         return r;
2054
2055                 r = sd_icmp6_nd_set_mac(link->icmp6_router_discovery,
2056                                         &link->mac);
2057                 if (r < 0)
2058                         return r;
2059
2060                 r = sd_icmp6_nd_set_index(link->icmp6_router_discovery,
2061                                           link->ifindex);
2062                 if (r < 0)
2063                         return r;
2064
2065                 r = sd_icmp6_nd_set_callback(link->icmp6_router_discovery,
2066                                              icmp6_router_handler, link);
2067                 if (r < 0)
2068                         return r;
2069         }
2070
2071         if (link_has_carrier(link->flags, link->kernel_operstate)) {
2072                 r = link_acquire_conf(link);
2073                 if (r < 0)
2074                         return r;
2075         }
2076
2077         return link_enter_join_netdev(link);
2078 }
2079
2080 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
2081         _cleanup_link_unref_ Link *link = userdata;
2082         Network *network;
2083         int r;
2084
2085         assert(link);
2086         assert(link->ifname);
2087         assert(link->manager);
2088
2089         if (link->state != LINK_STATE_INITIALIZING)
2090                 return 1;
2091
2092         log_debug_link(link, "link state is up-to-date");
2093
2094         r = network_get(link->manager, link->udev_device, link->ifname, &link->mac, &network);
2095         if (r == -ENOENT) {
2096                 link_enter_unmanaged(link);
2097                 return 1;
2098         } else if (r < 0)
2099                 return r;
2100
2101         r = network_apply(link->manager, network, link);
2102         if (r < 0)
2103                 return r;
2104
2105         r = link_configure(link);
2106         if (r < 0)
2107                 return r;
2108
2109         return 1;
2110 }
2111
2112 int link_initialized(Link *link, struct udev_device *device) {
2113         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
2114         int r;
2115
2116         assert(link);
2117         assert(link->manager);
2118         assert(link->manager->rtnl);
2119         assert(device);
2120
2121         if (link->state != LINK_STATE_INITIALIZING)
2122                 return 0;
2123
2124         log_debug_link(link, "udev initialized link");
2125
2126         link->udev_device = udev_device_ref(device);
2127
2128         /* udev has initialized the link, but we don't know if we have yet processed
2129            the NEWLINK messages with the latest state. Do a GETLINK, when it returns
2130            we know that the pending NEWLINKs have already been processed and that we
2131            are up-to-date */
2132
2133         r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK, link->ifindex);
2134         if (r < 0)
2135                 return r;
2136
2137         r = sd_rtnl_call_async(link->manager->rtnl, req, link_initialized_and_synced, link, 0, NULL);
2138         if (r < 0)
2139                 return r;
2140
2141         link_ref(link);
2142
2143         return 0;
2144 }
2145
2146 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
2147         Manager *m = userdata;
2148         Link *link = NULL;
2149         uint16_t type;
2150         _cleanup_address_free_ Address *address = NULL;
2151         Address *ad;
2152         char buf[INET6_ADDRSTRLEN];
2153         bool address_dropped = false;
2154         int r, ifindex;
2155
2156         assert(rtnl);
2157         assert(message);
2158         assert(m);
2159
2160         r = sd_rtnl_message_get_type(message, &type);
2161         if (r < 0) {
2162                 log_warning("rtnl: could not get message type");
2163                 return 0;
2164         }
2165
2166         r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
2167         if (r < 0 || ifindex <= 0) {
2168                 log_warning("rtnl: received address message without valid ifindex, ignoring");
2169                 return 0;
2170         } else {
2171                 r = link_get(m, ifindex, &link);
2172                 if (r < 0 || !link) {
2173                         log_warning("rtnl: received address for a nonexistent link, ignoring");
2174                         return 0;
2175                 }
2176         }
2177
2178         r = address_new_dynamic(&address);
2179         if (r < 0)
2180                 return r;
2181
2182         r = sd_rtnl_message_addr_get_family(message, &address->family);
2183         if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
2184                 log_warning_link(link, "rtnl: received address with invalid family, ignoring");
2185                 return 0;
2186         }
2187
2188         r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
2189         if (r < 0) {
2190                 log_warning_link(link, "rtnl: received address with invalid prefixlen, ignoring");
2191                 return 0;
2192         }
2193
2194         r = sd_rtnl_message_addr_get_scope(message, &address->scope);
2195         if (r < 0) {
2196                 log_warning_link(link, "rtnl: received address with invalid scope, ignoring");
2197                 return 0;
2198         }
2199
2200         switch (address->family) {
2201         case AF_INET:
2202                 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
2203                 if (r < 0) {
2204                         log_warning_link(link, "rtnl: received address without valid address, ignoring");
2205                         return 0;
2206                 }
2207
2208                 break;
2209
2210         case AF_INET6:
2211                 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
2212                 if (r < 0) {
2213                         log_warning_link(link, "rtnl: received address without valid address, ignoring");
2214                         return 0;
2215                 }
2216
2217                 break;
2218
2219         default:
2220                 assert_not_reached("invalid address family");
2221         }
2222
2223         if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
2224                 log_warning_link(link, "could not print address");
2225                 return 0;
2226         }
2227
2228         LIST_FOREACH(addresses, ad, link->addresses) {
2229                 if (address_equal(ad, address)) {
2230                         LIST_REMOVE(addresses, link->addresses, ad);
2231
2232                         address_free(ad);
2233
2234                         address_dropped = true;
2235
2236                         break;
2237                 }
2238         }
2239
2240         switch (type) {
2241         case RTM_NEWADDR:
2242                 if (!address_dropped)
2243                         log_debug_link(link, "added address: %s/%u", buf,
2244                                        address->prefixlen);
2245                 else
2246                         log_debug_link(link, "updated address: %s/%u", buf,
2247                                        address->prefixlen);
2248
2249                 LIST_PREPEND(addresses, link->addresses, address);
2250                 address = NULL;
2251
2252                 link_save(link);
2253
2254                 break;
2255         case RTM_DELADDR:
2256                 if (address_dropped) {
2257                         log_debug_link(link, "removed address: %s/%u", buf,
2258                                        address->prefixlen);
2259
2260                         link_save(link);
2261                 } else
2262                         log_warning_link(link, "removing non-existent address: %s/%u",
2263                                          buf, address->prefixlen);
2264
2265                 break;
2266         default:
2267                 assert_not_reached("Received invalid RTNL message type");
2268         }
2269
2270         return 1;
2271 }
2272
2273 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
2274         Link *link;
2275         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
2276         _cleanup_udev_device_unref_ struct udev_device *device = NULL;
2277         char ifindex_str[2 + DECIMAL_STR_MAX(int)];
2278         int r;
2279
2280         assert(m);
2281         assert(m->rtnl);
2282         assert(message);
2283         assert(ret);
2284
2285         r = link_new(m, message, ret);
2286         if (r < 0)
2287                 return r;
2288
2289         link = *ret;
2290
2291         log_debug_link(link, "link %"PRIu64" added", link->ifindex);
2292
2293         r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, link->ifindex, 0);
2294         if (r < 0)
2295                 return r;
2296
2297         r = sd_rtnl_call_async(m->rtnl, req, link_get_address_handler, link, 0, NULL);
2298         if (r < 0)
2299                 return r;
2300
2301         link_ref(link);
2302
2303         if (detect_container(NULL) <= 0) {
2304                 /* not in a container, udev will be around */
2305                 sprintf(ifindex_str, "n%"PRIu64, link->ifindex);
2306                 device = udev_device_new_from_device_id(m->udev, ifindex_str);
2307                 if (!device) {
2308                         log_warning_link(link, "could not find udev device");
2309                         return -errno;
2310                 }
2311
2312                 if (udev_device_get_is_initialized(device) <= 0) {
2313                         /* not yet ready */
2314                         log_debug_link(link, "udev initializing link...");
2315                         return 0;
2316                 }
2317
2318                 r = link_initialized(link, device);
2319                 if (r < 0)
2320                         return r;
2321         } else {
2322                 /* we are calling a callback directly, so must take a ref */
2323                 link_ref(link);
2324
2325                 r = link_initialized_and_synced(m->rtnl, NULL, link);
2326                 if (r < 0)
2327                         return r;
2328         }
2329
2330         return 0;
2331 }
2332
2333 int link_update(Link *link, sd_rtnl_message *m) {
2334         struct ether_addr mac;
2335         char *ifname;
2336         int r;
2337
2338         assert(link);
2339         assert(link->ifname);
2340         assert(m);
2341
2342         if (link->state == LINK_STATE_LINGER) {
2343                 link_ref(link);
2344                 log_info_link(link, "link readded");
2345                 link->state = LINK_STATE_ENSLAVING;
2346         }
2347
2348         r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
2349         if (r >= 0 && !streq(ifname, link->ifname)) {
2350                 log_info_link(link, "renamed to %s", ifname);
2351
2352                 free(link->ifname);
2353                 link->ifname = strdup(ifname);
2354                 if (!link->ifname)
2355                         return -ENOMEM;
2356         }
2357
2358         if (!link->original_mtu) {
2359                 r = sd_rtnl_message_read_u16(m, IFLA_MTU, &link->original_mtu);
2360                 if (r >= 0)
2361                         log_debug_link(link, "saved original MTU: %"
2362                                        PRIu16, link->original_mtu);
2363         }
2364
2365         /* The kernel may broadcast NEWLINK messages without the MAC address
2366            set, simply ignore them. */
2367         r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
2368         if (r >= 0) {
2369                 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN)) {
2370
2371                         memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN);
2372
2373                         log_debug_link(link, "MAC address: "
2374                                        "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2375                                        mac.ether_addr_octet[0],
2376                                        mac.ether_addr_octet[1],
2377                                        mac.ether_addr_octet[2],
2378                                        mac.ether_addr_octet[3],
2379                                        mac.ether_addr_octet[4],
2380                                        mac.ether_addr_octet[5]);
2381
2382                         if (link->ipv4ll) {
2383                                 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
2384                                 if (r < 0) {
2385                                         log_warning_link(link, "Could not update MAC "
2386                                                          "address in IPv4LL client: %s",
2387                                                          strerror(-r));
2388                                         return r;
2389                                 }
2390                         }
2391
2392                         if (link->dhcp_client) {
2393                                 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
2394                                 if (r < 0) {
2395                                         log_warning_link(link, "Could not update MAC "
2396                                                          "address in DHCP client: %s",
2397                                                          strerror(-r));
2398                                         return r;
2399                                 }
2400                         }
2401
2402                         if (link->dhcp6_client) {
2403                                 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
2404                                                             &link->mac);
2405                                 if (r < 0) {
2406                                         log_warning_link(link, "Could not update MAC address in DHCPv6 client: %s",
2407                                                          strerror(-r));
2408                                         return r;
2409                                 }
2410                         }
2411                 }
2412         }
2413
2414         return link_update_flags(link, m);
2415 }
2416
2417 static void serialize_addresses(FILE *f, const char *key, Address *address) {
2418         Address *ad;
2419
2420         assert(f);
2421         assert(key);
2422
2423         if (!address)
2424                 return;
2425
2426         fprintf(f, "%s=", key);
2427
2428         LIST_FOREACH(addresses, ad, address) {
2429                 char buf[INET6_ADDRSTRLEN];
2430
2431                 if (inet_ntop(ad->family, &ad->in_addr, buf, INET6_ADDRSTRLEN))
2432                         fprintf(f, "%s%s", buf, (ad->addresses_next) ? " ": "");
2433         }
2434
2435         fputs("\n", f);
2436 }
2437
2438 static void link_update_operstate(Link *link) {
2439
2440         assert(link);
2441
2442         if (link->kernel_operstate == IF_OPER_DORMANT)
2443                 link->operstate = LINK_OPERSTATE_DORMANT;
2444         else if (link_has_carrier(link->flags, link->kernel_operstate)) {
2445                 Address *address;
2446                 uint8_t scope = RT_SCOPE_NOWHERE;
2447
2448                 /* if we have carrier, check what addresses we have */
2449                 LIST_FOREACH(addresses, address, link->addresses) {
2450                         if (address->scope < scope)
2451                                 scope = address->scope;
2452                 }
2453
2454                 if (scope < RT_SCOPE_SITE)
2455                         /* universally accessible addresses found */
2456                         link->operstate = LINK_OPERSTATE_ROUTABLE;
2457                 else if (scope < RT_SCOPE_HOST)
2458                         /* only link or site local addresses found */
2459                         link->operstate = LINK_OPERSTATE_DEGRADED;
2460                 else
2461                         /* no useful addresses found */
2462                         link->operstate = LINK_OPERSTATE_CARRIER;
2463         } else
2464                 link->operstate = LINK_OPERSTATE_UNKNOWN;
2465 }
2466
2467 int link_save(Link *link) {
2468         _cleanup_free_ char *temp_path = NULL;
2469         _cleanup_fclose_ FILE *f = NULL;
2470         const char *admin_state, *oper_state;
2471         int r;
2472
2473         assert(link);
2474         assert(link->state_file);
2475         assert(link->lease_file);
2476         assert(link->manager);
2477
2478         link_update_operstate(link);
2479
2480         r = manager_save(link->manager);
2481         if (r < 0)
2482                 return r;
2483
2484         if (link->state == LINK_STATE_LINGER) {
2485                 unlink(link->state_file);
2486                 return 0;
2487         }
2488
2489         admin_state = link_state_to_string(link->state);
2490         assert(admin_state);
2491
2492         oper_state = link_operstate_to_string(link->operstate);
2493         assert(oper_state);
2494
2495         r = fopen_temporary(link->state_file, &f, &temp_path);
2496         if (r < 0)
2497                 goto finish;
2498
2499         fchmod(fileno(f), 0644);
2500
2501         fprintf(f,
2502                 "# This is private data. Do not parse.\n"
2503                 "ADMIN_STATE=%s\n"
2504                 "OPER_STATE=%s\n"
2505                 "FLAGS=%u\n",
2506                 admin_state, oper_state, link->flags);
2507
2508         if (link->network) {
2509                 serialize_addresses(f, "DNS", link->network->dns);
2510                 serialize_addresses(f, "NTP", link->network->ntp);
2511         }
2512
2513         if (link->dhcp_lease) {
2514                 assert(link->network);
2515
2516                 r = dhcp_lease_save(link->dhcp_lease, link->lease_file);
2517                 if (r < 0)
2518                         goto finish;
2519
2520                 fprintf(f,
2521                         "DHCP_LEASE=%s\n"
2522                         "DHCP_USE_DNS=%s\n"
2523                         "DHCP_USE_NTP=%s\n",
2524                         link->lease_file,
2525                         yes_no(link->network->dhcp_dns),
2526                         yes_no(link->network->dhcp_ntp));
2527         } else
2528                 unlink(link->lease_file);
2529
2530         fflush(f);
2531
2532         if (ferror(f) || rename(temp_path, link->state_file) < 0) {
2533                 r = -errno;
2534                 unlink(link->state_file);
2535                 unlink(temp_path);
2536         }
2537
2538 finish:
2539         if (r < 0)
2540                 log_error_link(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
2541
2542         return r;
2543 }
2544
2545 static const char* const link_state_table[_LINK_STATE_MAX] = {
2546         [LINK_STATE_INITIALIZING] = "initializing",
2547         [LINK_STATE_ENSLAVING] = "configuring",
2548         [LINK_STATE_SETTING_ADDRESSES] = "configuring",
2549         [LINK_STATE_SETTING_ROUTES] = "configuring",
2550         [LINK_STATE_CONFIGURED] = "configured",
2551         [LINK_STATE_UNMANAGED] = "unmanaged",
2552         [LINK_STATE_FAILED] = "failed",
2553         [LINK_STATE_LINGER] = "linger",
2554 };
2555
2556 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
2557
2558 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
2559         [LINK_OPERSTATE_UNKNOWN] = "unknown",
2560         [LINK_OPERSTATE_DORMANT] = "dormant",
2561         [LINK_OPERSTATE_CARRIER] = "carrier",
2562         [LINK_OPERSTATE_DEGRADED] = "degraded",
2563         [LINK_OPERSTATE_ROUTABLE] = "routable",
2564 };
2565
2566 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);
2567
2568 static const char* const dhcp_support_table[_DHCP_SUPPORT_MAX] = {
2569         [DHCP_SUPPORT_NONE] = "none",
2570         [DHCP_SUPPORT_BOTH] = "both",
2571         [DHCP_SUPPORT_V4] = "v4",
2572         [DHCP_SUPPORT_V6] = "v6",
2573 };
2574
2575 DEFINE_STRING_TABLE_LOOKUP(dhcp_support, DHCPSupport);
2576
2577 int config_parse_dhcp(
2578                 const char* unit,
2579                 const char *filename,
2580                 unsigned line,
2581                 const char *section,
2582                 unsigned section_line,
2583                 const char *lvalue,
2584                 int ltype,
2585                 const char *rvalue,
2586                 void *data,
2587                 void *userdata) {
2588
2589         DHCPSupport *dhcp = data;
2590         int k;
2591
2592         assert(filename);
2593         assert(lvalue);
2594         assert(rvalue);
2595         assert(data);
2596
2597         /* Our enum shall be a superset of booleans, hence first try
2598          * to parse as boolean, and then as enum */
2599
2600         k = parse_boolean(rvalue);
2601         if (k > 0)
2602                 *dhcp = DHCP_SUPPORT_BOTH;
2603         else if (k == 0)
2604                 *dhcp = DHCP_SUPPORT_NONE;
2605         else {
2606                 DHCPSupport s;
2607
2608                 s = dhcp_support_from_string(rvalue);
2609                 if (s < 0){
2610                         log_syntax(unit, LOG_ERR, filename, line, -s, "Failed to parse DHCP option, ignoring: %s", rvalue);
2611                         return 0;
2612                 }
2613
2614                 *dhcp = s;
2615         }
2616
2617         return 0;
2618 }