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                                 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;
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                 return link_enslaved(link);
1513
1514         if (link->network->bond) {
1515                 log_struct_link(LOG_DEBUG, link,
1516                                 "MESSAGE=%*s: enslaving by '%s'",
1517                                 IFNAMSIZ,
1518                                 link->ifname, link->network->bond->ifname,
1519                                 NETDEV(link->network->bond),
1520                                 NULL);
1521
1522                 r = netdev_enslave(link->network->bond, link, &enslave_handler);
1523                 if (r < 0) {
1524                         log_struct_link(LOG_WARNING, link,
1525                                         "MESSAGE=%*s: could not enslave by '%s': %s",
1526                                         IFNAMSIZ,
1527                                         link->ifname, link->network->bond->ifname, strerror(-r),
1528                                         NETDEV(link->network->bond),
1529                                         NULL);
1530                         link_enter_failed(link);
1531                         return r;
1532                 }
1533
1534                 link_ref(link);
1535                 link->enslaving ++;
1536         }
1537
1538         if (link->network->bridge) {
1539                 log_struct_link(LOG_DEBUG, link,
1540                                 "MESSAGE=%*s: enslaving by '%s'",
1541                                 IFNAMSIZ,
1542                                 link->ifname, link->network->bridge->ifname,
1543                                 NETDEV(link->network->bridge),
1544                                 NULL);
1545
1546                 r = netdev_enslave(link->network->bridge, link, &enslave_handler);
1547                 if (r < 0) {
1548                         log_struct_link(LOG_WARNING, link,
1549                                         "MESSAGE=%*s: could not enslave by '%s': %s",
1550                                         IFNAMSIZ,
1551                                         link->ifname, link->network->bridge->ifname, strerror(-r),
1552                                         NETDEV(link->network->bridge),
1553                                         NULL);
1554                         link_enter_failed(link);
1555                         return r;
1556                 }
1557
1558                 link_ref(link);
1559                 link->enslaving ++;
1560         }
1561
1562         if (link->network->tunnel) {
1563                 log_struct_link(LOG_DEBUG, link,
1564                                 "MESSAGE=%*s: enslaving by '%s'",
1565                                 IFNAMSIZ,
1566                                 link->ifname, link->network->tunnel->ifname,
1567                                 NETDEV(link->network->tunnel),
1568                                 NULL);
1569
1570                 r = netdev_enslave(link->network->tunnel, link, &enslave_handler);
1571                 if (r < 0) {
1572                         log_struct_link(LOG_WARNING, link,
1573                                         "MESSAGE=%*s: could not enslave by '%s': %s",
1574                                         IFNAMSIZ,
1575                                         link->ifname, link->network->tunnel->ifname, strerror(-r),
1576                                         NETDEV(link->network->tunnel),
1577                                         NULL);
1578                         link_enter_failed(link);
1579                         return r;
1580                 }
1581
1582                 link_ref(link);
1583                 link->enslaving ++;
1584         }
1585
1586         HASHMAP_FOREACH(vlan, link->network->vlans, i) {
1587                 log_struct_link(LOG_DEBUG, link,
1588                                 "MESSAGE=%*s: enslaving by '%s'",
1589                                 IFNAMSIZ,
1590                                 link->ifname, vlan->ifname, NETDEV(vlan), NULL);
1591
1592                 r = netdev_enslave(vlan, link, &enslave_handler);
1593                 if (r < 0) {
1594                         log_struct_link(LOG_WARNING, link,
1595                                         "MESSAGE=%*s: could not enslave by '%s': %s",
1596                                         IFNAMSIZ,
1597                                         link->ifname, vlan->ifname, strerror(-r),
1598                                         NETDEV(vlan), NULL);
1599                         link_enter_failed(link);
1600                         return r;
1601                 }
1602
1603                 link_ref(link);
1604                 link->enslaving ++;
1605         }
1606
1607         HASHMAP_FOREACH(macvlan, link->network->macvlans, i) {
1608                 log_struct_link(LOG_DEBUG, link,
1609                                 "MESSAGE=%*s: enslaving by '%s'",
1610                                 IFNAMSIZ,
1611                                 link->ifname, macvlan->ifname, NETDEV(macvlan), NULL);
1612
1613                 r = netdev_enslave(macvlan, link, &enslave_handler);
1614                 if (r < 0) {
1615                         log_struct_link(LOG_WARNING, link,
1616                                         "MESSAGE=%*s: could not enslave by '%s': %s",
1617                                         IFNAMSIZ,
1618                                         link->ifname, macvlan->ifname, strerror(-r),
1619                                         NETDEV(macvlan), NULL);
1620                         link_enter_failed(link);
1621                         return r;
1622                 }
1623
1624                 link_ref(link);
1625                 link->enslaving ++;
1626         }
1627
1628         return 0;
1629 }
1630
1631 static int link_configure(Link *link) {
1632         int r;
1633
1634         assert(link);
1635         assert(link->state == LINK_STATE_INITIALIZING);
1636
1637         if (link->network->ipv4ll) {
1638                 uint8_t seed[8];
1639
1640                 r = sd_ipv4ll_new(&link->ipv4ll);
1641                 if (r < 0)
1642                         return r;
1643
1644                 if (link->udev_device) {
1645                         r = net_get_unique_predictable_data(link->udev_device, seed);
1646                         if (r >= 0) {
1647                                 r = sd_ipv4ll_set_address_seed(link->ipv4ll, seed);
1648                                 if (r < 0)
1649                                         return r;
1650                         }
1651                 }
1652
1653                 r = sd_ipv4ll_attach_event(link->ipv4ll, NULL, 0);
1654                 if (r < 0)
1655                         return r;
1656
1657                 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1658                 if (r < 0)
1659                         return r;
1660
1661                 r = sd_ipv4ll_set_index(link->ipv4ll, link->ifindex);
1662                 if (r < 0)
1663                         return r;
1664
1665                 r = sd_ipv4ll_set_callback(link->ipv4ll, ipv4ll_handler, link);
1666                 if (r < 0)
1667                         return r;
1668         }
1669
1670         if (link->network->dhcp) {
1671                 r = sd_dhcp_client_new(&link->dhcp_client);
1672                 if (r < 0)
1673                         return r;
1674
1675                 r = sd_dhcp_client_attach_event(link->dhcp_client, NULL, 0);
1676                 if (r < 0)
1677                         return r;
1678
1679                 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
1680                 if (r < 0)
1681                         return r;
1682
1683                 r = sd_dhcp_client_set_index(link->dhcp_client, link->ifindex);
1684                 if (r < 0)
1685                         return r;
1686
1687                 r = sd_dhcp_client_set_callback(link->dhcp_client, dhcp_handler, link);
1688                 if (r < 0)
1689                         return r;
1690
1691                 if (link->network->dhcp_mtu) {
1692                         r = sd_dhcp_client_set_request_option(link->dhcp_client, 26);
1693                         if (r < 0)
1694                                 return r;
1695                 }
1696         }
1697
1698         if (link->network->dhcp_server) {
1699                 Address *address;
1700
1701                 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
1702                 if (r < 0)
1703                         return r;
1704
1705                 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
1706                 if (r < 0)
1707                         return r;
1708
1709                 LIST_FOREACH(addresses, address,
1710                              link->network->static_addresses) {
1711                         struct in_addr pool_start;
1712
1713                         if (address->family != AF_INET)
1714                                 continue;
1715
1716                         /* currently this is picked essentially at random */
1717                         r = sd_dhcp_server_set_address(link->dhcp_server,
1718                                                        &address->in_addr.in);
1719                         if (r < 0)
1720                                 return r;
1721
1722                         /* offer 32 addresses starting from the address following the server address */
1723                         pool_start.s_addr = htobe32(be32toh(address->in_addr.in.s_addr) + 1);
1724                         r = sd_dhcp_server_set_lease_pool(link->dhcp_server,
1725                                                           &pool_start, 32);
1726
1727                         break;
1728                 }
1729
1730                 /* TODO:
1731                 r = sd_dhcp_server_set_router(link->dhcp_server,
1732                                               &main_address->in_addr.in);
1733                 if (r < 0)
1734                         return r;
1735
1736                 r = sd_dhcp_server_set_prefixlen(link->dhcp_server,
1737                                                  main_address->prefixlen);
1738                 if (r < 0)
1739                         return r;
1740                 */
1741         }
1742
1743         if (link_has_carrier(link->flags, link->operstate)) {
1744                 r = link_acquire_conf(link);
1745                 if (r < 0)
1746                         return r;
1747         }
1748
1749         return link_enter_enslave(link);
1750 }
1751
1752 int link_initialized(Link *link, struct udev_device *device) {
1753         Network *network;
1754         int r;
1755
1756         assert(link);
1757         assert(link->ifname);
1758         assert(link->manager);
1759
1760         if (link->state != LINK_STATE_INITIALIZING)
1761                 return 0;
1762
1763         if (device)
1764                 link->udev_device = udev_device_ref(device);
1765
1766         log_debug_link(link, "udev initialized link");
1767
1768         r = network_get(link->manager, device, link->ifname, &link->mac, &network);
1769         if (r == -ENOENT) {
1770                 link_enter_unmanaged(link);
1771                 return 0;
1772         } else if (r < 0)
1773                 return r;
1774
1775         r = network_apply(link->manager, network, link);
1776         if (r < 0)
1777                 return r;
1778
1779         r = link_configure(link);
1780         if (r < 0)
1781                 return r;
1782
1783         return 0;
1784 }
1785
1786 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
1787         Manager *m = userdata;
1788         Link *link = NULL;
1789         uint16_t type;
1790         _cleanup_address_free_ Address *address = NULL;
1791         Address *ad;
1792         char buf[INET6_ADDRSTRLEN];
1793         bool address_dropped = false;
1794         int r, ifindex;
1795
1796         assert(rtnl);
1797         assert(message);
1798         assert(m);
1799
1800         r = sd_rtnl_message_get_type(message, &type);
1801         if (r < 0) {
1802                 log_warning("rtnl: could not get message type");
1803                 return 0;
1804         }
1805
1806         r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
1807         if (r < 0 || ifindex <= 0) {
1808                 log_warning("rtnl: received address message without valid ifindex, ignoring");
1809                 return 0;
1810         } else {
1811                 r = link_get(m, ifindex, &link);
1812                 if (r < 0 || !link) {
1813                         log_warning("rtnl: received address for a nonexistent link, ignoring");
1814                         return 0;
1815                 }
1816         }
1817
1818         r = address_new_dynamic(&address);
1819         if (r < 0)
1820                 return 0;
1821
1822         r = sd_rtnl_message_addr_get_family(message, &address->family);
1823         if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
1824                 log_warning_link(link, "rtnl: received address with invalid family, ignoring");
1825                 return 0;
1826         }
1827
1828         r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
1829         if (r < 0) {
1830                 log_warning_link(link, "rtnl: received address with invalid prefixlen, ignoring");
1831                 return 0;
1832         }
1833
1834         r = sd_rtnl_message_addr_get_scope(message, &address->scope);
1835         if (r < 0) {
1836                 log_warning_link(link, "rtnl: received address with invalid scope, ignoring");
1837                 return 0;
1838         }
1839
1840         switch (address->family) {
1841         case AF_INET:
1842                 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
1843                 if (r < 0) {
1844                         log_warning_link(link, "rtnl: received address without valid address, ignoring");
1845                         return 0;
1846                 }
1847
1848                 break;
1849
1850         case AF_INET6:
1851                 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
1852                 if (r < 0) {
1853                         log_warning_link(link, "rtnl: received address without valid address, ignoring");
1854                         return 0;
1855                 }
1856
1857                 break;
1858
1859         default:
1860                 assert_not_reached("invalid address family");
1861         }
1862
1863         if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
1864                 log_warning_link(link, "could not print address");
1865                 return 0;
1866         }
1867
1868         LIST_FOREACH(addresses, ad, link->addresses) {
1869                 if (address_equal(ad, address)) {
1870                         LIST_REMOVE(addresses, link->addresses, ad);
1871
1872                         address_free(ad);
1873
1874                         address_dropped = true;
1875
1876                         break;
1877                 }
1878         }
1879
1880         switch (type) {
1881         case RTM_NEWADDR:
1882                 if (!address_dropped)
1883                         log_debug_link(link, "added address: %s/%u", buf,
1884                                       address->prefixlen);
1885
1886                 LIST_PREPEND(addresses, link->addresses, address);
1887                 address = NULL;
1888
1889                 link_save(link);
1890
1891                 break;
1892         case RTM_DELADDR:
1893                 if (address_dropped) {
1894                         log_debug_link(link, "removed address: %s/%u", buf,
1895                                       address->prefixlen);
1896
1897                         link_save(link);
1898                 }
1899
1900                 break;
1901         default:
1902                 assert_not_reached("Received invalid RTNL message type");
1903         }
1904
1905         return 1;
1906 }
1907
1908 static int link_get_address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1909         Link *link = userdata;
1910         int r;
1911
1912         assert(rtnl);
1913         assert(m);
1914         assert(link);
1915
1916         for (; m; m = sd_rtnl_message_next(m)) {
1917                 r = sd_rtnl_message_get_errno(m);
1918                 if (r < 0) {
1919                         log_debug_link(link, "getting address failed: %s", strerror(-r));
1920                         continue;
1921                 }
1922
1923                 r = link_rtnl_process_address(rtnl, m, link->manager);
1924                 if (r < 0)
1925                         log_warning_link(link, "could not process address: %s", strerror(-r));
1926         }
1927
1928         return 1;
1929 }
1930
1931 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
1932         Link *link;
1933         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1934         _cleanup_udev_device_unref_ struct udev_device *device = NULL;
1935         char ifindex_str[2 + DECIMAL_STR_MAX(int)];
1936         int r;
1937
1938         assert(m);
1939         assert(m->rtnl);
1940         assert(message);
1941         assert(ret);
1942
1943         r = link_new(m, message, ret);
1944         if (r < 0)
1945                 return r;
1946
1947         link = *ret;
1948
1949         log_debug_link(link, "link %"PRIu64" added", link->ifindex);
1950
1951         r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, link->ifindex, 0);
1952         if (r < 0)
1953                 return r;
1954
1955         r = sd_rtnl_call_async(m->rtnl, req, link_get_address_handler, link, 0, NULL);
1956         if (r < 0)
1957                 return r;
1958
1959         if (detect_container(NULL) <= 0) {
1960                 /* not in a container, udev will be around */
1961                 sprintf(ifindex_str, "n%"PRIu64, link->ifindex);
1962                 device = udev_device_new_from_device_id(m->udev, ifindex_str);
1963                 if (!device) {
1964                         log_warning_link(link, "could not find udev device");
1965                         return -errno;
1966                 }
1967
1968                 if (udev_device_get_is_initialized(device) <= 0) {
1969                         /* not yet ready */
1970                         log_debug_link(link, "udev initializing link...");
1971                         return 0;
1972                 }
1973         }
1974
1975         r = link_initialized(link, device);
1976         if (r < 0)
1977                 return r;
1978
1979         return 0;
1980 }
1981
1982 int link_update(Link *link, sd_rtnl_message *m) {
1983         struct ether_addr mac;
1984         char *ifname;
1985         int r;
1986
1987         assert(link);
1988         assert(link->ifname);
1989         assert(m);
1990
1991         if (link->state == LINK_STATE_LINGER) {
1992                 link_ref(link);
1993                 log_info_link(link, "link readded");
1994                 link->state = LINK_STATE_ENSLAVING;
1995         }
1996
1997         r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
1998         if (r >= 0 && !streq(ifname, link->ifname)) {
1999                 log_info_link(link, "renamed to %s", ifname);
2000
2001                 free(link->ifname);
2002                 link->ifname = strdup(ifname);
2003                 if (!link->ifname)
2004                         return -ENOMEM;
2005         }
2006
2007         if (!link->original_mtu) {
2008                 r = sd_rtnl_message_read_u16(m, IFLA_MTU, &link->original_mtu);
2009                 if (r >= 0)
2010                         log_debug_link(link, "saved original MTU: %"
2011                                        PRIu16, link->original_mtu);
2012         }
2013
2014         /* The kernel may broadcast NEWLINK messages without the MAC address
2015            set, simply ignore them. */
2016         r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
2017         if (r >= 0) {
2018                 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN)) {
2019
2020                         memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN);
2021
2022                         log_debug_link(link, "MAC address: "
2023                                        "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2024                                        mac.ether_addr_octet[0],
2025                                        mac.ether_addr_octet[1],
2026                                        mac.ether_addr_octet[2],
2027                                        mac.ether_addr_octet[3],
2028                                        mac.ether_addr_octet[4],
2029                                        mac.ether_addr_octet[5]);
2030
2031                         if (link->ipv4ll) {
2032                                 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
2033                                 if (r < 0) {
2034                                         log_warning_link(link, "Could not update MAC "
2035                                                          "address in IPv4LL client: %s",
2036                                                          strerror(-r));
2037                                         return r;
2038                                 }
2039                         }
2040
2041                         if (link->dhcp_client) {
2042                                 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
2043                                 if (r < 0) {
2044                                         log_warning_link(link, "Could not update MAC "
2045                                                          "address in DHCP client: %s",
2046                                                          strerror(-r));
2047                                         return r;
2048                                 }
2049                         }
2050                 }
2051         }
2052
2053         return link_update_flags(link, m);
2054 }
2055
2056 static void serialize_addresses(FILE *f, const char *key, Address *address) {
2057         Address *ad;
2058
2059         assert(f);
2060         assert(key);
2061
2062         if (!address)
2063                 return;
2064
2065         fprintf(f, "%s=", key);
2066
2067         LIST_FOREACH(addresses, ad, address) {
2068                 char buf[INET6_ADDRSTRLEN];
2069
2070                 if (inet_ntop(ad->family, &ad->in_addr, buf, INET6_ADDRSTRLEN))
2071                         fprintf(f, "%s%s", buf, (ad->addresses_next) ? " ": "");
2072         }
2073
2074         fputs("\n", f);
2075 }
2076
2077 static void link_update_operstate(Link *link) {
2078
2079         assert(link);
2080
2081         if (link->kernel_operstate == IF_OPER_DORMANT)
2082                 link->operstate = LINK_OPERSTATE_DORMANT;
2083         else if (link_has_carrier(link->flags, link->kernel_operstate)) {
2084                 Address *address;
2085                 uint8_t scope = RT_SCOPE_NOWHERE;
2086
2087                 /* if we have carrier, check what addresses we have */
2088                 LIST_FOREACH(addresses, address, link->addresses) {
2089                         if (address->scope < scope)
2090                                 scope = address->scope;
2091                 }
2092
2093                 if (scope < RT_SCOPE_SITE)
2094                         /* universally accessible addresses found */
2095                         link->operstate = LINK_OPERSTATE_ROUTABLE;
2096                 else if (scope < RT_SCOPE_HOST)
2097                         /* only link or site local addresses found */
2098                         link->operstate = LINK_OPERSTATE_DEGRADED;
2099                 else
2100                         /* no useful addresses found */
2101                         link->operstate = LINK_OPERSTATE_CARRIER;
2102         } else
2103                 link->operstate = LINK_OPERSTATE_UNKNOWN;
2104 }
2105
2106 int link_save(Link *link) {
2107         _cleanup_free_ char *temp_path = NULL;
2108         _cleanup_fclose_ FILE *f = NULL;
2109         const char *admin_state, *oper_state;
2110         int r;
2111
2112         assert(link);
2113         assert(link->state_file);
2114         assert(link->lease_file);
2115         assert(link->manager);
2116
2117         link_update_operstate(link);
2118
2119         r = manager_save(link->manager);
2120         if (r < 0)
2121                 return r;
2122
2123         if (link->state == LINK_STATE_LINGER) {
2124                 unlink(link->state_file);
2125                 return 0;
2126         }
2127
2128         admin_state = link_state_to_string(link->state);
2129         assert(admin_state);
2130
2131         oper_state = link_operstate_to_string(link->operstate);
2132         assert(oper_state);
2133
2134         r = fopen_temporary(link->state_file, &f, &temp_path);
2135         if (r < 0)
2136                 goto finish;
2137
2138         fchmod(fileno(f), 0644);
2139
2140         fprintf(f,
2141                 "# This is private data. Do not parse.\n"
2142                 "ADMIN_STATE=%s\n"
2143                 "OPER_STATE=%s\n"
2144                 "FLAGS=%u\n",
2145                 admin_state, oper_state, link->flags);
2146
2147         if (link->network) {
2148                 serialize_addresses(f, "DNS", link->network->dns);
2149                 serialize_addresses(f, "NTP", link->network->ntp);
2150         }
2151
2152         if (link->dhcp_lease) {
2153                 r = dhcp_lease_save(link->dhcp_lease, link->lease_file);
2154                 if (r < 0)
2155                         goto finish;
2156
2157                 fprintf(f,
2158                         "DHCP_LEASE=%s\n"
2159                         "DHCP_USE_DNS=%s\n"
2160                         "DHCP_USE_NTP=%s\n",
2161                         link->lease_file,
2162                         yes_no(link->network->dhcp_dns),
2163                         yes_no(link->network->dhcp_ntp));
2164         } else
2165                 unlink(link->lease_file);
2166
2167         fflush(f);
2168
2169         if (ferror(f) || rename(temp_path, link->state_file) < 0) {
2170                 r = -errno;
2171                 unlink(link->state_file);
2172                 unlink(temp_path);
2173         }
2174
2175 finish:
2176         if (r < 0)
2177                 log_error_link(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
2178
2179         return r;
2180 }
2181
2182 static const char* const link_state_table[_LINK_STATE_MAX] = {
2183         [LINK_STATE_INITIALIZING] = "initializing",
2184         [LINK_STATE_ENSLAVING] = "configuring",
2185         [LINK_STATE_SETTING_ADDRESSES] = "configuring",
2186         [LINK_STATE_SETTING_ROUTES] = "configuring",
2187         [LINK_STATE_CONFIGURED] = "configured",
2188         [LINK_STATE_UNMANAGED] = "unmanaged",
2189         [LINK_STATE_FAILED] = "failed",
2190         [LINK_STATE_LINGER] = "linger",
2191 };
2192
2193 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
2194
2195 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
2196         [LINK_OPERSTATE_UNKNOWN] = "unknown",
2197         [LINK_OPERSTATE_DORMANT] = "dormant",
2198         [LINK_OPERSTATE_CARRIER] = "carrier",
2199         [LINK_OPERSTATE_DEGRADED] = "degraded",
2200         [LINK_OPERSTATE_ROUTABLE] = "routable",
2201 };
2202
2203 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);