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