src/network/networkd-link.c

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