src/network/networkd-link.c

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