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, valid_str);
1479                 else
1480                         log_debug_link(link, "updated address: %s/%u (valid for %s)",
1481                                        buf, address->prefixlen, valid_str);
1482
1483                 LIST_PREPEND(addresses, link->addresses, address);
1484                 address = NULL;
1485
1486                 link_save(link);
1487
1488                 break;
1489         case RTM_DELADDR:
1490                 if (address_dropped) {
1491                         log_debug_link(link, "removed address: %s/%u (valid for %s)",
1492                                        buf, address->prefixlen, valid_str);
1493
1494                         link_save(link);
1495                 } else
1496                         log_warning_link(link,
1497                                          "removing non-existent address: %s/%u (valid for %s)",
1498                                          buf, address->prefixlen, valid_str);
1499
1500                 break;
1501         default:
1502                 assert_not_reached("Received invalid RTNL message type");
1503         }
1504
1505         return 1;
1506 }
1507
1508 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
1509         Link *link;
1510         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1511         _cleanup_udev_device_unref_ struct udev_device *device = NULL;
1512         char ifindex_str[2 + DECIMAL_STR_MAX(int)];
1513         int r;
1514
1515         assert(m);
1516         assert(m->rtnl);
1517         assert(message);
1518         assert(ret);
1519
1520         r = link_new(m, message, ret);
1521         if (r < 0)
1522                 return r;
1523
1524         link = *ret;
1525
1526         log_debug_link(link, "link %d added", link->ifindex);
1527
1528         r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, link->ifindex,
1529                                      0);
1530         if (r < 0)
1531                 return r;
1532
1533         r = sd_rtnl_call_async(m->rtnl, req, link_get_address_handler, link, 0,
1534                                NULL);
1535         if (r < 0)
1536                 return r;
1537
1538         link_ref(link);
1539
1540         if (detect_container(NULL) <= 0) {
1541                 /* not in a container, udev will be around */
1542                 sprintf(ifindex_str, "n%d", link->ifindex);
1543                 device = udev_device_new_from_device_id(m->udev, ifindex_str);
1544                 if (!device) {
1545                         log_warning_link(link,
1546                                          "could not find udev device: %m");
1547                         return -errno;
1548                 }
1549
1550                 if (udev_device_get_is_initialized(device) <= 0) {
1551                         /* not yet ready */
1552                         log_debug_link(link, "link pending udev initialization...");
1553                         return 0;
1554                 }
1555
1556                 r = link_initialized(link, device);
1557                 if (r < 0)
1558                         return r;
1559         } else {
1560                 /* we are calling a callback directly, so must take a ref */
1561                 link_ref(link);
1562
1563                 r = link_initialized_and_synced(m->rtnl, NULL, link);
1564                 if (r < 0)
1565                         return r;
1566         }
1567
1568         return 0;
1569 }
1570
1571 int link_update(Link *link, sd_rtnl_message *m) {
1572         struct ether_addr mac;
1573         const char *ifname;
1574         uint32_t mtu;
1575         bool had_carrier, carrier_gained, carrier_lost;
1576         int r;
1577
1578         assert(link);
1579         assert(link->ifname);
1580         assert(m);
1581
1582         if (link->state == LINK_STATE_LINGER) {
1583                 link_ref(link);
1584                 log_info_link(link, "link readded");
1585                 link->state = LINK_STATE_ENSLAVING;
1586         }
1587
1588         r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
1589         if (r >= 0 && !streq(ifname, link->ifname)) {
1590                 log_info_link(link, "renamed to %s", ifname);
1591
1592                 free(link->ifname);
1593                 link->ifname = strdup(ifname);
1594                 if (!link->ifname)
1595                         return -ENOMEM;
1596         }
1597
1598         r = sd_rtnl_message_read_u32(m, IFLA_MTU, &mtu);
1599         if (r >= 0 && mtu > 0) {
1600                 link->mtu = mtu;
1601                 if (!link->original_mtu) {
1602                         link->original_mtu = mtu;
1603                         log_debug_link(link, "saved original MTU: %"
1604                                        PRIu32, link->original_mtu);
1605                 }
1606
1607                 if (link->dhcp_client) {
1608                         r = sd_dhcp_client_set_mtu(link->dhcp_client,
1609                                                    link->mtu);
1610                         if (r < 0) {
1611                                 log_warning_link(link,
1612                                                  "Could not update MTU in DHCP client: %s",
1613                                                  strerror(-r));
1614                                 return r;
1615                         }
1616                 }
1617         }
1618
1619         /* The kernel may broadcast NEWLINK messages without the MAC address
1620            set, simply ignore them. */
1621         r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
1622         if (r >= 0) {
1623                 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet,
1624                            ETH_ALEN)) {
1625
1626                         memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet,
1627                                ETH_ALEN);
1628
1629                         log_debug_link(link, "MAC address: "
1630                                        "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1631                                        mac.ether_addr_octet[0],
1632                                        mac.ether_addr_octet[1],
1633                                        mac.ether_addr_octet[2],
1634                                        mac.ether_addr_octet[3],
1635                                        mac.ether_addr_octet[4],
1636                                        mac.ether_addr_octet[5]);
1637
1638                         if (link->ipv4ll) {
1639                                 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1640                                 if (r < 0) {
1641                                         log_warning_link(link,
1642                                                          "Could not update MAC address in IPv4LL client: %s",
1643                                                          strerror(-r));
1644                                         return r;
1645                                 }
1646                         }
1647
1648                         if (link->dhcp_client) {
1649                                 r = sd_dhcp_client_set_mac(link->dhcp_client,
1650                                                            &link->mac);
1651                                 if (r < 0) {
1652                                         log_warning_link(link,
1653                                                          "Could not update MAC address in DHCP client: %s",
1654                                                          strerror(-r));
1655                                         return r;
1656                                 }
1657                         }
1658
1659                         if (link->dhcp6_client) {
1660                                 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
1661                                                             &link->mac);
1662                                 if (r < 0) {
1663                                         log_warning_link(link,
1664                                                          "Could not update MAC address in DHCPv6 client: %s",
1665                                                          strerror(-r));
1666                                         return r;
1667                                 }
1668                         }
1669                 }
1670         }
1671
1672         had_carrier = link_has_carrier(link);
1673
1674         r = link_update_flags(link, m);
1675         if (r < 0)
1676                 return r;
1677
1678         carrier_gained = !had_carrier && link_has_carrier(link);
1679         carrier_lost = had_carrier && !link_has_carrier(link);
1680
1681         if (carrier_gained) {
1682                 log_info_link(link, "gained carrier");
1683
1684                 if (link->network) {
1685                         r = link_acquire_conf(link);
1686                         if (r < 0) {
1687                                 link_enter_failed(link);
1688                                 return r;
1689                         }
1690                 }
1691         } else if (carrier_lost) {
1692                 log_info_link(link, "lost carrier");
1693
1694                 r = link_stop_clients(link);
1695                 if (r < 0) {
1696                         link_enter_failed(link);
1697                         return r;
1698                 }
1699         }
1700
1701         return 0;
1702 }
1703
1704 static void link_update_operstate(Link *link) {
1705
1706         assert(link);
1707
1708         if (link->kernel_operstate == IF_OPER_DORMANT)
1709                 link->operstate = LINK_OPERSTATE_DORMANT;
1710         else if (link_has_carrier(link)) {
1711                 Address *address;
1712                 uint8_t scope = RT_SCOPE_NOWHERE;
1713
1714                 /* if we have carrier, check what addresses we have */
1715                 LIST_FOREACH(addresses, address, link->addresses) {
1716                         if (address->flags & (IFA_F_TENTATIVE | IFA_F_DEPRECATED))
1717                                 continue;
1718
1719                         if (address->scope < scope)
1720                                 scope = address->scope;
1721                 }
1722
1723                 if (scope < RT_SCOPE_SITE)
1724                         /* universally accessible addresses found */
1725                         link->operstate = LINK_OPERSTATE_ROUTABLE;
1726                 else if (scope < RT_SCOPE_HOST)
1727                         /* only link or site local addresses found */
1728                         link->operstate = LINK_OPERSTATE_DEGRADED;
1729                 else
1730                         /* no useful addresses found */
1731                         link->operstate = LINK_OPERSTATE_CARRIER;
1732         } else if (link->flags & IFF_UP)
1733                 link->operstate = LINK_OPERSTATE_NO_CARRIER;
1734         else
1735                 link->operstate = LINK_OPERSTATE_OFF;
1736 }
1737
1738 int link_save(Link *link) {
1739         _cleanup_free_ char *temp_path = NULL;
1740         _cleanup_fclose_ FILE *f = NULL;
1741         const char *admin_state, *oper_state;
1742         int r;
1743
1744         assert(link);
1745         assert(link->state_file);
1746         assert(link->lease_file);
1747         assert(link->manager);
1748
1749         link_update_operstate(link);
1750
1751         r = manager_save(link->manager);
1752         if (r < 0)
1753                 return r;
1754
1755         if (link->state == LINK_STATE_LINGER) {
1756                 unlink(link->state_file);
1757                 return 0;
1758         }
1759
1760         admin_state = link_state_to_string(link->state);
1761         assert(admin_state);
1762
1763         oper_state = link_operstate_to_string(link->operstate);
1764         assert(oper_state);
1765
1766         r = fopen_temporary(link->state_file, &f, &temp_path);
1767         if (r < 0)
1768                 return r;
1769
1770         fchmod(fileno(f), 0644);
1771
1772         fprintf(f,
1773                 "# This is private data. Do not parse.\n"
1774                 "ADMIN_STATE=%s\n"
1775                 "OPER_STATE=%s\n",
1776                 admin_state, oper_state);
1777
1778         if (link->network) {
1779                 char **address, **domain;
1780                 bool space;
1781
1782                 fprintf(f, "NETWORK_FILE=%s\n", link->network->filename);
1783
1784                 fputs("DNS=", f);
1785                 space = false;
1786                 STRV_FOREACH(address, link->network->dns) {
1787                         if (space)
1788                                 fputc(' ', f);
1789                         fputs(*address, f);
1790                         space = true;
1791                 }
1792
1793                 if (link->network->dhcp_dns &&
1794                     link->dhcp_lease) {
1795                         const struct in_addr *addresses;
1796
1797                         r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
1798                         if (r > 0) {
1799                                 if (space)
1800                                         fputc(' ', f);
1801                                 serialize_in_addrs(f, addresses, r);
1802                         }
1803                 }
1804
1805                 fputs("\n", f);
1806
1807                 fprintf(f, "NTP=");
1808                 space = false;
1809                 STRV_FOREACH(address, link->network->ntp) {
1810                         if (space)
1811                                 fputc(' ', f);
1812                         fputs(*address, f);
1813                         space = true;
1814                 }
1815
1816                 if (link->network->dhcp_ntp &&
1817                     link->dhcp_lease) {
1818                         const struct in_addr *addresses;
1819
1820                         r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
1821                         if (r > 0) {
1822                                 if (space)
1823                                         fputc(' ', f);
1824                                 serialize_in_addrs(f, addresses, r);
1825                         }
1826                 }
1827
1828                 fputs("\n", f);
1829
1830                 fprintf(f, "DOMAINS=");
1831                 space = false;
1832                 STRV_FOREACH(domain, link->network->domains) {
1833                         if (space)
1834                                 fputc(' ', f);
1835                         fputs(*domain, f);
1836                         space = true;
1837                 }
1838
1839                 if (link->network->dhcp_domains &&
1840                     link->dhcp_lease) {
1841                         const char *domainname;
1842
1843                         r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
1844                         if (r >= 0) {
1845                                 if (space)
1846                                         fputc(' ', f);
1847                                 fputs(domainname, f);
1848                         }
1849                 }
1850
1851                 fputs("\n", f);
1852
1853                 fprintf(f, "WILDCARD_DOMAIN=%s\n",
1854                         yes_no(link->network->wildcard_domain));
1855
1856                 fprintf(f, "LLMNR=%s\n",
1857                         llmnr_support_to_string(link->network->llmnr));
1858         }
1859
1860         if (link->dhcp_lease) {
1861                 assert(link->network);
1862
1863                 r = dhcp_lease_save(link->dhcp_lease, link->lease_file);
1864                 if (r < 0)
1865                         goto fail;
1866
1867                 fprintf(f,
1868                         "DHCP_LEASE=%s\n",
1869                         link->lease_file);
1870         } else
1871                 unlink(link->lease_file);
1872
1873         r = fflush_and_check(f);
1874         if (r < 0)
1875                 goto fail;
1876
1877         if (rename(temp_path, link->state_file) < 0) {
1878                 r = -errno;
1879                 goto fail;
1880         }
1881
1882         return 0;
1883 fail:
1884         log_error_link(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
1885         unlink(link->state_file);
1886         unlink(temp_path);
1887         return r;
1888 }
1889
1890 static const char* const link_state_table[_LINK_STATE_MAX] = {
1891         [LINK_STATE_PENDING] = "pending",
1892         [LINK_STATE_ENSLAVING] = "configuring",
1893         [LINK_STATE_SETTING_ADDRESSES] = "configuring",
1894         [LINK_STATE_SETTING_ROUTES] = "configuring",
1895         [LINK_STATE_CONFIGURED] = "configured",
1896         [LINK_STATE_UNMANAGED] = "unmanaged",
1897         [LINK_STATE_FAILED] = "failed",
1898         [LINK_STATE_LINGER] = "linger",
1899 };
1900
1901 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
1902
1903 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
1904         [LINK_OPERSTATE_OFF] = "off",
1905         [LINK_OPERSTATE_NO_CARRIER] = "no-carrier",
1906         [LINK_OPERSTATE_DORMANT] = "dormant",
1907         [LINK_OPERSTATE_CARRIER] = "carrier",
1908         [LINK_OPERSTATE_DEGRADED] = "degraded",
1909         [LINK_OPERSTATE_ROUTABLE] = "routable",
1910 };
1911
1912 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);