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