src/network/networkd-link.c

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