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