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