src/network/networkd-link.c

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