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                 r = address_configure(address, link, &address_handler);
 764                 if (r < 0) {
 765                         log_warning_link(link,
 766                                          "could not set addresses: %s", strerror(-r));
 767                         link_enter_failed(link);
 768                         return r;
 769                 }
 770
 771                 link_ref(link);
 772                 link->addr_messages ++;
 773         }
 774
 775         return 0;
 776 }
 777
 778 static int address_update_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
 779         Link *link = userdata;
 780         int r;
 781
 782         assert(m);
 783         assert(link);
 784         assert(link->ifname);
 785
 786         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
 787                 link_unref(link);
 788                 return 1;
 789         }
 790
 791         r = sd_rtnl_message_get_errno(m);
 792         if (r < 0 && r != -ENOENT)
 793                 log_struct_link(LOG_WARNING, link,
 794                                 "MESSAGE=%-*s: could not update address: %s",
 795                                 IFNAMSIZ,
 796                                 link->ifname, strerror(-r),
 797                                 "ERRNO=%d", -r,
 798                                 NULL);
 799
 800         link_unref(link);
 801
 802         return 0;
 803 }
 804
 805 static int address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
 806         Link *link = userdata;
 807         int r;
 808
 809         assert(m);
 810         assert(link);
 811         assert(link->ifname);
 812
 813         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
 814                 link_unref(link);
 815                 return 1;
 816         }
 817
 818         r = sd_rtnl_message_get_errno(m);
 819         if (r < 0 && r != -EADDRNOTAVAIL)
 820                 log_struct_link(LOG_WARNING, link,
 821                                 "MESSAGE=%-*s: could not drop address: %s",
 822                                 IFNAMSIZ,
 823                                 link->ifname, strerror(-r),
 824                                 "ERRNO=%d", -r,
 825                                 NULL);
 826
 827         link_unref(link);
 828
 829         return 0;
 830 }
 831
 832 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
 833         Link *link = userdata;
 834         int r;
 835
 836         assert(link);
 837
 838         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
 839                 link_unref(link);
 840                 return 1;
 841         }
 842
 843         r = sd_bus_message_get_errno(m);
 844         if (r < 0)
 845                 log_warning_link(link, "Could not set hostname: %s", strerror(-r));
 846
 847         link_unref(link);
 848
 849         return 1;
 850 }
 851
 852 static int link_set_hostname(Link *link, const char *hostname) {
 853         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
 854         int r = 0;
 855
 856         assert(link);
 857         assert(link->manager);
 858         assert(hostname);
 859
 860         log_debug_link(link, "Setting transient hostname: '%s'", hostname);
 861
 862         if (!link->manager->bus) { /* TODO: replace by assert when we can rely on kdbus */
 863                 log_info_link(link, "Not connected to system bus, ignoring transient hostname.");
 864                 return 0;
 865         }
 866
 867         r = sd_bus_message_new_method_call(
 868                         link->manager->bus,
 869                         &m,
 870                         "org.freedesktop.hostname1",
 871                         "/org/freedesktop/hostname1",
 872                         "org.freedesktop.hostname1",
 873                         "SetHostname");
 874         if (r < 0)
 875                 return r;
 876
 877         r = sd_bus_message_append(m, "sb", hostname, false);
 878         if (r < 0)
 879                 return r;
 880
 881         r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler, link, 0);
 882         if (r < 0)
 883                 log_error_link(link, "Could not set transient hostname: %s", strerror(-r));
 884
 885         link_ref(link);
 886
 887         return r;
 888 }
 889
 890 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
 891         Link *link = userdata;
 892         int r;
 893
 894         assert(m);
 895         assert(link);
 896         assert(link->ifname);
 897
 898         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
 899                 link_unref(link);
 900                 return 1;
 901         }
 902
 903         r = sd_rtnl_message_get_errno(m);
 904         if (r < 0)
 905                 log_struct_link(LOG_WARNING, link,
 906                                 "MESSAGE=%-*s: could not set MTU: %s",
 907                                 IFNAMSIZ, link->ifname, strerror(-r),
 908                                 "ERRNO=%d", -r,
 909                                 NULL);
 910
 911         link_unref(link);
 912
 913         return 1;
 914 }
 915
 916 static int link_set_mtu(Link *link, uint32_t mtu) {
 917         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
 918         int r;
 919
 920         assert(link);
 921         assert(link->manager);
 922         assert(link->manager->rtnl);
 923
 924         log_debug_link(link, "setting MTU: %" PRIu32, mtu);
 925
 926         r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
 927                                      RTM_SETLINK, link->ifindex);
 928         if (r < 0) {
 929                 log_error_link(link, "Could not allocate RTM_SETLINK message");
 930                 return r;
 931         }
 932
 933         r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
 934         if (r < 0) {
 935                 log_error_link(link, "Could not append MTU: %s", strerror(-r));
 936                 return r;
 937         }
 938
 939         r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link, 0, NULL);
 940         if (r < 0) {
 941                 log_error_link(link,
 942                                "Could not send rtnetlink message: %s", strerror(-r));
 943                 return r;
 944         }
 945
 946         link_ref(link);
 947
 948         return 0;
 949 }
 950
 951 static int dhcp_lease_lost(Link *link) {
 952         _cleanup_address_free_ Address *address = NULL;
 953         struct in_addr addr;
 954         struct in_addr netmask;
 955         struct in_addr gateway;
 956         unsigned prefixlen;
 957         unsigned i;
 958         int r;
 959
 960         assert(link);
 961         assert(link->dhcp_lease);
 962
 963         log_warning_link(link, "DHCP lease lost");
 964
 965         if (link->network->dhcp_routes) {
 966                 struct sd_dhcp_route *routes;
 967                 size_t routes_size;
 968
 969                 r = sd_dhcp_lease_get_routes(link->dhcp_lease, &routes, &routes_size);
 970                 if (r >= 0) {
 971                         for (i = 0; i < routes_size; i++) {
 972                                 _cleanup_route_free_ Route *route = NULL;
 973
 974                                 r = route_new_dynamic(&route);
 975                                 if (r >= 0) {
 976                                         route->family = AF_INET;
 977                                         route->in_addr.in = routes[i].gw_addr;
 978                                         route->dst_addr.in = routes[i].dst_addr;
 979                                         route->dst_prefixlen = routes[i].dst_prefixlen;
 980
 981                                         route_drop(route, link, &route_drop_handler);
 982                                         link_ref(link);
 983                                 }
 984                         }
 985                 }
 986         }
 987
 988         r = address_new_dynamic(&address);
 989         if (r >= 0) {
 990                 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
 991                 if (r >= 0) {
 992                         _cleanup_route_free_ Route *route_gw = NULL;
 993                         _cleanup_route_free_ Route *route = NULL;
 994
 995                         r = route_new_dynamic(&route_gw);
 996                         if (r >= 0) {
 997                                 route_gw->family = AF_INET;
 998                                 route_gw->dst_addr.in = gateway;
 999                                 route_gw->dst_prefixlen = 32;
1000                                 route_gw->scope = RT_SCOPE_LINK;
1001
1002                                 route_drop(route_gw, link, &route_drop_handler);
1003                                 link_ref(link);
1004                         }
1005
1006                         r = route_new_dynamic(&route);
1007                         if (r >= 0) {
1008                                 route->family = AF_INET;
1009                                 route->in_addr.in = gateway;
1010
1011                                 route_drop(route, link, &route_drop_handler);
1012                                 link_ref(link);
1013                         }
1014                 }
1015
1016                 sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
1017                 sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
1018                 prefixlen = net_netmask_to_prefixlen(&netmask);
1019
1020                 address->family = AF_INET;
1021                 address->in_addr.in = addr;
1022                 address->prefixlen = prefixlen;
1023
1024                 address_drop(address, link, &address_drop_handler);
1025                 link_ref(link);
1026         }
1027
1028         if (link->network->dhcp_mtu) {
1029                 uint16_t mtu;
1030
1031                 r = sd_dhcp_lease_get_mtu(link->dhcp_lease, &mtu);
1032                 if (r >= 0 && link->original_mtu != mtu) {
1033                         r = link_set_mtu(link, link->original_mtu);
1034                         if (r < 0) {
1035                                 log_warning_link(link, "DHCP error: could not reset MTU");
1036                                 link_enter_failed(link);
1037                                 return r;
1038                         }
1039                 }
1040         }
1041
1042         if (link->network->dhcp_hostname) {
1043                 const char *hostname = NULL;
1044
1045                 r = sd_dhcp_lease_get_hostname(link->dhcp_lease, &hostname);
1046                 if (r >= 0 && hostname) {
1047                         r = link_set_hostname(link, "");
1048                         if (r < 0)
1049                                 log_error_link(link, "Failed to reset transient hostname");
1050                 }
1051         }
1052
1053         link->dhcp_lease = sd_dhcp_lease_unref(link->dhcp_lease);
1054
1055         return 0;
1056 }
1057
1058 static int dhcp_lease_renew(sd_dhcp_client *client, Link *link) {
1059         sd_dhcp_lease *lease;
1060         int r;
1061
1062         r = sd_dhcp_client_get_lease(client, &lease);
1063         if (r < 0) {
1064                 log_warning_link(link, "DHCP error: no lease %s",
1065                                  strerror(-r));
1066                 return r;
1067         }
1068
1069         sd_dhcp_lease_unref(link->dhcp_lease);
1070         link->dhcp_lease = lease;
1071
1072         link_enter_set_addresses(link);
1073
1074         return 0;
1075 }
1076
1077 static int dhcp_lease_acquired(sd_dhcp_client *client, Link *link) {
1078         sd_dhcp_lease *lease;
1079         struct in_addr address;
1080         struct in_addr netmask;
1081         struct in_addr gateway;
1082         unsigned prefixlen;
1083         int r;
1084
1085         assert(client);
1086         assert(link);
1087
1088         r = sd_dhcp_client_get_lease(client, &lease);
1089         if (r < 0) {
1090                 log_warning_link(link, "DHCP error: no lease: %s",
1091                                  strerror(-r));
1092                 return r;
1093         }
1094
1095         r = sd_dhcp_lease_get_address(lease, &address);
1096         if (r < 0) {
1097                 log_warning_link(link, "DHCP error: no address: %s",
1098                                  strerror(-r));
1099                 return r;
1100         }
1101
1102         r = sd_dhcp_lease_get_netmask(lease, &netmask);
1103         if (r < 0) {
1104                 log_warning_link(link, "DHCP error: no netmask: %s",
1105                                  strerror(-r));
1106                 return r;
1107         }
1108
1109         prefixlen = net_netmask_to_prefixlen(&netmask);
1110
1111         r = sd_dhcp_lease_get_router(lease, &gateway);
1112         if (r < 0 && r != -ENOENT) {
1113                 log_warning_link(link, "DHCP error: could not get gateway: %s",
1114                                  strerror(-r));
1115                 return r;
1116         }
1117
1118         if (r >= 0)
1119                 log_struct_link(LOG_INFO, link,
1120                                 "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u via %u.%u.%u.%u",
1121                                  IFNAMSIZ,
1122                                  link->ifname,
1123                                  ADDRESS_FMT_VAL(address),
1124                                  prefixlen,
1125                                  ADDRESS_FMT_VAL(gateway),
1126                                  "ADDRESS=%u.%u.%u.%u",
1127                                  ADDRESS_FMT_VAL(address),
1128                                  "PREFIXLEN=%u",
1129                                  prefixlen,
1130                                  "GATEWAY=%u.%u.%u.%u",
1131                                  ADDRESS_FMT_VAL(gateway),
1132                                  NULL);
1133         else
1134                 log_struct_link(LOG_INFO, link,
1135                                 "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u",
1136                                  IFNAMSIZ,
1137                                  link->ifname,
1138                                  ADDRESS_FMT_VAL(address),
1139                                  prefixlen,
1140                                  "ADDRESS=%u.%u.%u.%u",
1141                                  ADDRESS_FMT_VAL(address),
1142                                  "PREFIXLEN=%u",
1143                                  prefixlen,
1144                                  NULL);
1145
1146         link->dhcp_lease = lease;
1147
1148         if (link->network->dhcp_mtu) {
1149                 uint16_t mtu;
1150
1151                 r = sd_dhcp_lease_get_mtu(lease, &mtu);
1152                 if (r >= 0) {
1153                         r = link_set_mtu(link, mtu);
1154                         if (r < 0)
1155                                 log_error_link(link, "Failed to set MTU "
1156                                                "to %" PRIu16, mtu);
1157                 }
1158         }
1159
1160         if (link->network->dhcp_hostname) {
1161                 const char *hostname;
1162
1163                 r = sd_dhcp_lease_get_hostname(lease, &hostname);
1164                 if (r >= 0) {
1165                         r = link_set_hostname(link, hostname);
1166                         if (r < 0)
1167                                 log_error_link(link, "Failed to set transient hostname "
1168                                           "to '%s'", hostname);
1169                 }
1170         }
1171
1172         link_enter_set_addresses(link);
1173
1174         return 0;
1175 }
1176
1177 static void dhcp_handler(sd_dhcp_client *client, int event, void *userdata) {
1178         Link *link = userdata;
1179         int r = 0;
1180
1181         assert(link);
1182         assert(link->network);
1183         assert(link->manager);
1184
1185         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1186                 return;
1187
1188         switch (event) {
1189                 case DHCP_EVENT_NO_LEASE:
1190                         log_debug_link(link, "IP address in use.");
1191                         break;
1192                 case DHCP_EVENT_EXPIRED:
1193                 case DHCP_EVENT_STOP:
1194                 case DHCP_EVENT_IP_CHANGE:
1195                         if (link->network->dhcp_critical) {
1196                                 log_error_link(link, "DHCPv4 connection considered system critical, "
1197                                                "ignoring request to reconfigure it.");
1198                                 return;
1199                         }
1200
1201                         if (link->dhcp_lease) {
1202                                 r = dhcp_lease_lost(link);
1203                                 if (r < 0) {
1204                                         link_enter_failed(link);
1205                                         return;
1206                                 }
1207                         }
1208
1209                         if (event == DHCP_EVENT_IP_CHANGE) {
1210                                 r = dhcp_lease_acquired(client, link);
1211                                 if (r < 0) {
1212                                         link_enter_failed(link);
1213                                         return;
1214                                 }
1215                         }
1216
1217                         if (event == DHCP_EVENT_EXPIRED && link->network->ipv4ll) {
1218                                 if (!sd_ipv4ll_is_running(link->ipv4ll))
1219                                         r = sd_ipv4ll_start(link->ipv4ll);
1220                                 else if (ipv4ll_is_bound(link->ipv4ll))
1221                                         r = ipv4ll_address_update(link, false);
1222                                 if (r < 0) {
1223                                         link_enter_failed(link);
1224                                         return;
1225                                 }
1226                         }
1227
1228                         break;
1229                 case DHCP_EVENT_RENEW:
1230                         r = dhcp_lease_renew(client, link);
1231                         if (r < 0) {
1232                                 link_enter_failed(link);
1233                                 return;
1234                         }
1235                         break;
1236                 case DHCP_EVENT_IP_ACQUIRE:
1237                         r = dhcp_lease_acquired(client, link);
1238                         if (r < 0) {
1239                                 link_enter_failed(link);
1240                                 return;
1241                         }
1242                         if (link->ipv4ll) {
1243                                 if (ipv4ll_is_bound(link->ipv4ll))
1244                                         r = ipv4ll_address_update(link, true);
1245                                 else
1246                                         r = sd_ipv4ll_stop(link->ipv4ll);
1247                                 if (r < 0) {
1248                                         link_enter_failed(link);
1249                                         return;
1250                                 }
1251                         }
1252                         break;
1253                 default:
1254                         if (event < 0)
1255                                 log_warning_link(link, "DHCP error: client failed: %s", strerror(-event));
1256                         else
1257                                 log_warning_link(link, "DHCP unknown event: %d", event);
1258                         break;
1259         }
1260
1261         return;
1262 }
1263
1264 static int ipv4ll_address_update(Link *link, bool deprecate) {
1265         int r;
1266         struct in_addr addr;
1267
1268         assert(link);
1269
1270         r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1271         if (r >= 0) {
1272                 _cleanup_address_free_ Address *address = NULL;
1273
1274                 log_debug_link(link, "IPv4 link-local %s %u.%u.%u.%u",
1275                                deprecate ? "deprecate" : "approve",
1276                                ADDRESS_FMT_VAL(addr));
1277
1278                 r = address_new_dynamic(&address);
1279                 if (r < 0) {
1280                         log_error_link(link, "Could not allocate address: %s", strerror(-r));
1281                         return r;
1282                 }
1283
1284                 address->family = AF_INET;
1285                 address->in_addr.in = addr;
1286                 address->prefixlen = 16;
1287                 address->scope = RT_SCOPE_LINK;
1288                 address->cinfo.ifa_prefered = deprecate ? 0 : CACHE_INFO_INFINITY_LIFE_TIME;
1289                 address->broadcast.s_addr = address->in_addr.in.s_addr | htonl(0xfffffffflu >> address->prefixlen);
1290
1291                 address_update(address, link, &address_update_handler);
1292                 link_ref(link);
1293         }
1294
1295         return 0;
1296
1297 }
1298
1299 static int ipv4ll_address_lost(Link *link) {
1300         int r;
1301         struct in_addr addr;
1302
1303         assert(link);
1304
1305         r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1306         if (r >= 0) {
1307                 _cleanup_address_free_ Address *address = NULL;
1308                 _cleanup_route_free_ Route *route = NULL;
1309
1310                 log_debug_link(link, "IPv4 link-local release %u.%u.%u.%u",
1311                                 ADDRESS_FMT_VAL(addr));
1312
1313                 r = address_new_dynamic(&address);
1314                 if (r < 0) {
1315                         log_error_link(link, "Could not allocate address: %s", strerror(-r));
1316                         return r;
1317                 }
1318
1319                 address->family = AF_INET;
1320                 address->in_addr.in = addr;
1321                 address->prefixlen = 16;
1322                 address->scope = RT_SCOPE_LINK;
1323
1324                 address_drop(address, link, &address_drop_handler);
1325                 link_ref(link);
1326
1327                 r = route_new_dynamic(&route);
1328                 if (r < 0) {
1329                         log_error_link(link, "Could not allocate route: %s",
1330                                        strerror(-r));
1331                         return r;
1332                 }
1333
1334                 route->family = AF_INET;
1335                 route->scope = RT_SCOPE_LINK;
1336                 route->metrics = 99;
1337
1338                 route_drop(route, link, &route_drop_handler);
1339                 link_ref(link);
1340         }
1341
1342         return 0;
1343 }
1344
1345 static bool ipv4ll_is_bound(sd_ipv4ll *ll) {
1346         int r;
1347         struct in_addr addr;
1348
1349         assert(ll);
1350
1351         r = sd_ipv4ll_get_address(ll, &addr);
1352         if (r < 0)
1353                 return false;
1354         return true;
1355 }
1356
1357 static int ipv4ll_address_claimed(sd_ipv4ll *ll, Link *link) {
1358         struct in_addr address;
1359         int r;
1360
1361         assert(ll);
1362         assert(link);
1363
1364         r = sd_ipv4ll_get_address(ll, &address);
1365         if (r < 0)
1366                 return r;
1367
1368         log_struct_link(LOG_INFO, link,
1369                         "MESSAGE=%-*s: IPv4 link-local address %u.%u.%u.%u",
1370                         IFNAMSIZ,
1371                         link->ifname,
1372                         ADDRESS_FMT_VAL(address),
1373                         NULL);
1374
1375        link_enter_set_addresses(link);
1376
1377        return 0;
1378 }
1379
1380 static void ipv4ll_handler(sd_ipv4ll *ll, int event, void *userdata){
1381         Link *link = userdata;
1382         int r;
1383
1384         assert(link);
1385         assert(link->network);
1386         assert(link->manager);
1387
1388         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1389                 return;
1390
1391         switch(event) {
1392                 case IPV4LL_EVENT_STOP:
1393                 case IPV4LL_EVENT_CONFLICT:
1394                         r = ipv4ll_address_lost(link);
1395                         if (r < 0) {
1396                                 link_enter_failed(link);
1397                                 return;
1398                         }
1399                         break;
1400                 case IPV4LL_EVENT_BIND:
1401                         r = ipv4ll_address_claimed(ll, link);
1402                         if (r < 0) {
1403                                 link_enter_failed(link);
1404                                 return;
1405                         }
1406                         break;
1407                 default:
1408                         if (event < 0)
1409                                 log_warning_link(link, "IPv4 link-local error: %s", strerror(-event));
1410                         else
1411                                 log_warning_link(link, "IPv4 link-local unknown event: %d", event);
1412                         break;
1413         }
1414 }
1415
1416 static void dhcp6_handler(sd_dhcp6_client *client, int event, void *userdata) {
1417         Link *link = userdata;
1418
1419         assert(link);
1420         assert(link->network);
1421         assert(link->manager);
1422
1423         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1424                 return;
1425
1426         switch(event) {
1427         case DHCP6_EVENT_STOP:
1428         case DHCP6_EVENT_RESEND_EXPIRE:
1429         case DHCP6_EVENT_RETRANS_MAX:
1430         case DHCP6_EVENT_IP_ACQUIRE:
1431                 log_debug_link(link, "DHCPv6 event %d", event);
1432
1433                 break;
1434
1435         default:
1436                 if (event < 0)
1437                         log_warning_link(link, "DHCPv6 error: %s",
1438                                          strerror(-event));
1439                 else
1440                         log_warning_link(link, "DHCPv6 unknown event: %d",
1441                                          event);
1442                 return;
1443         }
1444 }
1445
1446 static void icmp6_router_handler(sd_icmp6_nd *nd, int event, void *userdata) {
1447         Link *link = userdata;
1448         int r;
1449
1450         assert(link);
1451         assert(link->network);
1452         assert(link->manager);
1453
1454         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1455                 return;
1456
1457         switch(event) {
1458         case ICMP6_EVENT_ROUTER_ADVERTISMENT_NONE:
1459         case ICMP6_EVENT_ROUTER_ADVERTISMENT_OTHER:
1460                 return;
1461
1462         case ICMP6_EVENT_ROUTER_ADVERTISMENT_TIMEOUT:
1463         case ICMP6_EVENT_ROUTER_ADVERTISMENT_MANAGED:
1464                 break;
1465
1466         default:
1467                 if (event < 0)
1468                         log_warning_link(link, "ICMPv6 error: %s",
1469                                          strerror(-event));
1470                 else
1471                         log_warning_link(link, "ICMPv6 unknown event: %d",
1472                                          event);
1473
1474                 return;
1475         }
1476
1477         if (link->dhcp6_client)
1478                 return;
1479
1480         r = sd_dhcp6_client_new(&link->dhcp6_client);
1481         if (r < 0)
1482                 return;
1483
1484         r = sd_dhcp6_client_attach_event(link->dhcp6_client, NULL, 0);
1485         if (r < 0) {
1486                 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1487                 return;
1488         }
1489
1490         r = sd_dhcp6_client_set_mac(link->dhcp6_client, &link->mac);
1491         if (r < 0) {
1492                 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1493                 return;
1494         }
1495
1496         r = sd_dhcp6_client_set_index(link->dhcp6_client, link->ifindex);
1497         if (r < 0) {
1498                 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1499                 return;
1500         }
1501
1502         r = sd_dhcp6_client_set_callback(link->dhcp6_client, dhcp6_handler,
1503                                          link);
1504         if (r < 0) {
1505                 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1506                 return;
1507         }
1508
1509         r = sd_dhcp6_client_start(link->dhcp6_client);
1510         if (r < 0)
1511                 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1512 }
1513
1514 static int link_acquire_conf(Link *link) {
1515         int r;
1516
1517         assert(link);
1518         assert(link->network);
1519         assert(link->manager);
1520         assert(link->manager->event);
1521
1522         if (link->network->ipv4ll) {
1523                 assert(link->ipv4ll);
1524
1525                 log_debug_link(link, "acquiring IPv4 link-local address");
1526
1527                 r = sd_ipv4ll_start(link->ipv4ll);
1528                 if (r < 0) {
1529                         log_warning_link(link, "could not acquire IPv4 "
1530                                          "link-local address");
1531                         return r;
1532                 }
1533         }
1534
1535         if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V4)) {
1536                 assert(link->dhcp_client);
1537
1538                 log_debug_link(link, "acquiring DHCPv4 lease");
1539
1540                 r = sd_dhcp_client_start(link->dhcp_client);
1541                 if (r < 0) {
1542                         log_warning_link(link, "could not acquire DHCPv4 "
1543                                          "lease");
1544                         return r;
1545                 }
1546         }
1547
1548         if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
1549                 assert(link->icmp6_router_discovery);
1550
1551                 log_debug_link(link, "discovering IPv6 routers");
1552
1553                 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
1554                 if (r < 0) {
1555                         log_warning_link(link, "could not start IPv6 router discovery");
1556                         return r;
1557                 }
1558         }
1559
1560         return 0;
1561 }
1562
1563 bool link_has_carrier(unsigned flags, uint8_t operstate) {
1564         /* see Documentation/networking/operstates.txt in the kernel sources */
1565
1566         if (operstate == IF_OPER_UP)
1567                 return true;
1568
1569         if (operstate == IF_OPER_UNKNOWN)
1570                 /* operstate may not be implemented, so fall back to flags */
1571                 if ((flags & IFF_LOWER_UP) && !(flags & IFF_DORMANT))
1572                         return true;
1573
1574         return false;
1575 }
1576
1577 #define FLAG_STRING(string, flag, old, new) \
1578         (((old ^ new) & flag) \
1579                 ? ((old & flag) ? (" -" string) : (" +" string)) \
1580                 : "")
1581
1582 static int link_update_flags(Link *link, sd_rtnl_message *m) {
1583         unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
1584         uint8_t operstate;
1585         bool carrier_gained = false, carrier_lost = false;
1586         int r;
1587
1588         assert(link);
1589
1590         r = sd_rtnl_message_link_get_flags(m, &flags);
1591         if (r < 0) {
1592                 log_warning_link(link, "Could not get link flags");
1593                 return r;
1594         }
1595
1596         r = sd_rtnl_message_read_u8(m, IFLA_OPERSTATE, &operstate);
1597         if (r < 0)
1598                 /* if we got a message without operstate, take it to mean
1599                    the state was unchanged */
1600                 operstate = link->kernel_operstate;
1601
1602         if ((link->flags == flags) && (link->kernel_operstate == operstate))
1603                 return 0;
1604
1605         if (link->flags != flags) {
1606                 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",
1607                                FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
1608                                FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
1609                                FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
1610                                FLAG_STRING("UP", IFF_UP, link->flags, flags),
1611                                FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
1612                                FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
1613                                FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
1614                                FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
1615                                FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
1616                                FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
1617                                FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
1618                                FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
1619                                FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
1620                                FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
1621                                FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
1622                                FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
1623                                FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
1624                                FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
1625                                FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
1626
1627                 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
1628                                   IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
1629                                   IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
1630                                   IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
1631                                   IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
1632                                   IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
1633                 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
1634                 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
1635
1636                 /* link flags are currently at most 18 bits, let's align to printing 20 */
1637                 if (unknown_flags_added)
1638                         log_debug_link(link, "unknown link flags gained: %#.5x (ignoring)",
1639                                        unknown_flags_added);
1640
1641                 if (unknown_flags_removed)
1642                         log_debug_link(link, "unknown link flags lost: %#.5x (ignoring)",
1643                                        unknown_flags_removed);
1644         }
1645
1646         carrier_gained = !link_has_carrier(link->flags, link->kernel_operstate) &&
1647                        link_has_carrier(flags, operstate);
1648         carrier_lost = link_has_carrier(link->flags, link->kernel_operstate) &&
1649                          !link_has_carrier(flags, operstate);
1650
1651         link->flags = flags;
1652         link->kernel_operstate = operstate;
1653
1654         link_save(link);
1655
1656         if (link->state == LINK_STATE_FAILED ||
1657             link->state == LINK_STATE_UNMANAGED)
1658                 return 0;
1659
1660         if (carrier_gained) {
1661                 log_info_link(link, "gained carrier");
1662
1663                 if (link->network) {
1664                         r = link_acquire_conf(link);
1665                         if (r < 0) {
1666                                 link_enter_failed(link);
1667                                 return r;
1668                         }
1669                 }
1670         } else if (carrier_lost) {
1671                 log_info_link(link, "lost carrier");
1672
1673                 r = link_stop_clients(link);
1674                 if (r < 0) {
1675                         link_enter_failed(link);
1676                         return r;
1677                 }
1678         }
1679
1680         return 0;
1681 }
1682
1683 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1684         Link *link = userdata;
1685         int r;
1686
1687         assert(link);
1688
1689         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
1690                 link_unref(link);
1691                 return 1;
1692         }
1693
1694         r = sd_rtnl_message_get_errno(m);
1695         if (r < 0) {
1696                 /* we warn but don't fail the link, as it may
1697                    be brought up later */
1698                 log_struct_link(LOG_WARNING, link,
1699                                 "MESSAGE=%-*s: could not bring up interface: %s",
1700                                 IFNAMSIZ,
1701                                 link->ifname, strerror(-r),
1702                                 "ERRNO=%d", -r,
1703                                 NULL);
1704         }
1705
1706         link_unref(link);
1707
1708         return 1;
1709 }
1710
1711 static int link_up(Link *link) {
1712         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1713         int r;
1714
1715         assert(link);
1716         assert(link->manager);
1717         assert(link->manager->rtnl);
1718
1719         log_debug_link(link, "bringing link up");
1720
1721         r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1722                                      RTM_SETLINK, link->ifindex);
1723         if (r < 0) {
1724                 log_error_link(link, "Could not allocate RTM_SETLINK message");
1725                 return r;
1726         }
1727
1728         r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1729         if (r < 0) {
1730                 log_error_link(link, "Could not set link flags: %s", strerror(-r));
1731                 return r;
1732         }
1733
1734         r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link, 0, NULL);
1735         if (r < 0) {
1736                 log_error_link(link,
1737                                "Could not send rtnetlink message: %s", strerror(-r));
1738                 return r;
1739         }
1740
1741         link_ref(link);
1742
1743         return 0;
1744 }
1745
1746 static int link_enslaved(Link *link) {
1747         int r;
1748
1749         assert(link);
1750         assert(link->state == LINK_STATE_ENSLAVING);
1751         assert(link->network);
1752
1753         if (!(link->flags & IFF_UP)) {
1754                 r = link_up(link);
1755                 if (r < 0) {
1756                         link_enter_failed(link);
1757                         return r;
1758                 }
1759         }
1760
1761         return link_enter_set_addresses(link);
1762 }
1763
1764 static int enslave_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1765         Link *link = userdata;
1766         int r;
1767
1768         assert(link);
1769         assert(IN_SET(link->state, LINK_STATE_ENSLAVING, LINK_STATE_FAILED,
1770                       LINK_STATE_LINGER));
1771         assert(link->network);
1772
1773         link->enslaving --;
1774
1775         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
1776                 link_unref(link);
1777                 return 1;
1778         }
1779
1780         r = sd_rtnl_message_get_errno(m);
1781         if (r < 0) {
1782                 log_struct_link(LOG_ERR, link,
1783                                 "MESSAGE=%-*s: could not enslave: %s",
1784                                 IFNAMSIZ,
1785                                 link->ifname, strerror(-r),
1786                                 "ERRNO=%d", -r,
1787                                 NULL);
1788                 link_enter_failed(link);
1789                 link_unref(link);
1790                 return 1;
1791         }
1792
1793         log_debug_link(link, "enslaved");
1794
1795         if (link->enslaving == 0)
1796                 link_enslaved(link);
1797
1798         link_unref(link);
1799
1800         return 1;
1801 }
1802
1803 static int link_enter_enslave(Link *link) {
1804         NetDev *vlan, *macvlan, *vxlan;
1805         Iterator i;
1806         int r;
1807
1808         assert(link);
1809         assert(link->network);
1810         assert(link->state == LINK_STATE_INITIALIZING);
1811
1812         link->state = LINK_STATE_ENSLAVING;
1813
1814         link_save(link);
1815
1816         if (!link->network->bridge &&
1817             !link->network->bond &&
1818             !link->network->tunnel &&
1819             hashmap_isempty(link->network->vlans) &&
1820             hashmap_isempty(link->network->macvlans) &&
1821             hashmap_isempty(link->network->vxlans))
1822                 return link_enslaved(link);
1823
1824         if (link->network->bond) {
1825                 log_struct_link(LOG_DEBUG, link,
1826                                 "MESSAGE=%-*s: enslaving by '%s'",
1827                                 IFNAMSIZ,
1828                                 link->ifname, link->network->bond->ifname,
1829                                 NETDEV(link->network->bond),
1830                                 NULL);
1831
1832                 r = netdev_enslave(link->network->bond, link, &enslave_handler);
1833                 if (r < 0) {
1834                         log_struct_link(LOG_WARNING, link,
1835                                         "MESSAGE=%-*s: could not enslave by '%s': %s",
1836                                         IFNAMSIZ,
1837                                         link->ifname, link->network->bond->ifname, strerror(-r),
1838                                         NETDEV(link->network->bond),
1839                                         NULL);
1840                         link_enter_failed(link);
1841                         return r;
1842                 }
1843
1844                 link_ref(link);
1845                 link->enslaving ++;
1846         }
1847
1848         if (link->network->bridge) {
1849                 log_struct_link(LOG_DEBUG, link,
1850                                 "MESSAGE=%-*s: enslaving by '%s'",
1851                                 IFNAMSIZ,
1852                                 link->ifname, link->network->bridge->ifname,
1853                                 NETDEV(link->network->bridge),
1854                                 NULL);
1855
1856                 r = netdev_enslave(link->network->bridge, link, &enslave_handler);
1857                 if (r < 0) {
1858                         log_struct_link(LOG_WARNING, link,
1859                                         "MESSAGE=%-*s: could not enslave by '%s': %s",
1860                                         IFNAMSIZ,
1861                                         link->ifname, link->network->bridge->ifname, strerror(-r),
1862                                         NETDEV(link->network->bridge),
1863                                         NULL);
1864                         link_enter_failed(link);
1865                         return r;
1866                 }
1867
1868                 link_ref(link);
1869                 link->enslaving ++;
1870         }
1871
1872         if (link->network->tunnel) {
1873                 log_struct_link(LOG_DEBUG, link,
1874                                 "MESSAGE=%-*s: enslaving by '%s'",
1875                                 IFNAMSIZ,
1876                                 link->ifname, link->network->tunnel->ifname,
1877                                 NETDEV(link->network->tunnel),
1878                                 NULL);
1879
1880                 r = netdev_enslave(link->network->tunnel, link, &enslave_handler);
1881                 if (r < 0) {
1882                         log_struct_link(LOG_WARNING, link,
1883                                         "MESSAGE=%-*s: could not enslave by '%s': %s",
1884                                         IFNAMSIZ,
1885                                         link->ifname, link->network->tunnel->ifname, strerror(-r),
1886                                         NETDEV(link->network->tunnel),
1887                                         NULL);
1888                         link_enter_failed(link);
1889                         return r;
1890                 }
1891
1892                 link_ref(link);
1893                 link->enslaving ++;
1894         }
1895
1896         HASHMAP_FOREACH(vlan, link->network->vlans, i) {
1897                 log_struct_link(LOG_DEBUG, link,
1898                                 "MESSAGE=%-*s: enslaving by '%s'",
1899                                 IFNAMSIZ,
1900                                 link->ifname, vlan->ifname, NETDEV(vlan), NULL);
1901
1902                 r = netdev_enslave(vlan, link, &enslave_handler);
1903                 if (r < 0) {
1904                         log_struct_link(LOG_WARNING, link,
1905                                         "MESSAGE=%-*s: could not enslave by '%s': %s",
1906                                         IFNAMSIZ,
1907                                         link->ifname, vlan->ifname, strerror(-r),
1908                                         NETDEV(vlan), NULL);
1909                         link_enter_failed(link);
1910                         return r;
1911                 }
1912
1913                 link_ref(link);
1914                 link->enslaving ++;
1915         }
1916
1917         HASHMAP_FOREACH(macvlan, link->network->macvlans, i) {
1918                 log_struct_link(LOG_DEBUG, link,
1919                                 "MESSAGE=%-*s: enslaving by '%s'",
1920                                 IFNAMSIZ,
1921                                 link->ifname, macvlan->ifname, NETDEV(macvlan), NULL);
1922
1923                 r = netdev_enslave(macvlan, link, &enslave_handler);
1924                 if (r < 0) {
1925                         log_struct_link(LOG_WARNING, link,
1926                                         "MESSAGE=%-*s: could not enslave by '%s': %s",
1927                                         IFNAMSIZ,
1928                                         link->ifname, macvlan->ifname, strerror(-r),
1929                                         NETDEV(macvlan), NULL);
1930                         link_enter_failed(link);
1931                         return r;
1932                 }
1933
1934                 link_ref(link);
1935                 link->enslaving ++;
1936         }
1937
1938         HASHMAP_FOREACH(vxlan, link->network->vxlans, i) {
1939                 log_struct_link(LOG_DEBUG, link,
1940                                 "MESSAGE=%*s: enslaving by '%s'",
1941                                 IFNAMSIZ,
1942                                 link->ifname, vxlan->ifname, NETDEV(vxlan), NULL);
1943
1944                 r = netdev_enslave(vxlan, link, &enslave_handler);
1945                 if (r < 0) {
1946                         log_struct_link(LOG_WARNING, link,
1947                                         "MESSAGE=%*s: could not enslave by '%s': %s",
1948                                         IFNAMSIZ,
1949                                         link->ifname, vxlan->ifname, strerror(-r),
1950                                         NETDEV(vxlan), NULL);
1951                         link_enter_failed(link);
1952                         return r;
1953                 }
1954
1955                 link_ref(link);
1956                 link->enslaving ++;
1957         }
1958
1959         return 0;
1960 }
1961
1962 static int link_configure(Link *link) {
1963         int r;
1964
1965         assert(link);
1966         assert(link->state == LINK_STATE_INITIALIZING);
1967
1968         if (link->network->ipv4ll) {
1969                 uint8_t seed[8];
1970
1971                 r = sd_ipv4ll_new(&link->ipv4ll);
1972                 if (r < 0)
1973                         return r;
1974
1975                 if (link->udev_device) {
1976                         r = net_get_unique_predictable_data(link->udev_device, seed);
1977                         if (r >= 0) {
1978                                 r = sd_ipv4ll_set_address_seed(link->ipv4ll, seed);
1979                                 if (r < 0)
1980                                         return r;
1981                         }
1982                 }
1983
1984                 r = sd_ipv4ll_attach_event(link->ipv4ll, NULL, 0);
1985                 if (r < 0)
1986                         return r;
1987
1988                 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1989                 if (r < 0)
1990                         return r;
1991
1992                 r = sd_ipv4ll_set_index(link->ipv4ll, link->ifindex);
1993                 if (r < 0)
1994                         return r;
1995
1996                 r = sd_ipv4ll_set_callback(link->ipv4ll, ipv4ll_handler, link);
1997                 if (r < 0)
1998                         return r;
1999         }
2000
2001         if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V4)) {
2002                 r = sd_dhcp_client_new(&link->dhcp_client);
2003                 if (r < 0)
2004                         return r;
2005
2006                 r = sd_dhcp_client_attach_event(link->dhcp_client, NULL, 0);
2007                 if (r < 0)
2008                         return r;
2009
2010                 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
2011                 if (r < 0)
2012                         return r;
2013
2014                 r = sd_dhcp_client_set_index(link->dhcp_client, link->ifindex);
2015                 if (r < 0)
2016                         return r;
2017
2018                 r = sd_dhcp_client_set_callback(link->dhcp_client, dhcp_handler, link);
2019                 if (r < 0)
2020                         return r;
2021
2022                 if (link->network->dhcp_mtu) {
2023                         r = sd_dhcp_client_set_request_option(link->dhcp_client, 26);
2024                         if (r < 0)
2025                                 return r;
2026                 }
2027                 if (link->network->dhcp_routes) {
2028                         r = sd_dhcp_client_set_request_option(link->dhcp_client, DHCP_OPTION_STATIC_ROUTE);
2029                         if (r < 0)
2030                                 return r;
2031                         r = sd_dhcp_client_set_request_option(link->dhcp_client, DHCP_OPTION_CLASSLESS_STATIC_ROUTE);
2032                         if (r < 0)
2033                                 return r;
2034                 }
2035         }
2036
2037         if (link->network->dhcp_server) {
2038                 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
2039                 if (r < 0)
2040                         return r;
2041
2042                 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
2043                 if (r < 0)
2044                         return r;
2045         }
2046
2047         if (IN_SET(link->network->dhcp, DHCP_SUPPORT_BOTH, DHCP_SUPPORT_V6)) {
2048                 r = sd_icmp6_nd_new(&link->icmp6_router_discovery);
2049                 if (r < 0)
2050                         return r;
2051
2052                 r = sd_icmp6_nd_attach_event(link->icmp6_router_discovery,
2053                                              NULL, 0);
2054                 if (r < 0)
2055                         return r;
2056
2057                 r = sd_icmp6_nd_set_mac(link->icmp6_router_discovery,
2058                                         &link->mac);
2059                 if (r < 0)
2060                         return r;
2061
2062                 r = sd_icmp6_nd_set_index(link->icmp6_router_discovery,
2063                                           link->ifindex);
2064                 if (r < 0)
2065                         return r;
2066
2067                 r = sd_icmp6_nd_set_callback(link->icmp6_router_discovery,
2068                                              icmp6_router_handler, link);
2069                 if (r < 0)
2070                         return r;
2071         }
2072
2073         if (link_has_carrier(link->flags, link->kernel_operstate)) {
2074                 r = link_acquire_conf(link);
2075                 if (r < 0)
2076                         return r;
2077         }
2078
2079         return link_enter_enslave(link);
2080 }
2081
2082 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
2083         Link *link = userdata;
2084         Network *network;
2085         int r;
2086
2087         assert(link);
2088         assert(link->ifname);
2089         assert(link->manager);
2090
2091         if (link->state != LINK_STATE_INITIALIZING)
2092                 return 0;
2093
2094         log_debug_link(link, "link state is up-to-date");
2095
2096         r = network_get(link->manager, link->udev_device, link->ifname, &link->mac, &network);
2097         if (r == -ENOENT) {
2098                 link_enter_unmanaged(link);
2099                 return 0;
2100         } else if (r < 0)
2101                 return r;
2102
2103         r = network_apply(link->manager, network, link);
2104         if (r < 0)
2105                 return r;
2106
2107         r = link_configure(link);
2108         if (r < 0)
2109                 return r;
2110
2111         return 0;
2112 }
2113
2114 int link_initialized(Link *link, struct udev_device *device) {
2115         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
2116         int r;
2117
2118         assert(link);
2119         assert(link->manager);
2120         assert(link->manager->rtnl);
2121         assert(device);
2122
2123         if (link->state != LINK_STATE_INITIALIZING)
2124                 return 0;
2125
2126         log_debug_link(link, "udev initialized link");
2127
2128         link->udev_device = udev_device_ref(device);
2129
2130         /* udev has initialized the link, but we don't know if we have yet processed
2131            the NEWLINK messages with the latest state. Do a GETLINK, when it returns
2132            we know that the pending NEWLINKs have already been processed and that we
2133            are up-to-date */
2134
2135         r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK, link->ifindex);
2136         if (r < 0)
2137                 return r;
2138
2139         r = sd_rtnl_call_async(link->manager->rtnl, req, link_initialized_and_synced, link, 0, NULL);
2140         if (r < 0)
2141                 return r;
2142
2143         return 0;
2144 }
2145
2146 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
2147         Manager *m = userdata;
2148         Link *link = NULL;
2149         uint16_t type;
2150         _cleanup_address_free_ Address *address = NULL;
2151         Address *ad;
2152         char buf[INET6_ADDRSTRLEN];
2153         bool address_dropped = false;
2154         int r, ifindex;
2155
2156         assert(rtnl);
2157         assert(message);
2158         assert(m);
2159
2160         r = sd_rtnl_message_get_type(message, &type);
2161         if (r < 0) {
2162                 log_warning("rtnl: could not get message type");
2163                 return 0;
2164         }
2165
2166         r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
2167         if (r < 0 || ifindex <= 0) {
2168                 log_warning("rtnl: received address message without valid ifindex, ignoring");
2169                 return 0;
2170         } else {
2171                 r = link_get(m, ifindex, &link);
2172                 if (r < 0 || !link) {
2173                         log_warning("rtnl: received address for a nonexistent link, ignoring");
2174                         return 0;
2175                 }
2176         }
2177
2178         r = address_new_dynamic(&address);
2179         if (r < 0)
2180                 return 0;
2181
2182         r = sd_rtnl_message_addr_get_family(message, &address->family);
2183         if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
2184                 log_warning_link(link, "rtnl: received address with invalid family, ignoring");
2185                 return 0;
2186         }
2187
2188         r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
2189         if (r < 0) {
2190                 log_warning_link(link, "rtnl: received address with invalid prefixlen, ignoring");
2191                 return 0;
2192         }
2193
2194         r = sd_rtnl_message_addr_get_scope(message, &address->scope);
2195         if (r < 0) {
2196                 log_warning_link(link, "rtnl: received address with invalid scope, ignoring");
2197                 return 0;
2198         }
2199
2200         switch (address->family) {
2201         case AF_INET:
2202                 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
2203                 if (r < 0) {
2204                         log_warning_link(link, "rtnl: received address without valid address, ignoring");
2205                         return 0;
2206                 }
2207
2208                 break;
2209
2210         case AF_INET6:
2211                 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
2212                 if (r < 0) {
2213                         log_warning_link(link, "rtnl: received address without valid address, ignoring");
2214                         return 0;
2215                 }
2216
2217                 break;
2218
2219         default:
2220                 assert_not_reached("invalid address family");
2221         }
2222
2223         if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
2224                 log_warning_link(link, "could not print address");
2225                 return 0;
2226         }
2227
2228         LIST_FOREACH(addresses, ad, link->addresses) {
2229                 if (address_equal(ad, address)) {
2230                         LIST_REMOVE(addresses, link->addresses, ad);
2231
2232                         address_free(ad);
2233
2234                         address_dropped = true;
2235
2236                         break;
2237                 }
2238         }
2239
2240         switch (type) {
2241         case RTM_NEWADDR:
2242                 if (!address_dropped)
2243                         log_debug_link(link, "added address: %s/%u", buf,
2244                                       address->prefixlen);
2245
2246                 LIST_PREPEND(addresses, link->addresses, address);
2247                 address = NULL;
2248
2249                 link_save(link);
2250
2251                 break;
2252         case RTM_DELADDR:
2253                 if (address_dropped) {
2254                         log_debug_link(link, "removed address: %s/%u", buf,
2255                                       address->prefixlen);
2256
2257                         link_save(link);
2258                 }
2259
2260                 break;
2261         default:
2262                 assert_not_reached("Received invalid RTNL message type");
2263         }
2264
2265         return 1;
2266 }
2267
2268 static int link_get_address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
2269         Link *link = userdata;
2270         int r;
2271
2272         assert(rtnl);
2273         assert(m);
2274         assert(link);
2275
2276         for (; m; m = sd_rtnl_message_next(m)) {
2277                 r = sd_rtnl_message_get_errno(m);
2278                 if (r < 0) {
2279                         log_debug_link(link, "getting address failed: %s", strerror(-r));
2280                         continue;
2281                 }
2282
2283                 r = link_rtnl_process_address(rtnl, m, link->manager);
2284                 if (r < 0)
2285                         log_warning_link(link, "could not process address: %s", strerror(-r));
2286         }
2287
2288         return 1;
2289 }
2290
2291 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
2292         Link *link;
2293         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
2294         _cleanup_udev_device_unref_ struct udev_device *device = NULL;
2295         char ifindex_str[2 + DECIMAL_STR_MAX(int)];
2296         int r;
2297
2298         assert(m);
2299         assert(m->rtnl);
2300         assert(message);
2301         assert(ret);
2302
2303         r = link_new(m, message, ret);
2304         if (r < 0)
2305                 return r;
2306
2307         link = *ret;
2308
2309         log_debug_link(link, "link %"PRIu64" added", link->ifindex);
2310
2311         r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, link->ifindex, 0);
2312         if (r < 0)
2313                 return r;
2314
2315         r = sd_rtnl_call_async(m->rtnl, req, link_get_address_handler, link, 0, NULL);
2316         if (r < 0)
2317                 return r;
2318
2319         if (detect_container(NULL) <= 0) {
2320                 /* not in a container, udev will be around */
2321                 sprintf(ifindex_str, "n%"PRIu64, link->ifindex);
2322                 device = udev_device_new_from_device_id(m->udev, ifindex_str);
2323                 if (!device) {
2324                         log_warning_link(link, "could not find udev device");
2325                         return -errno;
2326                 }
2327
2328                 if (udev_device_get_is_initialized(device) <= 0) {
2329                         /* not yet ready */
2330                         log_debug_link(link, "udev initializing link...");
2331                         return 0;
2332                 }
2333
2334                 r = link_initialized(link, device);
2335                 if (r < 0)
2336                         return r;
2337         } else {
2338                 r = link_initialized_and_synced(m->rtnl, NULL, link);
2339                 if (r < 0)
2340                         return r;
2341         }
2342
2343         return 0;
2344 }
2345
2346 int link_update(Link *link, sd_rtnl_message *m) {
2347         struct ether_addr mac;
2348         char *ifname;
2349         int r;
2350
2351         assert(link);
2352         assert(link->ifname);
2353         assert(m);
2354
2355         if (link->state == LINK_STATE_LINGER) {
2356                 link_ref(link);
2357                 log_info_link(link, "link readded");
2358                 link->state = LINK_STATE_ENSLAVING;
2359         }
2360
2361         r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
2362         if (r >= 0 && !streq(ifname, link->ifname)) {
2363                 log_info_link(link, "renamed to %s", ifname);
2364
2365                 free(link->ifname);
2366                 link->ifname = strdup(ifname);
2367                 if (!link->ifname)
2368                         return -ENOMEM;
2369         }
2370
2371         if (!link->original_mtu) {
2372                 r = sd_rtnl_message_read_u16(m, IFLA_MTU, &link->original_mtu);
2373                 if (r >= 0)
2374                         log_debug_link(link, "saved original MTU: %"
2375                                        PRIu16, link->original_mtu);
2376         }
2377
2378         /* The kernel may broadcast NEWLINK messages without the MAC address
2379            set, simply ignore them. */
2380         r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
2381         if (r >= 0) {
2382                 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN)) {
2383
2384                         memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN);
2385
2386                         log_debug_link(link, "MAC address: "
2387                                        "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2388                                        mac.ether_addr_octet[0],
2389                                        mac.ether_addr_octet[1],
2390                                        mac.ether_addr_octet[2],
2391                                        mac.ether_addr_octet[3],
2392                                        mac.ether_addr_octet[4],
2393                                        mac.ether_addr_octet[5]);
2394
2395                         if (link->ipv4ll) {
2396                                 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
2397                                 if (r < 0) {
2398                                         log_warning_link(link, "Could not update MAC "
2399                                                          "address in IPv4LL client: %s",
2400                                                          strerror(-r));
2401                                         return r;
2402                                 }
2403                         }
2404
2405                         if (link->dhcp_client) {
2406                                 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
2407                                 if (r < 0) {
2408                                         log_warning_link(link, "Could not update MAC "
2409                                                          "address in DHCP client: %s",
2410                                                          strerror(-r));
2411                                         return r;
2412                                 }
2413                         }
2414
2415                         if (link->dhcp6_client) {
2416                                 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
2417                                                             &link->mac);
2418                                 if (r < 0) {
2419                                         log_warning_link(link, "Could not update MAC address in DHCPv6 client: %s",
2420                                                          strerror(-r));
2421                                         return r;
2422                                 }
2423                         }
2424                 }
2425         }
2426
2427         return link_update_flags(link, m);
2428 }
2429
2430 static void serialize_addresses(FILE *f, const char *key, Address *address) {
2431         Address *ad;
2432
2433         assert(f);
2434         assert(key);
2435
2436         if (!address)
2437                 return;
2438
2439         fprintf(f, "%s=", key);
2440
2441         LIST_FOREACH(addresses, ad, address) {
2442                 char buf[INET6_ADDRSTRLEN];
2443
2444                 if (inet_ntop(ad->family, &ad->in_addr, buf, INET6_ADDRSTRLEN))
2445                         fprintf(f, "%s%s", buf, (ad->addresses_next) ? " ": "");
2446         }
2447
2448         fputs("\n", f);
2449 }
2450
2451 static void link_update_operstate(Link *link) {
2452
2453         assert(link);
2454
2455         if (link->kernel_operstate == IF_OPER_DORMANT)
2456                 link->operstate = LINK_OPERSTATE_DORMANT;
2457         else if (link_has_carrier(link->flags, link->kernel_operstate)) {
2458                 Address *address;
2459                 uint8_t scope = RT_SCOPE_NOWHERE;
2460
2461                 /* if we have carrier, check what addresses we have */
2462                 LIST_FOREACH(addresses, address, link->addresses) {
2463                         if (address->scope < scope)
2464                                 scope = address->scope;
2465                 }
2466
2467                 if (scope < RT_SCOPE_SITE)
2468                         /* universally accessible addresses found */
2469                         link->operstate = LINK_OPERSTATE_ROUTABLE;
2470                 else if (scope < RT_SCOPE_HOST)
2471                         /* only link or site local addresses found */
2472                         link->operstate = LINK_OPERSTATE_DEGRADED;
2473                 else
2474                         /* no useful addresses found */
2475                         link->operstate = LINK_OPERSTATE_CARRIER;
2476         } else
2477                 link->operstate = LINK_OPERSTATE_UNKNOWN;
2478 }
2479
2480 int link_save(Link *link) {
2481         _cleanup_free_ char *temp_path = NULL;
2482         _cleanup_fclose_ FILE *f = NULL;
2483         const char *admin_state, *oper_state;
2484         int r;
2485
2486         assert(link);
2487         assert(link->state_file);
2488         assert(link->lease_file);
2489         assert(link->manager);
2490
2491         link_update_operstate(link);
2492
2493         r = manager_save(link->manager);
2494         if (r < 0)
2495                 return r;
2496
2497         if (link->state == LINK_STATE_LINGER) {
2498                 unlink(link->state_file);
2499                 return 0;
2500         }
2501
2502         admin_state = link_state_to_string(link->state);
2503         assert(admin_state);
2504
2505         oper_state = link_operstate_to_string(link->operstate);
2506         assert(oper_state);
2507
2508         r = fopen_temporary(link->state_file, &f, &temp_path);
2509         if (r < 0)
2510                 goto finish;
2511
2512         fchmod(fileno(f), 0644);
2513
2514         fprintf(f,
2515                 "# This is private data. Do not parse.\n"
2516                 "ADMIN_STATE=%s\n"
2517                 "OPER_STATE=%s\n"
2518                 "FLAGS=%u\n",
2519                 admin_state, oper_state, link->flags);
2520
2521         if (link->network) {
2522                 serialize_addresses(f, "DNS", link->network->dns);
2523                 serialize_addresses(f, "NTP", link->network->ntp);
2524         }
2525
2526         if (link->dhcp_lease) {
2527                 assert(link->network);
2528
2529                 r = dhcp_lease_save(link->dhcp_lease, link->lease_file);
2530                 if (r < 0)
2531                         goto finish;
2532
2533                 fprintf(f,
2534                         "DHCP_LEASE=%s\n"
2535                         "DHCP_USE_DNS=%s\n"
2536                         "DHCP_USE_NTP=%s\n",
2537                         link->lease_file,
2538                         yes_no(link->network->dhcp_dns),
2539                         yes_no(link->network->dhcp_ntp));
2540         } else
2541                 unlink(link->lease_file);
2542
2543         fflush(f);
2544
2545         if (ferror(f) || rename(temp_path, link->state_file) < 0) {
2546                 r = -errno;
2547                 unlink(link->state_file);
2548                 unlink(temp_path);
2549         }
2550
2551 finish:
2552         if (r < 0)
2553                 log_error_link(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
2554
2555         return r;
2556 }
2557
2558 static const char* const link_state_table[_LINK_STATE_MAX] = {
2559         [LINK_STATE_INITIALIZING] = "initializing",
2560         [LINK_STATE_ENSLAVING] = "configuring",
2561         [LINK_STATE_SETTING_ADDRESSES] = "configuring",
2562         [LINK_STATE_SETTING_ROUTES] = "configuring",
2563         [LINK_STATE_CONFIGURED] = "configured",
2564         [LINK_STATE_UNMANAGED] = "unmanaged",
2565         [LINK_STATE_FAILED] = "failed",
2566         [LINK_STATE_LINGER] = "linger",
2567 };
2568
2569 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
2570
2571 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
2572         [LINK_OPERSTATE_UNKNOWN] = "unknown",
2573         [LINK_OPERSTATE_DORMANT] = "dormant",
2574         [LINK_OPERSTATE_CARRIER] = "carrier",
2575         [LINK_OPERSTATE_DEGRADED] = "degraded",
2576         [LINK_OPERSTATE_ROUTABLE] = "routable",
2577 };
2578
2579 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);
2580
2581 static const char* const dhcp_support_table[_DHCP_SUPPORT_MAX] = {
2582         [DHCP_SUPPORT_NONE] = "none",
2583         [DHCP_SUPPORT_BOTH] = "both",
2584         [DHCP_SUPPORT_V4] = "v4",
2585         [DHCP_SUPPORT_V6] = "v6",
2586 };
2587
2588 DEFINE_STRING_TABLE_LOOKUP(dhcp_support, DHCPSupport);
2589
2590 int config_parse_dhcp(
2591                 const char* unit,
2592                 const char *filename,
2593                 unsigned line,
2594                 const char *section,
2595                 unsigned section_line,
2596                 const char *lvalue,
2597                 int ltype,
2598                 const char *rvalue,
2599                 void *data,
2600                 void *userdata) {
2601
2602         DHCPSupport *dhcp = data;
2603         int k;
2604
2605         assert(filename);
2606         assert(lvalue);
2607         assert(rvalue);
2608         assert(data);
2609
2610         /* Our enum shall be a superset of booleans, hence first try
2611          * to parse as boolean, and then as enum */
2612
2613         k = parse_boolean(rvalue);
2614         if (k > 0)
2615                 *dhcp = DHCP_SUPPORT_BOTH;
2616         else if (k == 0)
2617                 *dhcp = DHCP_SUPPORT_NONE;
2618         else {
2619                 DHCPSupport s;
2620
2621                 s = dhcp_support_from_string(rvalue);
2622                 if (s < 0){
2623                         log_syntax(unit, LOG_ERR, filename, line, -s, "Failed to parse DHCP option, ignoring: %s", rvalue);
2624                         return 0;
2625                 }
2626
2627                 *dhcp = s;
2628         }
2629
2630         return 0;
2631 }