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