src/network/networkd-link.c

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