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