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