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