src/network/networkd-dhcp6.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2 /***
   3   Copyright © 2014 Intel Corporation. All rights reserved.
   4 ***/
   5
   6 #include "sd-dhcp6-client.h"
   7
   8 #include "hashmap.h"
   9 #include "hostname-setup.h"
  10 #include "hostname-util.h"
  11 #include "networkd-address.h"
  12 #include "networkd-dhcp-prefix-delegation.h"
  13 #include "networkd-dhcp6.h"
  14 #include "networkd-link.h"
  15 #include "networkd-manager.h"
  16 #include "networkd-queue.h"
  17 #include "networkd-route.h"
  18 #include "string-table.h"
  19 #include "string-util.h"
  20
  21 bool link_dhcp6_with_address_enabled(Link *link) {
  22         if (!link_dhcp6_enabled(link))
  23                 return false;
  24
  25         return link->network->dhcp6_use_address;
  26 }
  27
  28 static DHCP6ClientStartMode link_get_dhcp6_client_start_mode(Link *link) {
  29         assert(link);
  30
  31         if (!link->network)
  32                 return DHCP6_CLIENT_START_MODE_NO;
  33
  34         /* When WithoutRA= is explicitly specified, then honor it. */
  35         if (link->network->dhcp6_client_start_mode >= 0)
  36                 return link->network->dhcp6_client_start_mode;
  37
  38         /* When this interface itself is an uplink interface, then start dhcp6 client in solicit mode. */
  39         if (dhcp_pd_is_uplink(link, link, /* accept_auto = */ false))
  40                 return DHCP6_CLIENT_START_MODE_SOLICIT;
  41
  42         /* Otherwise, start dhcp6 client when RA is received. */
  43         return DHCP6_CLIENT_START_MODE_NO;
  44 }
  45
  46 static int dhcp6_remove(Link *link, bool only_marked) {
  47         Address *address;
  48         Route *route;
  49         int k, r = 0;
  50
  51         assert(link);
  52
  53         if (!only_marked)
  54                 link->dhcp6_configured = false;
  55
  56         SET_FOREACH(route, link->routes) {
  57                 if (route->source != NETWORK_CONFIG_SOURCE_DHCP6)
  58                         continue;
  59                 if (only_marked && !route_is_marked(route))
  60                         continue;
  61
  62                 k = route_remove(route);
  63                 if (k < 0)
  64                         r = k;
  65
  66                 route_cancel_request(route, link);
  67         }
  68
  69         SET_FOREACH(address, link->addresses) {
  70                 if (address->source != NETWORK_CONFIG_SOURCE_DHCP6)
  71                         continue;
  72                 if (only_marked && !address_is_marked(address))
  73                         continue;
  74
  75                 k = address_remove(address);
  76                 if (k < 0)
  77                         r = k;
  78
  79                 address_cancel_request(address);
  80         }
  81
  82         return r;
  83 }
  84
  85 static int dhcp6_address_ready_callback(Address *address) {
  86         Address *a;
  87
  88         assert(address);
  89         assert(address->link);
  90
  91         SET_FOREACH(a, address->link->addresses)
  92                 if (a->source == NETWORK_CONFIG_SOURCE_DHCP6)
  93                         a->callback = NULL;
  94
  95         return dhcp6_check_ready(address->link);
  96 }
  97
  98 int dhcp6_check_ready(Link *link) {
  99         bool has_ready = false;
 100         Address *address;
 101         int r;
 102
 103         assert(link);
 104
 105         if (link->dhcp6_messages > 0) {
 106                 log_link_debug(link, "%s(): DHCPv6 addresses and routes are not set.", __func__);
 107                 return 0;
 108         }
 109
 110         SET_FOREACH(address, link->addresses) {
 111                 if (address->source != NETWORK_CONFIG_SOURCE_DHCP6)
 112                         continue;
 113                 if (address_is_ready(address)) {
 114                         has_ready = true;
 115                         break;
 116                 }
 117         }
 118
 119         if (!has_ready) {
 120                 SET_FOREACH(address, link->addresses)
 121                         if (address->source == NETWORK_CONFIG_SOURCE_DHCP6)
 122                                 address->callback = dhcp6_address_ready_callback;
 123
 124                 log_link_debug(link, "%s(): no DHCPv6 address is ready.", __func__);
 125                 return 0;
 126         }
 127
 128         link->dhcp6_configured = true;
 129         log_link_debug(link, "DHCPv6 addresses and routes set.");
 130
 131         r = dhcp6_remove(link, /* only_marked = */ true);
 132         if (r < 0)
 133                 return r;
 134
 135         link_check_ready(link);
 136         return 0;
 137 }
 138
 139 static int dhcp6_address_handler(sd_netlink *rtnl, sd_netlink_message *m, Request *req, Link *link, Address *address) {
 140         int r;
 141
 142         assert(link);
 143
 144         r = address_configure_handler_internal(rtnl, m, link, "Could not set DHCPv6 address");
 145         if (r <= 0)
 146                 return r;
 147
 148         r = dhcp6_check_ready(link);
 149         if (r < 0)
 150                 link_enter_failed(link);
 151
 152         return 1;
 153 }
 154
 155 static int verify_dhcp6_address(Link *link, const Address *address) {
 156         bool by_ndisc = false;
 157         Address *existing;
 158         int log_level;
 159
 160         assert(link);
 161         assert(address);
 162         assert(address->family == AF_INET6);
 163
 164         const char *pretty = IN6_ADDR_TO_STRING(&address->in_addr.in6);
 165
 166         if (address_get(link, address, &existing) < 0 &&
 167             link_get_address(link, AF_INET6, &address->in_addr, 0, &existing) < 0) {
 168                 /* New address. */
 169                 log_level = LOG_INFO;
 170                 goto simple_log;
 171         } else
 172                 log_level = LOG_DEBUG;
 173
 174         if (address->prefixlen == existing->prefixlen)
 175                 /* Currently, only conflict in prefix length is reported. */
 176                 goto simple_log;
 177
 178         if (existing->source == NETWORK_CONFIG_SOURCE_NDISC)
 179                 by_ndisc = true;
 180
 181         log_link_warning(link, "Ignoring DHCPv6 address %s/%u (valid %s, preferred %s) which conflicts with %s/%u%s.",
 182                          pretty, address->prefixlen,
 183                          FORMAT_LIFETIME(address->lifetime_valid_usec),
 184                          FORMAT_LIFETIME(address->lifetime_preferred_usec),
 185                          pretty, existing->prefixlen,
 186                          by_ndisc ? " assigned by NDisc" : "");
 187         if (by_ndisc)
 188                 log_link_warning(link, "Hint: use IPv6Token= setting to change the address generated by NDisc or set UseAutonomousPrefix=no.");
 189
 190         return -EEXIST;
 191
 192 simple_log:
 193         log_link_full(link, log_level, "DHCPv6 address %s/%u (valid %s, preferred %s)",
 194                       pretty, address->prefixlen,
 195                       FORMAT_LIFETIME(address->lifetime_valid_usec),
 196                       FORMAT_LIFETIME(address->lifetime_preferred_usec));
 197         return 0;
 198 }
 199
 200 static int dhcp6_request_address(
 201                 Link *link,
 202                 const struct in6_addr *server_address,
 203                 const struct in6_addr *ip6_addr,
 204                 usec_t lifetime_preferred_usec,
 205                 usec_t lifetime_valid_usec) {
 206
 207         _cleanup_(address_freep) Address *addr = NULL;
 208         Address *existing;
 209         int r;
 210
 211         r = address_new(&addr);
 212         if (r < 0)
 213                 return log_oom();
 214
 215         addr->source = NETWORK_CONFIG_SOURCE_DHCP6;
 216         addr->provider.in6 = *server_address;
 217         addr->family = AF_INET6;
 218         addr->in_addr.in6 = *ip6_addr;
 219         addr->flags = IFA_F_NOPREFIXROUTE;
 220         addr->prefixlen = 128;
 221         addr->lifetime_preferred_usec = lifetime_preferred_usec;
 222         addr->lifetime_valid_usec = lifetime_valid_usec;
 223
 224         if (verify_dhcp6_address(link, addr) < 0)
 225                 return 0;
 226
 227         r = free_and_strdup_warn(&addr->netlabel, link->network->dhcp6_netlabel);
 228         if (r < 0)
 229                 return r;
 230
 231         if (address_get(link, addr, &existing) < 0)
 232                 link->dhcp6_configured = false;
 233         else
 234                 address_unmark(existing);
 235
 236         r = link_request_address(link, TAKE_PTR(addr), true, &link->dhcp6_messages,
 237                                  dhcp6_address_handler, NULL);
 238         if (r < 0)
 239                 return log_link_error_errno(link, r, "Failed to request DHCPv6 address %s/128: %m",
 240                                             IN6_ADDR_TO_STRING(ip6_addr));
 241         return 0;
 242 }
 243
 244 static int dhcp6_address_acquired(Link *link) {
 245         struct in6_addr server_address;
 246         usec_t timestamp_usec;
 247         int r;
 248
 249         assert(link);
 250         assert(link->network);
 251         assert(link->dhcp6_lease);
 252
 253         if (!link->network->dhcp6_use_address)
 254                 return 0;
 255
 256         r = sd_dhcp6_lease_get_server_address(link->dhcp6_lease, &server_address);
 257         if (r < 0)
 258                 return log_link_warning_errno(link, r, "Failed to get server address of DHCPv6 lease: %m");
 259
 260         r = sd_dhcp6_lease_get_timestamp(link->dhcp6_lease, CLOCK_BOOTTIME, &timestamp_usec);
 261         if (r < 0)
 262                 return log_link_warning_errno(link, r, "Failed to get timestamp of DHCPv6 lease: %m");
 263
 264         for (sd_dhcp6_lease_reset_address_iter(link->dhcp6_lease);;) {
 265                 uint32_t lifetime_preferred_sec, lifetime_valid_sec;
 266                 struct in6_addr ip6_addr;
 267
 268                 r = sd_dhcp6_lease_get_address(link->dhcp6_lease, &ip6_addr, &lifetime_preferred_sec, &lifetime_valid_sec);
 269                 if (r < 0)
 270                         break;
 271
 272                 r = dhcp6_request_address(link, &server_address, &ip6_addr,
 273                                           sec_to_usec(lifetime_preferred_sec, timestamp_usec),
 274                                           sec_to_usec(lifetime_valid_sec, timestamp_usec));
 275                 if (r < 0)
 276                         return r;
 277         }
 278
 279         if (link->network->dhcp6_use_hostname) {
 280                 const char *dhcpname = NULL;
 281                 _cleanup_free_ char *hostname = NULL;
 282
 283                 (void) sd_dhcp6_lease_get_fqdn(link->dhcp6_lease, &dhcpname);
 284
 285                 if (dhcpname) {
 286                         r = shorten_overlong(dhcpname, &hostname);
 287                         if (r < 0)
 288                                 log_link_warning_errno(link, r, "Unable to shorten overlong DHCP hostname '%s', ignoring: %m", dhcpname);
 289                         if (r == 1)
 290                                 log_link_notice(link, "Overlong DHCP hostname received, shortened from '%s' to '%s'", dhcpname, hostname);
 291                 }
 292                 if (hostname) {
 293                         r = manager_set_hostname(link->manager, hostname);
 294                         if (r < 0)
 295                                 log_link_error_errno(link, r, "Failed to set transient hostname to '%s': %m", hostname);
 296                 }
 297         }
 298
 299         return 0;
 300 }
 301
 302 static int dhcp6_lease_ip_acquired(sd_dhcp6_client *client, Link *link) {
 303         _cleanup_(sd_dhcp6_lease_unrefp) sd_dhcp6_lease *lease_old = NULL;
 304         sd_dhcp6_lease *lease;
 305         int r;
 306
 307         link_mark_addresses(link, NETWORK_CONFIG_SOURCE_DHCP6, NULL);
 308         link_mark_routes(link, NETWORK_CONFIG_SOURCE_DHCP6, NULL);
 309
 310         r = sd_dhcp6_client_get_lease(client, &lease);
 311         if (r < 0)
 312                 return log_link_error_errno(link, r, "Failed to get DHCPv6 lease: %m");
 313
 314         lease_old = TAKE_PTR(link->dhcp6_lease);
 315         link->dhcp6_lease = sd_dhcp6_lease_ref(lease);
 316
 317         r = dhcp6_address_acquired(link);
 318         if (r < 0)
 319                 return r;
 320
 321         if (dhcp6_lease_has_pd_prefix(lease)) {
 322                 r = dhcp6_pd_prefix_acquired(link);
 323                 if (r < 0)
 324                         return r;
 325         } else if (dhcp6_lease_has_pd_prefix(lease_old))
 326                 /* When we had PD prefixes but not now, we need to remove them. */
 327                 dhcp_pd_prefix_lost(link);
 328
 329         if (link->dhcp6_messages == 0) {
 330                 link->dhcp6_configured = true;
 331
 332                 r = dhcp6_remove(link, /* only_marked = */ true);
 333                 if (r < 0)
 334                         return r;
 335         } else
 336                 log_link_debug(link, "Setting DHCPv6 addresses and routes");
 337
 338         if (!link->dhcp6_configured)
 339                 link_set_state(link, LINK_STATE_CONFIGURING);
 340
 341         link_check_ready(link);
 342         return 0;
 343 }
 344
 345 static int dhcp6_lease_information_acquired(sd_dhcp6_client *client, Link *link) {
 346         return 0;
 347 }
 348
 349 static int dhcp6_lease_lost(Link *link) {
 350         int r;
 351
 352         assert(link);
 353         assert(link->manager);
 354
 355         log_link_info(link, "DHCPv6 lease lost");
 356
 357         if (dhcp6_lease_has_pd_prefix(link->dhcp6_lease))
 358                 dhcp_pd_prefix_lost(link);
 359
 360         link->dhcp6_lease = sd_dhcp6_lease_unref(link->dhcp6_lease);
 361
 362         r = dhcp6_remove(link, /* only_marked = */ false);
 363         if (r < 0)
 364                 return r;
 365
 366         return 0;
 367 }
 368
 369 static void dhcp6_handler(sd_dhcp6_client *client, int event, void *userdata) {
 370         Link *link = userdata;
 371         int r;
 372
 373         assert(link);
 374         assert(link->network);
 375
 376         if (IN_SET(link->state, LINK_STATE_FAILED, LINK_STATE_LINGER))
 377                 return;
 378
 379         switch (event) {
 380         case SD_DHCP6_CLIENT_EVENT_STOP:
 381         case SD_DHCP6_CLIENT_EVENT_RESEND_EXPIRE:
 382         case SD_DHCP6_CLIENT_EVENT_RETRANS_MAX:
 383                 r = dhcp6_lease_lost(link);
 384                 if (r < 0)
 385                         link_enter_failed(link);
 386                 break;
 387
 388         case SD_DHCP6_CLIENT_EVENT_IP_ACQUIRE:
 389                 r = dhcp6_lease_ip_acquired(client, link);
 390                 if (r < 0) {
 391                         link_enter_failed(link);
 392                         return;
 393                 }
 394
 395                 _fallthrough_;
 396         case SD_DHCP6_CLIENT_EVENT_INFORMATION_REQUEST:
 397                 r = dhcp6_lease_information_acquired(client, link);
 398                 if (r < 0)
 399                         link_enter_failed(link);
 400                 break;
 401
 402         default:
 403                 if (event < 0)
 404                         log_link_warning_errno(link, event, "DHCPv6 error: %m");
 405                 else
 406                         log_link_warning(link, "DHCPv6 unknown event: %d", event);
 407                 return;
 408         }
 409 }
 410
 411 int dhcp6_start_on_ra(Link *link, bool information_request) {
 412         int r;
 413
 414         assert(link);
 415         assert(link->dhcp6_client);
 416         assert(link->network);
 417         assert(in6_addr_is_link_local(&link->ipv6ll_address));
 418
 419         if (link_get_dhcp6_client_start_mode(link) != DHCP6_CLIENT_START_MODE_NO)
 420                 /* When WithoutRA= is specified, then the DHCPv6 client should be already running in
 421                  * the requested mode. Hence, ignore the requests by RA. */
 422                 return 0;
 423
 424         r = sd_dhcp6_client_is_running(link->dhcp6_client);
 425         if (r < 0)
 426                 return r;
 427
 428         if (r > 0) {
 429                 int inf_req;
 430
 431                 r = sd_dhcp6_client_get_information_request(link->dhcp6_client, &inf_req);
 432                 if (r < 0)
 433                         return r;
 434
 435                 if (inf_req == information_request)
 436                         /* The client is already running in the requested mode. */
 437                         return 0;
 438
 439                 if (!inf_req) {
 440                         log_link_debug(link,
 441                                        "The DHCPv6 client is already running in the managed mode, "
 442                                        "refusing to start the client in the information requesting mode.");
 443                         return 0;
 444                 }
 445
 446                 log_link_debug(link,
 447                                "The DHCPv6 client is running in the information requesting mode. "
 448                                "Restarting the client in the managed mode.");
 449
 450                 r = sd_dhcp6_client_stop(link->dhcp6_client);
 451                 if (r < 0)
 452                         return r;
 453         } else {
 454                 r = sd_dhcp6_client_set_local_address(link->dhcp6_client, &link->ipv6ll_address);
 455                 if (r < 0)
 456                         return r;
 457         }
 458
 459         r = sd_dhcp6_client_set_information_request(link->dhcp6_client, information_request);
 460         if (r < 0)
 461                 return r;
 462
 463         r = sd_dhcp6_client_start(link->dhcp6_client);
 464         if (r < 0)
 465                 return r;
 466
 467         return 0;
 468 }
 469
 470 int dhcp6_start(Link *link) {
 471         DHCP6ClientStartMode start_mode;
 472         int r;
 473
 474         assert(link);
 475         assert(link->network);
 476
 477         if (!link->dhcp6_client)
 478                 return 0;
 479
 480         if (!link_dhcp6_enabled(link))
 481                 return 0;
 482
 483         if (!link_has_carrier(link))
 484                 return 0;
 485
 486         if (sd_dhcp6_client_is_running(link->dhcp6_client) > 0)
 487                 return 0;
 488
 489         if (!in6_addr_is_link_local(&link->ipv6ll_address)) {
 490                 log_link_debug(link, "IPv6 link-local address is not set, delaying to start DHCPv6 client.");
 491                 return 0;
 492         }
 493
 494         r = sd_dhcp6_client_set_local_address(link->dhcp6_client, &link->ipv6ll_address);
 495         if (r < 0)
 496                 return r;
 497
 498         start_mode = link_get_dhcp6_client_start_mode(link);
 499         if (start_mode == DHCP6_CLIENT_START_MODE_NO)
 500                 return 0;
 501
 502         r = sd_dhcp6_client_set_information_request(link->dhcp6_client,
 503                                                     start_mode == DHCP6_CLIENT_START_MODE_INFORMATION_REQUEST);
 504         if (r < 0)
 505                 return r;
 506
 507         r = sd_dhcp6_client_start(link->dhcp6_client);
 508         if (r < 0)
 509                 return r;
 510
 511         return 1;
 512 }
 513
 514 static int dhcp6_set_hostname(sd_dhcp6_client *client, Link *link) {
 515         _cleanup_free_ char *hostname = NULL;
 516         const char *hn;
 517         int r;
 518
 519         assert(link);
 520
 521         if (!link->network->dhcp_send_hostname)
 522                 hn = NULL;
 523         else if (link->network->dhcp_hostname)
 524                 hn = link->network->dhcp_hostname;
 525         else {
 526                 r = gethostname_strict(&hostname);
 527                 if (r < 0 && r != -ENXIO) /* ENXIO: no hostname set or hostname is "localhost" */
 528                         return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to get hostname: %m");
 529
 530                 hn = hostname;
 531         }
 532
 533         r = sd_dhcp6_client_set_fqdn(client, hn);
 534         if (r == -EINVAL && hostname)
 535                 /* Ignore error when the machine's hostname is not suitable to send in DHCP packet. */
 536                 log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to set hostname from kernel hostname, ignoring: %m");
 537         else if (r < 0)
 538                 return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to set hostname: %m");
 539
 540         return 0;
 541 }
 542
 543 static int dhcp6_set_identifier(Link *link, sd_dhcp6_client *client) {
 544         const DUID *duid;
 545         int r;
 546
 547         assert(link);
 548         assert(link->network);
 549         assert(client);
 550
 551         r = sd_dhcp6_client_set_mac(client, link->hw_addr.bytes, link->hw_addr.length, link->iftype);
 552         if (r < 0)
 553                 return r;
 554
 555         if (link->network->dhcp6_iaid_set) {
 556                 r = sd_dhcp6_client_set_iaid(client, link->network->dhcp6_iaid);
 557                 if (r < 0)
 558                         return r;
 559         }
 560
 561         duid = link_get_dhcp6_duid(link);
 562         if (duid->type == DUID_TYPE_LLT && duid->raw_data_len == 0)
 563                 r = sd_dhcp6_client_set_duid_llt(client, duid->llt_time);
 564         else
 565                 r = sd_dhcp6_client_set_duid(client,
 566                                              duid->type,
 567                                              duid->raw_data_len > 0 ? duid->raw_data : NULL,
 568                                              duid->raw_data_len);
 569         if (r < 0)
 570                 return r;
 571
 572         return 0;
 573 }
 574
 575 static int dhcp6_configure(Link *link) {
 576         _cleanup_(sd_dhcp6_client_unrefp) sd_dhcp6_client *client = NULL;
 577         sd_dhcp6_option *vendor_option;
 578         sd_dhcp6_option *send_option;
 579         void *request_options;
 580         int r;
 581
 582         assert(link);
 583         assert(link->network);
 584
 585         if (link->dhcp6_client)
 586                 return log_link_debug_errno(link, SYNTHETIC_ERRNO(EBUSY), "DHCPv6 client is already configured.");
 587
 588         r = sd_dhcp6_client_new(&client);
 589         if (r == -ENOMEM)
 590                 return log_oom_debug();
 591         if (r < 0)
 592                 return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to create DHCPv6 client: %m");
 593
 594         r = sd_dhcp6_client_attach_event(client, link->manager->event, 0);
 595         if (r < 0)
 596                 return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to attach event: %m");
 597
 598         r = dhcp6_set_identifier(link, client);
 599         if (r < 0)
 600                 return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to set identifier: %m");
 601
 602         ORDERED_HASHMAP_FOREACH(send_option, link->network->dhcp6_client_send_options) {
 603                 r = sd_dhcp6_client_add_option(client, send_option);
 604                 if (r == -EEXIST)
 605                         continue;
 606                 if (r < 0)
 607                         return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to set option: %m");
 608         }
 609
 610         r = dhcp6_set_hostname(client, link);
 611         if (r < 0)
 612                 return r;
 613
 614         r = sd_dhcp6_client_set_ifindex(client, link->ifindex);
 615         if (r < 0)
 616                 return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to set ifindex: %m");
 617
 618         if (link->network->dhcp6_mudurl) {
 619                 r = sd_dhcp6_client_set_request_mud_url(client, link->network->dhcp6_mudurl);
 620                 if (r < 0)
 621                         return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to set MUD URL: %m");
 622         }
 623
 624         if (link->network->dhcp6_use_dns) {
 625                 r = sd_dhcp6_client_set_request_option(client, SD_DHCP6_OPTION_DNS_SERVER);
 626                 if (r < 0)
 627                         return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to request DNS servers: %m");
 628         }
 629
 630         if (link->network->dhcp6_use_domains > 0) {
 631                 r = sd_dhcp6_client_set_request_option(client, SD_DHCP6_OPTION_DOMAIN);
 632                 if (r < 0)
 633                         return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to request domains: %m");
 634         }
 635
 636         if (link->network->dhcp6_use_ntp) {
 637                 r = sd_dhcp6_client_set_request_option(client, SD_DHCP6_OPTION_NTP_SERVER);
 638                 if (r < 0)
 639                         return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to request NTP servers: %m");
 640
 641                 /* If the server does not provide NTP servers, then we fallback to use SNTP servers. */
 642                 r = sd_dhcp6_client_set_request_option(client, SD_DHCP6_OPTION_SNTP_SERVER);
 643                 if (r < 0)
 644                         return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to request SNTP servers: %m");
 645         }
 646
 647         SET_FOREACH(request_options, link->network->dhcp6_request_options) {
 648                 uint32_t option = PTR_TO_UINT32(request_options);
 649
 650                 r = sd_dhcp6_client_set_request_option(client, option);
 651                 if (r == -EEXIST) {
 652                         log_link_debug(link, "DHCPv6 CLIENT: Failed to set request flag for '%u' already exists, ignoring.", option);
 653                         continue;
 654                 }
 655                 if (r < 0)
 656                         return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to set request flag for '%u': %m", option);
 657         }
 658
 659         if (link->network->dhcp6_user_class) {
 660                 r = sd_dhcp6_client_set_request_user_class(client, link->network->dhcp6_user_class);
 661                 if (r < 0)
 662                         return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to set user class: %m");
 663         }
 664
 665         if (link->network->dhcp6_vendor_class) {
 666                 r = sd_dhcp6_client_set_request_vendor_class(client, link->network->dhcp6_vendor_class);
 667                 if (r < 0)
 668                         return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to set vendor class: %m");
 669         }
 670
 671         ORDERED_HASHMAP_FOREACH(vendor_option, link->network->dhcp6_client_send_vendor_options) {
 672                 r = sd_dhcp6_client_add_vendor_option(client, vendor_option);
 673                 if (r == -EEXIST)
 674                         continue;
 675                 if (r < 0)
 676                         return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to set vendor option: %m");
 677         }
 678
 679         r = sd_dhcp6_client_set_callback(client, dhcp6_handler, link);
 680         if (r < 0)
 681                 return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to set callback: %m");
 682
 683         r = sd_dhcp6_client_set_prefix_delegation(client, link->network->dhcp6_use_pd_prefix);
 684         if (r < 0)
 685                 return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to %s requesting prefixes to be delegated: %m",
 686                                             enable_disable(link->network->dhcp6_use_pd_prefix));
 687
 688         /* Even if UseAddress=no, we need to request IA_NA, as the dhcp6 client may be started in solicit mode. */
 689         r = sd_dhcp6_client_set_address_request(client, link->network->dhcp6_use_pd_prefix ? link->network->dhcp6_use_address : true);
 690         if (r < 0)
 691                 return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to %s requesting address: %m",
 692                                             enable_disable(link->network->dhcp6_use_address));
 693
 694         if (link->network->dhcp6_pd_prefix_length > 0) {
 695                 r = sd_dhcp6_client_set_prefix_delegation_hint(client,
 696                                                                link->network->dhcp6_pd_prefix_length,
 697                                                                &link->network->dhcp6_pd_prefix_hint);
 698                 if (r < 0)
 699                         return log_link_debug_errno(link, r, "DHCPv6 CLIENT: Failed to set prefix delegation hint: %m");
 700         }
 701
 702         r = sd_dhcp6_client_set_rapid_commit(client, link->network->dhcp6_use_rapid_commit);
 703         if (r < 0)
 704                 return log_link_debug_errno(link, r,
 705                                             "DHCPv6 CLIENT: Failed to %s rapid commit: %m",
 706                                             enable_disable(link->network->dhcp6_use_rapid_commit));
 707
 708         link->dhcp6_client = TAKE_PTR(client);
 709
 710         return 0;
 711 }
 712
 713 int dhcp6_update_mac(Link *link) {
 714         bool restart;
 715         int r;
 716
 717         assert(link);
 718
 719         if (!link->dhcp6_client)
 720                 return 0;
 721
 722         restart = sd_dhcp6_client_is_running(link->dhcp6_client) > 0;
 723
 724         if (restart) {
 725                 r = sd_dhcp6_client_stop(link->dhcp6_client);
 726                 if (r < 0)
 727                         return r;
 728         }
 729
 730         r = dhcp6_set_identifier(link, link->dhcp6_client);
 731         if (r < 0)
 732                 return r;
 733
 734         if (restart) {
 735                 r = sd_dhcp6_client_start(link->dhcp6_client);
 736                 if (r < 0)
 737                         return log_link_warning_errno(link, r, "Could not restart DHCPv6 client: %m");
 738         }
 739
 740         return 0;
 741 }
 742
 743 static int dhcp6_process_request(Request *req, Link *link, void *userdata) {
 744         int r;
 745
 746         assert(link);
 747
 748         if (!link_is_ready_to_configure(link, /* allow_unmanaged = */ false))
 749                 return 0;
 750
 751         r = dhcp_configure_duid(link, link_get_dhcp6_duid(link));
 752         if (r <= 0)
 753                 return r;
 754
 755         r = dhcp6_configure(link);
 756         if (r < 0)
 757                 return log_link_warning_errno(link, r, "Failed to configure DHCPv6 client: %m");
 758
 759         r = ndisc_start(link);
 760         if (r < 0)
 761                 return log_link_warning_errno(link, r, "Failed to start IPv6 Router Discovery: %m");
 762
 763         r = dhcp6_start(link);
 764         if (r < 0)
 765                 return log_link_warning_errno(link, r, "Failed to start DHCPv6 client: %m");
 766
 767         log_link_debug(link, "DHCPv6 client is configured%s.",
 768                        r > 0 ? ", acquiring DHCPv6 lease" : "");
 769         return 1;
 770 }
 771
 772 int link_request_dhcp6_client(Link *link) {
 773         int r;
 774
 775         assert(link);
 776
 777         if (!link_dhcp6_enabled(link) && !link_ipv6_accept_ra_enabled(link))
 778                 return 0;
 779
 780         if (link->dhcp6_client)
 781                 return 0;
 782
 783         r = link_queue_request(link, REQUEST_TYPE_DHCP6_CLIENT, dhcp6_process_request, NULL);
 784         if (r < 0)
 785                 return log_link_warning_errno(link, r, "Failed to request configuring of the DHCPv6 client: %m");
 786
 787         log_link_debug(link, "Requested configuring of the DHCPv6 client.");
 788         return 0;
 789 }
 790
 791 int link_serialize_dhcp6_client(Link *link, FILE *f) {
 792         _cleanup_free_ char *duid = NULL;
 793         uint32_t iaid;
 794         int r;
 795
 796         assert(link);
 797
 798         if (!link->dhcp6_client)
 799                 return 0;
 800
 801         r = sd_dhcp6_client_get_iaid(link->dhcp6_client, &iaid);
 802         if (r >= 0)
 803                 fprintf(f, "DHCP6_CLIENT_IAID=0x%x\n", iaid);
 804
 805         r = sd_dhcp6_client_duid_as_string(link->dhcp6_client, &duid);
 806         if (r >= 0)
 807                 fprintf(f, "DHCP6_CLIENT_DUID=%s\n", duid);
 808
 809         return 0;
 810 }
 811
 812 int config_parse_dhcp6_pd_prefix_hint(
 813                 const char* unit,
 814                 const char *filename,
 815                 unsigned line,
 816                 const char *section,
 817                 unsigned section_line,
 818                 const char *lvalue,
 819                 int ltype,
 820                 const char *rvalue,
 821                 void *data,
 822                 void *userdata) {
 823
 824         Network *network = userdata;
 825         union in_addr_union u;
 826         unsigned char prefixlen;
 827         int r;
 828
 829         assert(filename);
 830         assert(lvalue);
 831         assert(rvalue);
 832         assert(userdata);
 833
 834         r = in_addr_prefix_from_string(rvalue, AF_INET6, &u, &prefixlen);
 835         if (r < 0) {
 836                 log_syntax(unit, LOG_WARNING, filename, line, r,
 837                            "Failed to parse %s=%s, ignoring assignment.", lvalue, rvalue);
 838                 return 0;
 839         }
 840
 841         if (prefixlen < 1 || prefixlen > 128) {
 842                 log_syntax(unit, LOG_WARNING, filename, line, 0,
 843                            "Invalid prefix length in %s=%s, ignoring assignment.", lvalue, rvalue);
 844                 return 0;
 845         }
 846
 847         network->dhcp6_pd_prefix_hint = u.in6;
 848         network->dhcp6_pd_prefix_length = prefixlen;
 849
 850         return 0;
 851 }
 852
 853 DEFINE_CONFIG_PARSE_ENUM(config_parse_dhcp6_client_start_mode, dhcp6_client_start_mode, DHCP6ClientStartMode,
 854                          "Failed to parse WithoutRA= setting");
 855
 856 static const char* const dhcp6_client_start_mode_table[_DHCP6_CLIENT_START_MODE_MAX] = {
 857         [DHCP6_CLIENT_START_MODE_NO]                  = "no",
 858         [DHCP6_CLIENT_START_MODE_INFORMATION_REQUEST] = "information-request",
 859         [DHCP6_CLIENT_START_MODE_SOLICIT]             = "solicit",
 860 };
 861
 862 DEFINE_STRING_TABLE_LOOKUP(dhcp6_client_start_mode, DHCP6ClientStartMode);