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         bool b;
1241         int r;
1242
1243         b = link_ipv4_forward_enabled(link);
1244
1245         p = strappenda("/proc/sys/net/ipv4/conf/", link->ifname, "/forwarding");
1246         r = write_string_file_no_create(p, one_zero(b));
1247         if (r < 0)
1248                 log_link_warning_errno(link, r, "Cannot configure IPv4 forwarding for interface %s: %m", link->ifname);
1249
1250         if (b) {
1251                 _cleanup_free_ char *buf = NULL;
1252
1253                 /* If IP forwarding is turned on for this interface,
1254                  * then propagate this to the global setting. Given
1255                  * that turning this on has side-effects on other
1256                  * fields, we'll try to avoid doing this unless
1257                  * necessary, hence check the previous value
1258                  * first. Note that we never turn this option off
1259                  * again, since all interfaces we manage do not do
1260                  * forwarding anyway by default, and ownership rules
1261                  * of this control are so unclear. */
1262
1263                 r = read_one_line_file("/proc/sys/net/ipv4/ip_forward", &buf);
1264                 if (r < 0)
1265                         log_link_warning_errno(link, r, "Cannot read /proc/sys/net/ipv4/ip_forward: %m");
1266                 else if (!streq(buf, "1")) {
1267                         r = write_string_file_no_create("/proc/sys/net/ipv4/ip_forward", "1");
1268                         if (r < 0)
1269                                 log_link_warning_errno(link, r, "Cannot write /proc/sys/net/ipv4/ip_forward: %m");
1270                 }
1271         }
1272
1273         return 0;
1274 }
1275
1276 static int link_set_ipv6_forward(Link *link) {
1277         const char *p = NULL;
1278         int r;
1279
1280         p = strappenda("/proc/sys/net/ipv6/conf/", link->ifname, "/forwarding");
1281         r = write_string_file_no_create(p, one_zero(link_ipv6_forward_enabled(link)));
1282         if (r < 0)
1283                 log_link_warning_errno(link, r, "Cannot configure IPv6 forwarding for interface: %m");
1284
1285         return 0;
1286 }
1287
1288 static int link_configure(Link *link) {
1289         int r;
1290
1291         assert(link);
1292         assert(link->network);
1293         assert(link->state == LINK_STATE_PENDING);
1294
1295         r = link_set_bridge_fdb(link);
1296         if (r < 0)
1297                 return r;
1298
1299         r = link_set_ipv4_forward(link);
1300         if (r < 0)
1301                 return r;
1302
1303         r = link_set_ipv6_forward(link);
1304         if (r < 0)
1305                 return r;
1306
1307         if (link_ipv4ll_enabled(link)) {
1308                 r = ipv4ll_configure(link);
1309                 if (r < 0)
1310                         return r;
1311         }
1312
1313         if (link_dhcp4_enabled(link)) {
1314                 r = dhcp4_configure(link);
1315                 if (r < 0)
1316                         return r;
1317         }
1318
1319         if (link_dhcp4_server_enabled(link)) {
1320                 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
1321                 if (r < 0)
1322                         return r;
1323
1324                 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
1325                 if (r < 0)
1326                         return r;
1327         }
1328
1329         if (link_dhcp6_enabled(link)) {
1330                 r = icmp6_configure(link);
1331                 if (r < 0)
1332                         return r;
1333         }
1334
1335         if (link_lldp_enabled(link)) {
1336                 r = sd_lldp_new(link->ifindex, link->ifname, &link->mac, &link->lldp);
1337                 if (r < 0)
1338                         return r;
1339
1340                 r = sd_lldp_attach_event(link->lldp, NULL, 0);
1341                 if (r < 0)
1342                         return r;
1343
1344                 r = sd_lldp_set_callback(link->lldp,
1345                                          lldp_handler, link);
1346                 if (r < 0)
1347                         return r;
1348         }
1349
1350         if (link_has_carrier(link)) {
1351                 r = link_acquire_conf(link);
1352                 if (r < 0)
1353                         return r;
1354         }
1355
1356         return link_enter_join_netdev(link);
1357 }
1358
1359 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m,
1360                                        void *userdata) {
1361         _cleanup_link_unref_ Link *link = userdata;
1362         Network *network;
1363         int r;
1364
1365         assert(link);
1366         assert(link->ifname);
1367         assert(link->manager);
1368
1369         if (link->state != LINK_STATE_PENDING)
1370                 return 1;
1371
1372         log_link_debug(link, "link state is up-to-date");
1373
1374         r = network_get(link->manager, link->udev_device, link->ifname,
1375                         &link->mac, &network);
1376         if (r == -ENOENT) {
1377                 link_enter_unmanaged(link);
1378                 return 1;
1379         } else if (r < 0)
1380                 return r;
1381
1382         if (link->flags & IFF_LOOPBACK) {
1383                 if (network->ipv4ll)
1384                         log_link_debug(link, "ignoring IPv4LL for loopback link");
1385
1386                 if (network->dhcp != ADDRESS_FAMILY_NO)
1387                         log_link_debug(link, "ignoring DHCP clients for loopback link");
1388
1389                 if (network->dhcp_server)
1390                         log_link_debug(link, "ignoring DHCP server for loopback link");
1391         }
1392
1393         r = network_apply(link->manager, network, link);
1394         if (r < 0)
1395                 return r;
1396
1397         r = link_configure(link);
1398         if (r < 0)
1399                 return r;
1400
1401         return 1;
1402 }
1403
1404 int link_initialized(Link *link, struct udev_device *device) {
1405         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1406         int r;
1407
1408         assert(link);
1409         assert(link->manager);
1410         assert(link->manager->rtnl);
1411         assert(device);
1412
1413         if (link->state != LINK_STATE_PENDING)
1414                 return 0;
1415
1416         if (link->udev_device)
1417                 return 0;
1418
1419         log_link_debug(link, "udev initialized link");
1420
1421         link->udev_device = udev_device_ref(device);
1422
1423         /* udev has initialized the link, but we don't know if we have yet
1424          * processed the NEWLINK messages with the latest state. Do a GETLINK,
1425          * when it returns we know that the pending NEWLINKs have already been
1426          * processed and that we are up-to-date */
1427
1428         r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK,
1429                                      link->ifindex);
1430         if (r < 0)
1431                 return r;
1432
1433         r = sd_rtnl_call_async(link->manager->rtnl, req,
1434                                link_initialized_and_synced, link, 0, NULL);
1435         if (r < 0)
1436                 return r;
1437
1438         link_ref(link);
1439
1440         return 0;
1441 }
1442
1443 static Address* link_get_equal_address(Link *link, Address *needle) {
1444         Address *i;
1445
1446         assert(link);
1447         assert(needle);
1448
1449         LIST_FOREACH(addresses, i, link->addresses)
1450                 if (address_equal(i, needle))
1451                         return i;
1452
1453         return NULL;
1454 }
1455
1456 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
1457         Manager *m = userdata;
1458         Link *link = NULL;
1459         uint16_t type;
1460         _cleanup_address_free_ Address *address = NULL;
1461         Address *existing;
1462         char buf[INET6_ADDRSTRLEN], valid_buf[FORMAT_TIMESPAN_MAX];
1463         const char *valid_str = NULL;
1464         int r, ifindex;
1465
1466         assert(rtnl);
1467         assert(message);
1468         assert(m);
1469
1470         if (sd_rtnl_message_is_error(message)) {
1471                 r = sd_rtnl_message_get_errno(message);
1472                 if (r < 0)
1473                         log_warning_errno(r, "rtnl: failed to receive address: %m");
1474
1475                 return 0;
1476         }
1477
1478         r = sd_rtnl_message_get_type(message, &type);
1479         if (r < 0) {
1480                 log_warning("rtnl: could not get message type");
1481                 return 0;
1482         }
1483
1484         r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
1485         if (r < 0) {
1486                 log_warning_errno(r, "rtnl: could not get ifindex: %m");
1487                 return 0;
1488         } else if (ifindex <= 0) {
1489                 log_warning("rtnl: received address message with invalid ifindex: %d", ifindex);
1490                 return 0;
1491         } else {
1492                 r = link_get(m, ifindex, &link);
1493                 if (r < 0 || !link) {
1494                         log_warning("rtnl: received address for nonexistent link (%d), ignoring", ifindex);
1495                         return 0;
1496                 }
1497         }
1498
1499         r = address_new_dynamic(&address);
1500         if (r < 0)
1501                 return r;
1502
1503         r = sd_rtnl_message_addr_get_family(message, &address->family);
1504         if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
1505                 log_link_warning(link, "rtnl: received address with invalid family, ignoring");
1506                 return 0;
1507         }
1508
1509         r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
1510         if (r < 0) {
1511                 log_link_warning(link, "rtnl: received address with invalid prefixlen, ignoring");
1512                 return 0;
1513         }
1514
1515         r = sd_rtnl_message_addr_get_scope(message, &address->scope);
1516         if (r < 0) {
1517                 log_link_warning(link, "rtnl: received address with invalid scope, ignoring");
1518                 return 0;
1519         }
1520
1521         r = sd_rtnl_message_addr_get_flags(message, &address->flags);
1522         if (r < 0) {
1523                 log_link_warning(link, "rtnl: received address with invalid flags, ignoring");
1524                 return 0;
1525         }
1526
1527         switch (address->family) {
1528         case AF_INET:
1529                 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
1530                 if (r < 0) {
1531                         log_link_warning(link, "rtnl: received address without valid address, ignoring");
1532                         return 0;
1533                 }
1534
1535                 break;
1536
1537         case AF_INET6:
1538                 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
1539                 if (r < 0) {
1540                         log_link_warning(link, "rtnl: received address without valid address, ignoring");
1541                         return 0;
1542                 }
1543
1544                 break;
1545
1546         default:
1547                 assert_not_reached("invalid address family");
1548         }
1549
1550         if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
1551                 log_link_warning(link, "could not print address");
1552                 return 0;
1553         }
1554
1555         r = sd_rtnl_message_read_cache_info(message, IFA_CACHEINFO, &address->cinfo);
1556         if (r >= 0) {
1557                 if (address->cinfo.ifa_valid == CACHE_INFO_INFINITY_LIFE_TIME)
1558                         valid_str = "ever";
1559                 else
1560                         valid_str = format_timespan(valid_buf, FORMAT_TIMESPAN_MAX,
1561                                                     address->cinfo.ifa_valid * USEC_PER_SEC,
1562                                                     USEC_PER_SEC);
1563         }
1564
1565         existing = link_get_equal_address(link, address);
1566
1567         switch (type) {
1568         case RTM_NEWADDR:
1569                 if (existing) {
1570                         log_link_debug(link, "Updating address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1571
1572
1573                         existing->scope = address->scope;
1574                         existing->flags = address->flags;
1575                         existing->cinfo = address->cinfo;
1576
1577                 } else {
1578                         log_link_debug(link, "Adding address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1579
1580                         LIST_PREPEND(addresses, link->addresses, address);
1581                         address_establish(address, link);
1582
1583                         address = NULL;
1584
1585                         link_save(link);
1586                 }
1587
1588                 break;
1589
1590         case RTM_DELADDR:
1591
1592                 if (existing) {
1593                         log_link_debug(link, "Removing address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1594                         address_release(existing, link);
1595                         LIST_REMOVE(addresses, link->addresses, existing);
1596                         address_free(existing);
1597                 } else
1598                         log_link_warning(link, "Removing non-existent address: %s/%u (valid for %s)", buf, address->prefixlen, valid_str);
1599
1600                 break;
1601         default:
1602                 assert_not_reached("Received invalid RTNL message type");
1603         }
1604
1605         return 1;
1606 }
1607
1608 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
1609         Link *link;
1610         _cleanup_udev_device_unref_ struct udev_device *device = NULL;
1611         char ifindex_str[2 + DECIMAL_STR_MAX(int)];
1612         int r;
1613
1614         assert(m);
1615         assert(m->rtnl);
1616         assert(message);
1617         assert(ret);
1618
1619         r = link_new(m, message, ret);
1620         if (r < 0)
1621                 return r;
1622
1623         link = *ret;
1624
1625         log_link_debug(link, "link %d added", link->ifindex);
1626
1627         if (detect_container(NULL) <= 0) {
1628                 /* not in a container, udev will be around */
1629                 sprintf(ifindex_str, "n%d", link->ifindex);
1630                 device = udev_device_new_from_device_id(m->udev, ifindex_str);
1631                 if (!device) {
1632                         log_link_warning(link,
1633                                          "could not find udev device: %m");
1634                         return -errno;
1635                 }
1636
1637                 if (udev_device_get_is_initialized(device) <= 0) {
1638                         /* not yet ready */
1639                         log_link_debug(link, "link pending udev initialization...");
1640                         return 0;
1641                 }
1642
1643                 r = link_initialized(link, device);
1644                 if (r < 0)
1645                         return r;
1646         } else {
1647                 /* we are calling a callback directly, so must take a ref */
1648                 link_ref(link);
1649
1650                 r = link_initialized_and_synced(m->rtnl, NULL, link);
1651                 if (r < 0)
1652                         return r;
1653         }
1654
1655         return 0;
1656 }
1657
1658 int link_update(Link *link, sd_rtnl_message *m) {
1659         struct ether_addr mac;
1660         const char *ifname;
1661         uint32_t mtu;
1662         bool had_carrier, carrier_gained, carrier_lost;
1663         int r;
1664
1665         assert(link);
1666         assert(link->ifname);
1667         assert(m);
1668
1669         if (link->state == LINK_STATE_LINGER) {
1670                 link_ref(link);
1671                 log_link_info(link, "link readded");
1672                 link->state = LINK_STATE_ENSLAVING;
1673         }
1674
1675         r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
1676         if (r >= 0 && !streq(ifname, link->ifname)) {
1677                 log_link_info(link, "renamed to %s", ifname);
1678
1679                 free(link->ifname);
1680                 link->ifname = strdup(ifname);
1681                 if (!link->ifname)
1682                         return -ENOMEM;
1683         }
1684
1685         r = sd_rtnl_message_read_u32(m, IFLA_MTU, &mtu);
1686         if (r >= 0 && mtu > 0) {
1687                 link->mtu = mtu;
1688                 if (!link->original_mtu) {
1689                         link->original_mtu = mtu;
1690                         log_link_debug(link, "saved original MTU: %"
1691                                        PRIu32, link->original_mtu);
1692                 }
1693
1694                 if (link->dhcp_client) {
1695                         r = sd_dhcp_client_set_mtu(link->dhcp_client,
1696                                                    link->mtu);
1697                         if (r < 0) {
1698                                 log_link_warning(link,
1699                                                  "Could not update MTU in DHCP client: %s",
1700                                                  strerror(-r));
1701                                 return r;
1702                         }
1703                 }
1704         }
1705
1706         /* The kernel may broadcast NEWLINK messages without the MAC address
1707            set, simply ignore them. */
1708         r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
1709         if (r >= 0) {
1710                 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet,
1711                            ETH_ALEN)) {
1712
1713                         memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet,
1714                                ETH_ALEN);
1715
1716                         log_link_debug(link, "MAC address: "
1717                                        "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1718                                        mac.ether_addr_octet[0],
1719                                        mac.ether_addr_octet[1],
1720                                        mac.ether_addr_octet[2],
1721                                        mac.ether_addr_octet[3],
1722                                        mac.ether_addr_octet[4],
1723                                        mac.ether_addr_octet[5]);
1724
1725                         if (link->ipv4ll) {
1726                                 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1727                                 if (r < 0) {
1728                                         log_link_warning(link,
1729                                                          "Could not update MAC address in IPv4LL client: %s",
1730                                                          strerror(-r));
1731                                         return r;
1732                                 }
1733                         }
1734
1735                         if (link->dhcp_client) {
1736                                 r = sd_dhcp_client_set_mac(link->dhcp_client,
1737                                                            (const uint8_t *) &link->mac,
1738                                                            sizeof (link->mac),
1739                                                            ARPHRD_ETHER);
1740                                 if (r < 0) {
1741                                         log_link_warning(link,
1742                                                          "Could not update MAC address in DHCP client: %s",
1743                                                          strerror(-r));
1744                                         return r;
1745                                 }
1746                         }
1747
1748                         if (link->dhcp6_client) {
1749                                 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
1750                                                             (const uint8_t *) &link->mac,
1751                                                             sizeof (link->mac),
1752                                                             ARPHRD_ETHER);
1753                                 if (r < 0) {
1754                                         log_link_warning(link,
1755                                                          "Could not update MAC address in DHCPv6 client: %s",
1756                                                          strerror(-r));
1757                                         return r;
1758                                 }
1759                         }
1760                 }
1761         }
1762
1763         had_carrier = link_has_carrier(link);
1764
1765         r = link_update_flags(link, m);
1766         if (r < 0)
1767                 return r;
1768
1769         carrier_gained = !had_carrier && link_has_carrier(link);
1770         carrier_lost = had_carrier && !link_has_carrier(link);
1771
1772         if (carrier_gained) {
1773                 log_link_info(link, "gained carrier");
1774
1775                 if (link->network) {
1776                         r = link_acquire_conf(link);
1777                         if (r < 0) {
1778                                 link_enter_failed(link);
1779                                 return r;
1780                         }
1781                 }
1782         } else if (carrier_lost) {
1783                 log_link_info(link, "lost carrier");
1784
1785                 r = link_stop_clients(link);
1786                 if (r < 0) {
1787                         link_enter_failed(link);
1788                         return r;
1789                 }
1790         }
1791
1792         return 0;
1793 }
1794
1795 static void link_update_operstate(Link *link) {
1796
1797         assert(link);
1798
1799         if (link->kernel_operstate == IF_OPER_DORMANT)
1800                 link->operstate = LINK_OPERSTATE_DORMANT;
1801         else if (link_has_carrier(link)) {
1802                 Address *address;
1803                 uint8_t scope = RT_SCOPE_NOWHERE;
1804
1805                 /* if we have carrier, check what addresses we have */
1806                 LIST_FOREACH(addresses, address, link->addresses) {
1807                         if (address->flags & (IFA_F_TENTATIVE | IFA_F_DEPRECATED))
1808                                 continue;
1809
1810                         if (address->scope < scope)
1811                                 scope = address->scope;
1812                 }
1813
1814                 if (scope < RT_SCOPE_SITE)
1815                         /* universally accessible addresses found */
1816                         link->operstate = LINK_OPERSTATE_ROUTABLE;
1817                 else if (scope < RT_SCOPE_HOST)
1818                         /* only link or site local addresses found */
1819                         link->operstate = LINK_OPERSTATE_DEGRADED;
1820                 else
1821                         /* no useful addresses found */
1822                         link->operstate = LINK_OPERSTATE_CARRIER;
1823         } else if (link->flags & IFF_UP)
1824                 link->operstate = LINK_OPERSTATE_NO_CARRIER;
1825         else
1826                 link->operstate = LINK_OPERSTATE_OFF;
1827 }
1828
1829 int link_save(Link *link) {
1830         _cleanup_free_ char *temp_path = NULL;
1831         _cleanup_fclose_ FILE *f = NULL;
1832         const char *admin_state, *oper_state;
1833         int r;
1834
1835         assert(link);
1836         assert(link->state_file);
1837         assert(link->lease_file);
1838         assert(link->manager);
1839
1840         link_update_operstate(link);
1841
1842         r = manager_save(link->manager);
1843         if (r < 0)
1844                 return r;
1845
1846         if (link->state == LINK_STATE_LINGER) {
1847                 unlink(link->state_file);
1848                 return 0;
1849         }
1850
1851         admin_state = link_state_to_string(link->state);
1852         assert(admin_state);
1853
1854         oper_state = link_operstate_to_string(link->operstate);
1855         assert(oper_state);
1856
1857         r = fopen_temporary(link->state_file, &f, &temp_path);
1858         if (r < 0)
1859                 return r;
1860
1861         fchmod(fileno(f), 0644);
1862
1863         fprintf(f,
1864                 "# This is private data. Do not parse.\n"
1865                 "ADMIN_STATE=%s\n"
1866                 "OPER_STATE=%s\n",
1867                 admin_state, oper_state);
1868
1869         if (link->network) {
1870                 char **address, **domain;
1871                 bool space;
1872
1873                 fprintf(f, "NETWORK_FILE=%s\n", link->network->filename);
1874
1875                 fputs("DNS=", f);
1876                 space = false;
1877                 STRV_FOREACH(address, link->network->dns) {
1878                         if (space)
1879                                 fputc(' ', f);
1880                         fputs(*address, f);
1881                         space = true;
1882                 }
1883
1884                 if (link->network->dhcp_dns &&
1885                     link->dhcp_lease) {
1886                         const struct in_addr *addresses;
1887
1888                         r = sd_dhcp_lease_get_dns(link->dhcp_lease, &addresses);
1889                         if (r > 0) {
1890                                 if (space)
1891                                         fputc(' ', f);
1892                                 serialize_in_addrs(f, addresses, r);
1893                         }
1894                 }
1895
1896                 fputs("\n", f);
1897
1898                 fprintf(f, "NTP=");
1899                 space = false;
1900                 STRV_FOREACH(address, link->network->ntp) {
1901                         if (space)
1902                                 fputc(' ', f);
1903                         fputs(*address, f);
1904                         space = true;
1905                 }
1906
1907                 if (link->network->dhcp_ntp &&
1908                     link->dhcp_lease) {
1909                         const struct in_addr *addresses;
1910
1911                         r = sd_dhcp_lease_get_ntp(link->dhcp_lease, &addresses);
1912                         if (r > 0) {
1913                                 if (space)
1914                                         fputc(' ', f);
1915                                 serialize_in_addrs(f, addresses, r);
1916                         }
1917                 }
1918
1919                 fputs("\n", f);
1920
1921                 fprintf(f, "DOMAINS=");
1922                 space = false;
1923                 STRV_FOREACH(domain, link->network->domains) {
1924                         if (space)
1925                                 fputc(' ', f);
1926                         fputs(*domain, f);
1927                         space = true;
1928                 }
1929
1930                 if (link->network->dhcp_domains &&
1931                     link->dhcp_lease) {
1932                         const char *domainname;
1933
1934                         r = sd_dhcp_lease_get_domainname(link->dhcp_lease, &domainname);
1935                         if (r >= 0) {
1936                                 if (space)
1937                                         fputc(' ', f);
1938                                 fputs(domainname, f);
1939                         }
1940                 }
1941
1942                 fputs("\n", f);
1943
1944                 fprintf(f, "WILDCARD_DOMAIN=%s\n",
1945                         yes_no(link->network->wildcard_domain));
1946
1947                 fprintf(f, "LLMNR=%s\n",
1948                         llmnr_support_to_string(link->network->llmnr));
1949         }
1950
1951         if (link->dhcp_lease) {
1952                 assert(link->network);
1953
1954                 r = sd_dhcp_lease_save(link->dhcp_lease, link->lease_file);
1955                 if (r < 0)
1956                         goto fail;
1957
1958                 fprintf(f,
1959                         "DHCP_LEASE=%s\n",
1960                         link->lease_file);
1961         } else
1962                 unlink(link->lease_file);
1963
1964         if (link->lldp) {
1965                 assert(link->network);
1966
1967                 r = sd_lldp_save(link->lldp, link->lldp_file);
1968                 if (r < 0)
1969                         goto fail;
1970
1971                 fprintf(f,
1972                         "LLDP_FILE=%s\n",
1973                         link->lldp_file);
1974         } else
1975                 unlink(link->lldp_file);
1976
1977         r = fflush_and_check(f);
1978         if (r < 0)
1979                 goto fail;
1980
1981         if (rename(temp_path, link->state_file) < 0) {
1982                 r = -errno;
1983                 goto fail;
1984         }
1985
1986         return 0;
1987 fail:
1988         log_link_error(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
1989         unlink(link->state_file);
1990         unlink(temp_path);
1991         return r;
1992 }
1993
1994 static const char* const link_state_table[_LINK_STATE_MAX] = {
1995         [LINK_STATE_PENDING] = "pending",
1996         [LINK_STATE_ENSLAVING] = "configuring",
1997         [LINK_STATE_SETTING_ADDRESSES] = "configuring",
1998         [LINK_STATE_SETTING_ROUTES] = "configuring",
1999         [LINK_STATE_CONFIGURED] = "configured",
2000         [LINK_STATE_UNMANAGED] = "unmanaged",
2001         [LINK_STATE_FAILED] = "failed",
2002         [LINK_STATE_LINGER] = "linger",
2003 };
2004
2005 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
2006
2007 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
2008         [LINK_OPERSTATE_OFF] = "off",
2009         [LINK_OPERSTATE_NO_CARRIER] = "no-carrier",
2010         [LINK_OPERSTATE_DORMANT] = "dormant",
2011         [LINK_OPERSTATE_CARRIER] = "carrier",
2012         [LINK_OPERSTATE_DEGRADED] = "degraded",
2013         [LINK_OPERSTATE_ROUTABLE] = "routable",
2014 };
2015
2016 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);