src/network/networkd-link.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2013 Tom Gundersen <teg@jklm.no>
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <netinet/ether.h>
  23 #include <linux/if.h>
  24
  25 #include "networkd.h"
  26 #include "libudev-private.h"
  27 #include "udev-util.h"
  28 #include "util.h"
  29 #include "virt.h"
  30 #include "bus-util.h"
  31 #include "network-internal.h"
  32 #include "conf-parser.h"
  33
  34 #include "network-util.h"
  35 #include "dhcp-lease-internal.h"
  36
  37 static int ipv4ll_address_update(Link *link, bool deprecate);
  38 static bool ipv4ll_is_bound(sd_ipv4ll *ll);
  39
  40 static int link_new(Manager *manager, sd_rtnl_message *message, Link **ret) {
  41         _cleanup_link_unref_ Link *link = NULL;
  42         uint16_t type;
  43         char *ifname;
  44         int r, ifindex;
  45
  46         assert(manager);
  47         assert(manager->links);
  48         assert(message);
  49         assert(ret);
  50
  51         r = sd_rtnl_message_get_type(message, &type);
  52         if (r < 0)
  53                 return r;
  54         else if (type != RTM_NEWLINK)
  55                 return -EINVAL;
  56
  57         r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
  58         if (r < 0)
  59                 return r;
  60         else if (ifindex <= 0)
  61                 return -EINVAL;
  62
  63         r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &ifname);
  64         if (r < 0)
  65                 return r;
  66
  67         link = new0(Link, 1);
  68         if (!link)
  69                 return -ENOMEM;
  70
  71         link->n_ref = 1;
  72         link->manager = manager;
  73         link->state = LINK_STATE_INITIALIZING;
  74         link->ifindex = ifindex;
  75         link->ifname = strdup(ifname);
  76         if (!link->ifname)
  77                 return -ENOMEM;
  78
  79         r = sd_rtnl_message_read_ether_addr(message, IFLA_ADDRESS, &link->mac);
  80         if (r < 0)
  81                 return r;
  82
  83         r = asprintf(&link->state_file, "/run/systemd/netif/links/%"PRIu64,
  84                      link->ifindex);
  85         if (r < 0)
  86                 return -ENOMEM;
  87
  88         r = asprintf(&link->lease_file, "/run/systemd/netif/leases/%"PRIu64,
  89                      link->ifindex);
  90         if (r < 0)
  91                 return -ENOMEM;
  92
  93         r = hashmap_put(manager->links, &link->ifindex, link);
  94         if (r < 0)
  95                 return r;
  96
  97         *ret = link;
  98         link = NULL;
  99
 100         return 0;
 101 }
 102
 103 static void link_free(Link *link) {
 104         Address *address;
 105
 106         if (!link)
 107                 return;
 108
 109         assert(link->manager);
 110
 111         while ((address = link->addresses)) {
 112                 LIST_REMOVE(addresses, link->addresses, address);
 113                 address_free(address);
 114         }
 115
 116         while ((address = link->pool_addresses)) {
 117                 LIST_REMOVE(addresses, link->pool_addresses, address);
 118                 address_free(address);
 119         }
 120
 121         sd_dhcp_client_unref(link->dhcp_client);
 122         sd_dhcp_lease_unref(link->dhcp_lease);
 123
 124         unlink(link->lease_file);
 125         free(link->lease_file);
 126
 127         sd_ipv4ll_unref(link->ipv4ll);
 128         sd_dhcp6_client_unref(link->dhcp6_client);
 129         sd_icmp6_nd_unref(link->icmp6_router_discovery);
 130
 131         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         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                 link_unref(link);
 381                 return 1;
 382         }
 383
 384         r = sd_rtnl_message_get_errno(m);
 385         if (r < 0 && r != -EEXIST)
 386                 log_struct_link(LOG_WARNING, link,
 387                                 "MESSAGE=%-*s: could not set route: %s",
 388                                 IFNAMSIZ,
 389                                 link->ifname, strerror(-r),
 390                                 "ERRNO=%d", -r,
 391                                 NULL);
 392
 393         /* we might have received an old reply after moving back to SETTING_ADDRESSES,
 394          * ignore it */
 395         if (link->route_messages == 0 && link->state == LINK_STATE_SETTING_ROUTES) {
 396                 log_debug_link(link, "routes set");
 397                 link_enter_configured(link);
 398         }
 399
 400         link_unref(link);
 401
 402         return 1;
 403 }
 404
 405 static int link_set_dhcp_routes(Link *link) {
 406         struct sd_dhcp_route *static_routes;
 407         size_t static_routes_size;
 408         int r;
 409         unsigned i;
 410
 411         assert(link);
 412
 413         r = sd_dhcp_lease_get_routes(link->dhcp_lease, &static_routes, &static_routes_size);
 414         if (r < 0) {
 415                 if (r != -ENOENT)
 416                         log_warning_link(link, "DHCP error: could not get routes: %s", strerror(-r));
 417                 return r;
 418         }
 419
 420         for (i = 0; i < static_routes_size; i++) {
 421                 _cleanup_route_free_ Route *route = NULL;
 422
 423                 r = route_new_dynamic(&route);
 424                 if (r < 0) {
 425                         log_error_link(link, "Could not allocate route: %s",
 426                                        strerror(-r));
 427                         return r;
 428                 }
 429
 430                 route->family = AF_INET;
 431                 route->in_addr.in = static_routes[i].gw_addr;
 432                 route->dst_addr.in = static_routes[i].dst_addr;
 433                 route->dst_prefixlen = static_routes[i].dst_prefixlen;
 434                 route->metrics = DHCP_STATIC_ROUTE_METRIC;
 435
 436                 r = route_configure(route, link, &route_handler);
 437                 if (r < 0) {
 438                         log_warning_link(link,
 439                                          "could not set host route: %s", strerror(-r));
 440                         return r;
 441                 }
 442
 443                 link_ref(link);
 444                 link->route_messages ++;
 445         }
 446
 447         return 0;
 448 }
 449
 450 static int link_enter_set_routes(Link *link) {
 451         Route *rt;
 452         int r;
 453
 454         assert(link);
 455         assert(link->network);
 456         assert(link->state == LINK_STATE_SETTING_ADDRESSES);
 457
 458         link->state = LINK_STATE_SETTING_ROUTES;
 459
 460         if (!link->network->static_routes && !link->dhcp_lease &&
 461             (!link->ipv4ll || ipv4ll_is_bound(link->ipv4ll) == false))
 462                 return link_enter_configured(link);
 463
 464         log_debug_link(link, "setting routes");
 465
 466         LIST_FOREACH(routes, rt, link->network->static_routes) {
 467                 r = route_configure(rt, link, &route_handler);
 468                 if (r < 0) {
 469                         log_warning_link(link,
 470                                          "could not set routes: %s", strerror(-r));
 471                         link_enter_failed(link);
 472                         return r;
 473                 }
 474
 475                 link_ref(link);
 476                 link->route_messages ++;
 477         }
 478
 479         if (link->ipv4ll && !link->dhcp_lease) {
 480                 _cleanup_route_free_ Route *route = NULL;
 481                 struct in_addr addr;
 482
 483                 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
 484                 if (r < 0 && r != -ENOENT) {
 485                         log_warning_link(link, "IPV4LL error: no address: %s",
 486                                         strerror(-r));
 487                         return r;
 488                 }
 489
 490                 if (r != -ENOENT) {
 491                         r = route_new_dynamic(&route);
 492                         if (r < 0) {
 493                                 log_error_link(link, "Could not allocate route: %s",
 494                                                strerror(-r));
 495                                 return r;
 496                         }
 497
 498                         route->family = AF_INET;
 499                         route->scope = RT_SCOPE_LINK;
 500                         route->metrics = 99;
 501
 502                         r = route_configure(route, link, &route_handler);
 503                         if (r < 0) {
 504                                 log_warning_link(link,
 505                                                  "could not set routes: %s", strerror(-r));
 506                                 link_enter_failed(link);
 507                                 return r;
 508                         }
 509
 510                         link_ref(link);
 511                         link->route_messages ++;
 512                 }
 513         }
 514
 515         if (link->dhcp_lease) {
 516                 _cleanup_route_free_ Route *route = NULL;
 517                 _cleanup_route_free_ Route *route_gw = NULL;
 518                 struct in_addr gateway;
 519
 520                 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
 521                 if (r < 0 && r != -ENOENT) {
 522                         log_warning_link(link, "DHCP error: could not get gateway: %s",
 523                                          strerror(-r));
 524                         return r;
 525                 }
 526
 527                 if (r >= 0) {
 528                         r = route_new_dynamic(&route);
 529                         if (r < 0) {
 530                                 log_error_link(link, "Could not allocate route: %s",
 531                                                strerror(-r));
 532                                 return r;
 533                         }
 534
 535                         r = route_new_dynamic(&route_gw);
 536                         if (r < 0) {
 537                                 log_error_link(link, "Could not allocate route: %s",
 538                                                strerror(-r));
 539                                 return r;
 540                         }
 541
 542                         /* The dhcp netmask may mask out the gateway. Add an explicit
 543                          * route for the gw host so that we can route no matter the
 544                          * netmask or existing kernel route tables. */
 545                         route_gw->family = AF_INET;
 546                         route_gw->dst_addr.in = gateway;
 547                         route_gw->dst_prefixlen = 32;
 548                         route_gw->scope = RT_SCOPE_LINK;
 549
 550                         r = route_configure(route_gw, link, &route_handler);
 551                         if (r < 0) {
 552                                 log_warning_link(link,
 553                                                  "could not set host route: %s", strerror(-r));
 554                                 return r;
 555                         }
 556
 557                         link_ref(link);
 558                         link->route_messages ++;
 559
 560                         route->family = AF_INET;
 561                         route->in_addr.in = gateway;
 562
 563                         r = route_configure(route, link, &route_handler);
 564                         if (r < 0) {
 565                                 log_warning_link(link,
 566                                                  "could not set routes: %s", strerror(-r));
 567                                 link_enter_failed(link);
 568                                 return r;
 569                         }
 570
 571                         link_ref(link);
 572                         link->route_messages ++;
 573                 }
 574
 575                 if (link->network->dhcp_routes)
 576                         link_set_dhcp_routes(link);
 577         }
 578
 579         if (link->route_messages == 0) {
 580                 link_enter_configured(link);
 581         }
 582
 583         return 0;
 584 }
 585
 586 static int route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
 587         Link *link = userdata;
 588         int r;
 589
 590         assert(m);
 591         assert(link);
 592         assert(link->ifname);
 593
 594         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
 595                 link_unref(link);
 596                 return 1;
 597         }
 598
 599         r = sd_rtnl_message_get_errno(m);
 600         if (r < 0 && r != -ESRCH)
 601                 log_struct_link(LOG_WARNING, link,
 602                                 "MESSAGE=%-*s: could not drop route: %s",
 603                                 IFNAMSIZ,
 604                                 link->ifname, strerror(-r),
 605                                 "ERRNO=%d", -r,
 606                                 NULL);
 607
 608         link_unref(link);
 609
 610         return 0;
 611 }
 612
 613 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
 614         Link *link = userdata;
 615         int r;
 616
 617         assert(m);
 618         assert(link);
 619         assert(link->ifname);
 620         assert(link->addr_messages > 0);
 621         assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
 622                LINK_STATE_FAILED, LINK_STATE_LINGER));
 623
 624         link->addr_messages --;
 625
 626         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
 627                 link_unref(link);
 628                 return 1;
 629         }
 630
 631         r = sd_rtnl_message_get_errno(m);
 632         if (r < 0 && r != -EEXIST)
 633                 log_struct_link(LOG_WARNING, link,
 634                                 "MESSAGE=%-*s: could not set address: %s",
 635                                 IFNAMSIZ,
 636                                 link->ifname, strerror(-r),
 637                                 "ERRNO=%d", -r,
 638                                 NULL);
 639
 640         if (link->addr_messages == 0) {
 641                 log_debug_link(link, "addresses set");
 642                 link_enter_set_routes(link);
 643         }
 644
 645         link_unref(link);
 646
 647         return 1;
 648 }
 649
 650 static int link_enter_set_addresses(Link *link) {
 651         Address *ad;
 652         int r;
 653         uint32_t lifetime = CACHE_INFO_INFINITY_LIFE_TIME;
 654
 655         assert(link);
 656         assert(link->network);
 657         assert(link->state != _LINK_STATE_INVALID);
 658
 659         link->state = LINK_STATE_SETTING_ADDRESSES;
 660
 661         if (!link->network->static_addresses && !link->dhcp_lease &&
 662                 (!link->ipv4ll || ipv4ll_is_bound(link->ipv4ll) == false))
 663                 return link_enter_set_routes(link);
 664
 665         log_debug_link(link, "setting addresses");
 666
 667         LIST_FOREACH(addresses, ad, link->network->static_addresses) {
 668                 r = address_configure(ad, link, &address_handler);
 669                 if (r < 0) {
 670                         log_warning_link(link,
 671                                          "could not set addresses: %s", strerror(-r));
 672                         link_enter_failed(link);
 673                         return r;
 674                 }
 675
 676                 link_ref(link);
 677                 link->addr_messages ++;
 678         }
 679
 680         if (link->ipv4ll && !link->dhcp_lease) {
 681                 _cleanup_address_free_ Address *ll_addr = NULL;
 682                 struct in_addr addr;
 683
 684                 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
 685                 if (r < 0 && r != -ENOENT) {
 686                         log_warning_link(link, "IPV4LL error: no address: %s",
 687                                         strerror(-r));
 688                         return r;
 689                 }
 690
 691                 if (r != -ENOENT) {
 692                         r = address_new_dynamic(&ll_addr);
 693                         if (r < 0) {
 694                                 log_error_link(link, "Could not allocate address: %s", strerror(-r));
 695                                 return r;
 696                         }
 697
 698                         ll_addr->family = AF_INET;
 699                         ll_addr->in_addr.in = addr;
 700                         ll_addr->prefixlen = 16;
 701                         ll_addr->broadcast.s_addr = ll_addr->in_addr.in.s_addr | htonl(0xfffffffflu >> ll_addr->prefixlen);
 702                         ll_addr->scope = RT_SCOPE_LINK;
 703
 704                         r = address_configure(ll_addr, link, &address_handler);
 705                         if (r < 0) {
 706                                 log_warning_link(link,
 707                                          "could not set addresses: %s", strerror(-r));
 708                                 link_enter_failed(link);
 709                                 return r;
 710                         }
 711
 712                         link_ref(link);
 713                         link->addr_messages ++;
 714                 }
 715         }
 716
 717         if (link->dhcp_lease) {
 718                 _cleanup_address_free_ Address *address = NULL;
 719                 struct in_addr addr;
 720                 struct in_addr netmask;
 721                 unsigned prefixlen;
 722
 723                 r = sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
 724                 if (r < 0) {
 725                         log_warning_link(link, "DHCP error: no address: %s",
 726                                          strerror(-r));
 727                         return r;
 728                 }
 729
 730                 if (!link->network->dhcp_critical) {
 731                         r = sd_dhcp_lease_get_lifetime(link->dhcp_lease,
 732                                                        &lifetime);
 733                         if (r < 0) {
 734                                 log_warning_link(link, "DHCP error: no lifetime: %s",
 735                                                  strerror(-r));
 736                                 return r;
 737                         }
 738                 }
 739
 740                 r = sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
 741                 if (r < 0) {
 742                         log_warning_link(link, "DHCP error: no netmask: %s",
 743                                          strerror(-r));
 744                         return r;
 745                 }
 746
 747                 prefixlen = net_netmask_to_prefixlen(&netmask);
 748
 749                 r = address_new_dynamic(&address);
 750                 if (r < 0) {
 751                         log_error_link(link, "Could not allocate address: %s",
 752                                        strerror(-r));
 753                         return r;
 754                 }
 755
 756                 address->family = AF_INET;
 757                 address->in_addr.in = addr;
 758                 address->cinfo.ifa_prefered = lifetime;
 759                 address->cinfo.ifa_valid = lifetime;
 760                 address->prefixlen = prefixlen;
 761                 address->broadcast.s_addr = addr.s_addr | ~netmask.s_addr;
 762
 763                 /* use update rather than configure so that we will update the lifetime
 764                    of an existing address if it has already been configured */
 765                 r = address_update(address, link, &address_handler);
 766                 if (r < 0) {
 767                         log_warning_link(link,
 768                                          "could not set addresses: %s", strerror(-r));
 769                         link_enter_failed(link);
 770                         return r;
 771                 }
 772
 773                 link_ref(link);
 774                 link->addr_messages ++;
 775         }
 776
 777         return 0;
 778 }
 779
 780 static int address_update_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
 781         Link *link = userdata;
 782         int r;
 783
 784         assert(m);
 785         assert(link);
 786         assert(link->ifname);
 787
 788         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
 789                 link_unref(link);
 790                 return 1;
 791         }
 792
 793         r = sd_rtnl_message_get_errno(m);
 794         if (r < 0 && r != -ENOENT)
 795                 log_struct_link(LOG_WARNING, link,
 796                                 "MESSAGE=%-*s: could not update address: %s",
 797                                 IFNAMSIZ,
 798                                 link->ifname, strerror(-r),
 799                                 "ERRNO=%d", -r,
 800                                 NULL);
 801
 802         link_unref(link);
 803
 804         return 0;
 805 }
 806
 807 static int address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
 808         Link *link = userdata;
 809         int r;
 810
 811         assert(m);
 812         assert(link);
 813         assert(link->ifname);
 814
 815         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
 816                 link_unref(link);
 817                 return 1;
 818         }
 819
 820         r = sd_rtnl_message_get_errno(m);
 821         if (r < 0 && r != -EADDRNOTAVAIL)
 822                 log_struct_link(LOG_WARNING, link,
 823                                 "MESSAGE=%-*s: could not drop address: %s",
 824                                 IFNAMSIZ,
 825                                 link->ifname, strerror(-r),
 826                                 "ERRNO=%d", -r,
 827                                 NULL);
 828
 829         link_unref(link);
 830
 831         return 0;
 832 }
 833
 834 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
 835         Link *link = userdata;
 836         int r;
 837
 838         assert(link);
 839
 840         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
 841                 link_unref(link);
 842                 return 1;
 843         }
 844
 845         r = sd_bus_message_get_errno(m);
 846         if (r < 0)
 847                 log_warning_link(link, "Could not set hostname: %s", strerror(-r));
 848
 849         link_unref(link);
 850
 851         return 1;
 852 }
 853
 854 static int link_set_hostname(Link *link, const char *hostname) {
 855         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
 856         int r = 0;
 857
 858         assert(link);
 859         assert(link->manager);
 860         assert(hostname);
 861
 862         log_debug_link(link, "Setting transient hostname: '%s'", hostname);
 863
 864         if (!link->manager->bus) { /* TODO: replace by assert when we can rely on kdbus */
 865                 log_info_link(link, "Not connected to system bus, ignoring transient hostname.");
 866                 return 0;
 867         }
 868
 869         r = sd_bus_message_new_method_call(
 870                         link->manager->bus,
 871                         &m,
 872                         "org.freedesktop.hostname1",
 873                         "/org/freedesktop/hostname1",
 874                         "org.freedesktop.hostname1",
 875                         "SetHostname");
 876         if (r < 0)
 877                 return r;
 878
 879         r = sd_bus_message_append(m, "sb", hostname, false);
 880         if (r < 0)
 881                 return r;
 882
 883         r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler, link, 0);
 884         if (r < 0)
 885                 log_error_link(link, "Could not set transient hostname: %s", strerror(-r));
 886
 887         link_ref(link);
 888
 889         return r;
 890 }
 891
 892 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
 893         Link *link = userdata;
 894         int r;
 895
 896         assert(m);
 897         assert(link);
 898         assert(link->ifname);
 899
 900         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
 901                 link_unref(link);
 902                 return 1;
 903         }
 904
 905         r = sd_rtnl_message_get_errno(m);
 906         if (r < 0)
 907                 log_struct_link(LOG_WARNING, link,
 908                                 "MESSAGE=%-*s: could not set MTU: %s",
 909                                 IFNAMSIZ, link->ifname, strerror(-r),
 910                                 "ERRNO=%d", -r,
 911                                 NULL);
 912
 913         link_unref(link);
 914
 915         return 1;
 916 }
 917
 918 static int link_set_mtu(Link *link, uint32_t mtu) {
 919         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
 920         int r;
 921
 922         assert(link);
 923         assert(link->manager);
 924         assert(link->manager->rtnl);
 925
 926         log_debug_link(link, "setting MTU: %" PRIu32, mtu);
 927
 928         r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
 929                                      RTM_SETLINK, link->ifindex);
 930         if (r < 0) {
 931                 log_error_link(link, "Could not allocate RTM_SETLINK message");
 932                 return r;
 933         }
 934
 935         r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
 936         if (r < 0) {
 937                 log_error_link(link, "Could not append MTU: %s", strerror(-r));
 938                 return r;
 939         }
 940
 941         r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link, 0, NULL);
 942         if (r < 0) {
 943                 log_error_link(link,
 944                                "Could not send rtnetlink message: %s", strerror(-r));
 945                 return r;
 946         }
 947
 948         link_ref(link);
 949
 950         return 0;
 951 }
 952
 953 static int dhcp_lease_lost(Link *link) {
 954         _cleanup_address_free_ Address *address = NULL;
 955         struct in_addr addr;
 956         struct in_addr netmask;
 957         struct in_addr gateway;
 958         unsigned prefixlen;
 959         unsigned i;
 960         int r;
 961
 962         assert(link);
 963         assert(link->dhcp_lease);
 964
 965         log_warning_link(link, "DHCP lease lost");
 966
 967         if (link->network->dhcp_routes) {
 968                 struct sd_dhcp_route *routes;
 969                 size_t routes_size;
 970
 971                 r = sd_dhcp_lease_get_routes(link->dhcp_lease, &routes, &routes_size);
 972                 if (r >= 0) {
 973                         for (i = 0; i < routes_size; i++) {
 974                                 _cleanup_route_free_ Route *route = NULL;
 975
 976                                 r = route_new_dynamic(&route);
 977                                 if (r >= 0) {
 978                                         route->family = AF_INET;
 979                                         route->in_addr.in = routes[i].gw_addr;
 980                                         route->dst_addr.in = routes[i].dst_addr;
 981                                         route->dst_prefixlen = routes[i].dst_prefixlen;
 982
 983                                         route_drop(route, link, &route_drop_handler);
 984                                         link_ref(link);
 985                                 }
 986                         }
 987                 }
 988         }
 989
 990         r = address_new_dynamic(&address);
 991         if (r >= 0) {
 992                 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
 993                 if (r >= 0) {
 994                         _cleanup_route_free_ Route *route_gw = NULL;
 995                         _cleanup_route_free_ Route *route = NULL;
 996
 997                         r = route_new_dynamic(&route_gw);
 998                         if (r >= 0) {
 999                                 route_gw->family = AF_INET;
1000                                 route_gw->dst_addr.in = gateway;
1001                                 route_gw->dst_prefixlen = 32;
1002                                 route_gw->scope = RT_SCOPE_LINK;
1003
1004                                 route_drop(route_gw, link, &route_drop_handler);
1005                                 link_ref(link);
1006                         }
1007
1008                         r = route_new_dynamic(&route);
1009                         if (r >= 0) {
1010                                 route->family = AF_INET;
1011                                 route->in_addr.in = gateway;
1012
1013                                 route_drop(route, link, &route_drop_handler);
1014                                 link_ref(link);
1015                         }
1016                 }
1017
1018                 sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
1019                 sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
1020                 prefixlen = net_netmask_to_prefixlen(&netmask);
1021
1022                 address->family = AF_INET;
1023                 address->in_addr.in = addr;
1024                 address->prefixlen = prefixlen;
1025
1026                 address_drop(address, link, &address_drop_handler);
1027                 link_ref(link);
1028         }
1029
1030         if (link->network->dhcp_mtu) {
1031                 uint16_t mtu;
1032
1033                 r = sd_dhcp_lease_get_mtu(link->dhcp_lease, &mtu);
1034                 if (r >= 0 && link->original_mtu != mtu) {
1035                         r = link_set_mtu(link, link->original_mtu);
1036                         if (r < 0) {
1037                                 log_warning_link(link, "DHCP error: could not reset MTU");
1038                                 link_enter_failed(link);
1039                                 return r;
1040                         }
1041                 }
1042         }
1043
1044         if (link->network->dhcp_hostname) {
1045                 const char *hostname = NULL;
1046
1047                 r = sd_dhcp_lease_get_hostname(link->dhcp_lease, &hostname);
1048                 if (r >= 0 && hostname) {
1049                         r = link_set_hostname(link, "");
1050                         if (r < 0)
1051                                 log_error_link(link, "Failed to reset transient hostname");
1052                 }
1053         }
1054
1055         link->dhcp_lease = sd_dhcp_lease_unref(link->dhcp_lease);
1056
1057         return 0;
1058 }
1059
1060 static int dhcp_lease_renew(sd_dhcp_client *client, Link *link) {
1061         sd_dhcp_lease *lease;
1062         int r;
1063
1064         r = sd_dhcp_client_get_lease(client, &lease);
1065         if (r < 0) {
1066                 log_warning_link(link, "DHCP error: no lease %s",
1067                                  strerror(-r));
1068                 return r;
1069         }
1070
1071         sd_dhcp_lease_unref(link->dhcp_lease);
1072         link->dhcp_lease = lease;
1073
1074         link_enter_set_addresses(link);
1075
1076         return 0;
1077 }
1078
1079 static int dhcp_lease_acquired(sd_dhcp_client *client, Link *link) {
1080         sd_dhcp_lease *lease;
1081         struct in_addr address;
1082         struct in_addr netmask;
1083         struct in_addr gateway;
1084         unsigned prefixlen;
1085         int r;
1086
1087         assert(client);
1088         assert(link);
1089
1090         r = sd_dhcp_client_get_lease(client, &lease);
1091         if (r < 0) {
1092                 log_warning_link(link, "DHCP error: no lease: %s",
1093                                  strerror(-r));
1094                 return r;
1095         }
1096
1097         r = sd_dhcp_lease_get_address(lease, &address);
1098         if (r < 0) {
1099                 log_warning_link(link, "DHCP error: no address: %s",
1100                                  strerror(-r));
1101                 return r;
1102         }
1103
1104         r = sd_dhcp_lease_get_netmask(lease, &netmask);
1105         if (r < 0) {
1106                 log_warning_link(link, "DHCP error: no netmask: %s",
1107                                  strerror(-r));
1108                 return r;
1109         }
1110
1111         prefixlen = net_netmask_to_prefixlen(&netmask);
1112
1113         r = sd_dhcp_lease_get_router(lease, &gateway);
1114         if (r < 0 && r != -ENOENT) {
1115                 log_warning_link(link, "DHCP error: could not get gateway: %s",
1116                                  strerror(-r));
1117                 return r;
1118         }
1119
1120         if (r >= 0)
1121                 log_struct_link(LOG_INFO, link,
1122                                 "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u via %u.%u.%u.%u",
1123                                  IFNAMSIZ,
1124                                  link->ifname,
1125                                  ADDRESS_FMT_VAL(address),
1126                                  prefixlen,
1127                                  ADDRESS_FMT_VAL(gateway),
1128                                  "ADDRESS=%u.%u.%u.%u",
1129                                  ADDRESS_FMT_VAL(address),
1130                                  "PREFIXLEN=%u",
1131                                  prefixlen,
1132                                  "GATEWAY=%u.%u.%u.%u",
1133                                  ADDRESS_FMT_VAL(gateway),
1134                                  NULL);
1135         else
1136                 log_struct_link(LOG_INFO, link,
1137                                 "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u",
1138                                  IFNAMSIZ,
1139                                  link->ifname,
1140                                  ADDRESS_FMT_VAL(address),
1141                                  prefixlen,
1142                                  "ADDRESS=%u.%u.%u.%u",
1143                                  ADDRESS_FMT_VAL(address),
1144                                  "PREFIXLEN=%u",
1145                                  prefixlen,
1146                                  NULL);
1147
1148         link->dhcp_lease = lease;
1149
1150         if (link->network->dhcp_mtu) {
1151                 uint16_t mtu;
1152
1153                 r = sd_dhcp_lease_get_mtu(lease, &mtu);
1154                 if (r >= 0) {
1155                         r = link_set_mtu(link, mtu);
1156                         if (r < 0)
1157                                 log_error_link(link, "Failed to set MTU "
1158                                                "to %" PRIu16, mtu);
1159                 }
1160         }
1161
1162         if (link->network->dhcp_hostname) {
1163                 const char *hostname;
1164
1165                 r = sd_dhcp_lease_get_hostname(lease, &hostname);
1166                 if (r >= 0) {
1167                         r = link_set_hostname(link, hostname);
1168                         if (r < 0)
1169                                 log_error_link(link, "Failed to set transient hostname "
1170                                           "to '%s'", hostname);
1171                 }
1172         }
1173
1174         link_enter_set_addresses(link);
1175
1176         return 0;
1177 }
1178
1179 static void dhcp_handler(sd_dhcp_client *client, int event, void *userdata) {
1180         Link *link = userdata;
1181         int r = 0;
1182
1183         assert(link);
1184         assert(link->network);
1185         assert(link->manager);
1186
1187         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1188                 return;
1189
1190         switch (event) {
1191                 case DHCP_EVENT_NO_LEASE:
1192                         log_debug_link(link, "IP address in use.");
1193                         break;
1194                 case DHCP_EVENT_EXPIRED:
1195                 case DHCP_EVENT_STOP:
1196                 case DHCP_EVENT_IP_CHANGE:
1197                         if (link->network->dhcp_critical) {
1198                                 log_error_link(link, "DHCPv4 connection considered system critical, "
1199                                                "ignoring request to reconfigure it.");
1200                                 return;
1201                         }
1202
1203                         if (link->dhcp_lease) {
1204                                 r = dhcp_lease_lost(link);
1205                                 if (r < 0) {
1206                                         link_enter_failed(link);
1207                                         return;
1208                                 }
1209                         }
1210
1211                         if (event == DHCP_EVENT_IP_CHANGE) {
1212                                 r = dhcp_lease_acquired(client, link);
1213                                 if (r < 0) {
1214                                         link_enter_failed(link);
1215                                         return;
1216                                 }
1217                         }
1218
1219                         if (event == DHCP_EVENT_EXPIRED && link->network->ipv4ll) {
1220                                 if (!sd_ipv4ll_is_running(link->ipv4ll))
1221                                         r = sd_ipv4ll_start(link->ipv4ll);
1222                                 else if (ipv4ll_is_bound(link->ipv4ll))
1223                                         r = ipv4ll_address_update(link, false);
1224                                 if (r < 0) {
1225                                         link_enter_failed(link);
1226                                         return;
1227                                 }
1228                         }
1229
1230                         break;
1231                 case DHCP_EVENT_RENEW:
1232                         r = dhcp_lease_renew(client, link);
1233                         if (r < 0) {
1234                                 link_enter_failed(link);
1235                                 return;
1236                         }
1237                         break;
1238                 case DHCP_EVENT_IP_ACQUIRE:
1239                         r = dhcp_lease_acquired(client, link);
1240                         if (r < 0) {
1241                                 link_enter_failed(link);
1242                                 return;
1243                         }
1244                         if (link->ipv4ll) {
1245                                 if (ipv4ll_is_bound(link->ipv4ll))
1246                                         r = ipv4ll_address_update(link, true);
1247                                 else
1248                                         r = sd_ipv4ll_stop(link->ipv4ll);
1249                                 if (r < 0) {
1250                                         link_enter_failed(link);
1251                                         return;
1252                                 }
1253                         }
1254                         break;
1255                 default:
1256                         if (event < 0)
1257                                 log_warning_link(link, "DHCP error: client failed: %s", strerror(-event));
1258                         else
1259                                 log_warning_link(link, "DHCP unknown event: %d", event);
1260                         break;
1261         }
1262
1263         return;
1264 }
1265
1266 static int ipv4ll_address_update(Link *link, bool deprecate) {
1267         int r;
1268         struct in_addr addr;
1269
1270         assert(link);
1271
1272         r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1273         if (r >= 0) {
1274                 _cleanup_address_free_ Address *address = NULL;
1275
1276                 log_debug_link(link, "IPv4 link-local %s %u.%u.%u.%u",
1277                                deprecate ? "deprecate" : "approve",
1278                                ADDRESS_FMT_VAL(addr));
1279
1280                 r = address_new_dynamic(&address);
1281                 if (r < 0) {
1282                         log_error_link(link, "Could not allocate address: %s", strerror(-r));
1283                         return r;
1284                 }
1285
1286                 address->family = AF_INET;
1287                 address->in_addr.in = addr;
1288                 address->prefixlen = 16;
1289                 address->scope = RT_SCOPE_LINK;
1290                 address->cinfo.ifa_prefered = deprecate ? 0 : CACHE_INFO_INFINITY_LIFE_TIME;
1291                 address->broadcast.s_addr = address->in_addr.in.s_addr | htonl(0xfffffffflu >> address->prefixlen);
1292
1293                 address_update(address, link, &address_update_handler);
1294                 link_ref(link);
1295         }
1296
1297         return 0;
1298
1299 }
1300
1301 static int ipv4ll_address_lost(Link *link) {
1302         int r;
1303         struct in_addr addr;
1304
1305         assert(link);
1306
1307         r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1308         if (r >= 0) {
1309                 _cleanup_address_free_ Address *address = NULL;
1310                 _cleanup_route_free_ Route *route = NULL;
1311
1312                 log_debug_link(link, "IPv4 link-local release %u.%u.%u.%u",
1313                                 ADDRESS_FMT_VAL(addr));
1314
1315                 r = address_new_dynamic(&address);
1316                 if (r < 0) {
1317                         log_error_link(link, "Could not allocate address: %s", strerror(-r));
1318                         return r;
1319                 }
1320
1321                 address->family = AF_INET;
1322                 address->in_addr.in = addr;
1323                 address->prefixlen = 16;
1324                 address->scope = RT_SCOPE_LINK;
1325
1326                 address_drop(address, link, &address_drop_handler);
1327                 link_ref(link);
1328
1329                 r = route_new_dynamic(&route);
1330                 if (r < 0) {
1331                         log_error_link(link, "Could not allocate route: %s",
1332                                        strerror(-r));
1333                         return r;
1334                 }
1335
1336                 route->family = AF_INET;
1337                 route->scope = RT_SCOPE_LINK;
1338                 route->metrics = 99;
1339
1340                 route_drop(route, link, &route_drop_handler);
1341                 link_ref(link);
1342         }
1343
1344         return 0;
1345 }
1346
1347 static bool ipv4ll_is_bound(sd_ipv4ll *ll) {
1348         int r;
1349         struct in_addr addr;
1350
1351         assert(ll);
1352
1353         r = sd_ipv4ll_get_address(ll, &addr);
1354         if (r < 0)
1355                 return false;
1356         return true;
1357 }
1358
1359 static int ipv4ll_address_claimed(sd_ipv4ll *ll, Link *link) {
1360         struct in_addr address;
1361         int r;
1362
1363         assert(ll);
1364         assert(link);
1365
1366         r = sd_ipv4ll_get_address(ll, &address);
1367         if (r < 0)
1368                 return r;
1369
1370         log_struct_link(LOG_INFO, link,
1371                         "MESSAGE=%-*s: IPv4 link-local address %u.%u.%u.%u",
1372                         IFNAMSIZ,
1373                         link->ifname,
1374                         ADDRESS_FMT_VAL(address),
1375                         NULL);
1376
1377        link_enter_set_addresses(link);
1378
1379        return 0;
1380 }
1381
1382 static void ipv4ll_handler(sd_ipv4ll *ll, int event, void *userdata){
1383         Link *link = userdata;
1384         int r;
1385
1386         assert(link);
1387         assert(link->network);
1388         assert(link->manager);
1389
1390         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1391                 return;
1392
1393         switch(event) {
1394                 case IPV4LL_EVENT_STOP:
1395                 case IPV4LL_EVENT_CONFLICT:
1396                         r = ipv4ll_address_lost(link);
1397                         if (r < 0) {
1398                                 link_enter_failed(link);
1399                                 return;
1400                         }
1401                         break;
1402                 case IPV4LL_EVENT_BIND:
1403                         r = ipv4ll_address_claimed(ll, link);
1404                         if (r < 0) {
1405                                 link_enter_failed(link);
1406                                 return;
1407                         }
1408                         break;
1409                 default:
1410                         if (event < 0)
1411                                 log_warning_link(link, "IPv4 link-local error: %s", strerror(-event));
1412                         else
1413                                 log_warning_link(link, "IPv4 link-local unknown event: %d", event);
1414                         break;
1415         }
1416 }
1417
1418 static void dhcp6_handler(sd_dhcp6_client *client, int event, void *userdata) {
1419         Link *link = userdata;
1420
1421         assert(link);
1422         assert(link->network);
1423         assert(link->manager);
1424
1425         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1426                 return;
1427
1428         switch(event) {
1429         case DHCP6_EVENT_STOP:
1430         case DHCP6_EVENT_RESEND_EXPIRE:
1431         case DHCP6_EVENT_RETRANS_MAX:
1432         case DHCP6_EVENT_IP_ACQUIRE:
1433                 log_debug_link(link, "DHCPv6 event %d", event);
1434
1435                 break;
1436
1437         default:
1438                 if (event < 0)
1439                         log_warning_link(link, "DHCPv6 error: %s",
1440                                          strerror(-event));
1441                 else
1442                         log_warning_link(link, "DHCPv6 unknown event: %d",
1443                                          event);
1444                 return;
1445         }
1446 }
1447
1448 static void icmp6_router_handler(sd_icmp6_nd *nd, int event, void *userdata) {
1449         Link *link = userdata;
1450         int r;
1451
1452         assert(link);
1453         assert(link->network);
1454         assert(link->manager);
1455
1456         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1457                 return;
1458
1459         switch(event) {
1460         case ICMP6_EVENT_ROUTER_ADVERTISMENT_NONE:
1461         case ICMP6_EVENT_ROUTER_ADVERTISMENT_OTHER:
1462                 return;
1463
1464         case ICMP6_EVENT_ROUTER_ADVERTISMENT_TIMEOUT:
1465         case ICMP6_EVENT_ROUTER_ADVERTISMENT_MANAGED:
1466                 break;
1467
1468         default:
1469                 if (event < 0)
1470                         log_warning_link(link, "ICMPv6 error: %s",
1471                                          strerror(-event));
1472                 else
1473                         log_warning_link(link, "ICMPv6 unknown event: %d",
1474                                          event);
1475
1476                 return;
1477         }
1478
1479         if (link->dhcp6_client)
1480                 return;
1481
1482         r = sd_dhcp6_client_new(&link->dhcp6_client);
1483         if (r < 0)
1484                 return;
1485
1486         r = sd_dhcp6_client_attach_event(link->dhcp6_client, NULL, 0);
1487         if (r < 0) {
1488                 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1489                 return;
1490         }
1491
1492         r = sd_dhcp6_client_set_mac(link->dhcp6_client, &link->mac);
1493         if (r < 0) {
1494                 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1495                 return;
1496         }
1497
1498         r = sd_dhcp6_client_set_index(link->dhcp6_client, link->ifindex);
1499         if (r < 0) {
1500                 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1501                 return;
1502         }
1503
1504         r = sd_dhcp6_client_set_callback(link->dhcp6_client, dhcp6_handler,
1505                                          link);
1506         if (r < 0) {
1507                 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1508                 return;
1509         }
1510
1511         r = sd_dhcp6_client_start(link->dhcp6_client);
1512         if (r < 0)
1513                 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1514 }
1515
1516 static int link_acquire_conf(Link *link) {
1517         int r;
1518
1519         assert(link);
1520         assert(link->network);
1521         assert(link->manager);
1522         assert(link->manager->event);
1523
1524         if (link->network->ipv4ll) {
1525                 assert(link->ipv4ll);
1526
1527                 log_debug_link(link, "acquiring IPv4 link-local address");
1528
1529                 r = sd_ipv4ll_start(link->ipv4ll);
1530                 if (r < 0) {
1531                         log_warning_link(link, "could not acquire IPv4 "
1532                                          "link-local address");
1533                         return r;
1534                 }
1535         }
1536
1537         if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V4)) {
1538                 assert(link->dhcp_client);
1539
1540                 log_debug_link(link, "acquiring DHCPv4 lease");
1541
1542                 r = sd_dhcp_client_start(link->dhcp_client);
1543                 if (r < 0) {
1544                         log_warning_link(link, "could not acquire DHCPv4 "
1545                                          "lease");
1546                         return r;
1547                 }
1548         }
1549
1550         if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
1551                 assert(link->icmp6_router_discovery);
1552
1553                 log_debug_link(link, "discovering IPv6 routers");
1554
1555                 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
1556                 if (r < 0) {
1557                         log_warning_link(link, "could not start IPv6 router discovery");
1558                         return r;
1559                 }
1560         }
1561
1562         return 0;
1563 }
1564
1565 bool link_has_carrier(unsigned flags, uint8_t operstate) {
1566         /* see Documentation/networking/operstates.txt in the kernel sources */
1567
1568         if (operstate == IF_OPER_UP)
1569                 return true;
1570
1571         if (operstate == IF_OPER_UNKNOWN)
1572                 /* operstate may not be implemented, so fall back to flags */
1573                 if ((flags & IFF_LOWER_UP) && !(flags & IFF_DORMANT))
1574                         return true;
1575
1576         return false;
1577 }
1578
1579 #define FLAG_STRING(string, flag, old, new) \
1580         (((old ^ new) & flag) \
1581                 ? ((old & flag) ? (" -" string) : (" +" string)) \
1582                 : "")
1583
1584 static int link_update_flags(Link *link, sd_rtnl_message *m) {
1585         unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
1586         uint8_t operstate;
1587         bool carrier_gained = false, carrier_lost = false;
1588         int r;
1589
1590         assert(link);
1591
1592         r = sd_rtnl_message_link_get_flags(m, &flags);
1593         if (r < 0) {
1594                 log_warning_link(link, "Could not get link flags");
1595                 return r;
1596         }
1597
1598         r = sd_rtnl_message_read_u8(m, IFLA_OPERSTATE, &operstate);
1599         if (r < 0)
1600                 /* if we got a message without operstate, take it to mean
1601                    the state was unchanged */
1602                 operstate = link->kernel_operstate;
1603
1604         if ((link->flags == flags) && (link->kernel_operstate == operstate))
1605                 return 0;
1606
1607         if (link->flags != flags) {
1608                 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",
1609                                FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
1610                                FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
1611                                FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
1612                                FLAG_STRING("UP", IFF_UP, link->flags, flags),
1613                                FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
1614                                FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
1615                                FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
1616                                FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
1617                                FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
1618                                FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
1619                                FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
1620                                FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
1621                                FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
1622                                FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
1623                                FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
1624                                FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
1625                                FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
1626                                FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
1627                                FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
1628
1629                 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
1630                                   IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
1631                                   IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
1632                                   IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
1633                                   IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
1634                                   IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
1635                 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
1636                 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
1637
1638                 /* link flags are currently at most 18 bits, let's align to printing 20 */
1639                 if (unknown_flags_added)
1640                         log_debug_link(link, "unknown link flags gained: %#.5x (ignoring)",
1641                                        unknown_flags_added);
1642
1643                 if (unknown_flags_removed)
1644                         log_debug_link(link, "unknown link flags lost: %#.5x (ignoring)",
1645                                        unknown_flags_removed);
1646         }
1647
1648         carrier_gained = !link_has_carrier(link->flags, link->kernel_operstate) &&
1649                        link_has_carrier(flags, operstate);
1650         carrier_lost = link_has_carrier(link->flags, link->kernel_operstate) &&
1651                          !link_has_carrier(flags, operstate);
1652
1653         link->flags = flags;
1654         link->kernel_operstate = operstate;
1655
1656         link_save(link);
1657
1658         if (link->state == LINK_STATE_FAILED ||
1659             link->state == LINK_STATE_UNMANAGED)
1660                 return 0;
1661
1662         if (carrier_gained) {
1663                 log_info_link(link, "gained carrier");
1664
1665                 if (link->network) {
1666                         r = link_acquire_conf(link);
1667                         if (r < 0) {
1668                                 link_enter_failed(link);
1669                                 return r;
1670                         }
1671                 }
1672         } else if (carrier_lost) {
1673                 log_info_link(link, "lost carrier");
1674
1675                 r = link_stop_clients(link);
1676                 if (r < 0) {
1677                         link_enter_failed(link);
1678                         return r;
1679                 }
1680         }
1681
1682         return 0;
1683 }
1684
1685 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1686         Link *link = userdata;
1687         int r;
1688
1689         assert(link);
1690
1691         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
1692                 link_unref(link);
1693                 return 1;
1694         }
1695
1696         r = sd_rtnl_message_get_errno(m);
1697         if (r < 0) {
1698                 /* we warn but don't fail the link, as it may
1699                    be brought up later */
1700                 log_struct_link(LOG_WARNING, link,
1701                                 "MESSAGE=%-*s: could not bring up interface: %s",
1702                                 IFNAMSIZ,
1703                                 link->ifname, strerror(-r),
1704                                 "ERRNO=%d", -r,
1705                                 NULL);
1706         }
1707
1708         link_unref(link);
1709
1710         return 1;
1711 }
1712
1713 static int link_up(Link *link) {
1714         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1715         int r;
1716
1717         assert(link);
1718         assert(link->manager);
1719         assert(link->manager->rtnl);
1720
1721         log_debug_link(link, "bringing link up");
1722
1723         r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1724                                      RTM_SETLINK, link->ifindex);
1725         if (r < 0) {
1726                 log_error_link(link, "Could not allocate RTM_SETLINK message");
1727                 return r;
1728         }
1729
1730         r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1731         if (r < 0) {
1732                 log_error_link(link, "Could not set link flags: %s", strerror(-r));
1733                 return r;
1734         }
1735
1736         r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link, 0, NULL);
1737         if (r < 0) {
1738                 log_error_link(link,
1739                                "Could not send rtnetlink message: %s", strerror(-r));
1740                 return r;
1741         }
1742
1743         link_ref(link);
1744
1745         return 0;
1746 }
1747
1748 static int link_enslaved(Link *link) {
1749         int r;
1750
1751         assert(link);
1752         assert(link->state == LINK_STATE_ENSLAVING);
1753         assert(link->network);
1754
1755         if (!(link->flags & IFF_UP)) {
1756                 r = link_up(link);
1757                 if (r < 0) {
1758                         link_enter_failed(link);
1759                         return r;
1760                 }
1761         }
1762
1763         return link_enter_set_addresses(link);
1764 }
1765
1766 static int enslave_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1767         Link *link = userdata;
1768         int r;
1769
1770         assert(link);
1771         assert(IN_SET(link->state, LINK_STATE_ENSLAVING, LINK_STATE_FAILED,
1772                       LINK_STATE_LINGER));
1773         assert(link->network);
1774
1775         link->enslaving --;
1776
1777         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
1778                 link_unref(link);
1779                 return 1;
1780         }
1781
1782         r = sd_rtnl_message_get_errno(m);
1783         if (r < 0) {
1784                 log_struct_link(LOG_ERR, link,
1785                                 "MESSAGE=%-*s: could not enslave: %s",
1786                                 IFNAMSIZ,
1787                                 link->ifname, strerror(-r),
1788                                 "ERRNO=%d", -r,
1789                                 NULL);
1790                 link_enter_failed(link);
1791                 link_unref(link);
1792                 return 1;
1793         }
1794
1795         log_debug_link(link, "enslaved");
1796
1797         if (link->enslaving == 0)
1798                 link_enslaved(link);
1799
1800         link_unref(link);
1801
1802         return 1;
1803 }
1804
1805 static int link_enter_enslave(Link *link) {
1806         NetDev *vlan, *macvlan, *vxlan;
1807         Iterator i;
1808         int r;
1809
1810         assert(link);
1811         assert(link->network);
1812         assert(link->state == LINK_STATE_INITIALIZING);
1813
1814         link->state = LINK_STATE_ENSLAVING;
1815
1816         link_save(link);
1817
1818         if (!link->network->bridge &&
1819             !link->network->bond &&
1820             !link->network->tunnel &&
1821             hashmap_isempty(link->network->vlans) &&
1822             hashmap_isempty(link->network->macvlans) &&
1823             hashmap_isempty(link->network->vxlans))
1824                 return link_enslaved(link);
1825
1826         if (link->network->bond) {
1827                 log_struct_link(LOG_DEBUG, link,
1828                                 "MESSAGE=%-*s: enslaving by '%s'",
1829                                 IFNAMSIZ,
1830                                 link->ifname, link->network->bond->ifname,
1831                                 NETDEV(link->network->bond),
1832                                 NULL);
1833
1834                 r = netdev_enslave(link->network->bond, link, &enslave_handler);
1835                 if (r < 0) {
1836                         log_struct_link(LOG_WARNING, link,
1837                                         "MESSAGE=%-*s: could not enslave by '%s': %s",
1838                                         IFNAMSIZ,
1839                                         link->ifname, link->network->bond->ifname, strerror(-r),
1840                                         NETDEV(link->network->bond),
1841                                         NULL);
1842                         link_enter_failed(link);
1843                         return r;
1844                 }
1845
1846                 link_ref(link);
1847                 link->enslaving ++;
1848         }
1849
1850         if (link->network->bridge) {
1851                 log_struct_link(LOG_DEBUG, link,
1852                                 "MESSAGE=%-*s: enslaving by '%s'",
1853                                 IFNAMSIZ,
1854                                 link->ifname, link->network->bridge->ifname,
1855                                 NETDEV(link->network->bridge),
1856                                 NULL);
1857
1858                 r = netdev_enslave(link->network->bridge, link, &enslave_handler);
1859                 if (r < 0) {
1860                         log_struct_link(LOG_WARNING, link,
1861                                         "MESSAGE=%-*s: could not enslave by '%s': %s",
1862                                         IFNAMSIZ,
1863                                         link->ifname, link->network->bridge->ifname, strerror(-r),
1864                                         NETDEV(link->network->bridge),
1865                                         NULL);
1866                         link_enter_failed(link);
1867                         return r;
1868                 }
1869
1870                 link_ref(link);
1871                 link->enslaving ++;
1872         }
1873
1874         if (link->network->tunnel) {
1875                 log_struct_link(LOG_DEBUG, link,
1876                                 "MESSAGE=%-*s: enslaving by '%s'",
1877                                 IFNAMSIZ,
1878                                 link->ifname, link->network->tunnel->ifname,
1879                                 NETDEV(link->network->tunnel),
1880                                 NULL);
1881
1882                 r = netdev_enslave(link->network->tunnel, link, &enslave_handler);
1883                 if (r < 0) {
1884                         log_struct_link(LOG_WARNING, link,
1885                                         "MESSAGE=%-*s: could not enslave by '%s': %s",
1886                                         IFNAMSIZ,
1887                                         link->ifname, link->network->tunnel->ifname, strerror(-r),
1888                                         NETDEV(link->network->tunnel),
1889                                         NULL);
1890                         link_enter_failed(link);
1891                         return r;
1892                 }
1893
1894                 link_ref(link);
1895                 link->enslaving ++;
1896         }
1897
1898         HASHMAP_FOREACH(vlan, link->network->vlans, i) {
1899                 log_struct_link(LOG_DEBUG, link,
1900                                 "MESSAGE=%-*s: enslaving by '%s'",
1901                                 IFNAMSIZ,
1902                                 link->ifname, vlan->ifname, NETDEV(vlan), NULL);
1903
1904                 r = netdev_enslave(vlan, link, &enslave_handler);
1905                 if (r < 0) {
1906                         log_struct_link(LOG_WARNING, link,
1907                                         "MESSAGE=%-*s: could not enslave by '%s': %s",
1908                                         IFNAMSIZ,
1909                                         link->ifname, vlan->ifname, strerror(-r),
1910                                         NETDEV(vlan), NULL);
1911                         link_enter_failed(link);
1912                         return r;
1913                 }
1914
1915                 link_ref(link);
1916                 link->enslaving ++;
1917         }
1918
1919         HASHMAP_FOREACH(macvlan, link->network->macvlans, i) {
1920                 log_struct_link(LOG_DEBUG, link,
1921                                 "MESSAGE=%-*s: enslaving by '%s'",
1922                                 IFNAMSIZ,
1923                                 link->ifname, macvlan->ifname, NETDEV(macvlan), NULL);
1924
1925                 r = netdev_enslave(macvlan, link, &enslave_handler);
1926                 if (r < 0) {
1927                         log_struct_link(LOG_WARNING, link,
1928                                         "MESSAGE=%-*s: could not enslave by '%s': %s",
1929                                         IFNAMSIZ,
1930                                         link->ifname, macvlan->ifname, strerror(-r),
1931                                         NETDEV(macvlan), NULL);
1932                         link_enter_failed(link);
1933                         return r;
1934                 }
1935
1936                 link_ref(link);
1937                 link->enslaving ++;
1938         }
1939
1940         HASHMAP_FOREACH(vxlan, link->network->vxlans, i) {
1941                 log_struct_link(LOG_DEBUG, link,
1942                                 "MESSAGE=%*s: enslaving by '%s'",
1943                                 IFNAMSIZ,
1944                                 link->ifname, vxlan->ifname, NETDEV(vxlan), NULL);
1945
1946                 r = netdev_enslave(vxlan, link, &enslave_handler);
1947                 if (r < 0) {
1948                         log_struct_link(LOG_WARNING, link,
1949                                         "MESSAGE=%*s: could not enslave by '%s': %s",
1950                                         IFNAMSIZ,
1951                                         link->ifname, vxlan->ifname, strerror(-r),
1952                                         NETDEV(vxlan), NULL);
1953                         link_enter_failed(link);
1954                         return r;
1955                 }
1956
1957                 link_ref(link);
1958                 link->enslaving ++;
1959         }
1960
1961         return 0;
1962 }
1963
1964 static int link_configure(Link *link) {
1965         int r;
1966
1967         assert(link);
1968         assert(link->state == LINK_STATE_INITIALIZING);
1969
1970         if (link->network->ipv4ll) {
1971                 uint8_t seed[8];
1972
1973                 r = sd_ipv4ll_new(&link->ipv4ll);
1974                 if (r < 0)
1975                         return r;
1976
1977                 if (link->udev_device) {
1978                         r = net_get_unique_predictable_data(link->udev_device, seed);
1979                         if (r >= 0) {
1980                                 r = sd_ipv4ll_set_address_seed(link->ipv4ll, seed);
1981                                 if (r < 0)
1982                                         return r;
1983                         }
1984                 }
1985
1986                 r = sd_ipv4ll_attach_event(link->ipv4ll, NULL, 0);
1987                 if (r < 0)
1988                         return r;
1989
1990                 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1991                 if (r < 0)
1992                         return r;
1993
1994                 r = sd_ipv4ll_set_index(link->ipv4ll, link->ifindex);
1995                 if (r < 0)
1996                         return r;
1997
1998                 r = sd_ipv4ll_set_callback(link->ipv4ll, ipv4ll_handler, link);
1999                 if (r < 0)
2000                         return r;
2001         }
2002
2003         if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V4)) {
2004                 r = sd_dhcp_client_new(&link->dhcp_client);
2005                 if (r < 0)
2006                         return r;
2007
2008                 r = sd_dhcp_client_attach_event(link->dhcp_client, NULL, 0);
2009                 if (r < 0)
2010                         return r;
2011
2012                 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
2013                 if (r < 0)
2014                         return r;
2015
2016                 r = sd_dhcp_client_set_index(link->dhcp_client, link->ifindex);
2017                 if (r < 0)
2018                         return r;
2019
2020                 r = sd_dhcp_client_set_callback(link->dhcp_client, dhcp_handler, link);
2021                 if (r < 0)
2022                         return r;
2023
2024                 if (link->network->dhcp_mtu) {
2025                         r = sd_dhcp_client_set_request_option(link->dhcp_client, 26);
2026                         if (r < 0)
2027                                 return r;
2028                 }
2029                 if (link->network->dhcp_routes) {
2030                         r = sd_dhcp_client_set_request_option(link->dhcp_client, DHCP_OPTION_STATIC_ROUTE);
2031                         if (r < 0)
2032                                 return r;
2033                         r = sd_dhcp_client_set_request_option(link->dhcp_client, DHCP_OPTION_CLASSLESS_STATIC_ROUTE);
2034                         if (r < 0)
2035                                 return r;
2036                 }
2037         }
2038
2039         if (link->network->dhcp_server) {
2040                 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
2041                 if (r < 0)
2042                         return r;
2043
2044                 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
2045                 if (r < 0)
2046                         return r;
2047         }
2048
2049         if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
2050                 r = sd_icmp6_nd_new(&link->icmp6_router_discovery);
2051                 if (r < 0)
2052                         return r;
2053
2054                 r = sd_icmp6_nd_attach_event(link->icmp6_router_discovery,
2055                                              NULL, 0);
2056                 if (r < 0)
2057                         return r;
2058
2059                 r = sd_icmp6_nd_set_mac(link->icmp6_router_discovery,
2060                                         &link->mac);
2061                 if (r < 0)
2062                         return r;
2063
2064                 r = sd_icmp6_nd_set_index(link->icmp6_router_discovery,
2065                                           link->ifindex);
2066                 if (r < 0)
2067                         return r;
2068
2069                 r = sd_icmp6_nd_set_callback(link->icmp6_router_discovery,
2070                                              icmp6_router_handler, link);
2071                 if (r < 0)
2072                         return r;
2073         }
2074
2075         if (link_has_carrier(link->flags, link->kernel_operstate)) {
2076                 r = link_acquire_conf(link);
2077                 if (r < 0)
2078                         return r;
2079         }
2080
2081         return link_enter_enslave(link);
2082 }
2083
2084 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
2085         Link *link = userdata;
2086         Network *network;
2087         int r;
2088
2089         assert(link);
2090         assert(link->ifname);
2091         assert(link->manager);
2092
2093         if (link->state != LINK_STATE_INITIALIZING)
2094                 return 0;
2095
2096         log_debug_link(link, "link state is up-to-date");
2097
2098         r = network_get(link->manager, link->udev_device, link->ifname, &link->mac, &network);
2099         if (r == -ENOENT) {
2100                 link_enter_unmanaged(link);
2101                 return 0;
2102         } else if (r < 0)
2103                 return r;
2104
2105         r = network_apply(link->manager, network, link);
2106         if (r < 0)
2107                 return r;
2108
2109         r = link_configure(link);
2110         if (r < 0)
2111                 return r;
2112
2113         return 0;
2114 }
2115
2116 int link_initialized(Link *link, struct udev_device *device) {
2117         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
2118         int r;
2119
2120         assert(link);
2121         assert(link->manager);
2122         assert(link->manager->rtnl);
2123         assert(device);
2124
2125         if (link->state != LINK_STATE_INITIALIZING)
2126                 return 0;
2127
2128         log_debug_link(link, "udev initialized link");
2129
2130         link->udev_device = udev_device_ref(device);
2131
2132         /* udev has initialized the link, but we don't know if we have yet processed
2133            the NEWLINK messages with the latest state. Do a GETLINK, when it returns
2134            we know that the pending NEWLINKs have already been processed and that we
2135            are up-to-date */
2136
2137         r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK, link->ifindex);
2138         if (r < 0)
2139                 return r;
2140
2141         r = sd_rtnl_call_async(link->manager->rtnl, req, link_initialized_and_synced, link, 0, NULL);
2142         if (r < 0)
2143                 return r;
2144
2145         return 0;
2146 }
2147
2148 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
2149         Manager *m = userdata;
2150         Link *link = NULL;
2151         uint16_t type;
2152         _cleanup_address_free_ Address *address = NULL;
2153         Address *ad;
2154         char buf[INET6_ADDRSTRLEN];
2155         bool address_dropped = false;
2156         int r, ifindex;
2157
2158         assert(rtnl);
2159         assert(message);
2160         assert(m);
2161
2162         r = sd_rtnl_message_get_type(message, &type);
2163         if (r < 0) {
2164                 log_warning("rtnl: could not get message type");
2165                 return 0;
2166         }
2167
2168         r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
2169         if (r < 0 || ifindex <= 0) {
2170                 log_warning("rtnl: received address message without valid ifindex, ignoring");
2171                 return 0;
2172         } else {
2173                 r = link_get(m, ifindex, &link);
2174                 if (r < 0 || !link) {
2175                         log_warning("rtnl: received address for a nonexistent link, ignoring");
2176                         return 0;
2177                 }
2178         }
2179
2180         r = address_new_dynamic(&address);
2181         if (r < 0)
2182                 return 0;
2183
2184         r = sd_rtnl_message_addr_get_family(message, &address->family);
2185         if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
2186                 log_warning_link(link, "rtnl: received address with invalid family, ignoring");
2187                 return 0;
2188         }
2189
2190         r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
2191         if (r < 0) {
2192                 log_warning_link(link, "rtnl: received address with invalid prefixlen, ignoring");
2193                 return 0;
2194         }
2195
2196         r = sd_rtnl_message_addr_get_scope(message, &address->scope);
2197         if (r < 0) {
2198                 log_warning_link(link, "rtnl: received address with invalid scope, ignoring");
2199                 return 0;
2200         }
2201
2202         switch (address->family) {
2203         case AF_INET:
2204                 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
2205                 if (r < 0) {
2206                         log_warning_link(link, "rtnl: received address without valid address, ignoring");
2207                         return 0;
2208                 }
2209
2210                 break;
2211
2212         case AF_INET6:
2213                 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
2214                 if (r < 0) {
2215                         log_warning_link(link, "rtnl: received address without valid address, ignoring");
2216                         return 0;
2217                 }
2218
2219                 break;
2220
2221         default:
2222                 assert_not_reached("invalid address family");
2223         }
2224
2225         if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
2226                 log_warning_link(link, "could not print address");
2227                 return 0;
2228         }
2229
2230         LIST_FOREACH(addresses, ad, link->addresses) {
2231                 if (address_equal(ad, address)) {
2232                         LIST_REMOVE(addresses, link->addresses, ad);
2233
2234                         address_free(ad);
2235
2236                         address_dropped = true;
2237
2238                         break;
2239                 }
2240         }
2241
2242         switch (type) {
2243         case RTM_NEWADDR:
2244                 if (!address_dropped)
2245                         log_debug_link(link, "added address: %s/%u", buf,
2246                                       address->prefixlen);
2247
2248                 LIST_PREPEND(addresses, link->addresses, address);
2249                 address = NULL;
2250
2251                 link_save(link);
2252
2253                 break;
2254         case RTM_DELADDR:
2255                 if (address_dropped) {
2256                         log_debug_link(link, "removed address: %s/%u", buf,
2257                                       address->prefixlen);
2258
2259                         link_save(link);
2260                 }
2261
2262                 break;
2263         default:
2264                 assert_not_reached("Received invalid RTNL message type");
2265         }
2266
2267         return 1;
2268 }
2269
2270 static int link_get_address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
2271         Link *link = userdata;
2272         int r;
2273
2274         assert(rtnl);
2275         assert(m);
2276         assert(link);
2277
2278         for (; m; m = sd_rtnl_message_next(m)) {
2279                 r = sd_rtnl_message_get_errno(m);
2280                 if (r < 0) {
2281                         log_debug_link(link, "getting address failed: %s", strerror(-r));
2282                         continue;
2283                 }
2284
2285                 r = link_rtnl_process_address(rtnl, m, link->manager);
2286                 if (r < 0)
2287                         log_warning_link(link, "could not process address: %s", strerror(-r));
2288         }
2289
2290         return 1;
2291 }
2292
2293 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
2294         Link *link;
2295         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
2296         _cleanup_udev_device_unref_ struct udev_device *device = NULL;
2297         char ifindex_str[2 + DECIMAL_STR_MAX(int)];
2298         int r;
2299
2300         assert(m);
2301         assert(m->rtnl);
2302         assert(message);
2303         assert(ret);
2304
2305         r = link_new(m, message, ret);
2306         if (r < 0)
2307                 return r;
2308
2309         link = *ret;
2310
2311         log_debug_link(link, "link %"PRIu64" added", link->ifindex);
2312
2313         r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, link->ifindex, 0);
2314         if (r < 0)
2315                 return r;
2316
2317         r = sd_rtnl_call_async(m->rtnl, req, link_get_address_handler, link, 0, NULL);
2318         if (r < 0)
2319                 return r;
2320
2321         if (detect_container(NULL) <= 0) {
2322                 /* not in a container, udev will be around */
2323                 sprintf(ifindex_str, "n%"PRIu64, link->ifindex);
2324                 device = udev_device_new_from_device_id(m->udev, ifindex_str);
2325                 if (!device) {
2326                         log_warning_link(link, "could not find udev device");
2327                         return -errno;
2328                 }
2329
2330                 if (udev_device_get_is_initialized(device) <= 0) {
2331                         /* not yet ready */
2332                         log_debug_link(link, "udev initializing link...");
2333                         return 0;
2334                 }
2335
2336                 r = link_initialized(link, device);
2337                 if (r < 0)
2338                         return r;
2339         } else {
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 }