src/network/networkd-link.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2013 Tom Gundersen <teg@jklm.no>
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <netinet/ether.h>
  23 #include <linux/if.h>
  24 #include <unistd.h>
  25
  26 #include "networkd-link.h"
  27 #include "networkd-netdev.h"
  28 #include "libudev-private.h"
  29 #include "udev-util.h"
  30 #include "util.h"
  31 #include "virt.h"
  32 #include "bus-util.h"
  33 #include "network-internal.h"
  34 #include "conf-parser.h"
  35
  36 #include "dhcp-lease-internal.h"
  37
  38 static bool link_dhcp6_enabled(Link *link) {
  39         if (link->flags & IFF_LOOPBACK)
  40                 return false;
  41
  42         if (!link->network)
  43                 return false;
  44
  45         return IN_SET(link->network->dhcp, DHCP_SUPPORT_V6, DHCP_SUPPORT_BOTH);
  46 }
  47
  48 static bool link_dhcp4_enabled(Link *link) {
  49         if (link->flags & IFF_LOOPBACK)
  50                 return false;
  51
  52         if (!link->network)
  53                 return false;
  54
  55         return IN_SET(link->network->dhcp, DHCP_SUPPORT_V4, DHCP_SUPPORT_BOTH);
  56 }
  57
  58 static bool link_dhcp4_server_enabled(Link *link) {
  59         if (link->flags & IFF_LOOPBACK)
  60                 return false;
  61
  62         if (!link->network)
  63                 return false;
  64
  65         return link->network->dhcp_server;
  66 }
  67
  68 static bool link_ipv4ll_enabled(Link *link) {
  69         if (link->flags & IFF_LOOPBACK)
  70                 return false;
  71
  72         if (!link->network)
  73                 return false;
  74
  75         return link->network->ipv4ll;
  76 }
  77
  78 static bool link_lldp_enabled(Link *link) {
  79         if (link->flags & IFF_LOOPBACK)
  80                 return false;
  81
  82         if (!link->network)
  83                 return false;
  84
  85         if(link->network->bridge)
  86                 return false;
  87
  88         return link->network->lldp;
  89 }
  90
  91 #define FLAG_STRING(string, flag, old, new) \
  92         (((old ^ new) & flag) \
  93                 ? ((old & flag) ? (" -" string) : (" +" string)) \
  94                 : "")
  95
  96 static int link_update_flags(Link *link, sd_rtnl_message *m) {
  97         unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
  98         uint8_t operstate;
  99         int r;
 100
 101         assert(link);
 102
 103         r = sd_rtnl_message_link_get_flags(m, &flags);
 104         if (r < 0) {
 105                 log_link_warning(link, "Could not get link flags");
 106                 return r;
 107         }
 108
 109         r = sd_rtnl_message_read_u8(m, IFLA_OPERSTATE, &operstate);
 110         if (r < 0)
 111                 /* if we got a message without operstate, take it to mean
 112                    the state was unchanged */
 113                 operstate = link->kernel_operstate;
 114
 115         if ((link->flags == flags) && (link->kernel_operstate == operstate))
 116                 return 0;
 117
 118         if (link->flags != flags) {
 119                 log_link_debug(link, "flags change:%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
 120                                FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
 121                                FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
 122                                FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
 123                                FLAG_STRING("UP", IFF_UP, link->flags, flags),
 124                                FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
 125                                FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
 126                                FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
 127                                FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
 128                                FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
 129                                FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
 130                                FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
 131                                FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
 132                                FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
 133                                FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
 134                                FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
 135                                FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
 136                                FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
 137                                FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
 138                                FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
 139
 140                 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
 141                                   IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
 142                                   IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
 143                                   IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
 144                                   IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
 145                                   IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
 146                 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
 147                 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
 148
 149                 /* link flags are currently at most 18 bits, let's align to
 150                  * printing 20 */
 151                 if (unknown_flags_added)
 152                         log_link_debug(link,
 153                                        "unknown link flags gained: %#.5x (ignoring)",
 154                                        unknown_flags_added);
 155
 156                 if (unknown_flags_removed)
 157                         log_link_debug(link,
 158                                        "unknown link flags lost: %#.5x (ignoring)",
 159                                        unknown_flags_removed);
 160         }
 161
 162         link->flags = flags;
 163         link->kernel_operstate = operstate;
 164
 165         link_save(link);
 166
 167         return 0;
 168 }
 169
 170 static int link_new(Manager *manager, sd_rtnl_message *message, Link **ret) {
 171         _cleanup_link_unref_ Link *link = NULL;
 172         uint16_t type;
 173         const char *ifname;
 174         int r, ifindex;
 175
 176         assert(manager);
 177         assert(message);
 178         assert(ret);
 179
 180         r = sd_rtnl_message_get_type(message, &type);
 181         if (r < 0)
 182                 return r;
 183         else if (type != RTM_NEWLINK)
 184                 return -EINVAL;
 185
 186         r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
 187         if (r < 0)
 188                 return r;
 189         else if (ifindex <= 0)
 190                 return -EINVAL;
 191
 192         r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &ifname);
 193         if (r < 0)
 194                 return r;
 195
 196         link = new0(Link, 1);
 197         if (!link)
 198                 return -ENOMEM;
 199
 200         link->n_ref = 1;
 201         link->manager = manager;
 202         link->state = LINK_STATE_PENDING;
 203         link->ifindex = ifindex;
 204         link->ifname = strdup(ifname);
 205         if (!link->ifname)
 206                 return -ENOMEM;
 207
 208         r = sd_rtnl_message_read_ether_addr(message, IFLA_ADDRESS, &link->mac);
 209         if (r < 0)
 210                 log_link_debug(link, "MAC address not found for new device, continuing without");
 211
 212         r = asprintf(&link->state_file, "/run/systemd/netif/links/%d",
 213                      link->ifindex);
 214         if (r < 0)
 215                 return -ENOMEM;
 216
 217         r = asprintf(&link->lease_file, "/run/systemd/netif/leases/%d",
 218                      link->ifindex);
 219         if (r < 0)
 220                 return -ENOMEM;
 221
 222         r = hashmap_ensure_allocated(&manager->links, NULL);
 223         if (r < 0)
 224                 return r;
 225
 226         r = hashmap_put(manager->links, INT_TO_PTR(link->ifindex), link);
 227         if (r < 0)
 228                 return r;
 229
 230         r = link_update_flags(link, message);
 231         if (r < 0)
 232                 return r;
 233
 234         *ret = link;
 235         link = NULL;
 236
 237         return 0;
 238 }
 239
 240 static void link_free(Link *link) {
 241         Address *address;
 242
 243         if (!link)
 244                 return;
 245
 246         while ((address = link->addresses)) {
 247                 LIST_REMOVE(addresses, link->addresses, address);
 248                 address_free(address);
 249         }
 250
 251         while ((address = link->pool_addresses)) {
 252                 LIST_REMOVE(addresses, link->pool_addresses, address);
 253                 address_free(address);
 254         }
 255
 256         sd_dhcp_client_unref(link->dhcp_client);
 257         sd_dhcp_lease_unref(link->dhcp_lease);
 258
 259         unlink(link->lease_file);
 260         free(link->lease_file);
 261
 262         sd_ipv4ll_unref(link->ipv4ll);
 263         sd_dhcp6_client_unref(link->dhcp6_client);
 264         sd_icmp6_nd_unref(link->icmp6_router_discovery);
 265
 266         if (link->manager)
 267                 hashmap_remove(link->manager->links, INT_TO_PTR(link->ifindex));
 268
 269         free(link->ifname);
 270
 271         unlink(link->state_file);
 272         free(link->state_file);
 273
 274         udev_device_unref(link->udev_device);
 275
 276         free(link);
 277 }
 278
 279 Link *link_unref(Link *link) {
 280         if (link && (-- link->n_ref <= 0))
 281                 link_free(link);
 282
 283         return NULL;
 284 }
 285
 286 Link *link_ref(Link *link) {
 287         if (link)
 288                 assert_se(++ link->n_ref >= 2);
 289
 290         return link;
 291 }
 292
 293 int link_get(Manager *m, int ifindex, Link **ret) {
 294         Link *link;
 295
 296         assert(m);
 297         assert(ifindex);
 298         assert(ret);
 299
 300         link = hashmap_get(m->links, INT_TO_PTR(ifindex));
 301         if (!link)
 302                 return -ENODEV;
 303
 304         *ret = link;
 305
 306         return 0;
 307 }
 308
 309 void link_drop(Link *link) {
 310         if (!link || link->state == LINK_STATE_LINGER)
 311                 return;
 312
 313         link->state = LINK_STATE_LINGER;
 314
 315         log_link_debug(link, "link removed");
 316
 317         link_unref(link);
 318
 319         return;
 320 }
 321
 322 static void link_enter_unmanaged(Link *link) {
 323         assert(link);
 324
 325         log_link_debug(link, "unmanaged");
 326
 327         link->state = LINK_STATE_UNMANAGED;
 328
 329         link_save(link);
 330 }
 331
 332 static int link_stop_clients(Link *link) {
 333         int r = 0, k;
 334
 335         assert(link);
 336         assert(link->manager);
 337         assert(link->manager->event);
 338
 339         if (!link->network)
 340                 return 0;
 341
 342         if (link->dhcp_client) {
 343                 k = sd_dhcp_client_stop(link->dhcp_client);
 344                 if (k < 0) {
 345                         log_link_warning(link, "Could not stop DHCPv4 client: %s",
 346                                          strerror(-r));
 347                         r = k;
 348                 }
 349         }
 350
 351         if (link->ipv4ll) {
 352                 k = sd_ipv4ll_stop(link->ipv4ll);
 353                 if (k < 0) {
 354                         log_link_warning(link, "Could not stop IPv4 link-local: %s",
 355                                          strerror(-r));
 356                         r = k;
 357                 }
 358         }
 359
 360         if(link->icmp6_router_discovery) {
 361
 362                 if (link->dhcp6_client) {
 363                         k = sd_dhcp6_client_stop(link->dhcp6_client);
 364                         if (k < 0) {
 365                                 log_link_warning(link, "Could not stop DHCPv6 client: %s",
 366                                                  strerror(-r));
 367                                 r = k;
 368                         }
 369                 }
 370
 371                 k = sd_icmp6_nd_stop(link->icmp6_router_discovery);
 372                 if (k < 0) {
 373                         log_link_warning(link,
 374                                          "Could not stop ICMPv6 router discovery: %s",
 375                                          strerror(-r));
 376                         r = k;
 377                 }
 378         }
 379
 380         if (link->lldp) {
 381
 382                 k = sd_lldp_stop(link->lldp);
 383                 if (k < 0) {
 384                         log_link_warning(link, "Could not stop LLDP : %s",
 385                                          strerror(-r));
 386                         r = k;
 387                 }
 388         }
 389
 390         return r;
 391 }
 392
 393 void link_enter_failed(Link *link) {
 394         assert(link);
 395
 396         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 397                 return;
 398
 399         log_link_warning(link, "failed");
 400
 401         link->state = LINK_STATE_FAILED;
 402
 403         link_stop_clients(link);
 404
 405         link_save(link);
 406 }
 407
 408 static Address* link_find_dhcp_server_address(Link *link) {
 409         Address *address;
 410
 411         assert(link);
 412         assert(link->network);
 413
 414         /* The the first statically configured address if there is any */
 415         LIST_FOREACH(addresses, address, link->network->static_addresses) {
 416
 417                 if (address->family != AF_INET)
 418                         continue;
 419
 420                 if (in_addr_is_null(address->family, &address->in_addr))
 421                         continue;
 422
 423                 return address;
 424         }
 425
 426         /* If that didn't work, find a suitable address we got from the pool */
 427         LIST_FOREACH(addresses, address, link->pool_addresses) {
 428                 if (address->family != AF_INET)
 429                         continue;
 430
 431                 return address;
 432         }
 433
 434         return NULL;
 435 }
 436
 437 static int link_enter_configured(Link *link) {
 438         int r;
 439
 440         assert(link);
 441         assert(link->network);
 442         assert(link->state == LINK_STATE_SETTING_ROUTES);
 443
 444         if (link_dhcp4_server_enabled(link) &&
 445             !sd_dhcp_server_is_running(link->dhcp_server)) {
 446                 struct in_addr pool_start;
 447                 Address *address;
 448
 449                 address = link_find_dhcp_server_address(link);
 450                 if (!address) {
 451                         log_link_warning(link,
 452                                          "Failed to find suitable address for DHCPv4 server instance.");
 453                         link_enter_failed(link);
 454                         return 0;
 455                 }
 456
 457                 log_link_debug(link, "offering DHCPv4 leases");
 458
 459                 r = sd_dhcp_server_set_address(link->dhcp_server,
 460                                                &address->in_addr.in,
 461                                                address->prefixlen);
 462                 if (r < 0)
 463                         return r;
 464
 465                 /* offer 32 addresses starting from the address following the server address */
 466                 pool_start.s_addr = htobe32(be32toh(address->in_addr.in.s_addr) + 1);
 467                 r = sd_dhcp_server_set_lease_pool(link->dhcp_server,
 468                                                   &pool_start, 32);
 469                 if (r < 0)
 470                         return r;
 471
 472                 /* TODO:
 473                 r = sd_dhcp_server_set_router(link->dhcp_server,
 474                                               &main_address->in_addr.in);
 475                 if (r < 0)
 476                         return r;
 477
 478                 r = sd_dhcp_server_set_prefixlen(link->dhcp_server,
 479                                                  main_address->prefixlen);
 480                 if (r < 0)
 481                         return r;
 482                 */
 483
 484                 r = sd_dhcp_server_start(link->dhcp_server);
 485                 if (r < 0) {
 486                         log_link_warning(link, "could not start DHCPv4 server "
 487                                          "instance: %s", strerror(-r));
 488
 489                         link_enter_failed(link);
 490
 491                         return 0;
 492                 }
 493         }
 494
 495         log_link_info(link, "link configured");
 496
 497         link->state = LINK_STATE_CONFIGURED;
 498
 499         link_save(link);
 500
 501         return 0;
 502 }
 503
 504 void link_client_handler(Link *link) {
 505         assert(link);
 506         assert(link->network);
 507
 508         if (!link->static_configured)
 509                 return;
 510
 511         if (link_ipv4ll_enabled(link))
 512                 if (!link->ipv4ll_address ||
 513                     !link->ipv4ll_route)
 514                         return;
 515
 516         if (link_dhcp4_enabled(link) && !link->dhcp4_configured)
 517                         return;
 518
 519         if (link->state != LINK_STATE_CONFIGURED)
 520                 link_enter_configured(link);
 521
 522         return;
 523 }
 524
 525 static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
 526         _cleanup_link_unref_ Link *link = userdata;
 527         int r;
 528
 529         assert(link->link_messages > 0);
 530         assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
 531                       LINK_STATE_SETTING_ROUTES, LINK_STATE_FAILED,
 532                       LINK_STATE_LINGER));
 533
 534         link->link_messages --;
 535
 536         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 537                 return 1;
 538
 539         r = sd_rtnl_message_get_errno(m);
 540         if (r < 0 && r != -EEXIST)
 541                 log_link_warning_errno(link, -r, "%-*s: could not set route: %m", IFNAMSIZ, link->ifname);
 542
 543         if (link->link_messages == 0) {
 544                 log_link_debug(link, "routes set");
 545                 link->static_configured = true;
 546                 link_client_handler(link);
 547         }
 548
 549         return 1;
 550 }
 551
 552 static int link_enter_set_routes(Link *link) {
 553         Route *rt;
 554         int r;
 555
 556         assert(link);
 557         assert(link->network);
 558         assert(link->state == LINK_STATE_SETTING_ADDRESSES);
 559
 560         link->state = LINK_STATE_SETTING_ROUTES;
 561
 562         LIST_FOREACH(routes, rt, link->network->static_routes) {
 563                 r = route_configure(rt, link, &route_handler);
 564                 if (r < 0) {
 565                         log_link_warning(link,
 566                                          "could not set routes: %s",
 567                                          strerror(-r));
 568                         link_enter_failed(link);
 569                         return r;
 570                 }
 571
 572                 link->link_messages ++;
 573         }
 574
 575         if (link->link_messages == 0) {
 576                 link->static_configured = true;
 577                 link_client_handler(link);
 578         } else
 579                 log_link_debug(link, "setting routes");
 580
 581         return 0;
 582 }
 583
 584 int link_route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
 585         _cleanup_link_unref_ Link *link = userdata;
 586         int r;
 587
 588         assert(m);
 589         assert(link);
 590         assert(link->ifname);
 591
 592         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 593                 return 1;
 594
 595         r = sd_rtnl_message_get_errno(m);
 596         if (r < 0 && r != -ESRCH)
 597                 log_link_warning_errno(link, -r, "%-*s: could not drop route: %m", IFNAMSIZ, link->ifname);
 598
 599         return 1;
 600 }
 601
 602 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
 603         _cleanup_link_unref_ Link *link = userdata;
 604         int r;
 605
 606         assert(rtnl);
 607         assert(m);
 608         assert(link);
 609         assert(link->ifname);
 610         assert(link->link_messages > 0);
 611         assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
 612                LINK_STATE_FAILED, LINK_STATE_LINGER));
 613
 614         link->link_messages --;
 615
 616         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 617                 return 1;
 618
 619         r = sd_rtnl_message_get_errno(m);
 620         if (r < 0 && r != -EEXIST)
 621                 log_link_warning_errno(link, -r, "%-*s: could not set address: %m", IFNAMSIZ, link->ifname);
 622         else if (r >= 0)
 623                 link_rtnl_process_address(rtnl, m, link->manager);
 624
 625         if (link->link_messages == 0) {
 626                 log_link_debug(link, "addresses set");
 627                 link_enter_set_routes(link);
 628         }
 629
 630         return 1;
 631 }
 632
 633 static int link_enter_set_addresses(Link *link) {
 634         Address *ad;
 635         int r;
 636
 637         assert(link);
 638         assert(link->network);
 639         assert(link->state != _LINK_STATE_INVALID);
 640
 641         link->state = LINK_STATE_SETTING_ADDRESSES;
 642
 643         LIST_FOREACH(addresses, ad, link->network->static_addresses) {
 644                 r = address_configure(ad, link, &address_handler);
 645                 if (r < 0) {
 646                         log_link_warning(link,
 647                                          "could not set addresses: %s",
 648                                          strerror(-r));
 649                         link_enter_failed(link);
 650                         return r;
 651                 }
 652
 653                 link->link_messages ++;
 654         }
 655
 656         if (link->link_messages == 0) {
 657                 link_enter_set_routes(link);
 658         } else
 659                 log_link_debug(link, "setting addresses");
 660
 661         return 0;
 662 }
 663
 664 int link_address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
 665         _cleanup_link_unref_ Link *link = userdata;
 666         int r;
 667
 668         assert(m);
 669         assert(link);
 670         assert(link->ifname);
 671
 672         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 673                 return 1;
 674
 675         r = sd_rtnl_message_get_errno(m);
 676         if (r < 0 && r != -EADDRNOTAVAIL)
 677                 log_link_warning_errno(link, -r, "%-*s: could not drop address: %m", IFNAMSIZ, link->ifname);
 678
 679         return 1;
 680 }
 681
 682 static int link_set_bridge_fdb(const Link *const link) {
 683         FdbEntry *fdb_entry;
 684         int r = 0;
 685
 686         LIST_FOREACH(static_fdb_entries, fdb_entry, link->network->static_fdb_entries) {
 687                 r = fdb_entry_configure(link->manager->rtnl, fdb_entry, link->ifindex);
 688                 if(r < 0) {
 689                         log_link_error(link, "Failed to add MAC entry to static MAC table: %s", strerror(-r));
 690                         break;
 691                 }
 692         }
 693
 694         return r;
 695 }
 696
 697 static int link_set_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
 698         _cleanup_link_unref_ Link *link = userdata;
 699         int r;
 700
 701         log_link_debug(link, "set link");
 702
 703         r = sd_rtnl_message_get_errno(m);
 704         if (r < 0 && r != -EEXIST) {
 705                 log_link_struct(link, LOG_ERR,
 706                                 "MESSAGE=%-*s: could not join netdev: %s",
 707                                 IFNAMSIZ,
 708                                 link->ifname, strerror(-r),
 709                                 "ERRNO=%d", -r,
 710                                 NULL);
 711                 link_enter_failed(link);
 712                 return 1;
 713         }
 714
 715         return 0;
 716 }
 717
 718 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata,
 719                                 sd_bus_error *ret_error) {
 720         _cleanup_link_unref_ Link *link = userdata;
 721         int r;
 722
 723         assert(link);
 724
 725         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 726                 return 1;
 727
 728         r = sd_bus_message_get_errno(m);
 729         if (r > 0)
 730                 log_link_warning(link, "Could not set hostname: %s",
 731                                  strerror(r));
 732
 733         return 1;
 734 }
 735
 736 int link_set_hostname(Link *link, const char *hostname) {
 737         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
 738         int r = 0;
 739
 740         assert(link);
 741         assert(link->manager);
 742         assert(hostname);
 743
 744         log_link_debug(link, "Setting transient hostname: '%s'", hostname);
 745
 746         if (!link->manager->bus) {
 747                 /* TODO: replace by assert when we can rely on kdbus */
 748                 log_link_info(link,
 749                               "Not connected to system bus, ignoring transient hostname.");
 750                 return 0;
 751         }
 752
 753         r = sd_bus_message_new_method_call(
 754                         link->manager->bus,
 755                         &m,
 756                         "org.freedesktop.hostname1",
 757                         "/org/freedesktop/hostname1",
 758                         "org.freedesktop.hostname1",
 759                         "SetHostname");
 760         if (r < 0)
 761                 return r;
 762
 763         r = sd_bus_message_append(m, "sb", hostname, false);
 764         if (r < 0)
 765                 return r;
 766
 767         r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler,
 768                               link, 0);
 769         if (r < 0) {
 770                 log_link_error(link, "Could not set transient hostname: %s",
 771                                strerror(-r));
 772                 return r;
 773         }
 774
 775         link_ref(link);
 776
 777         return 0;
 778 }
 779
 780 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
 781         _cleanup_link_unref_ Link *link = userdata;
 782         int r;
 783
 784         assert(m);
 785         assert(link);
 786         assert(link->ifname);
 787
 788         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 789                 return 1;
 790
 791         r = sd_rtnl_message_get_errno(m);
 792         if (r < 0)
 793                 log_link_warning_errno(link, -r, "%-*s: could not set MTU: %m", IFNAMSIZ, link->ifname);
 794
 795         return 1;
 796 }
 797
 798 int link_set_mtu(Link *link, uint32_t mtu) {
 799         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
 800         int r;
 801
 802         assert(link);
 803         assert(link->manager);
 804         assert(link->manager->rtnl);
 805
 806         log_link_debug(link, "setting MTU: %" PRIu32, mtu);
 807
 808         r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
 809                                      RTM_SETLINK, link->ifindex);
 810         if (r < 0) {
 811                 log_link_error(link, "Could not allocate RTM_SETLINK message");
 812                 return r;
 813         }
 814
 815         r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
 816         if (r < 0) {
 817                 log_link_error(link, "Could not append MTU: %s", strerror(-r));
 818                 return r;
 819         }
 820
 821         r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link,
 822                                0, NULL);
 823         if (r < 0) {
 824                 log_link_error(link,
 825                                "Could not send rtnetlink message: %s",
 826                                strerror(-r));
 827                 return r;
 828         }
 829
 830         link_ref(link);
 831
 832         return 0;
 833 }
 834
 835 static int link_set_bridge(Link *link) {
 836         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
 837         int r;
 838
 839         assert(link);
 840         assert(link->network);
 841
 842         if(link->network->cost == 0)
 843                 return 0;
 844
 845         r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
 846                                      RTM_SETLINK, link->ifindex);
 847         if (r < 0) {
 848                 log_link_error(link, "Could not allocate RTM_SETLINK message");
 849                 return r;
 850         }
 851
 852         r = sd_rtnl_message_link_set_family(req, PF_BRIDGE);
 853         if (r < 0) {
 854                 log_link_error(link,
 855                                "Could not set message family %s", strerror(-r));
 856                 return r;
 857         }
 858
 859         r = sd_rtnl_message_open_container(req, IFLA_PROTINFO);
 860         if (r < 0) {
 861                 log_link_error(link,
 862                                "Could not append IFLA_PROTINFO attribute: %s",
 863                                strerror(-r));
 864                 return r;
 865         }
 866
 867         if(link->network->cost != 0) {
 868                 r = sd_rtnl_message_append_u32(req, IFLA_BRPORT_COST, link->network->cost);
 869                 if (r < 0) {
 870                         log_link_error(link,
 871                                        "Could not append IFLA_BRPORT_COST attribute: %s",
 872                                        strerror(-r));
 873                         return r;
 874                 }
 875         }
 876
 877         r = sd_rtnl_message_close_container(req);
 878         if (r < 0) {
 879                 log_link_error(link,
 880                                "Could not append IFLA_LINKINFO attribute: %s",
 881                                strerror(-r));
 882                 return r;
 883         }
 884
 885         r = sd_rtnl_call_async(link->manager->rtnl, req, link_set_handler, link, 0, NULL);
 886         if (r < 0) {
 887                 log_link_error(link,
 888                                "Could not send rtnetlink message: %s",
 889                                strerror(-r));
 890                 return r;
 891         }
 892
 893         link_ref(link);
 894
 895         return r;
 896 }
 897
 898 static int link_acquire_conf(Link *link) {
 899         int r;
 900
 901         assert(link);
 902         assert(link->network);
 903         assert(link->manager);
 904         assert(link->manager->event);
 905
 906         if (link_ipv4ll_enabled(link)) {
 907                 assert(link->ipv4ll);
 908
 909                 log_link_debug(link, "acquiring IPv4 link-local address");
 910
 911                 r = sd_ipv4ll_start(link->ipv4ll);
 912                 if (r < 0) {
 913                         log_link_warning(link, "could not acquire IPv4 "
 914                                          "link-local address");
 915                         return r;
 916                 }
 917         }
 918
 919         if (link_dhcp4_enabled(link)) {
 920                 assert(link->dhcp_client);
 921
 922                 log_link_debug(link, "acquiring DHCPv4 lease");
 923
 924                 r = sd_dhcp_client_start(link->dhcp_client);
 925                 if (r < 0) {
 926                         log_link_warning(link, "could not acquire DHCPv4 "
 927                                          "lease");
 928                         return r;
 929                 }
 930         }
 931
 932         if (link_dhcp6_enabled(link)) {
 933                 assert(link->icmp6_router_discovery);
 934
 935                 log_link_debug(link, "discovering IPv6 routers");
 936
 937                 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
 938                 if (r < 0) {
 939                         log_link_warning(link,
 940                                          "could not start IPv6 router discovery");
 941                         return r;
 942                 }
 943         }
 944
 945         if (link_lldp_enabled(link)) {
 946                 assert(link->lldp);
 947
 948                 log_link_debug(link, "Starting LLDP");
 949
 950                 r = sd_lldp_start(link->lldp);
 951                 if (r < 0) {
 952                         log_link_warning(link, "could not start LLDP ");
 953                         return r;
 954                 }
 955         }
 956
 957         return 0;
 958 }
 959
 960 bool link_has_carrier(Link *link) {
 961         /* see Documentation/networking/operstates.txt in the kernel sources */
 962
 963         if (link->kernel_operstate == IF_OPER_UP)
 964                 return true;
 965
 966         if (link->kernel_operstate == IF_OPER_UNKNOWN)
 967                 /* operstate may not be implemented, so fall back to flags */
 968                 if ((link->flags & IFF_LOWER_UP) && !(link->flags & IFF_DORMANT))
 969                         return true;
 970
 971         return false;
 972 }
 973
 974 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
 975         _cleanup_link_unref_ Link *link = userdata;
 976         int r;
 977
 978         assert(link);
 979
 980         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 981                 return 1;
 982
 983         r = sd_rtnl_message_get_errno(m);
 984         if (r < 0) {
 985                 /* we warn but don't fail the link, as it may
 986                    be brought up later */
 987                 log_link_warning_errno(link, -r, "%-*s: could not bring up interface: %m", IFNAMSIZ, link->ifname);
 988         }
 989
 990         return 1;
 991 }
 992
 993 static int link_up(Link *link) {
 994         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
 995         int r;
 996
 997         assert(link);
 998         assert(link->network);
 999         assert(link->manager);
1000         assert(link->manager->rtnl);
1001
1002         log_link_debug(link, "bringing link up");
1003
1004         r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1005                                      RTM_SETLINK, link->ifindex);
1006         if (r < 0) {
1007                 log_link_error(link, "Could not allocate RTM_SETLINK message");
1008                 return r;
1009         }
1010
1011         r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1012         if (r < 0) {
1013                 log_link_error(link, "Could not set link flags: %s",
1014                                strerror(-r));
1015                 return r;
1016         }
1017
1018         if (link->network->mac) {
1019                 r = sd_rtnl_message_append_ether_addr(req, IFLA_ADDRESS, link->network->mac);
1020                 if (r < 0) {
1021                         log_link_error(link, "Could not set MAC address: %s", strerror(-r));
1022                         return r;
1023                 }
1024         }
1025
1026         if (link->network->mtu) {
1027                 r = sd_rtnl_message_append_u32(req, IFLA_MTU, link->network->mtu);
1028                 if (r < 0) {
1029                         log_link_error(link, "Could not set MTU: %s", strerror(-r));
1030                         return r;
1031                 }
1032         }
1033
1034         r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link,
1035                                0, NULL);
1036         if (r < 0) {
1037                 log_link_error(link,
1038                                "Could not send rtnetlink message: %s",
1039                                strerror(-r));
1040                 return r;
1041         }
1042
1043         link_ref(link);
1044
1045         return 0;
1046 }
1047
1048 static int link_joined(Link *link) {
1049         int r;
1050
1051         assert(link);
1052         assert(link->network);
1053
1054         if (!(link->flags & IFF_UP)) {
1055                 r = link_up(link);
1056                 if (r < 0) {
1057                         link_enter_failed(link);
1058                         return r;
1059                 }
1060         }
1061
1062         if(link->network->bridge) {
1063                 r = link_set_bridge(link);
1064                 if (r < 0) {
1065                         log_link_error(link,
1066                                        "Could not set bridge message: %s",
1067                                        strerror(-r));
1068                 }
1069         }
1070
1071         return link_enter_set_addresses(link);
1072 }
1073
1074 static int netdev_join_handler(sd_rtnl *rtnl, sd_rtnl_message *m,
1075                                void *userdata) {
1076         _cleanup_link_unref_ Link *link = userdata;
1077         int r;
1078
1079         assert(link);
1080         assert(link->network);
1081
1082         link->enslaving --;
1083
1084         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1085                 return 1;
1086
1087         r = sd_rtnl_message_get_errno(m);
1088         if (r < 0 && r != -EEXIST) {
1089                 log_link_error_errno(link, -r, "%-*s: could not join netdev: %m", IFNAMSIZ, link->ifname);
1090                 link_enter_failed(link);
1091                 return 1;
1092         } else
1093                 log_link_debug(link, "joined netdev");
1094
1095         if (link->enslaving <= 0)
1096                 link_joined(link);
1097
1098         return 1;
1099 }
1100
1101 static int link_enter_join_netdev(Link *link) {
1102         NetDev *netdev;
1103         Iterator i;
1104         int r;
1105
1106         assert(link);
1107         assert(link->network);
1108         assert(link->state == LINK_STATE_PENDING);
1109
1110         link->state = LINK_STATE_ENSLAVING;
1111
1112         link_save(link);
1113
1114         if (!link->network->bridge &&
1115             !link->network->bond &&
1116             hashmap_isempty(link->network->stacked_netdevs))
1117                 return link_joined(link);
1118
1119         if (link->network->bond) {
1120                 log_link_struct(link, LOG_DEBUG,
1121                                 "MESSAGE=%-*s: enslaving by '%s'",
1122                                 IFNAMSIZ,
1123                                 link->ifname, link->network->bond->ifname,
1124                                 NETDEVIF(link->network->bond),
1125                                 NULL);
1126
1127                 r = netdev_join(link->network->bond, link, &netdev_join_handler);
1128                 if (r < 0) {
1129                         log_link_struct(link, LOG_WARNING,
1130                                         "MESSAGE=%-*s: could not join netdev '%s': %s",
1131                                         IFNAMSIZ,
1132                                         link->ifname, link->network->bond->ifname,
1133                                         strerror(-r),
1134                                         NETDEVIF(link->network->bond),
1135                                         NULL);
1136                         link_enter_failed(link);
1137                         return r;
1138                 }
1139
1140                 link->enslaving ++;
1141         }
1142
1143         if (link->network->bridge) {
1144                 log_link_struct(link, LOG_DEBUG,
1145                                 "MESSAGE=%-*s: enslaving by '%s'",
1146                                 IFNAMSIZ,
1147                                 link->ifname, link->network->bridge->ifname,
1148                                 NETDEVIF(link->network->bridge),
1149                                 NULL);
1150
1151                 r = netdev_join(link->network->bridge, link,
1152                                 &netdev_join_handler);
1153                 if (r < 0) {
1154                         log_link_struct(link, LOG_WARNING,
1155                                         "MESSAGE=%-*s: could not join netdev '%s': %s",
1156                                         IFNAMSIZ,
1157                                         link->ifname, link->network->bridge->ifname,
1158                                         strerror(-r),
1159                                         NETDEVIF(link->network->bridge),
1160                                         NULL);
1161                         link_enter_failed(link);
1162                         return r;
1163                 }
1164
1165                 link->enslaving ++;
1166         }
1167
1168         HASHMAP_FOREACH(netdev, link->network->stacked_netdevs, i) {
1169                 log_link_struct(link, LOG_DEBUG,
1170                                 "MESSAGE=%-*s: enslaving by '%s'",
1171                                 IFNAMSIZ,
1172                                 link->ifname, netdev->ifname, NETDEVIF(netdev),
1173                                 NULL);
1174
1175                 r = netdev_join(netdev, link, &netdev_join_handler);
1176                 if (r < 0) {
1177                         log_link_struct(link, LOG_WARNING,
1178                                         "MESSAGE=%-*s: could not join netdev '%s': %s",
1179                                         IFNAMSIZ,
1180                                         link->ifname, netdev->ifname,
1181                                         strerror(-r),
1182                                         NETDEVIF(netdev), NULL);
1183                         link_enter_failed(link);
1184                         return r;
1185                 }
1186
1187                 link->enslaving ++;
1188         }
1189
1190         return 0;
1191 }
1192
1193 static int link_configure(Link *link) {
1194         int r;
1195
1196         assert(link);
1197         assert(link->network);
1198         assert(link->state == LINK_STATE_PENDING);
1199
1200         r = link_set_bridge_fdb(link);
1201         if (r < 0)
1202                 return r;
1203
1204         if (link_ipv4ll_enabled(link)) {
1205                 r = ipv4ll_configure(link);
1206                 if (r < 0)
1207                         return r;
1208         }
1209
1210         if (link_dhcp4_enabled(link)) {
1211                 r = dhcp4_configure(link);
1212                 if (r < 0)
1213                         return r;
1214         }
1215
1216         if (link_dhcp4_server_enabled(link)) {
1217                 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
1218                 if (r < 0)
1219                         return r;
1220
1221                 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
1222                 if (r < 0)
1223                         return r;
1224         }
1225
1226         if (link_dhcp6_enabled(link)) {
1227                 r = icmp6_configure(link);
1228                 if (r < 0)
1229                         return r;
1230         }
1231
1232         if (link_lldp_enabled(link)) {
1233                 r = sd_lldp_new(link->ifindex, link->ifname, &link->mac, &link->lldp);
1234                 if (r < 0)
1235                         return r;
1236
1237                 r = sd_lldp_attach_event(link->lldp, NULL, 0);
1238                 if (r < 0)
1239                         return r;
1240         }
1241
1242         if (link_has_carrier(link)) {
1243                 r = link_acquire_conf(link);
1244                 if (r < 0)
1245                         return r;
1246         }
1247
1248         return link_enter_join_netdev(link);
1249 }
1250
1251 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m,
1252                                        void *userdata) {
1253         _cleanup_link_unref_ Link *link = userdata;
1254         Network *network;
1255         int r;
1256
1257         assert(link);
1258         assert(link->ifname);
1259         assert(link->manager);
1260
1261         if (link->state != LINK_STATE_PENDING)
1262                 return 1;
1263
1264         log_link_debug(link, "link state is up-to-date");
1265
1266         r = network_get(link->manager, link->udev_device, link->ifname,
1267                         &link->mac, &network);
1268         if (r == -ENOENT) {
1269                 link_enter_unmanaged(link);
1270                 return 1;
1271         } else if (r < 0)
1272                 return r;
1273
1274         if (link->flags & IFF_LOOPBACK) {
1275                 if (network->ipv4ll)
1276                         log_link_debug(link, "ignoring IPv4LL for loopback link");
1277
1278                 if (network->dhcp != DHCP_SUPPORT_NONE)
1279                         log_link_debug(link, "ignoring DHCP clients for loopback link");
1280
1281                 if (network->dhcp_server)
1282                         log_link_debug(link, "ignoring DHCP server for loopback link");
1283         }
1284
1285         r = network_apply(link->manager, network, link);
1286         if (r < 0)
1287                 return r;
1288
1289         r = link_configure(link);
1290         if (r < 0)
1291                 return r;
1292
1293         return 1;
1294 }
1295
1296 int link_initialized(Link *link, struct udev_device *device) {
1297         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1298         int r;
1299
1300         assert(link);
1301         assert(link->manager);
1302         assert(link->manager->rtnl);
1303         assert(device);
1304
1305         if (link->state != LINK_STATE_PENDING)
1306                 return 0;
1307
1308         if (link->udev_device)
1309                 return 0;
1310
1311         log_link_debug(link, "udev initialized link");
1312
1313         link->udev_device = udev_device_ref(device);
1314
1315         /* udev has initialized the link, but we don't know if we have yet
1316          * processed the NEWLINK messages with the latest state. Do a GETLINK,
1317          * when it returns we know that the pending NEWLINKs have already been
1318          * processed and that we are up-to-date */
1319
1320         r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK,
1321                                      link->ifindex);
1322         if (r < 0)
1323                 return r;
1324
1325         r = sd_rtnl_call_async(link->manager->rtnl, req,
1326                                link_initialized_and_synced, link, 0, NULL);
1327         if (r < 0)
1328                 return r;
1329
1330         link_ref(link);
1331
1332         return 0;
1333 }
1334
1335 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
1336         Manager *m = userdata;
1337         Link *link = NULL;
1338         uint16_t type;
1339         _cleanup_address_free_ Address *address = NULL;
1340         Address *ad;
1341         char buf[INET6_ADDRSTRLEN];
1342         char valid_buf[FORMAT_TIMESPAN_MAX];
1343         const char *valid_str = NULL;
1344         bool address_dropped = false;
1345         int r, ifindex;
1346
1347         assert(rtnl);
1348         assert(message);
1349         assert(m);
1350
1351         if (sd_rtnl_message_is_error(message)) {
1352                 r = sd_rtnl_message_get_errno(message);
1353                 if (r < 0)
1354                         log_warning_errno(r, "rtnl: failed to receive address: %m");
1355
1356                 return 0;
1357         }
1358
1359         r = sd_rtnl_message_get_type(message, &type);
1360         if (r < 0) {
1361                 log_warning("rtnl: could not get message type");
1362                 return 0;
1363         }
1364
1365         r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
1366         if (r < 0) {
1367                 log_warning_errno(r, "rtnl: could not get ifindex: %m");
1368                 return 0;
1369         } else if (ifindex <= 0) {
1370                 log_warning("rtnl: received address message with invalid ifindex: %d", ifindex);
1371                 return 0;
1372         } else {
1373                 r = link_get(m, ifindex, &link);
1374                 if (r < 0 || !link) {
1375                         log_warning("rtnl: received address for nonexistent link (%d), ignoring", ifindex);
1376                         return 0;
1377                 }
1378         }
1379
1380         r = address_new_dynamic(&address);
1381         if (r < 0)
1382                 return r;
1383
1384         r = sd_rtnl_message_addr_get_family(message, &address->family);
1385         if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
1386                 log_link_warning(link,
1387                                  "rtnl: received address with invalid family, ignoring");
1388                 return 0;
1389         }
1390
1391         r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
1392         if (r < 0) {
1393                 log_link_warning(link,
1394                                  "rtnl: received address with invalid prefixlen, ignoring");
1395                 return 0;
1396         }
1397
1398         r = sd_rtnl_message_addr_get_scope(message, &address->scope);
1399         if (r < 0) {
1400                 log_link_warning(link,
1401                                  "rtnl: received address with invalid scope, ignoring");
1402                 return 0;
1403         }
1404
1405         r = sd_rtnl_message_addr_get_flags(message, &address->flags);
1406         if (r < 0) {
1407                 log_link_warning(link,
1408                                  "rtnl: received address with invalid flags, ignoring");
1409                 return 0;
1410         }
1411
1412         switch (address->family) {
1413         case AF_INET:
1414                 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL,
1415                                                  &address->in_addr.in);
1416                 if (r < 0) {
1417                         log_link_warning(link,
1418                                          "rtnl: received address without valid address, ignoring");
1419                         return 0;
1420                 }
1421
1422                 break;
1423
1424         case AF_INET6:
1425                 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS,
1426                                                   &address->in_addr.in6);
1427                 if (r < 0) {
1428                         log_link_warning(link,
1429                                          "rtnl: received address without valid address, ignoring");
1430                         return 0;
1431                 }
1432
1433                 break;
1434
1435         default:
1436                 assert_not_reached("invalid address family");
1437         }
1438
1439         if (!inet_ntop(address->family, &address->in_addr, buf,
1440                        INET6_ADDRSTRLEN)) {
1441                 log_link_warning(link, "could not print address");
1442                 return 0;
1443         }
1444
1445         r = sd_rtnl_message_read_cache_info(message, IFA_CACHEINFO,
1446                                             &address->cinfo);
1447         if (r >= 0) {
1448                 if (address->cinfo.ifa_valid == CACHE_INFO_INFINITY_LIFE_TIME)
1449                         valid_str = "ever";
1450                 else
1451                         valid_str = format_timespan(valid_buf, FORMAT_TIMESPAN_MAX,
1452                                                     address->cinfo.ifa_valid * USEC_PER_SEC,
1453                                                     USEC_PER_SEC);
1454         }
1455
1456         LIST_FOREACH(addresses, ad, link->addresses) {
1457                 if (address_equal(ad, address)) {
1458                         LIST_REMOVE(addresses, link->addresses, ad);
1459
1460                         address_free(ad);
1461
1462                         address_dropped = true;
1463
1464                         break;
1465                 }
1466         }
1467
1468         switch (type) {
1469         case RTM_NEWADDR:
1470                 if (!address_dropped)
1471                         log_link_debug(link, "added address: %s/%u (valid for %s)",
1472                                        buf, address->prefixlen, valid_str);
1473                 else
1474                         log_link_debug(link, "updated address: %s/%u (valid for %s)",
1475                                        buf, address->prefixlen, valid_str);
1476
1477                 LIST_PREPEND(addresses, link->addresses, address);
1478                 address = NULL;
1479
1480                 link_save(link);
1481
1482                 break;
1483         case RTM_DELADDR:
1484                 if (address_dropped) {
1485                         log_link_debug(link, "removed address: %s/%u (valid for %s)",
1486                                        buf, address->prefixlen, valid_str);
1487
1488                         link_save(link);
1489                 } else
1490                         log_link_warning(link,
1491                                          "removing non-existent address: %s/%u (valid for %s)",
1492                                          buf, address->prefixlen, valid_str);
1493
1494                 break;
1495         default:
1496                 assert_not_reached("Received invalid RTNL message type");
1497         }
1498
1499         return 1;
1500 }
1501
1502 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
1503         Link *link;
1504         _cleanup_udev_device_unref_ struct udev_device *device = NULL;
1505         char ifindex_str[2 + DECIMAL_STR_MAX(int)];
1506         int r;
1507
1508         assert(m);
1509         assert(m->rtnl);
1510         assert(message);
1511         assert(ret);
1512
1513         r = link_new(m, message, ret);
1514         if (r < 0)
1515                 return r;
1516
1517         link = *ret;
1518
1519         log_link_debug(link, "link %d added", link->ifindex);
1520
1521         if (detect_container(NULL) <= 0) {
1522                 /* not in a container, udev will be around */
1523                 sprintf(ifindex_str, "n%d", link->ifindex);
1524                 device = udev_device_new_from_device_id(m->udev, ifindex_str);
1525                 if (!device) {
1526                         log_link_warning(link,
1527                                          "could not find udev device: %m");
1528                         return -errno;
1529                 }
1530
1531                 if (udev_device_get_is_initialized(device) <= 0) {
1532                         /* not yet ready */
1533                         log_link_debug(link, "link pending udev initialization...");
1534                         return 0;
1535                 }
1536
1537                 r = link_initialized(link, device);
1538                 if (r < 0)
1539                         return r;
1540         } else {
1541                 /* we are calling a callback directly, so must take a ref */
1542                 link_ref(link);
1543
1544                 r = link_initialized_and_synced(m->rtnl, NULL, link);
1545                 if (r < 0)
1546                         return r;
1547         }
1548
1549         return 0;
1550 }
1551
1552 int link_update(Link *link, sd_rtnl_message *m) {
1553         struct ether_addr mac;
1554         const char *ifname;
1555         uint32_t mtu;
1556         bool had_carrier, carrier_gained, carrier_lost;
1557         int r;
1558
1559         assert(link);
1560         assert(link->ifname);
1561         assert(m);
1562
1563         if (link->state == LINK_STATE_LINGER) {
1564                 link_ref(link);
1565                 log_link_info(link, "link readded");
1566                 link->state = LINK_STATE_ENSLAVING;
1567         }
1568
1569         r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
1570         if (r >= 0 && !streq(ifname, link->ifname)) {
1571                 log_link_info(link, "renamed to %s", ifname);
1572
1573                 free(link->ifname);
1574                 link->ifname = strdup(ifname);
1575                 if (!link->ifname)
1576                         return -ENOMEM;
1577         }
1578
1579         r = sd_rtnl_message_read_u32(m, IFLA_MTU, &mtu);
1580         if (r >= 0 && mtu > 0) {
1581                 link->mtu = mtu;
1582                 if (!link->original_mtu) {
1583                         link->original_mtu = mtu;
1584                         log_link_debug(link, "saved original MTU: %"
1585                                        PRIu32, link->original_mtu);
1586                 }
1587
1588                 if (link->dhcp_client) {
1589                         r = sd_dhcp_client_set_mtu(link->dhcp_client,
1590                                                    link->mtu);
1591                         if (r < 0) {
1592                                 log_link_warning(link,
1593                                                  "Could not update MTU in DHCP client: %s",
1594                                                  strerror(-r));
1595                                 return r;
1596                         }
1597                 }
1598         }
1599
1600         /* The kernel may broadcast NEWLINK messages without the MAC address
1601            set, simply ignore them. */
1602         r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
1603         if (r >= 0) {
1604                 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet,
1605                            ETH_ALEN)) {
1606
1607                         memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet,
1608                                ETH_ALEN);
1609
1610                         log_link_debug(link, "MAC address: "
1611                                        "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1612                                        mac.ether_addr_octet[0],
1613                                        mac.ether_addr_octet[1],
1614                                        mac.ether_addr_octet[2],
1615                                        mac.ether_addr_octet[3],
1616                                        mac.ether_addr_octet[4],
1617                                        mac.ether_addr_octet[5]);
1618
1619                         if (link->ipv4ll) {
1620                                 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1621                                 if (r < 0) {
1622                                         log_link_warning(link,
1623                                                          "Could not update MAC address in IPv4LL client: %s",
1624                                                          strerror(-r));
1625                                         return r;
1626                                 }
1627                         }
1628
1629                         if (link->dhcp_client) {
1630                                 r = sd_dhcp_client_set_mac(link->dhcp_client,
1631                                                            (const uint8_t *) &link->mac,
1632                                                            sizeof (link->mac),
1633                                                            ARPHRD_ETHER);
1634                                 if (r < 0) {
1635                                         log_link_warning(link,
1636                                                          "Could not update MAC address in DHCP client: %s",
1637                                                          strerror(-r));
1638                                         return r;
1639                                 }
1640                         }
1641
1642                         if (link->dhcp6_client) {
1643                                 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
1644                                                             (const uint8_t *) &link->mac,
1645                                                             sizeof (link->mac),
1646                                                             ARPHRD_ETHER);
1647                                 if (r < 0) {
1648                                         log_link_warning(link,
1649                                                          "Could not update MAC address in DHCPv6 client: %s",
1650                                                          strerror(-r));
1651                                         return r;
1652                                 }
1653                         }
1654                 }
1655         }
1656
1657         had_carrier = link_has_carrier(link);
1658
1659         r = link_update_flags(link, m);
1660         if (r < 0)
1661                 return r;
1662
1663         carrier_gained = !had_carrier && link_has_carrier(link);
1664         carrier_lost = had_carrier && !link_has_carrier(link);
1665
1666         if (carrier_gained) {
1667                 log_link_info(link, "gained carrier");
1668
1669                 if (link->network) {
1670                         r = link_acquire_conf(link);
1671                         if (r < 0) {
1672                                 link_enter_failed(link);
1673                                 return r;
1674                         }
1675                 }
1676         } else if (carrier_lost) {
1677                 log_link_info(link, "lost carrier");
1678
1679                 r = link_stop_clients(link);
1680                 if (r < 0) {
1681                         link_enter_failed(link);
1682                         return r;
1683                 }
1684         }
1685
1686         return 0;
1687 }
1688
1689 static void link_update_operstate(Link *link) {
1690
1691         assert(link);
1692
1693         if (link->kernel_operstate == IF_OPER_DORMANT)
1694                 link->operstate = LINK_OPERSTATE_DORMANT;
1695         else if (link_has_carrier(link)) {
1696                 Address *address;
1697                 uint8_t scope = RT_SCOPE_NOWHERE;
1698
1699                 /* if we have carrier, check what addresses we have */
1700                 LIST_FOREACH(addresses, address, link->addresses) {
1701                         if (address->flags & (IFA_F_TENTATIVE | IFA_F_DEPRECATED))
1702                                 continue;
1703
1704                         if (address->scope < scope)
1705                                 scope = address->scope;
1706                 }
1707
1708                 if (scope < RT_SCOPE_SITE)
1709                         /* universally accessible addresses found */
1710                         link->operstate = LINK_OPERSTATE_ROUTABLE;
1711                 else if (scope < RT_SCOPE_HOST)
1712                         /* only link or site local addresses found */
1713                         link->operstate = LINK_OPERSTATE_DEGRADED;
1714                 else
1715                         /* no useful addresses found */
1716                         link->operstate = LINK_OPERSTATE_CARRIER;
1717         } else if (link->flags & IFF_UP)
1718                 link->operstate = LINK_OPERSTATE_NO_CARRIER;
1719         else
1720                 link->operstate = LINK_OPERSTATE_OFF;
1721 }
1722
1723 int link_save(Link *link) {
1724         _cleanup_free_ char *temp_path = NULL;
1725         _cleanup_fclose_ FILE *f = NULL;
1726         const char *admin_state, *oper_state;
1727         int r;
1728
1729         assert(link);
1730         assert(link->state_file);
1731         assert(link->lease_file);
1732         assert(link->manager);
1733
1734         link_update_operstate(link);
1735
1736         r = manager_save(link->manager);
1737         if (r < 0)
1738                 return r;
1739
1740         if (link->state == LINK_STATE_LINGER) {
1741                 unlink(link->state_file);
1742                 return 0;
1743         }
1744
1745         admin_state = link_state_to_string(link->state);
1746         assert(admin_state);
1747
1748         oper_state = link_operstate_to_string(link->operstate);
1749         assert(oper_state);
1750
1751         r = fopen_temporary(link->state_file, &f, &temp_path);
1752         if (r < 0)
1753                 return r;
1754
1755         fchmod(fileno(f), 0644);
1756
1757         fprintf(f,
1758                 "# This is private data. Do not parse.\n"
1759                 "ADMIN_STATE=%s\n"
1760                 "OPER_STATE=%s\n",
1761                 admin_state, oper_state);
1762
1763         if (link->network) {
1764                 char **address, **domain;
1765                 bool space;
1766
1767                 fprintf(f, "NETWORK_FILE=%s\n", link->network->filename);
1768
1769                 fputs("DNS=", f);
1770                 space = false;
1771                 STRV_FOREACH(address, link->network->dns) {
1772                         if (space)
1773                                 fputc(' ', f);
1774                         fputs(*address, f);
1775                         space = true;
1776                 }
1777
1778                 if (link->network->dhcp_dns &&
1779                     link->dhcp_lease) {
1780                         const struct in_addr *addresses;
1781
1782                         r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
1783                         if (r > 0) {
1784                                 if (space)
1785                                         fputc(' ', f);
1786                                 serialize_in_addrs(f, addresses, r);
1787                         }
1788                 }
1789
1790                 fputs("\n", f);
1791
1792                 fprintf(f, "NTP=");
1793                 space = false;
1794                 STRV_FOREACH(address, link->network->ntp) {
1795                         if (space)
1796                                 fputc(' ', f);
1797                         fputs(*address, f);
1798                         space = true;
1799                 }
1800
1801                 if (link->network->dhcp_ntp &&
1802                     link->dhcp_lease) {
1803                         const struct in_addr *addresses;
1804
1805                         r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
1806                         if (r > 0) {
1807                                 if (space)
1808                                         fputc(' ', f);
1809                                 serialize_in_addrs(f, addresses, r);
1810                         }
1811                 }
1812
1813                 fputs("\n", f);
1814
1815                 fprintf(f, "DOMAINS=");
1816                 space = false;
1817                 STRV_FOREACH(domain, link->network->domains) {
1818                         if (space)
1819                                 fputc(' ', f);
1820                         fputs(*domain, f);
1821                         space = true;
1822                 }
1823
1824                 if (link->network->dhcp_domains &&
1825                     link->dhcp_lease) {
1826                         const char *domainname;
1827
1828                         r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
1829                         if (r >= 0) {
1830                                 if (space)
1831                                         fputc(' ', f);
1832                                 fputs(domainname, f);
1833                         }
1834                 }
1835
1836                 fputs("\n", f);
1837
1838                 fprintf(f, "WILDCARD_DOMAIN=%s\n",
1839                         yes_no(link->network->wildcard_domain));
1840
1841                 fprintf(f, "LLMNR=%s\n",
1842                         llmnr_support_to_string(link->network->llmnr));
1843         }
1844
1845         if (link->dhcp_lease) {
1846                 assert(link->network);
1847
1848                 r = sd_dhcp_lease_save(link->dhcp_lease, link->lease_file);
1849                 if (r < 0)
1850                         goto fail;
1851
1852                 fprintf(f,
1853                         "DHCP_LEASE=%s\n",
1854                         link->lease_file);
1855         } else
1856                 unlink(link->lease_file);
1857
1858         r = fflush_and_check(f);
1859         if (r < 0)
1860                 goto fail;
1861
1862         if (rename(temp_path, link->state_file) < 0) {
1863                 r = -errno;
1864                 goto fail;
1865         }
1866
1867         return 0;
1868 fail:
1869         log_link_error(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
1870         unlink(link->state_file);
1871         unlink(temp_path);
1872         return r;
1873 }
1874
1875 static const char* const link_state_table[_LINK_STATE_MAX] = {
1876         [LINK_STATE_PENDING] = "pending",
1877         [LINK_STATE_ENSLAVING] = "configuring",
1878         [LINK_STATE_SETTING_ADDRESSES] = "configuring",
1879         [LINK_STATE_SETTING_ROUTES] = "configuring",
1880         [LINK_STATE_CONFIGURED] = "configured",
1881         [LINK_STATE_UNMANAGED] = "unmanaged",
1882         [LINK_STATE_FAILED] = "failed",
1883         [LINK_STATE_LINGER] = "linger",
1884 };
1885
1886 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
1887
1888 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
1889         [LINK_OPERSTATE_OFF] = "off",
1890         [LINK_OPERSTATE_NO_CARRIER] = "no-carrier",
1891         [LINK_OPERSTATE_DORMANT] = "dormant",
1892         [LINK_OPERSTATE_CARRIER] = "carrier",
1893         [LINK_OPERSTATE_DEGRADED] = "degraded",
1894         [LINK_OPERSTATE_ROUTABLE] = "routable",
1895 };
1896
1897 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);