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
  25 #include "networkd.h"
  26 #include "libudev-private.h"
  27 #include "udev-util.h"
  28 #include "util.h"
  29 #include "virt.h"
  30 #include "bus-util.h"
  31 #include "network-internal.h"
  32
  33 #include "network-util.h"
  34 #include "dhcp-lease-internal.h"
  35
  36 static int ipv4ll_address_update(Link *link, bool deprecate);
  37 static bool ipv4ll_is_bound(sd_ipv4ll *ll);
  38
  39 static int link_new(Manager *manager, sd_rtnl_message *message, Link **ret) {
  40         _cleanup_link_unref_ Link *link = NULL;
  41         uint16_t type;
  42         char *ifname;
  43         int r, ifindex;
  44
  45         assert(manager);
  46         assert(manager->links);
  47         assert(message);
  48         assert(ret);
  49
  50         r = sd_rtnl_message_get_type(message, &type);
  51         if (r < 0)
  52                 return r;
  53         else if (type != RTM_NEWLINK)
  54                 return -EINVAL;
  55
  56         r = sd_rtnl_message_link_get_ifindex(message, &ifindex);
  57         if (r < 0)
  58                 return r;
  59         else if (ifindex <= 0)
  60                 return -EINVAL;
  61
  62         r = sd_rtnl_message_read_string(message, IFLA_IFNAME, &ifname);
  63         if (r < 0)
  64                 return r;
  65
  66         link = new0(Link, 1);
  67         if (!link)
  68                 return -ENOMEM;
  69
  70         link->n_ref = 1;
  71         link->manager = manager;
  72         link->state = LINK_STATE_INITIALIZING;
  73         link->ifindex = ifindex;
  74         link->ifname = strdup(ifname);
  75         if (!link->ifname)
  76                 return -ENOMEM;
  77
  78         r = sd_rtnl_message_read_ether_addr(message, IFLA_ADDRESS, &link->mac);
  79         if (r < 0)
  80                 return r;
  81
  82         r = asprintf(&link->state_file, "/run/systemd/netif/links/%"PRIu64,
  83                      link->ifindex);
  84         if (r < 0)
  85                 return -ENOMEM;
  86
  87         r = asprintf(&link->lease_file, "/run/systemd/netif/leases/%"PRIu64,
  88                      link->ifindex);
  89         if (r < 0)
  90                 return -ENOMEM;
  91
  92         r = hashmap_put(manager->links, &link->ifindex, link);
  93         if (r < 0)
  94                 return r;
  95
  96         *ret = link;
  97         link = NULL;
  98
  99         return 0;
 100 }
 101
 102 static void link_free(Link *link) {
 103         Address *address;
 104
 105         if (!link)
 106                 return;
 107
 108         assert(link->manager);
 109
 110         while ((address = link->addresses)) {
 111                 LIST_REMOVE(addresses, link->addresses, address);
 112                 address_free(address);
 113         }
 114
 115         while ((address = link->pool_addresses)) {
 116                 LIST_REMOVE(addresses, link->pool_addresses, address);
 117                 address_free(address);
 118         }
 119
 120         sd_dhcp_client_unref(link->dhcp_client);
 121         sd_dhcp_lease_unref(link->dhcp_lease);
 122
 123         unlink(link->lease_file);
 124         free(link->lease_file);
 125
 126         sd_ipv4ll_unref(link->ipv4ll);
 127         sd_dhcp6_client_unref(link->dhcp6_client);
 128         sd_icmp6_nd_unref(link->icmp6_router_discovery);
 129
 130         hashmap_remove(link->manager->links, &link->ifindex);
 131
 132         free(link->ifname);
 133
 134         unlink(link->state_file);
 135         free(link->state_file);
 136
 137         udev_device_unref(link->udev_device);
 138
 139         free(link);
 140 }
 141
 142 Link *link_unref(Link *link) {
 143         if (link && (-- link->n_ref <= 0))
 144                 link_free(link);
 145
 146         return NULL;
 147 }
 148
 149 Link *link_ref(Link *link) {
 150         if (link)
 151                 assert_se(++ link->n_ref >= 2);
 152
 153         return link;
 154 }
 155
 156 int link_get(Manager *m, int ifindex, Link **ret) {
 157         Link *link;
 158         uint64_t ifindex_64;
 159
 160         assert(m);
 161         assert(m->links);
 162         assert(ifindex);
 163         assert(ret);
 164
 165         ifindex_64 = ifindex;
 166         link = hashmap_get(m->links, &ifindex_64);
 167         if (!link)
 168                 return -ENODEV;
 169
 170         *ret = link;
 171
 172         return 0;
 173 }
 174
 175 void link_drop(Link *link) {
 176         if (!link || link->state == LINK_STATE_LINGER)
 177                 return;
 178
 179         link->state = LINK_STATE_LINGER;
 180
 181         log_debug_link(link, "link removed");
 182
 183         link_unref(link);
 184
 185         return;
 186 }
 187
 188 static void link_enter_unmanaged(Link *link) {
 189         assert(link);
 190
 191         log_debug_link(link, "unmanaged");
 192
 193         link->state = LINK_STATE_UNMANAGED;
 194
 195         link_save(link);
 196 }
 197
 198 static int link_stop_clients(Link *link) {
 199         int r = 0, k;
 200
 201         assert(link);
 202         assert(link->manager);
 203         assert(link->manager->event);
 204
 205         if (!link->network)
 206                 return 0;
 207
 208         if (link->network->dhcp) {
 209                 assert(link->dhcp_client);
 210
 211                 k = sd_dhcp_client_stop(link->dhcp_client);
 212                 if (k < 0) {
 213                         log_warning_link(link, "Could not stop DHCPv4 client: %s", strerror(-r));
 214                         r = k;
 215                 }
 216         }
 217
 218         if (link->network->ipv4ll) {
 219                 assert(link->ipv4ll);
 220
 221                 k = sd_ipv4ll_stop(link->ipv4ll);
 222                 if (k < 0) {
 223                         log_warning_link(link, "Could not stop IPv4 link-local: %s", strerror(-r));
 224                         r = k;
 225                 }
 226         }
 227
 228         if (link->network->dhcp_server) {
 229                 assert(link->dhcp_server);
 230
 231                 k = sd_dhcp_server_stop(link->dhcp_server);
 232                 if (k < 0) {
 233                         log_warning_link(link, "Could not stop DHCPv4 server: %s", strerror(-r));
 234                         r = k;
 235                 }
 236         }
 237
 238         if (link->network->dhcp6) {
 239                 assert(link->icmp6_router_discovery);
 240
 241                 if (link->dhcp6_client) {
 242                         k = sd_dhcp6_client_stop(link->dhcp6_client);
 243                         if (k < 0) {
 244                                 log_warning_link(link, "Could not stop DHCPv6 client: %s", strerror(-r));
 245                                 r = k;
 246                         }
 247                 }
 248
 249                 k = sd_icmp6_nd_stop(link->icmp6_router_discovery);
 250                 if (k < 0) {
 251                         log_warning_link(link, "Could not stop ICMPv6 router discovery: %s", strerror(-r));
 252                         r = k;
 253                 }
 254         }
 255
 256         return r;
 257 }
 258
 259 static void link_enter_failed(Link *link) {
 260         assert(link);
 261
 262         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 263                 return;
 264
 265         log_warning_link(link, "failed");
 266
 267         link->state = LINK_STATE_FAILED;
 268
 269         link_stop_clients(link);
 270
 271         link_save(link);
 272 }
 273
 274 static Address* link_find_dhcp_server_address(Link *link) {
 275         Address *address;
 276
 277         assert(link);
 278         assert(link->network);
 279
 280         /* The the first statically configured address if there is any */
 281         LIST_FOREACH(addresses, address, link->network->static_addresses) {
 282
 283                 if (address->family != AF_INET)
 284                         continue;
 285
 286                 if (in_addr_null(address->family, &address->in_addr))
 287                         continue;
 288
 289                 return address;
 290         }
 291
 292         /* If that didn't work, find a suitable address we got from the pool */
 293         LIST_FOREACH(addresses, address, link->pool_addresses) {
 294                 if (address->family != AF_INET)
 295                         continue;
 296
 297                 return address;
 298         }
 299
 300         return NULL;
 301 }
 302
 303 static int link_enter_configured(Link *link) {
 304         int r;
 305
 306         assert(link);
 307         assert(link->network);
 308         assert(link->state == LINK_STATE_SETTING_ROUTES);
 309
 310         if (link->network->dhcp_server &&
 311             !sd_dhcp_server_is_running(link->dhcp_server)) {
 312                 struct in_addr pool_start;
 313                 Address *address;
 314
 315                 address = link_find_dhcp_server_address(link);
 316                 if (!address) {
 317                         log_warning_link(link, "Failed to find suitable address for DHCPv4 server instance.");
 318                         link_enter_failed(link);
 319                         return 0;
 320                 }
 321
 322                 log_debug_link(link, "offering DHCPv4 leases");
 323
 324                 r = sd_dhcp_server_set_address(link->dhcp_server, &address->in_addr.in);
 325                 if (r < 0)
 326                         return r;
 327
 328                 /* offer 32 addresses starting from the address following the server address */
 329                 pool_start.s_addr = htobe32(be32toh(address->in_addr.in.s_addr) + 1);
 330                 r = sd_dhcp_server_set_lease_pool(link->dhcp_server,
 331                                                   &pool_start, 32);
 332                 if (r < 0)
 333                         return r;
 334
 335                 /* TODO:
 336                 r = sd_dhcp_server_set_router(link->dhcp_server,
 337                                               &main_address->in_addr.in);
 338                 if (r < 0)
 339                         return r;
 340
 341                 r = sd_dhcp_server_set_prefixlen(link->dhcp_server,
 342                                                  main_address->prefixlen);
 343                 if (r < 0)
 344                         return r;
 345                 */
 346
 347                 r = sd_dhcp_server_start(link->dhcp_server);
 348                 if (r < 0) {
 349                         log_warning_link(link, "could not start DHCPv4 server "
 350                                          "instance: %s", strerror(-r));
 351
 352                         link_enter_failed(link);
 353
 354                         return 0;
 355                 }
 356         }
 357
 358         log_info_link(link, "link configured");
 359
 360         link->state = LINK_STATE_CONFIGURED;
 361
 362         link_save(link);
 363
 364         return 0;
 365 }
 366
 367 static int route_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
 368         Link *link = userdata;
 369         int r;
 370
 371         assert(link->route_messages > 0);
 372         assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
 373                       LINK_STATE_SETTING_ROUTES, LINK_STATE_FAILED,
 374                       LINK_STATE_LINGER));
 375
 376         link->route_messages --;
 377
 378         if (IN_SET(LINK_STATE_FAILED, LINK_STATE_LINGER)) {
 379                 link_unref(link);
 380                 return 1;
 381         }
 382
 383         r = sd_rtnl_message_get_errno(m);
 384         if (r < 0 && r != -EEXIST)
 385                 log_struct_link(LOG_WARNING, link,
 386                                 "MESSAGE=%-*s: could not set route: %s",
 387                                 IFNAMSIZ,
 388                                 link->ifname, strerror(-r),
 389                                 "ERRNO=%d", -r,
 390                                 NULL);
 391
 392         /* we might have received an old reply after moving back to SETTING_ADDRESSES,
 393          * ignore it */
 394         if (link->route_messages == 0 && link->state == LINK_STATE_SETTING_ROUTES) {
 395                 log_debug_link(link, "routes set");
 396                 link_enter_configured(link);
 397         }
 398
 399         link_unref(link);
 400
 401         return 1;
 402 }
 403
 404 static int link_enter_set_routes(Link *link) {
 405         Route *rt;
 406         int r;
 407
 408         assert(link);
 409         assert(link->network);
 410         assert(link->state == LINK_STATE_SETTING_ADDRESSES);
 411
 412         link->state = LINK_STATE_SETTING_ROUTES;
 413
 414         if (!link->network->static_routes && !link->dhcp_lease &&
 415             (!link->ipv4ll || ipv4ll_is_bound(link->ipv4ll) == false))
 416                 return link_enter_configured(link);
 417
 418         log_debug_link(link, "setting routes");
 419
 420         LIST_FOREACH(routes, rt, link->network->static_routes) {
 421                 r = route_configure(rt, link, &route_handler);
 422                 if (r < 0) {
 423                         log_warning_link(link,
 424                                          "could not set routes: %s", strerror(-r));
 425                         link_enter_failed(link);
 426                         return r;
 427                 }
 428
 429                 link_ref(link);
 430                 link->route_messages ++;
 431         }
 432
 433         if (link->ipv4ll && !link->dhcp_lease) {
 434                 _cleanup_route_free_ Route *route = NULL;
 435                 struct in_addr addr;
 436
 437                 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
 438                 if (r < 0 && r != -ENOENT) {
 439                         log_warning_link(link, "IPV4LL error: no address: %s",
 440                                         strerror(-r));
 441                         return r;
 442                 }
 443
 444                 if (r != -ENOENT) {
 445                         r = route_new_dynamic(&route);
 446                         if (r < 0) {
 447                                 log_error_link(link, "Could not allocate route: %s",
 448                                                strerror(-r));
 449                                 return r;
 450                         }
 451
 452                         route->family = AF_INET;
 453                         route->scope = RT_SCOPE_LINK;
 454                         route->metrics = 99;
 455
 456                         r = route_configure(route, link, &route_handler);
 457                         if (r < 0) {
 458                                 log_warning_link(link,
 459                                                  "could not set routes: %s", strerror(-r));
 460                                 link_enter_failed(link);
 461                                 return r;
 462                         }
 463
 464                         link_ref(link);
 465                         link->route_messages ++;
 466                 }
 467         }
 468
 469         if (link->dhcp_lease) {
 470                 _cleanup_route_free_ Route *route = NULL;
 471                 _cleanup_route_free_ Route *route_gw = NULL;
 472                 struct in_addr gateway;
 473
 474                 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
 475                 if (r < 0 && r != -ENOENT) {
 476                         log_warning_link(link, "DHCP error: %s", strerror(-r));
 477                         return r;
 478                 }
 479
 480                 if (r >= 0) {
 481                         r = route_new_dynamic(&route);
 482                         if (r < 0) {
 483                                 log_error_link(link, "Could not allocate route: %s",
 484                                                strerror(-r));
 485                                 return r;
 486                         }
 487
 488                         r = route_new_dynamic(&route_gw);
 489                         if (r < 0) {
 490                                 log_error_link(link, "Could not allocate route: %s",
 491                                                strerror(-r));
 492                                 return r;
 493                         }
 494
 495                         /* The dhcp netmask may mask out the gateway. Add an explicit
 496                          * route for the gw host so that we can route no matter the
 497                          * netmask or existing kernel route tables. */
 498                         route_gw->family = AF_INET;
 499                         route_gw->dst_addr.in = gateway;
 500                         route_gw->dst_prefixlen = 32;
 501                         route_gw->scope = RT_SCOPE_LINK;
 502
 503                         r = route_configure(route_gw, link, &route_handler);
 504                         if (r < 0) {
 505                                 log_warning_link(link,
 506                                                  "could not set host route: %s", strerror(-r));
 507                                 return r;
 508                         }
 509
 510                         link_ref(link);
 511                         link->route_messages ++;
 512
 513                         route->family = AF_INET;
 514                         route->in_addr.in = gateway;
 515
 516                         r = route_configure(route, link, &route_handler);
 517                         if (r < 0) {
 518                                 log_warning_link(link,
 519                                                  "could not set routes: %s", strerror(-r));
 520                                 link_enter_failed(link);
 521                                 return r;
 522                         }
 523
 524                         link_ref(link);
 525                         link->route_messages ++;
 526                 }
 527         }
 528
 529         if (link->route_messages == 0) {
 530                 link_enter_configured(link);
 531         }
 532
 533         return 0;
 534 }
 535
 536 static int route_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
 537         Link *link = userdata;
 538         int r;
 539
 540         assert(m);
 541         assert(link);
 542         assert(link->ifname);
 543
 544         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
 545                 link_unref(link);
 546                 return 1;
 547         }
 548
 549         r = sd_rtnl_message_get_errno(m);
 550         if (r < 0 && r != -ESRCH)
 551                 log_struct_link(LOG_WARNING, link,
 552                                 "MESSAGE=%-*s: could not drop route: %s",
 553                                 IFNAMSIZ,
 554                                 link->ifname, strerror(-r),
 555                                 "ERRNO=%d", -r,
 556                                 NULL);
 557
 558         link_unref(link);
 559
 560         return 0;
 561 }
 562
 563 static int address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
 564         Link *link = userdata;
 565         int r;
 566
 567         assert(m);
 568         assert(link);
 569         assert(link->ifname);
 570         assert(link->addr_messages > 0);
 571         assert(IN_SET(link->state, LINK_STATE_SETTING_ADDRESSES,
 572                LINK_STATE_FAILED, LINK_STATE_LINGER));
 573
 574         link->addr_messages --;
 575
 576         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
 577                 link_unref(link);
 578                 return 1;
 579         }
 580
 581         r = sd_rtnl_message_get_errno(m);
 582         if (r < 0 && r != -EEXIST)
 583                 log_struct_link(LOG_WARNING, link,
 584                                 "MESSAGE=%-*s: could not set address: %s",
 585                                 IFNAMSIZ,
 586                                 link->ifname, strerror(-r),
 587                                 "ERRNO=%d", -r,
 588                                 NULL);
 589
 590         if (link->addr_messages == 0) {
 591                 log_debug_link(link, "addresses set");
 592                 link_enter_set_routes(link);
 593         }
 594
 595         link_unref(link);
 596
 597         return 1;
 598 }
 599
 600 static int link_enter_set_addresses(Link *link) {
 601         Address *ad;
 602         int r;
 603
 604         assert(link);
 605         assert(link->network);
 606         assert(link->state != _LINK_STATE_INVALID);
 607
 608         link->state = LINK_STATE_SETTING_ADDRESSES;
 609
 610         if (!link->network->static_addresses && !link->dhcp_lease &&
 611                 (!link->ipv4ll || ipv4ll_is_bound(link->ipv4ll) == false))
 612                 return link_enter_set_routes(link);
 613
 614         log_debug_link(link, "setting addresses");
 615
 616         LIST_FOREACH(addresses, ad, link->network->static_addresses) {
 617                 r = address_configure(ad, link, &address_handler);
 618                 if (r < 0) {
 619                         log_warning_link(link,
 620                                          "could not set addresses: %s", strerror(-r));
 621                         link_enter_failed(link);
 622                         return r;
 623                 }
 624
 625                 link_ref(link);
 626                 link->addr_messages ++;
 627         }
 628
 629         if (link->ipv4ll && !link->dhcp_lease) {
 630                 _cleanup_address_free_ Address *ll_addr = NULL;
 631                 struct in_addr addr;
 632
 633                 r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
 634                 if (r < 0 && r != -ENOENT) {
 635                         log_warning_link(link, "IPV4LL error: no address: %s",
 636                                         strerror(-r));
 637                         return r;
 638                 }
 639
 640                 if (r != -ENOENT) {
 641                         r = address_new_dynamic(&ll_addr);
 642                         if (r < 0) {
 643                                 log_error_link(link, "Could not allocate address: %s", strerror(-r));
 644                                 return r;
 645                         }
 646
 647                         ll_addr->family = AF_INET;
 648                         ll_addr->in_addr.in = addr;
 649                         ll_addr->prefixlen = 16;
 650                         ll_addr->broadcast.s_addr = ll_addr->in_addr.in.s_addr | htonl(0xfffffffflu >> ll_addr->prefixlen);
 651                         ll_addr->scope = RT_SCOPE_LINK;
 652
 653                         r = address_configure(ll_addr, link, &address_handler);
 654                         if (r < 0) {
 655                                 log_warning_link(link,
 656                                          "could not set addresses: %s", strerror(-r));
 657                                 link_enter_failed(link);
 658                                 return r;
 659                         }
 660
 661                         link_ref(link);
 662                         link->addr_messages ++;
 663                 }
 664         }
 665
 666         if (link->dhcp_lease) {
 667                 _cleanup_address_free_ Address *address = NULL;
 668                 struct in_addr addr;
 669                 struct in_addr netmask;
 670                 unsigned prefixlen;
 671
 672                 r = sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
 673                 if (r < 0) {
 674                         log_warning_link(link, "DHCP error: no address: %s",
 675                                          strerror(-r));
 676                         return r;
 677                 }
 678
 679                 r = sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
 680                 if (r < 0) {
 681                         log_warning_link(link, "DHCP error: no netmask: %s",
 682                                          strerror(-r));
 683                         return r;
 684                 }
 685
 686                 prefixlen = net_netmask_to_prefixlen(&netmask);
 687
 688                 r = address_new_dynamic(&address);
 689                 if (r < 0) {
 690                         log_error_link(link, "Could not allocate address: %s",
 691                                        strerror(-r));
 692                         return r;
 693                 }
 694
 695                 address->family = AF_INET;
 696                 address->in_addr.in = addr;
 697                 address->prefixlen = prefixlen;
 698                 address->broadcast.s_addr = addr.s_addr | ~netmask.s_addr;
 699
 700                 r = address_configure(address, link, &address_handler);
 701                 if (r < 0) {
 702                         log_warning_link(link,
 703                                          "could not set addresses: %s", strerror(-r));
 704                         link_enter_failed(link);
 705                         return r;
 706                 }
 707
 708                 link_ref(link);
 709                 link->addr_messages ++;
 710         }
 711
 712         return 0;
 713 }
 714
 715 static int address_update_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
 716         Link *link = userdata;
 717         int r;
 718
 719         assert(m);
 720         assert(link);
 721         assert(link->ifname);
 722
 723         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
 724                 link_unref(link);
 725                 return 1;
 726         }
 727
 728         r = sd_rtnl_message_get_errno(m);
 729         if (r < 0 && r != -ENOENT)
 730                 log_struct_link(LOG_WARNING, link,
 731                                 "MESSAGE=%-*s: could not update address: %s",
 732                                 IFNAMSIZ,
 733                                 link->ifname, strerror(-r),
 734                                 "ERRNO=%d", -r,
 735                                 NULL);
 736
 737         link_unref(link);
 738
 739         return 0;
 740 }
 741
 742 static int address_drop_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
 743         Link *link = userdata;
 744         int r;
 745
 746         assert(m);
 747         assert(link);
 748         assert(link->ifname);
 749
 750         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
 751                 link_unref(link);
 752                 return 1;
 753         }
 754
 755         r = sd_rtnl_message_get_errno(m);
 756         if (r < 0 && r != -EADDRNOTAVAIL)
 757                 log_struct_link(LOG_WARNING, link,
 758                                 "MESSAGE=%-*s: could not drop address: %s",
 759                                 IFNAMSIZ,
 760                                 link->ifname, strerror(-r),
 761                                 "ERRNO=%d", -r,
 762                                 NULL);
 763
 764         link_unref(link);
 765
 766         return 0;
 767 }
 768
 769 static int set_hostname_handler(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
 770         Link *link = userdata;
 771         int r;
 772
 773         assert(link);
 774
 775         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
 776                 link_unref(link);
 777                 return 1;
 778         }
 779
 780         r = sd_bus_message_get_errno(m);
 781         if (r < 0)
 782                 log_warning_link(link, "Could not set hostname: %s", strerror(-r));
 783
 784         link_unref(link);
 785
 786         return 1;
 787 }
 788
 789 static int link_set_hostname(Link *link, const char *hostname) {
 790         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
 791         int r = 0;
 792
 793         assert(link);
 794         assert(link->manager);
 795         assert(hostname);
 796
 797         log_debug_link(link, "Setting transient hostname: '%s'", hostname);
 798
 799         if (!link->manager->bus) { /* TODO: replace by assert when we can rely on kdbus */
 800                 log_info_link(link, "Not connected to system bus, ignoring transient hostname.");
 801                 return 0;
 802         }
 803
 804         r = sd_bus_message_new_method_call(
 805                         link->manager->bus,
 806                         &m,
 807                         "org.freedesktop.hostname1",
 808                         "/org/freedesktop/hostname1",
 809                         "org.freedesktop.hostname1",
 810                         "SetHostname");
 811         if (r < 0)
 812                 return r;
 813
 814         r = sd_bus_message_append(m, "sb", hostname, false);
 815         if (r < 0)
 816                 return r;
 817
 818         r = sd_bus_call_async(link->manager->bus, NULL, m, set_hostname_handler, link, 0);
 819         if (r < 0)
 820                 log_error_link(link, "Could not set transient hostname: %s", strerror(-r));
 821
 822         link_ref(link);
 823
 824         return r;
 825 }
 826
 827 static int set_mtu_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
 828         Link *link = userdata;
 829         int r;
 830
 831         assert(m);
 832         assert(link);
 833         assert(link->ifname);
 834
 835         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
 836                 link_unref(link);
 837                 return 1;
 838         }
 839
 840         r = sd_rtnl_message_get_errno(m);
 841         if (r < 0)
 842                 log_struct_link(LOG_WARNING, link,
 843                                 "MESSAGE=%-*s: could not set MTU: %s",
 844                                 IFNAMSIZ, link->ifname, strerror(-r),
 845                                 "ERRNO=%d", -r,
 846                                 NULL);
 847
 848         link_unref(link);
 849
 850         return 1;
 851 }
 852
 853 static int link_set_mtu(Link *link, uint32_t mtu) {
 854         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
 855         int r;
 856
 857         assert(link);
 858         assert(link->manager);
 859         assert(link->manager->rtnl);
 860
 861         log_debug_link(link, "setting MTU: %" PRIu32, mtu);
 862
 863         r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
 864                                      RTM_SETLINK, link->ifindex);
 865         if (r < 0) {
 866                 log_error_link(link, "Could not allocate RTM_SETLINK message");
 867                 return r;
 868         }
 869
 870         r = sd_rtnl_message_append_u32(req, IFLA_MTU, mtu);
 871         if (r < 0) {
 872                 log_error_link(link, "Could not append MTU: %s", strerror(-r));
 873                 return r;
 874         }
 875
 876         r = sd_rtnl_call_async(link->manager->rtnl, req, set_mtu_handler, link, 0, NULL);
 877         if (r < 0) {
 878                 log_error_link(link,
 879                                "Could not send rtnetlink message: %s", strerror(-r));
 880                 return r;
 881         }
 882
 883         link_ref(link);
 884
 885         return 0;
 886 }
 887
 888 static int dhcp_lease_lost(Link *link) {
 889         _cleanup_address_free_ Address *address = NULL;
 890         _cleanup_route_free_ Route *route_gw = NULL;
 891         _cleanup_route_free_ Route *route = NULL;
 892         struct in_addr addr;
 893         struct in_addr netmask;
 894         struct in_addr gateway;
 895         unsigned prefixlen;
 896         int r;
 897
 898         assert(link);
 899         assert(link->dhcp_lease);
 900
 901         log_warning_link(link, "DHCP lease lost");
 902
 903         r = address_new_dynamic(&address);
 904         if (r >= 0) {
 905                 r = sd_dhcp_lease_get_router(link->dhcp_lease, &gateway);
 906                 if (r >= 0) {
 907                         r = route_new_dynamic(&route_gw);
 908                         if (r >= 0) {
 909                                 route_gw->family = AF_INET;
 910                                 route_gw->dst_addr.in = gateway;
 911                                 route_gw->dst_prefixlen = 32;
 912                                 route_gw->scope = RT_SCOPE_LINK;
 913
 914                                 route_drop(route_gw, link, &route_drop_handler);
 915                                 link_ref(link);
 916                         }
 917
 918                         r = route_new_dynamic(&route);
 919                         if (r >= 0) {
 920                                 route->family = AF_INET;
 921                                 route->in_addr.in = gateway;
 922
 923                                 route_drop(route, link, &route_drop_handler);
 924                                 link_ref(link);
 925                         }
 926                 }
 927
 928                 sd_dhcp_lease_get_address(link->dhcp_lease, &addr);
 929                 sd_dhcp_lease_get_netmask(link->dhcp_lease, &netmask);
 930                 prefixlen = net_netmask_to_prefixlen(&netmask);
 931
 932                 address->family = AF_INET;
 933                 address->in_addr.in = addr;
 934                 address->prefixlen = prefixlen;
 935
 936                 address_drop(address, link, &address_drop_handler);
 937                 link_ref(link);
 938         }
 939
 940         if (link->network->dhcp_mtu) {
 941                 uint16_t mtu;
 942
 943                 r = sd_dhcp_lease_get_mtu(link->dhcp_lease, &mtu);
 944                 if (r >= 0 && link->original_mtu != mtu) {
 945                         r = link_set_mtu(link, link->original_mtu);
 946                         if (r < 0) {
 947                                 log_warning_link(link, "DHCP error: could not reset MTU");
 948                                 link_enter_failed(link);
 949                                 return r;
 950                         }
 951                 }
 952         }
 953
 954         if (link->network->dhcp_hostname) {
 955                 const char *hostname = NULL;
 956
 957                 r = sd_dhcp_lease_get_hostname(link->dhcp_lease, &hostname);
 958                 if (r >= 0 && hostname) {
 959                         r = link_set_hostname(link, "");
 960                         if (r < 0)
 961                                 log_error_link(link, "Failed to reset transient hostname");
 962                 }
 963         }
 964
 965         link->dhcp_lease = sd_dhcp_lease_unref(link->dhcp_lease);
 966
 967         return 0;
 968 }
 969
 970 static int dhcp_lease_acquired(sd_dhcp_client *client, Link *link) {
 971         sd_dhcp_lease *lease;
 972         struct in_addr address;
 973         struct in_addr netmask;
 974         struct in_addr gateway;
 975         unsigned prefixlen;
 976         int r;
 977
 978         assert(client);
 979         assert(link);
 980
 981         r = sd_dhcp_client_get_lease(client, &lease);
 982         if (r < 0) {
 983                 log_warning_link(link, "DHCP error: no lease: %s",
 984                                  strerror(-r));
 985                 return r;
 986         }
 987
 988         r = sd_dhcp_lease_get_address(lease, &address);
 989         if (r < 0) {
 990                 log_warning_link(link, "DHCP error: no address: %s",
 991                                  strerror(-r));
 992                 return r;
 993         }
 994
 995         r = sd_dhcp_lease_get_netmask(lease, &netmask);
 996         if (r < 0) {
 997                 log_warning_link(link, "DHCP error: no netmask: %s",
 998                                  strerror(-r));
 999                 return r;
1000         }
1001
1002         prefixlen = net_netmask_to_prefixlen(&netmask);
1003
1004         r = sd_dhcp_lease_get_router(lease, &gateway);
1005         if (r < 0 && r != -ENOENT) {
1006                 log_warning_link(link, "DHCP error: %s", strerror(-r));
1007                 return r;
1008         }
1009
1010         if (r >= 0)
1011                 log_struct_link(LOG_INFO, link,
1012                                 "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u via %u.%u.%u.%u",
1013                                  IFNAMSIZ,
1014                                  link->ifname,
1015                                  ADDRESS_FMT_VAL(address),
1016                                  prefixlen,
1017                                  ADDRESS_FMT_VAL(gateway),
1018                                  "ADDRESS=%u.%u.%u.%u",
1019                                  ADDRESS_FMT_VAL(address),
1020                                  "PREFIXLEN=%u",
1021                                  prefixlen,
1022                                  "GATEWAY=%u.%u.%u.%u",
1023                                  ADDRESS_FMT_VAL(gateway),
1024                                  NULL);
1025         else
1026                 log_struct_link(LOG_INFO, link,
1027                                 "MESSAGE=%-*s: DHCPv4 address %u.%u.%u.%u/%u",
1028                                  IFNAMSIZ,
1029                                  link->ifname,
1030                                  ADDRESS_FMT_VAL(address),
1031                                  prefixlen,
1032                                  "ADDRESS=%u.%u.%u.%u",
1033                                  ADDRESS_FMT_VAL(address),
1034                                  "PREFIXLEN=%u",
1035                                  prefixlen,
1036                                  NULL);
1037
1038         link->dhcp_lease = lease;
1039
1040         if (link->network->dhcp_mtu) {
1041                 uint16_t mtu;
1042
1043                 r = sd_dhcp_lease_get_mtu(lease, &mtu);
1044                 if (r >= 0) {
1045                         r = link_set_mtu(link, mtu);
1046                         if (r < 0)
1047                                 log_error_link(link, "Failed to set MTU "
1048                                                "to %" PRIu16, mtu);
1049                 }
1050         }
1051
1052         if (link->network->dhcp_hostname) {
1053                 const char *hostname;
1054
1055                 r = sd_dhcp_lease_get_hostname(lease, &hostname);
1056                 if (r >= 0) {
1057                         r = link_set_hostname(link, hostname);
1058                         if (r < 0)
1059                                 log_error_link(link, "Failed to set transient hostname "
1060                                           "to '%s'", hostname);
1061                 }
1062         }
1063
1064         link_enter_set_addresses(link);
1065
1066         return 0;
1067 }
1068
1069 static void dhcp_handler(sd_dhcp_client *client, int event, void *userdata) {
1070         Link *link = userdata;
1071         int r = 0;
1072
1073         assert(link);
1074         assert(link->network);
1075         assert(link->manager);
1076
1077         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1078                 return;
1079
1080         switch (event) {
1081                 case DHCP_EVENT_NO_LEASE:
1082                         log_debug_link(link, "IP address in use.");
1083                         break;
1084                 case DHCP_EVENT_EXPIRED:
1085                 case DHCP_EVENT_STOP:
1086                 case DHCP_EVENT_IP_CHANGE:
1087                         if (link->network->dhcp_critical) {
1088                                 log_error_link(link, "DHCPv4 connection considered system critical, "
1089                                                "ignoring request to reconfigure it.");
1090                                 return;
1091                         }
1092
1093                         if (link->dhcp_lease) {
1094                                 r = dhcp_lease_lost(link);
1095                                 if (r < 0) {
1096                                         link_enter_failed(link);
1097                                         return;
1098                                 }
1099                         }
1100
1101                         if (event == DHCP_EVENT_IP_CHANGE) {
1102                                 r = dhcp_lease_acquired(client, link);
1103                                 if (r < 0) {
1104                                         link_enter_failed(link);
1105                                         return;
1106                                 }
1107                         }
1108
1109                         if (event == DHCP_EVENT_EXPIRED && link->network->ipv4ll) {
1110                                 if (!sd_ipv4ll_is_running(link->ipv4ll))
1111                                         r = sd_ipv4ll_start(link->ipv4ll);
1112                                 else if (ipv4ll_is_bound(link->ipv4ll))
1113                                         r = ipv4ll_address_update(link, false);
1114                                 if (r < 0) {
1115                                         link_enter_failed(link);
1116                                         return;
1117                                 }
1118                         }
1119
1120                         break;
1121                 case DHCP_EVENT_IP_ACQUIRE:
1122                         r = dhcp_lease_acquired(client, link);
1123                         if (r < 0) {
1124                                 link_enter_failed(link);
1125                                 return;
1126                         }
1127                         if (link->ipv4ll) {
1128                                 if (ipv4ll_is_bound(link->ipv4ll))
1129                                         r = ipv4ll_address_update(link, true);
1130                                 else
1131                                         r = sd_ipv4ll_stop(link->ipv4ll);
1132                                 if (r < 0) {
1133                                         link_enter_failed(link);
1134                                         return;
1135                                 }
1136                         }
1137                         break;
1138                 default:
1139                         if (event < 0)
1140                                 log_warning_link(link, "DHCP error: %s", strerror(-event));
1141                         else
1142                                 log_warning_link(link, "DHCP unknown event: %d", event);
1143                         break;
1144         }
1145
1146         return;
1147 }
1148
1149 static int ipv4ll_address_update(Link *link, bool deprecate) {
1150         int r;
1151         struct in_addr addr;
1152
1153         assert(link);
1154
1155         r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1156         if (r >= 0) {
1157                 _cleanup_address_free_ Address *address = NULL;
1158
1159                 log_debug_link(link, "IPv4 link-local %s %u.%u.%u.%u",
1160                                deprecate ? "deprecate" : "approve",
1161                                ADDRESS_FMT_VAL(addr));
1162
1163                 r = address_new_dynamic(&address);
1164                 if (r < 0) {
1165                         log_error_link(link, "Could not allocate address: %s", strerror(-r));
1166                         return r;
1167                 }
1168
1169                 address->family = AF_INET;
1170                 address->in_addr.in = addr;
1171                 address->prefixlen = 16;
1172                 address->scope = RT_SCOPE_LINK;
1173                 address->cinfo.ifa_prefered = deprecate ? 0 : CACHE_INFO_INFINITY_LIFE_TIME;
1174                 address->broadcast.s_addr = address->in_addr.in.s_addr | htonl(0xfffffffflu >> address->prefixlen);
1175
1176                 address_update(address, link, &address_update_handler);
1177                 link_ref(link);
1178         }
1179
1180         return 0;
1181
1182 }
1183
1184 static int ipv4ll_address_lost(Link *link) {
1185         int r;
1186         struct in_addr addr;
1187
1188         assert(link);
1189
1190         r = sd_ipv4ll_get_address(link->ipv4ll, &addr);
1191         if (r >= 0) {
1192                 _cleanup_address_free_ Address *address = NULL;
1193                 _cleanup_route_free_ Route *route = NULL;
1194
1195                 log_debug_link(link, "IPv4 link-local release %u.%u.%u.%u",
1196                                 ADDRESS_FMT_VAL(addr));
1197
1198                 r = address_new_dynamic(&address);
1199                 if (r < 0) {
1200                         log_error_link(link, "Could not allocate address: %s", strerror(-r));
1201                         return r;
1202                 }
1203
1204                 address->family = AF_INET;
1205                 address->in_addr.in = addr;
1206                 address->prefixlen = 16;
1207                 address->scope = RT_SCOPE_LINK;
1208
1209                 address_drop(address, link, &address_drop_handler);
1210                 link_ref(link);
1211
1212                 r = route_new_dynamic(&route);
1213                 if (r < 0) {
1214                         log_error_link(link, "Could not allocate route: %s",
1215                                        strerror(-r));
1216                         return r;
1217                 }
1218
1219                 route->family = AF_INET;
1220                 route->scope = RT_SCOPE_LINK;
1221                 route->metrics = 99;
1222
1223                 route_drop(route, link, &route_drop_handler);
1224                 link_ref(link);
1225         }
1226
1227         return 0;
1228 }
1229
1230 static bool ipv4ll_is_bound(sd_ipv4ll *ll) {
1231         int r;
1232         struct in_addr addr;
1233
1234         assert(ll);
1235
1236         r = sd_ipv4ll_get_address(ll, &addr);
1237         if (r < 0)
1238                 return false;
1239         return true;
1240 }
1241
1242 static int ipv4ll_address_claimed(sd_ipv4ll *ll, Link *link) {
1243         struct in_addr address;
1244         int r;
1245
1246         assert(ll);
1247         assert(link);
1248
1249         r = sd_ipv4ll_get_address(ll, &address);
1250         if (r < 0)
1251                 return r;
1252
1253         log_struct_link(LOG_INFO, link,
1254                         "MESSAGE=%-*s: IPv4 link-local address %u.%u.%u.%u",
1255                         IFNAMSIZ,
1256                         link->ifname,
1257                         ADDRESS_FMT_VAL(address),
1258                         NULL);
1259
1260        link_enter_set_addresses(link);
1261
1262        return 0;
1263 }
1264
1265 static void ipv4ll_handler(sd_ipv4ll *ll, int event, void *userdata){
1266         Link *link = userdata;
1267         int r;
1268
1269         assert(link);
1270         assert(link->network);
1271         assert(link->manager);
1272
1273         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1274                 return;
1275
1276         switch(event) {
1277                 case IPV4LL_EVENT_STOP:
1278                 case IPV4LL_EVENT_CONFLICT:
1279                         r = ipv4ll_address_lost(link);
1280                         if (r < 0) {
1281                                 link_enter_failed(link);
1282                                 return;
1283                         }
1284                         break;
1285                 case IPV4LL_EVENT_BIND:
1286                         r = ipv4ll_address_claimed(ll, link);
1287                         if (r < 0) {
1288                                 link_enter_failed(link);
1289                                 return;
1290                         }
1291                         break;
1292                 default:
1293                         if (event < 0)
1294                                 log_warning_link(link, "IPv4 link-local error: %s", strerror(-event));
1295                         else
1296                                 log_warning_link(link, "IPv4 link-local unknown event: %d", event);
1297                         break;
1298         }
1299 }
1300
1301 static void dhcp6_handler(sd_dhcp6_client *client, int event, void *userdata) {
1302         Link *link = userdata;
1303
1304         assert(link);
1305         assert(link->network);
1306         assert(link->manager);
1307
1308         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1309                 return;
1310
1311         switch(event) {
1312         case DHCP6_EVENT_STOP:
1313         case DHCP6_EVENT_RESEND_EXPIRE:
1314         case DHCP6_EVENT_RETRANS_MAX:
1315         case DHCP6_EVENT_IP_ACQUIRE:
1316                 log_debug_link(link, "DHCPv6 event %d", event);
1317
1318                 break;
1319
1320         default:
1321                 if (event < 0)
1322                         log_warning_link(link, "DHCPv6 error: %s",
1323                                          strerror(-event));
1324                 else
1325                         log_warning_link(link, "DHCPv6 unknown event: %d",
1326                                          event);
1327                 return;
1328         }
1329 }
1330
1331 static void icmp6_router_handler(sd_icmp6_nd *nd, int event, void *userdata) {
1332         Link *link = userdata;
1333         int r;
1334
1335         assert(link);
1336         assert(link->network);
1337         assert(link->manager);
1338
1339         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
1340                 return;
1341
1342         switch(event) {
1343         case ICMP6_EVENT_ROUTER_ADVERTISMENT_NONE:
1344         case ICMP6_EVENT_ROUTER_ADVERTISMENT_OTHER:
1345                 return;
1346
1347         case ICMP6_EVENT_ROUTER_ADVERTISMENT_TIMEOUT:
1348         case ICMP6_EVENT_ROUTER_ADVERTISMENT_MANAGED:
1349                 break;
1350
1351         default:
1352                 if (event < 0)
1353                         log_warning_link(link, "ICMPv6 error: %s",
1354                                          strerror(-event));
1355                 else
1356                         log_warning_link(link, "ICMPv6 unknown event: %d",
1357                                          event);
1358
1359                 return;
1360         }
1361
1362         if (link->dhcp6_client)
1363                 return;
1364
1365         r = sd_dhcp6_client_new(&link->dhcp6_client);
1366         if (r < 0)
1367                 return;
1368
1369         r = sd_dhcp6_client_attach_event(link->dhcp6_client, NULL, 0);
1370         if (r < 0) {
1371                 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1372                 return;
1373         }
1374
1375         r = sd_dhcp6_client_set_mac(link->dhcp6_client, &link->mac);
1376         if (r < 0) {
1377                 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1378                 return;
1379         }
1380
1381         r = sd_dhcp6_client_set_index(link->dhcp6_client, link->ifindex);
1382         if (r < 0) {
1383                 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1384                 return;
1385         }
1386
1387         r = sd_dhcp6_client_set_callback(link->dhcp6_client, dhcp6_handler,
1388                                          link);
1389         if (r < 0) {
1390                 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1391                 return;
1392         }
1393
1394         r = sd_dhcp6_client_start(link->dhcp6_client);
1395         if (r < 0)
1396                 link->dhcp6_client = sd_dhcp6_client_unref(link->dhcp6_client);
1397 }
1398
1399 static int link_acquire_conf(Link *link) {
1400         int r;
1401
1402         assert(link);
1403         assert(link->network);
1404         assert(link->manager);
1405         assert(link->manager->event);
1406
1407         if (link->network->ipv4ll) {
1408                 assert(link->ipv4ll);
1409
1410                 log_debug_link(link, "acquiring IPv4 link-local address");
1411
1412                 r = sd_ipv4ll_start(link->ipv4ll);
1413                 if (r < 0) {
1414                         log_warning_link(link, "could not acquire IPv4 "
1415                                          "link-local address");
1416                         return r;
1417                 }
1418         }
1419
1420         if (link->network->dhcp) {
1421                 assert(link->dhcp_client);
1422
1423                 log_debug_link(link, "acquiring DHCPv4 lease");
1424
1425                 r = sd_dhcp_client_start(link->dhcp_client);
1426                 if (r < 0) {
1427                         log_warning_link(link, "could not acquire DHCPv4 "
1428                                          "lease");
1429                         return r;
1430                 }
1431         }
1432
1433         if (link->network->dhcp6) {
1434                 assert(link->icmp6_router_discovery);
1435
1436                 log_debug_link(link, "discovering IPv6 routers");
1437
1438                 r = sd_icmp6_router_solicitation_start(link->icmp6_router_discovery);
1439                 if (r < 0) {
1440                         log_warning_link(link, "could not start IPv6 router discovery");
1441                         return r;
1442                 }
1443         }
1444
1445         return 0;
1446 }
1447
1448 bool link_has_carrier(unsigned flags, uint8_t operstate) {
1449         /* see Documentation/networking/operstates.txt in the kernel sources */
1450
1451         if (operstate == IF_OPER_UP)
1452                 return true;
1453
1454         if (operstate == IF_OPER_UNKNOWN)
1455                 /* operstate may not be implemented, so fall back to flags */
1456                 if ((flags & IFF_LOWER_UP) && !(flags & IFF_DORMANT))
1457                         return true;
1458
1459         return false;
1460 }
1461
1462 #define FLAG_STRING(string, flag, old, new) \
1463         (((old ^ new) & flag) \
1464                 ? ((old & flag) ? (" -" string) : (" +" string)) \
1465                 : "")
1466
1467 static int link_update_flags(Link *link, sd_rtnl_message *m) {
1468         unsigned flags, unknown_flags_added, unknown_flags_removed, unknown_flags;
1469         uint8_t operstate;
1470         bool carrier_gained = false, carrier_lost = false;
1471         int r;
1472
1473         assert(link);
1474
1475         r = sd_rtnl_message_link_get_flags(m, &flags);
1476         if (r < 0) {
1477                 log_warning_link(link, "Could not get link flags");
1478                 return r;
1479         }
1480
1481         r = sd_rtnl_message_read_u8(m, IFLA_OPERSTATE, &operstate);
1482         if (r < 0)
1483                 /* if we got a message without operstate, take it to mean
1484                    the state was unchanged */
1485                 operstate = link->kernel_operstate;
1486
1487         if ((link->flags == flags) && (link->kernel_operstate == operstate))
1488                 return 0;
1489
1490         if (link->flags != flags) {
1491                 log_debug_link(link, "flags change:%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
1492                                FLAG_STRING("LOOPBACK", IFF_LOOPBACK, link->flags, flags),
1493                                FLAG_STRING("MASTER", IFF_MASTER, link->flags, flags),
1494                                FLAG_STRING("SLAVE", IFF_SLAVE, link->flags, flags),
1495                                FLAG_STRING("UP", IFF_UP, link->flags, flags),
1496                                FLAG_STRING("DORMANT", IFF_DORMANT, link->flags, flags),
1497                                FLAG_STRING("LOWER_UP", IFF_LOWER_UP, link->flags, flags),
1498                                FLAG_STRING("RUNNING", IFF_RUNNING, link->flags, flags),
1499                                FLAG_STRING("MULTICAST", IFF_MULTICAST, link->flags, flags),
1500                                FLAG_STRING("BROADCAST", IFF_BROADCAST, link->flags, flags),
1501                                FLAG_STRING("POINTOPOINT", IFF_POINTOPOINT, link->flags, flags),
1502                                FLAG_STRING("PROMISC", IFF_PROMISC, link->flags, flags),
1503                                FLAG_STRING("ALLMULTI", IFF_ALLMULTI, link->flags, flags),
1504                                FLAG_STRING("PORTSEL", IFF_PORTSEL, link->flags, flags),
1505                                FLAG_STRING("AUTOMEDIA", IFF_AUTOMEDIA, link->flags, flags),
1506                                FLAG_STRING("DYNAMIC", IFF_DYNAMIC, link->flags, flags),
1507                                FLAG_STRING("NOARP", IFF_NOARP, link->flags, flags),
1508                                FLAG_STRING("NOTRAILERS", IFF_NOTRAILERS, link->flags, flags),
1509                                FLAG_STRING("DEBUG", IFF_DEBUG, link->flags, flags),
1510                                FLAG_STRING("ECHO", IFF_ECHO, link->flags, flags));
1511
1512                 unknown_flags = ~(IFF_LOOPBACK | IFF_MASTER | IFF_SLAVE | IFF_UP |
1513                                   IFF_DORMANT | IFF_LOWER_UP | IFF_RUNNING |
1514                                   IFF_MULTICAST | IFF_BROADCAST | IFF_POINTOPOINT |
1515                                   IFF_PROMISC | IFF_ALLMULTI | IFF_PORTSEL |
1516                                   IFF_AUTOMEDIA | IFF_DYNAMIC | IFF_NOARP |
1517                                   IFF_NOTRAILERS | IFF_DEBUG | IFF_ECHO);
1518                 unknown_flags_added = ((link->flags ^ flags) & flags & unknown_flags);
1519                 unknown_flags_removed = ((link->flags ^ flags) & link->flags & unknown_flags);
1520
1521                 /* link flags are currently at most 18 bits, let's align to printing 20 */
1522                 if (unknown_flags_added)
1523                         log_debug_link(link, "unknown link flags gained: %#.5x (ignoring)",
1524                                        unknown_flags_added);
1525
1526                 if (unknown_flags_removed)
1527                         log_debug_link(link, "unknown link flags lost: %#.5x (ignoring)",
1528                                        unknown_flags_removed);
1529         }
1530
1531         carrier_gained = !link_has_carrier(link->flags, link->kernel_operstate) &&
1532                        link_has_carrier(flags, operstate);
1533         carrier_lost = link_has_carrier(link->flags, link->kernel_operstate) &&
1534                          !link_has_carrier(flags, operstate);
1535
1536         link->flags = flags;
1537         link->kernel_operstate = operstate;
1538
1539         link_save(link);
1540
1541         if (link->state == LINK_STATE_FAILED ||
1542             link->state == LINK_STATE_UNMANAGED)
1543                 return 0;
1544
1545         if (carrier_gained) {
1546                 log_info_link(link, "gained carrier");
1547
1548                 if (link->network) {
1549                         r = link_acquire_conf(link);
1550                         if (r < 0) {
1551                                 link_enter_failed(link);
1552                                 return r;
1553                         }
1554                 }
1555         } else if (carrier_lost) {
1556                 log_info_link(link, "lost carrier");
1557
1558                 r = link_stop_clients(link);
1559                 if (r < 0) {
1560                         link_enter_failed(link);
1561                         return r;
1562                 }
1563         }
1564
1565         return 0;
1566 }
1567
1568 static int link_up_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1569         Link *link = userdata;
1570         int r;
1571
1572         assert(link);
1573
1574         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
1575                 link_unref(link);
1576                 return 1;
1577         }
1578
1579         r = sd_rtnl_message_get_errno(m);
1580         if (r < 0) {
1581                 /* we warn but don't fail the link, as it may
1582                    be brought up later */
1583                 log_struct_link(LOG_WARNING, link,
1584                                 "MESSAGE=%-*s: could not bring up interface: %s",
1585                                 IFNAMSIZ,
1586                                 link->ifname, strerror(-r),
1587                                 "ERRNO=%d", -r,
1588                                 NULL);
1589         }
1590
1591         link_unref(link);
1592
1593         return 1;
1594 }
1595
1596 static int link_up(Link *link) {
1597         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1598         int r;
1599
1600         assert(link);
1601         assert(link->manager);
1602         assert(link->manager->rtnl);
1603
1604         log_debug_link(link, "bringing link up");
1605
1606         r = sd_rtnl_message_new_link(link->manager->rtnl, &req,
1607                                      RTM_SETLINK, link->ifindex);
1608         if (r < 0) {
1609                 log_error_link(link, "Could not allocate RTM_SETLINK message");
1610                 return r;
1611         }
1612
1613         r = sd_rtnl_message_link_set_flags(req, IFF_UP, IFF_UP);
1614         if (r < 0) {
1615                 log_error_link(link, "Could not set link flags: %s", strerror(-r));
1616                 return r;
1617         }
1618
1619         r = sd_rtnl_call_async(link->manager->rtnl, req, link_up_handler, link, 0, NULL);
1620         if (r < 0) {
1621                 log_error_link(link,
1622                                "Could not send rtnetlink message: %s", strerror(-r));
1623                 return r;
1624         }
1625
1626         link_ref(link);
1627
1628         return 0;
1629 }
1630
1631 static int link_enslaved(Link *link) {
1632         int r;
1633
1634         assert(link);
1635         assert(link->state == LINK_STATE_ENSLAVING);
1636         assert(link->network);
1637
1638         if (!(link->flags & IFF_UP)) {
1639                 r = link_up(link);
1640                 if (r < 0) {
1641                         link_enter_failed(link);
1642                         return r;
1643                 }
1644         }
1645
1646         if (!link->network->dhcp && !link->network->ipv4ll)
1647                 return link_enter_set_addresses(link);
1648
1649         return 0;
1650 }
1651
1652 static int enslave_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1653         Link *link = userdata;
1654         int r;
1655
1656         assert(link);
1657         assert(IN_SET(link->state, LINK_STATE_ENSLAVING, LINK_STATE_FAILED,
1658                       LINK_STATE_LINGER));
1659         assert(link->network);
1660
1661         link->enslaving --;
1662
1663         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER)) {
1664                 link_unref(link);
1665                 return 1;
1666         }
1667
1668         r = sd_rtnl_message_get_errno(m);
1669         if (r < 0) {
1670                 log_struct_link(LOG_ERR, link,
1671                                 "MESSAGE=%-*s: could not enslave: %s",
1672                                 IFNAMSIZ,
1673                                 link->ifname, strerror(-r),
1674                                 "ERRNO=%d", -r,
1675                                 NULL);
1676                 link_enter_failed(link);
1677                 link_unref(link);
1678                 return 1;
1679         }
1680
1681         log_debug_link(link, "enslaved");
1682
1683         if (link->enslaving == 0)
1684                 link_enslaved(link);
1685
1686         link_unref(link);
1687
1688         return 1;
1689 }
1690
1691 static int link_enter_enslave(Link *link) {
1692         NetDev *vlan, *macvlan, *vxlan;
1693         Iterator i;
1694         int r;
1695
1696         assert(link);
1697         assert(link->network);
1698         assert(link->state == LINK_STATE_INITIALIZING);
1699
1700         link->state = LINK_STATE_ENSLAVING;
1701
1702         link_save(link);
1703
1704         if (!link->network->bridge &&
1705             !link->network->bond &&
1706             !link->network->tunnel &&
1707             hashmap_isempty(link->network->vlans) &&
1708             hashmap_isempty(link->network->macvlans) &&
1709             hashmap_isempty(link->network->vxlans))
1710                 return link_enslaved(link);
1711
1712         if (link->network->bond) {
1713                 log_struct_link(LOG_DEBUG, link,
1714                                 "MESSAGE=%-*s: enslaving by '%s'",
1715                                 IFNAMSIZ,
1716                                 link->ifname, link->network->bond->ifname,
1717                                 NETDEV(link->network->bond),
1718                                 NULL);
1719
1720                 r = netdev_enslave(link->network->bond, link, &enslave_handler);
1721                 if (r < 0) {
1722                         log_struct_link(LOG_WARNING, link,
1723                                         "MESSAGE=%-*s: could not enslave by '%s': %s",
1724                                         IFNAMSIZ,
1725                                         link->ifname, link->network->bond->ifname, strerror(-r),
1726                                         NETDEV(link->network->bond),
1727                                         NULL);
1728                         link_enter_failed(link);
1729                         return r;
1730                 }
1731
1732                 link_ref(link);
1733                 link->enslaving ++;
1734         }
1735
1736         if (link->network->bridge) {
1737                 log_struct_link(LOG_DEBUG, link,
1738                                 "MESSAGE=%-*s: enslaving by '%s'",
1739                                 IFNAMSIZ,
1740                                 link->ifname, link->network->bridge->ifname,
1741                                 NETDEV(link->network->bridge),
1742                                 NULL);
1743
1744                 r = netdev_enslave(link->network->bridge, link, &enslave_handler);
1745                 if (r < 0) {
1746                         log_struct_link(LOG_WARNING, link,
1747                                         "MESSAGE=%-*s: could not enslave by '%s': %s",
1748                                         IFNAMSIZ,
1749                                         link->ifname, link->network->bridge->ifname, strerror(-r),
1750                                         NETDEV(link->network->bridge),
1751                                         NULL);
1752                         link_enter_failed(link);
1753                         return r;
1754                 }
1755
1756                 link_ref(link);
1757                 link->enslaving ++;
1758         }
1759
1760         if (link->network->tunnel) {
1761                 log_struct_link(LOG_DEBUG, link,
1762                                 "MESSAGE=%-*s: enslaving by '%s'",
1763                                 IFNAMSIZ,
1764                                 link->ifname, link->network->tunnel->ifname,
1765                                 NETDEV(link->network->tunnel),
1766                                 NULL);
1767
1768                 r = netdev_enslave(link->network->tunnel, link, &enslave_handler);
1769                 if (r < 0) {
1770                         log_struct_link(LOG_WARNING, link,
1771                                         "MESSAGE=%-*s: could not enslave by '%s': %s",
1772                                         IFNAMSIZ,
1773                                         link->ifname, link->network->tunnel->ifname, strerror(-r),
1774                                         NETDEV(link->network->tunnel),
1775                                         NULL);
1776                         link_enter_failed(link);
1777                         return r;
1778                 }
1779
1780                 link_ref(link);
1781                 link->enslaving ++;
1782         }
1783
1784         HASHMAP_FOREACH(vlan, link->network->vlans, i) {
1785                 log_struct_link(LOG_DEBUG, link,
1786                                 "MESSAGE=%-*s: enslaving by '%s'",
1787                                 IFNAMSIZ,
1788                                 link->ifname, vlan->ifname, NETDEV(vlan), NULL);
1789
1790                 r = netdev_enslave(vlan, link, &enslave_handler);
1791                 if (r < 0) {
1792                         log_struct_link(LOG_WARNING, link,
1793                                         "MESSAGE=%-*s: could not enslave by '%s': %s",
1794                                         IFNAMSIZ,
1795                                         link->ifname, vlan->ifname, strerror(-r),
1796                                         NETDEV(vlan), NULL);
1797                         link_enter_failed(link);
1798                         return r;
1799                 }
1800
1801                 link_ref(link);
1802                 link->enslaving ++;
1803         }
1804
1805         HASHMAP_FOREACH(macvlan, link->network->macvlans, i) {
1806                 log_struct_link(LOG_DEBUG, link,
1807                                 "MESSAGE=%-*s: enslaving by '%s'",
1808                                 IFNAMSIZ,
1809                                 link->ifname, macvlan->ifname, NETDEV(macvlan), NULL);
1810
1811                 r = netdev_enslave(macvlan, link, &enslave_handler);
1812                 if (r < 0) {
1813                         log_struct_link(LOG_WARNING, link,
1814                                         "MESSAGE=%-*s: could not enslave by '%s': %s",
1815                                         IFNAMSIZ,
1816                                         link->ifname, macvlan->ifname, strerror(-r),
1817                                         NETDEV(macvlan), NULL);
1818                         link_enter_failed(link);
1819                         return r;
1820                 }
1821
1822                 link_ref(link);
1823                 link->enslaving ++;
1824         }
1825
1826         HASHMAP_FOREACH(vxlan, link->network->vxlans, i) {
1827                 log_struct_link(LOG_DEBUG, link,
1828                                 "MESSAGE=%*s: enslaving by '%s'",
1829                                 IFNAMSIZ,
1830                                 link->ifname, vxlan->ifname, NETDEV(vxlan), NULL);
1831
1832                 r = netdev_enslave(vxlan, link, &enslave_handler);
1833                 if (r < 0) {
1834                         log_struct_link(LOG_WARNING, link,
1835                                         "MESSAGE=%*s: could not enslave by '%s': %s",
1836                                         IFNAMSIZ,
1837                                         link->ifname, vxlan->ifname, strerror(-r),
1838                                         NETDEV(vxlan), NULL);
1839                         link_enter_failed(link);
1840                         return r;
1841                 }
1842
1843                 link_ref(link);
1844                 link->enslaving ++;
1845         }
1846
1847         return 0;
1848 }
1849
1850 static int link_configure(Link *link) {
1851         int r;
1852
1853         assert(link);
1854         assert(link->state == LINK_STATE_INITIALIZING);
1855
1856         if (link->network->ipv4ll) {
1857                 uint8_t seed[8];
1858
1859                 r = sd_ipv4ll_new(&link->ipv4ll);
1860                 if (r < 0)
1861                         return r;
1862
1863                 if (link->udev_device) {
1864                         r = net_get_unique_predictable_data(link->udev_device, seed);
1865                         if (r >= 0) {
1866                                 r = sd_ipv4ll_set_address_seed(link->ipv4ll, seed);
1867                                 if (r < 0)
1868                                         return r;
1869                         }
1870                 }
1871
1872                 r = sd_ipv4ll_attach_event(link->ipv4ll, NULL, 0);
1873                 if (r < 0)
1874                         return r;
1875
1876                 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
1877                 if (r < 0)
1878                         return r;
1879
1880                 r = sd_ipv4ll_set_index(link->ipv4ll, link->ifindex);
1881                 if (r < 0)
1882                         return r;
1883
1884                 r = sd_ipv4ll_set_callback(link->ipv4ll, ipv4ll_handler, link);
1885                 if (r < 0)
1886                         return r;
1887         }
1888
1889         if (link->network->dhcp) {
1890                 r = sd_dhcp_client_new(&link->dhcp_client);
1891                 if (r < 0)
1892                         return r;
1893
1894                 r = sd_dhcp_client_attach_event(link->dhcp_client, NULL, 0);
1895                 if (r < 0)
1896                         return r;
1897
1898                 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
1899                 if (r < 0)
1900                         return r;
1901
1902                 r = sd_dhcp_client_set_index(link->dhcp_client, link->ifindex);
1903                 if (r < 0)
1904                         return r;
1905
1906                 r = sd_dhcp_client_set_callback(link->dhcp_client, dhcp_handler, link);
1907                 if (r < 0)
1908                         return r;
1909
1910                 if (link->network->dhcp_mtu) {
1911                         r = sd_dhcp_client_set_request_option(link->dhcp_client, 26);
1912                         if (r < 0)
1913                                 return r;
1914                 }
1915         }
1916
1917         if (link->network->dhcp_server) {
1918                 r = sd_dhcp_server_new(&link->dhcp_server, link->ifindex);
1919                 if (r < 0)
1920                         return r;
1921
1922                 r = sd_dhcp_server_attach_event(link->dhcp_server, NULL, 0);
1923                 if (r < 0)
1924                         return r;
1925         }
1926
1927         if (link->network->dhcp6) {
1928                 r = sd_icmp6_nd_new(&link->icmp6_router_discovery);
1929                 if (r < 0)
1930                         return r;
1931
1932                 r = sd_icmp6_nd_attach_event(link->icmp6_router_discovery,
1933                                              NULL, 0);
1934                 if (r < 0)
1935                         return r;
1936
1937                 r = sd_icmp6_nd_set_mac(link->icmp6_router_discovery,
1938                                         &link->mac);
1939                 if (r < 0)
1940                         return r;
1941
1942                 r = sd_icmp6_nd_set_index(link->icmp6_router_discovery,
1943                                           link->ifindex);
1944                 if (r < 0)
1945                         return r;
1946
1947                 r = sd_icmp6_nd_set_callback(link->icmp6_router_discovery,
1948                                              icmp6_router_handler, link);
1949                 if (r < 0)
1950                         return r;
1951         }
1952
1953         if (link_has_carrier(link->flags, link->kernel_operstate)) {
1954                 r = link_acquire_conf(link);
1955                 if (r < 0)
1956                         return r;
1957         }
1958
1959         return link_enter_enslave(link);
1960 }
1961
1962 static int link_initialized_and_synced(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
1963         Link *link = userdata;
1964         Network *network;
1965         int r;
1966
1967         assert(link);
1968         assert(link->ifname);
1969         assert(link->manager);
1970
1971         if (link->state != LINK_STATE_INITIALIZING)
1972                 return 0;
1973
1974         log_debug_link(link, "link state is up-to-date");
1975
1976         r = network_get(link->manager, link->udev_device, link->ifname, &link->mac, &network);
1977         if (r == -ENOENT) {
1978                 link_enter_unmanaged(link);
1979                 return 0;
1980         } else if (r < 0)
1981                 return r;
1982
1983         r = network_apply(link->manager, network, link);
1984         if (r < 0)
1985                 return r;
1986
1987         r = link_configure(link);
1988         if (r < 0)
1989                 return r;
1990
1991         return 0;
1992 }
1993
1994 int link_initialized(Link *link, struct udev_device *device) {
1995         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
1996         int r;
1997
1998         assert(link);
1999         assert(link->manager);
2000         assert(link->manager->rtnl);
2001         assert(device);
2002
2003         if (link->state != LINK_STATE_INITIALIZING)
2004                 return 0;
2005
2006         log_debug_link(link, "udev initialized link");
2007
2008         link->udev_device = udev_device_ref(device);
2009
2010         /* udev has initialized the link, but we don't know if we have yet processed
2011            the NEWLINK messages with the latest state. Do a GETLINK, when it returns
2012            we know that the pending NEWLINKs have already been processed and that we
2013            are up-to-date */
2014
2015         r = sd_rtnl_message_new_link(link->manager->rtnl, &req, RTM_GETLINK, link->ifindex);
2016         if (r < 0)
2017                 return r;
2018
2019         r = sd_rtnl_call_async(link->manager->rtnl, req, link_initialized_and_synced, link, 0, NULL);
2020         if (r < 0)
2021                 return r;
2022
2023         return 0;
2024 }
2025
2026 int link_rtnl_process_address(sd_rtnl *rtnl, sd_rtnl_message *message, void *userdata) {
2027         Manager *m = userdata;
2028         Link *link = NULL;
2029         uint16_t type;
2030         _cleanup_address_free_ Address *address = NULL;
2031         Address *ad;
2032         char buf[INET6_ADDRSTRLEN];
2033         bool address_dropped = false;
2034         int r, ifindex;
2035
2036         assert(rtnl);
2037         assert(message);
2038         assert(m);
2039
2040         r = sd_rtnl_message_get_type(message, &type);
2041         if (r < 0) {
2042                 log_warning("rtnl: could not get message type");
2043                 return 0;
2044         }
2045
2046         r = sd_rtnl_message_addr_get_ifindex(message, &ifindex);
2047         if (r < 0 || ifindex <= 0) {
2048                 log_warning("rtnl: received address message without valid ifindex, ignoring");
2049                 return 0;
2050         } else {
2051                 r = link_get(m, ifindex, &link);
2052                 if (r < 0 || !link) {
2053                         log_warning("rtnl: received address for a nonexistent link, ignoring");
2054                         return 0;
2055                 }
2056         }
2057
2058         r = address_new_dynamic(&address);
2059         if (r < 0)
2060                 return 0;
2061
2062         r = sd_rtnl_message_addr_get_family(message, &address->family);
2063         if (r < 0 || !IN_SET(address->family, AF_INET, AF_INET6)) {
2064                 log_warning_link(link, "rtnl: received address with invalid family, ignoring");
2065                 return 0;
2066         }
2067
2068         r = sd_rtnl_message_addr_get_prefixlen(message, &address->prefixlen);
2069         if (r < 0) {
2070                 log_warning_link(link, "rtnl: received address with invalid prefixlen, ignoring");
2071                 return 0;
2072         }
2073
2074         r = sd_rtnl_message_addr_get_scope(message, &address->scope);
2075         if (r < 0) {
2076                 log_warning_link(link, "rtnl: received address with invalid scope, ignoring");
2077                 return 0;
2078         }
2079
2080         switch (address->family) {
2081         case AF_INET:
2082                 r = sd_rtnl_message_read_in_addr(message, IFA_LOCAL, &address->in_addr.in);
2083                 if (r < 0) {
2084                         log_warning_link(link, "rtnl: received address without valid address, ignoring");
2085                         return 0;
2086                 }
2087
2088                 break;
2089
2090         case AF_INET6:
2091                 r = sd_rtnl_message_read_in6_addr(message, IFA_ADDRESS, &address->in_addr.in6);
2092                 if (r < 0) {
2093                         log_warning_link(link, "rtnl: received address without valid address, ignoring");
2094                         return 0;
2095                 }
2096
2097                 break;
2098
2099         default:
2100                 assert_not_reached("invalid address family");
2101         }
2102
2103         if (!inet_ntop(address->family, &address->in_addr, buf, INET6_ADDRSTRLEN)) {
2104                 log_warning_link(link, "could not print address");
2105                 return 0;
2106         }
2107
2108         LIST_FOREACH(addresses, ad, link->addresses) {
2109                 if (address_equal(ad, address)) {
2110                         LIST_REMOVE(addresses, link->addresses, ad);
2111
2112                         address_free(ad);
2113
2114                         address_dropped = true;
2115
2116                         break;
2117                 }
2118         }
2119
2120         switch (type) {
2121         case RTM_NEWADDR:
2122                 if (!address_dropped)
2123                         log_debug_link(link, "added address: %s/%u", buf,
2124                                       address->prefixlen);
2125
2126                 LIST_PREPEND(addresses, link->addresses, address);
2127                 address = NULL;
2128
2129                 link_save(link);
2130
2131                 break;
2132         case RTM_DELADDR:
2133                 if (address_dropped) {
2134                         log_debug_link(link, "removed address: %s/%u", buf,
2135                                       address->prefixlen);
2136
2137                         link_save(link);
2138                 }
2139
2140                 break;
2141         default:
2142                 assert_not_reached("Received invalid RTNL message type");
2143         }
2144
2145         return 1;
2146 }
2147
2148 static int link_get_address_handler(sd_rtnl *rtnl, sd_rtnl_message *m, void *userdata) {
2149         Link *link = userdata;
2150         int r;
2151
2152         assert(rtnl);
2153         assert(m);
2154         assert(link);
2155
2156         for (; m; m = sd_rtnl_message_next(m)) {
2157                 r = sd_rtnl_message_get_errno(m);
2158                 if (r < 0) {
2159                         log_debug_link(link, "getting address failed: %s", strerror(-r));
2160                         continue;
2161                 }
2162
2163                 r = link_rtnl_process_address(rtnl, m, link->manager);
2164                 if (r < 0)
2165                         log_warning_link(link, "could not process address: %s", strerror(-r));
2166         }
2167
2168         return 1;
2169 }
2170
2171 int link_add(Manager *m, sd_rtnl_message *message, Link **ret) {
2172         Link *link;
2173         _cleanup_rtnl_message_unref_ sd_rtnl_message *req = NULL;
2174         _cleanup_udev_device_unref_ struct udev_device *device = NULL;
2175         char ifindex_str[2 + DECIMAL_STR_MAX(int)];
2176         int r;
2177
2178         assert(m);
2179         assert(m->rtnl);
2180         assert(message);
2181         assert(ret);
2182
2183         r = link_new(m, message, ret);
2184         if (r < 0)
2185                 return r;
2186
2187         link = *ret;
2188
2189         log_debug_link(link, "link %"PRIu64" added", link->ifindex);
2190
2191         r = sd_rtnl_message_new_addr(m->rtnl, &req, RTM_GETADDR, link->ifindex, 0);
2192         if (r < 0)
2193                 return r;
2194
2195         r = sd_rtnl_call_async(m->rtnl, req, link_get_address_handler, link, 0, NULL);
2196         if (r < 0)
2197                 return r;
2198
2199         if (detect_container(NULL) <= 0) {
2200                 /* not in a container, udev will be around */
2201                 sprintf(ifindex_str, "n%"PRIu64, link->ifindex);
2202                 device = udev_device_new_from_device_id(m->udev, ifindex_str);
2203                 if (!device) {
2204                         log_warning_link(link, "could not find udev device");
2205                         return -errno;
2206                 }
2207
2208                 if (udev_device_get_is_initialized(device) <= 0) {
2209                         /* not yet ready */
2210                         log_debug_link(link, "udev initializing link...");
2211                         return 0;
2212                 }
2213
2214                 r = link_initialized(link, device);
2215                 if (r < 0)
2216                         return r;
2217         } else {
2218                 r = link_initialized_and_synced(m->rtnl, NULL, link);
2219                 if (r < 0)
2220                         return r;
2221         }
2222
2223         return 0;
2224 }
2225
2226 int link_update(Link *link, sd_rtnl_message *m) {
2227         struct ether_addr mac;
2228         char *ifname;
2229         int r;
2230
2231         assert(link);
2232         assert(link->ifname);
2233         assert(m);
2234
2235         if (link->state == LINK_STATE_LINGER) {
2236                 link_ref(link);
2237                 log_info_link(link, "link readded");
2238                 link->state = LINK_STATE_ENSLAVING;
2239         }
2240
2241         r = sd_rtnl_message_read_string(m, IFLA_IFNAME, &ifname);
2242         if (r >= 0 && !streq(ifname, link->ifname)) {
2243                 log_info_link(link, "renamed to %s", ifname);
2244
2245                 free(link->ifname);
2246                 link->ifname = strdup(ifname);
2247                 if (!link->ifname)
2248                         return -ENOMEM;
2249         }
2250
2251         if (!link->original_mtu) {
2252                 r = sd_rtnl_message_read_u16(m, IFLA_MTU, &link->original_mtu);
2253                 if (r >= 0)
2254                         log_debug_link(link, "saved original MTU: %"
2255                                        PRIu16, link->original_mtu);
2256         }
2257
2258         /* The kernel may broadcast NEWLINK messages without the MAC address
2259            set, simply ignore them. */
2260         r = sd_rtnl_message_read_ether_addr(m, IFLA_ADDRESS, &mac);
2261         if (r >= 0) {
2262                 if (memcmp(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN)) {
2263
2264                         memcpy(link->mac.ether_addr_octet, mac.ether_addr_octet, ETH_ALEN);
2265
2266                         log_debug_link(link, "MAC address: "
2267                                        "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
2268                                        mac.ether_addr_octet[0],
2269                                        mac.ether_addr_octet[1],
2270                                        mac.ether_addr_octet[2],
2271                                        mac.ether_addr_octet[3],
2272                                        mac.ether_addr_octet[4],
2273                                        mac.ether_addr_octet[5]);
2274
2275                         if (link->ipv4ll) {
2276                                 r = sd_ipv4ll_set_mac(link->ipv4ll, &link->mac);
2277                                 if (r < 0) {
2278                                         log_warning_link(link, "Could not update MAC "
2279                                                          "address in IPv4LL client: %s",
2280                                                          strerror(-r));
2281                                         return r;
2282                                 }
2283                         }
2284
2285                         if (link->dhcp_client) {
2286                                 r = sd_dhcp_client_set_mac(link->dhcp_client, &link->mac);
2287                                 if (r < 0) {
2288                                         log_warning_link(link, "Could not update MAC "
2289                                                          "address in DHCP client: %s",
2290                                                          strerror(-r));
2291                                         return r;
2292                                 }
2293                         }
2294
2295                         if (link->dhcp6_client) {
2296                                 r = sd_dhcp6_client_set_mac(link->dhcp6_client,
2297                                                             &link->mac);
2298                                 if (r < 0) {
2299                                         log_warning_link(link, "Could not update MAC address in DHCPv6 client: %s",
2300                                                          strerror(-r));
2301                                         return r;
2302                                 }
2303                         }
2304                 }
2305         }
2306
2307         return link_update_flags(link, m);
2308 }
2309
2310 static void serialize_addresses(FILE *f, const char *key, Address *address) {
2311         Address *ad;
2312
2313         assert(f);
2314         assert(key);
2315
2316         if (!address)
2317                 return;
2318
2319         fprintf(f, "%s=", key);
2320
2321         LIST_FOREACH(addresses, ad, address) {
2322                 char buf[INET6_ADDRSTRLEN];
2323
2324                 if (inet_ntop(ad->family, &ad->in_addr, buf, INET6_ADDRSTRLEN))
2325                         fprintf(f, "%s%s", buf, (ad->addresses_next) ? " ": "");
2326         }
2327
2328         fputs("\n", f);
2329 }
2330
2331 static void link_update_operstate(Link *link) {
2332
2333         assert(link);
2334
2335         if (link->kernel_operstate == IF_OPER_DORMANT)
2336                 link->operstate = LINK_OPERSTATE_DORMANT;
2337         else if (link_has_carrier(link->flags, link->kernel_operstate)) {
2338                 Address *address;
2339                 uint8_t scope = RT_SCOPE_NOWHERE;
2340
2341                 /* if we have carrier, check what addresses we have */
2342                 LIST_FOREACH(addresses, address, link->addresses) {
2343                         if (address->scope < scope)
2344                                 scope = address->scope;
2345                 }
2346
2347                 if (scope < RT_SCOPE_SITE)
2348                         /* universally accessible addresses found */
2349                         link->operstate = LINK_OPERSTATE_ROUTABLE;
2350                 else if (scope < RT_SCOPE_HOST)
2351                         /* only link or site local addresses found */
2352                         link->operstate = LINK_OPERSTATE_DEGRADED;
2353                 else
2354                         /* no useful addresses found */
2355                         link->operstate = LINK_OPERSTATE_CARRIER;
2356         } else
2357                 link->operstate = LINK_OPERSTATE_UNKNOWN;
2358 }
2359
2360 int link_save(Link *link) {
2361         _cleanup_free_ char *temp_path = NULL;
2362         _cleanup_fclose_ FILE *f = NULL;
2363         const char *admin_state, *oper_state;
2364         int r;
2365
2366         assert(link);
2367         assert(link->state_file);
2368         assert(link->lease_file);
2369         assert(link->manager);
2370
2371         link_update_operstate(link);
2372
2373         r = manager_save(link->manager);
2374         if (r < 0)
2375                 return r;
2376
2377         if (link->state == LINK_STATE_LINGER) {
2378                 unlink(link->state_file);
2379                 return 0;
2380         }
2381
2382         admin_state = link_state_to_string(link->state);
2383         assert(admin_state);
2384
2385         oper_state = link_operstate_to_string(link->operstate);
2386         assert(oper_state);
2387
2388         r = fopen_temporary(link->state_file, &f, &temp_path);
2389         if (r < 0)
2390                 goto finish;
2391
2392         fchmod(fileno(f), 0644);
2393
2394         fprintf(f,
2395                 "# This is private data. Do not parse.\n"
2396                 "ADMIN_STATE=%s\n"
2397                 "OPER_STATE=%s\n"
2398                 "FLAGS=%u\n",
2399                 admin_state, oper_state, link->flags);
2400
2401         if (link->network) {
2402                 serialize_addresses(f, "DNS", link->network->dns);
2403                 serialize_addresses(f, "NTP", link->network->ntp);
2404         }
2405
2406         if (link->dhcp_lease) {
2407                 assert(link->network);
2408
2409                 r = dhcp_lease_save(link->dhcp_lease, link->lease_file);
2410                 if (r < 0)
2411                         goto finish;
2412
2413                 fprintf(f,
2414                         "DHCP_LEASE=%s\n"
2415                         "DHCP_USE_DNS=%s\n"
2416                         "DHCP_USE_NTP=%s\n",
2417                         link->lease_file,
2418                         yes_no(link->network->dhcp_dns),
2419                         yes_no(link->network->dhcp_ntp));
2420         } else
2421                 unlink(link->lease_file);
2422
2423         fflush(f);
2424
2425         if (ferror(f) || rename(temp_path, link->state_file) < 0) {
2426                 r = -errno;
2427                 unlink(link->state_file);
2428                 unlink(temp_path);
2429         }
2430
2431 finish:
2432         if (r < 0)
2433                 log_error_link(link, "Failed to save link data to %s: %s", link->state_file, strerror(-r));
2434
2435         return r;
2436 }
2437
2438 static const char* const link_state_table[_LINK_STATE_MAX] = {
2439         [LINK_STATE_INITIALIZING] = "initializing",
2440         [LINK_STATE_ENSLAVING] = "configuring",
2441         [LINK_STATE_SETTING_ADDRESSES] = "configuring",
2442         [LINK_STATE_SETTING_ROUTES] = "configuring",
2443         [LINK_STATE_CONFIGURED] = "configured",
2444         [LINK_STATE_UNMANAGED] = "unmanaged",
2445         [LINK_STATE_FAILED] = "failed",
2446         [LINK_STATE_LINGER] = "linger",
2447 };
2448
2449 DEFINE_STRING_TABLE_LOOKUP(link_state, LinkState);
2450
2451 static const char* const link_operstate_table[_LINK_OPERSTATE_MAX] = {
2452         [LINK_OPERSTATE_UNKNOWN] = "unknown",
2453         [LINK_OPERSTATE_DORMANT] = "dormant",
2454         [LINK_OPERSTATE_CARRIER] = "carrier",
2455         [LINK_OPERSTATE_DEGRADED] = "degraded",
2456         [LINK_OPERSTATE_ROUTABLE] = "routable",
2457 };
2458
2459 DEFINE_STRING_TABLE_LOOKUP(link_operstate, LinkOperationalState);