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