Debian Codegraph @

src/network/networkd-dhcp6.c

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