src/network/networkd-link.c

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