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