src/network/networkd-link.c

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