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