1 /* SPDX-License-Identifier: LGPL-2.1+ */
3 This file is part of systemd.
5 Copyright 2013-2014 Tom Gundersen <teg@jklm.no>
8 #include <netinet/ether.h>
11 #include "alloc-util.h"
12 #include "dhcp-lease-internal.h"
13 #include "hostname-util.h"
14 #include "parse-util.h"
15 #include "netdev/vrf.h"
16 #include "network-internal.h"
17 #include "networkd-link.h"
18 #include "networkd-manager.h"
19 #include "networkd-network.h"
20 #include "string-util.h"
21 #include "sysctl-util.h"
23 static int dhcp4_route_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
,
25 _cleanup_(link_unrefp
) Link
*link
= userdata
;
29 assert(link
->dhcp4_messages
> 0);
31 link
->dhcp4_messages
--;
33 r
= sd_netlink_message_get_errno(m
);
34 if (r
< 0 && r
!= -EEXIST
) {
35 log_link_error_errno(link
, r
, "Could not set DHCPv4 route: %m");
36 link_enter_failed(link
);
39 if (link
->dhcp4_messages
== 0) {
40 link
->dhcp4_configured
= true;
41 link_check_ready(link
);
47 static int route_scope_from_address(const Route
*route
, const struct in_addr
*self_addr
) {
51 if (in_addr_is_localhost(AF_INET
, &route
->dst
) ||
52 (self_addr
->s_addr
&& route
->dst
.in
.s_addr
== self_addr
->s_addr
))
54 else if (in4_addr_is_null(&route
->gw
.in
))
57 return RT_SCOPE_UNIVERSE
;
60 static int link_set_dhcp_routes(Link
*link
) {
61 _cleanup_free_ sd_dhcp_route
**static_routes
= NULL
;
62 bool classless_route
= false, static_route
= false;
63 struct in_addr gateway
, address
;
69 if (!link
->dhcp_lease
) /* link went down while we configured the IP addresses? */
72 if (!link
->network
) /* link went down while we configured the IP addresses? */
75 if (!link
->network
->dhcp_use_routes
)
78 /* When the interface is part of an VRF use the VRFs routing table, unless
79 * there is a another table specified. */
80 table
= link
->network
->dhcp_route_table
;
81 if (!link
->network
->dhcp_route_table_set
&& link
->network
->vrf
!= NULL
)
82 table
= VRF(link
->network
->vrf
)->table
;
84 r
= sd_dhcp_lease_get_address(link
->dhcp_lease
, &address
);
86 return log_link_warning_errno(link
, r
, "DHCP error: could not get address: %m");
88 n
= sd_dhcp_lease_get_routes(link
->dhcp_lease
, &static_routes
);
90 log_link_debug_errno(link
, n
, "DHCP error: could not get routes: %m");
92 for (i
= 0; i
< n
; i
++) {
93 if (static_routes
[i
]->option
== SD_DHCP_OPTION_CLASSLESS_STATIC_ROUTE
)
94 classless_route
= true;
96 if (static_routes
[i
]->option
== SD_DHCP_OPTION_STATIC_ROUTE
)
100 for (i
= 0; i
< n
; i
++) {
101 _cleanup_(route_freep
) Route
*route
= NULL
;
103 /* if the DHCP server returns both a Classless Static Routes option and a Static Routes option,
104 the DHCP client MUST ignore the Static Routes option. */
105 if (classless_route
&& static_routes
[i
]->option
== SD_DHCP_OPTION_STATIC_ROUTE
)
108 r
= route_new(&route
);
110 return log_link_error_errno(link
, r
, "Could not allocate route: %m");
112 route
->family
= AF_INET
;
113 route
->protocol
= RTPROT_DHCP
;
114 assert_se(sd_dhcp_route_get_gateway(static_routes
[i
], &route
->gw
.in
) >= 0);
115 assert_se(sd_dhcp_route_get_destination(static_routes
[i
], &route
->dst
.in
) >= 0);
116 assert_se(sd_dhcp_route_get_destination_prefix_length(static_routes
[i
], &route
->dst_prefixlen
) >= 0);
117 route
->priority
= link
->network
->dhcp_route_metric
;
118 route
->table
= table
;
119 route
->scope
= route_scope_from_address(route
, &address
);
121 r
= route_configure(route
, link
, dhcp4_route_handler
);
123 return log_link_warning_errno(link
, r
, "Could not set host route: %m");
125 link
->dhcp4_messages
++;
128 r
= sd_dhcp_lease_get_router(link
->dhcp_lease
, &gateway
);
130 log_link_info_errno(link
, r
, "DHCP: No routes received from DHCP server: %m");
132 log_link_warning_errno(link
, r
, "DHCP error: could not get gateway: %m");
134 /* According to RFC 3442: If the DHCP server returns both a Classless Static Routes option and
135 a Router option, the DHCP client MUST ignore the Router option. */
136 if (classless_route
&& static_route
)
137 log_link_warning(link
, "Classless static routes received from DHCP server: ignoring static-route option and router option");
139 if (r
>= 0 && !classless_route
) {
140 _cleanup_(route_freep
) Route
*route
= NULL
;
141 _cleanup_(route_freep
) Route
*route_gw
= NULL
;
143 r
= route_new(&route
);
145 return log_link_error_errno(link
, r
, "Could not allocate route: %m");
147 route
->protocol
= RTPROT_DHCP
;
149 r
= route_new(&route_gw
);
151 return log_link_error_errno(link
, r
, "Could not allocate route: %m");
153 /* The dhcp netmask may mask out the gateway. Add an explicit
154 * route for the gw host so that we can route no matter the
155 * netmask or existing kernel route tables. */
156 route_gw
->family
= AF_INET
;
157 route_gw
->dst
.in
= gateway
;
158 route_gw
->dst_prefixlen
= 32;
159 route_gw
->prefsrc
.in
= address
;
160 route_gw
->scope
= RT_SCOPE_LINK
;
161 route_gw
->protocol
= RTPROT_DHCP
;
162 route_gw
->priority
= link
->network
->dhcp_route_metric
;
163 route_gw
->table
= table
;
165 r
= route_configure(route_gw
, link
, dhcp4_route_handler
);
167 return log_link_warning_errno(link
, r
, "Could not set host route: %m");
169 link
->dhcp4_messages
++;
171 route
->family
= AF_INET
;
172 route
->gw
.in
= gateway
;
173 route
->prefsrc
.in
= address
;
174 route
->priority
= link
->network
->dhcp_route_metric
;
175 route
->table
= table
;
177 r
= route_configure(route
, link
, dhcp4_route_handler
);
179 log_link_warning_errno(link
, r
, "Could not set routes: %m");
180 link_enter_failed(link
);
184 link
->dhcp4_messages
++;
190 static int dhcp_lease_lost(Link
*link
) {
191 _cleanup_(address_freep
) Address
*address
= NULL
;
193 struct in_addr netmask
;
194 struct in_addr gateway
;
195 unsigned prefixlen
= 0;
199 assert(link
->dhcp_lease
);
201 log_link_warning(link
, "DHCP lease lost");
203 if (link
->network
->dhcp_use_routes
) {
204 _cleanup_free_ sd_dhcp_route
**routes
= NULL
;
207 n
= sd_dhcp_lease_get_routes(link
->dhcp_lease
, &routes
);
209 for (i
= 0; i
< n
; i
++) {
210 _cleanup_(route_freep
) Route
*route
= NULL
;
212 r
= route_new(&route
);
214 route
->family
= AF_INET
;
215 assert_se(sd_dhcp_route_get_gateway(routes
[i
], &route
->gw
.in
) >= 0);
216 assert_se(sd_dhcp_route_get_destination(routes
[i
], &route
->dst
.in
) >= 0);
217 assert_se(sd_dhcp_route_get_destination_prefix_length(routes
[i
], &route
->dst_prefixlen
) >= 0);
219 route_remove(route
, link
,
220 link_route_remove_handler
);
226 r
= address_new(&address
);
228 r
= sd_dhcp_lease_get_router(link
->dhcp_lease
, &gateway
);
230 _cleanup_(route_freep
) Route
*route_gw
= NULL
;
231 _cleanup_(route_freep
) Route
*route
= NULL
;
233 r
= route_new(&route_gw
);
235 route_gw
->family
= AF_INET
;
236 route_gw
->dst
.in
= gateway
;
237 route_gw
->dst_prefixlen
= 32;
238 route_gw
->scope
= RT_SCOPE_LINK
;
240 route_remove(route_gw
, link
,
241 link_route_remove_handler
);
244 r
= route_new(&route
);
246 route
->family
= AF_INET
;
247 route
->gw
.in
= gateway
;
249 route_remove(route
, link
,
250 link_route_remove_handler
);
254 r
= sd_dhcp_lease_get_address(link
->dhcp_lease
, &addr
);
256 r
= sd_dhcp_lease_get_netmask(link
->dhcp_lease
, &netmask
);
258 prefixlen
= in4_addr_netmask_to_prefixlen(&netmask
);
260 address
->family
= AF_INET
;
261 address
->in_addr
.in
= addr
;
262 address
->prefixlen
= prefixlen
;
264 address_remove(address
, link
, link_address_remove_handler
);
268 if (link
->network
->dhcp_use_mtu
) {
271 r
= sd_dhcp_lease_get_mtu(link
->dhcp_lease
, &mtu
);
272 if (r
>= 0 && link
->original_mtu
!= mtu
) {
273 r
= link_set_mtu(link
, link
->original_mtu
);
275 log_link_warning(link
,
276 "DHCP error: could not reset MTU");
277 link_enter_failed(link
);
283 if (link
->network
->dhcp_use_hostname
) {
284 const char *hostname
= NULL
;
286 if (link
->network
->dhcp_hostname
)
287 hostname
= link
->network
->dhcp_hostname
;
289 (void) sd_dhcp_lease_get_hostname(link
->dhcp_lease
, &hostname
);
292 /* If a hostname was set due to the lease, then unset it now. */
293 r
= manager_set_hostname(link
->manager
, NULL
);
295 log_link_warning_errno(link
, r
, "Failed to reset transient hostname: %m");
299 link
->dhcp_lease
= sd_dhcp_lease_unref(link
->dhcp_lease
);
301 link
->dhcp4_configured
= false;
306 static int dhcp4_address_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
,
308 _cleanup_(link_unrefp
) Link
*link
= userdata
;
313 r
= sd_netlink_message_get_errno(m
);
314 if (r
< 0 && r
!= -EEXIST
) {
315 log_link_error_errno(link
, r
, "Could not set DHCPv4 address: %m");
316 link_enter_failed(link
);
318 manager_rtnl_process_address(rtnl
, m
, link
->manager
);
320 link_set_dhcp_routes(link
);
322 if (link
->dhcp4_messages
== 0) {
323 link
->dhcp4_configured
= true;
324 link_check_ready(link
);
330 static int dhcp4_update_address(Link
*link
,
331 struct in_addr
*address
,
332 struct in_addr
*netmask
,
334 _cleanup_(address_freep
) Address
*addr
= NULL
;
342 prefixlen
= in4_addr_netmask_to_prefixlen(netmask
);
344 r
= address_new(&addr
);
348 addr
->family
= AF_INET
;
349 addr
->in_addr
.in
.s_addr
= address
->s_addr
;
350 addr
->cinfo
.ifa_prefered
= lifetime
;
351 addr
->cinfo
.ifa_valid
= lifetime
;
352 addr
->prefixlen
= prefixlen
;
353 addr
->broadcast
.s_addr
= address
->s_addr
| ~netmask
->s_addr
;
355 /* allow reusing an existing address and simply update its lifetime
356 * in case it already exists */
357 r
= address_configure(addr
, link
, dhcp4_address_handler
, true);
364 static int dhcp_lease_renew(sd_dhcp_client
*client
, Link
*link
) {
365 sd_dhcp_lease
*lease
;
366 struct in_addr address
;
367 struct in_addr netmask
;
368 uint32_t lifetime
= CACHE_INFO_INFINITY_LIFE_TIME
;
373 assert(link
->network
);
375 r
= sd_dhcp_client_get_lease(client
, &lease
);
377 return log_link_warning_errno(link
, r
, "DHCP error: no lease: %m");
379 sd_dhcp_lease_unref(link
->dhcp_lease
);
380 link
->dhcp4_configured
= false;
381 link
->dhcp_lease
= sd_dhcp_lease_ref(lease
);
384 r
= sd_dhcp_lease_get_address(lease
, &address
);
386 return log_link_warning_errno(link
, r
, "DHCP error: no address: %m");
388 r
= sd_dhcp_lease_get_netmask(lease
, &netmask
);
390 return log_link_warning_errno(link
, r
, "DHCP error: no netmask: %m");
392 if (!link
->network
->dhcp_critical
) {
393 r
= sd_dhcp_lease_get_lifetime(link
->dhcp_lease
, &lifetime
);
395 return log_link_warning_errno(link
, r
, "DHCP error: no lifetime: %m");
398 r
= dhcp4_update_address(link
, &address
, &netmask
, lifetime
);
400 log_link_warning_errno(link
, r
, "Could not update IP address: %m");
401 link_enter_failed(link
);
408 static int dhcp_lease_acquired(sd_dhcp_client
*client
, Link
*link
) {
409 sd_dhcp_lease
*lease
;
410 struct in_addr address
;
411 struct in_addr netmask
;
412 struct in_addr gateway
;
414 uint32_t lifetime
= CACHE_INFO_INFINITY_LIFE_TIME
;
420 r
= sd_dhcp_client_get_lease(client
, &lease
);
422 return log_link_error_errno(link
, r
, "DHCP error: No lease: %m");
424 r
= sd_dhcp_lease_get_address(lease
, &address
);
426 return log_link_error_errno(link
, r
, "DHCP error: No address: %m");
428 r
= sd_dhcp_lease_get_netmask(lease
, &netmask
);
430 return log_link_error_errno(link
, r
, "DHCP error: No netmask: %m");
432 prefixlen
= in4_addr_netmask_to_prefixlen(&netmask
);
434 r
= sd_dhcp_lease_get_router(lease
, &gateway
);
435 if (r
< 0 && r
!= -ENODATA
)
436 return log_link_error_errno(link
, r
, "DHCP error: Could not get gateway: %m");
440 LOG_LINK_INTERFACE(link
),
441 LOG_LINK_MESSAGE(link
, "DHCPv4 address %u.%u.%u.%u/%u via %u.%u.%u.%u",
442 ADDRESS_FMT_VAL(address
),
444 ADDRESS_FMT_VAL(gateway
)),
445 "ADDRESS=%u.%u.%u.%u", ADDRESS_FMT_VAL(address
),
446 "PREFIXLEN=%u", prefixlen
,
447 "GATEWAY=%u.%u.%u.%u", ADDRESS_FMT_VAL(gateway
),
451 LOG_LINK_INTERFACE(link
),
452 LOG_LINK_MESSAGE(link
, "DHCPv4 address %u.%u.%u.%u/%u",
453 ADDRESS_FMT_VAL(address
),
455 "ADDRESS=%u.%u.%u.%u", ADDRESS_FMT_VAL(address
),
456 "PREFIXLEN=%u", prefixlen
,
459 link
->dhcp_lease
= sd_dhcp_lease_ref(lease
);
462 if (link
->network
->dhcp_use_mtu
) {
465 r
= sd_dhcp_lease_get_mtu(lease
, &mtu
);
467 r
= link_set_mtu(link
, mtu
);
469 log_link_error_errno(link
, r
, "Failed to set MTU to %" PRIu16
": %m", mtu
);
473 if (link
->network
->dhcp_use_hostname
) {
474 const char *dhcpname
= NULL
;
475 _cleanup_free_
char *hostname
= NULL
;
477 if (link
->network
->dhcp_hostname
)
478 dhcpname
= link
->network
->dhcp_hostname
;
480 (void) sd_dhcp_lease_get_hostname(lease
, &dhcpname
);
483 r
= shorten_overlong(dhcpname
, &hostname
);
485 log_link_warning_errno(link
, r
, "Unable to shorten overlong DHCP hostname '%s', ignoring: %m", dhcpname
);
487 log_link_notice(link
, "Overlong DCHP hostname received, shortened from '%s' to '%s'", dhcpname
, hostname
);
491 r
= manager_set_hostname(link
->manager
, hostname
);
493 log_link_error_errno(link
, r
, "Failed to set transient hostname to '%s': %m", hostname
);
497 if (link
->network
->dhcp_use_timezone
) {
498 const char *tz
= NULL
;
500 (void) sd_dhcp_lease_get_timezone(link
->dhcp_lease
, &tz
);
503 r
= manager_set_timezone(link
->manager
, tz
);
505 log_link_error_errno(link
, r
, "Failed to set timezone to '%s': %m", tz
);
509 if (!link
->network
->dhcp_critical
) {
510 r
= sd_dhcp_lease_get_lifetime(link
->dhcp_lease
, &lifetime
);
512 log_link_warning_errno(link
, r
, "DHCP error: no lifetime: %m");
517 r
= dhcp4_update_address(link
, &address
, &netmask
, lifetime
);
519 log_link_warning_errno(link
, r
, "Could not update IP address: %m");
520 link_enter_failed(link
);
526 static void dhcp4_handler(sd_dhcp_client
*client
, int event
, void *userdata
) {
527 Link
*link
= userdata
;
531 assert(link
->network
);
532 assert(link
->manager
);
534 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
538 case SD_DHCP_CLIENT_EVENT_EXPIRED
:
539 case SD_DHCP_CLIENT_EVENT_STOP
:
540 case SD_DHCP_CLIENT_EVENT_IP_CHANGE
:
541 if (link
->network
->dhcp_critical
) {
542 log_link_error(link
, "DHCPv4 connection considered system critical, ignoring request to reconfigure it.");
546 if (link
->dhcp_lease
) {
547 r
= dhcp_lease_lost(link
);
549 link_enter_failed(link
);
554 if (event
== SD_DHCP_CLIENT_EVENT_IP_CHANGE
) {
555 r
= dhcp_lease_acquired(client
, link
);
557 link_enter_failed(link
);
563 case SD_DHCP_CLIENT_EVENT_RENEW
:
564 r
= dhcp_lease_renew(client
, link
);
566 link_enter_failed(link
);
570 case SD_DHCP_CLIENT_EVENT_IP_ACQUIRE
:
571 r
= dhcp_lease_acquired(client
, link
);
573 link_enter_failed(link
);
579 log_link_warning_errno(link
, event
, "DHCP error: Client failed: %m");
581 log_link_warning(link
, "DHCP unknown event: %i", event
);
588 static int dhcp4_set_hostname(Link
*link
) {
589 _cleanup_free_
char *hostname
= NULL
;
595 if (!link
->network
->dhcp_send_hostname
)
597 else if (link
->network
->dhcp_hostname
)
598 hn
= link
->network
->dhcp_hostname
;
600 r
= gethostname_strict(&hostname
);
601 if (r
< 0 && r
!= -ENXIO
) /* ENXIO: no hostname set or hostname is "localhost" */
607 return sd_dhcp_client_set_hostname(link
->dhcp_client
, hn
);
610 static bool promote_secondaries_enabled(const char *ifname
) {
611 _cleanup_free_
char *promote_secondaries_sysctl
= NULL
;
612 char *promote_secondaries_path
;
615 promote_secondaries_path
= strjoina("net/ipv4/conf/", ifname
, "/promote_secondaries");
616 r
= sysctl_read(promote_secondaries_path
, &promote_secondaries_sysctl
);
618 log_debug_errno(r
, "Cannot read sysctl %s", promote_secondaries_path
);
622 truncate_nl(promote_secondaries_sysctl
);
623 r
= parse_boolean(promote_secondaries_sysctl
);
625 log_warning_errno(r
, "Cannot parse sysctl %s with content %s as boolean", promote_secondaries_path
, promote_secondaries_sysctl
);
629 /* dhcp4_set_promote_secondaries will ensure this interface has
630 * the "promote_secondaries" option in the kernel set. If this sysctl
631 * is not set DHCP will work only as long as the IP address does not
632 * changes between leases. The kernel will remove all secondary IP
633 * addresses of an interface otherwise. The way systemd-network works
634 * is that the new IP of a lease is added as a secondary IP and when
635 * the primary one expires it relies on the kernel to promote the
636 * secondary IP. See also https://github.com/systemd/systemd/issues/7163
638 int dhcp4_set_promote_secondaries(Link
*link
) {
642 assert(link
->network
);
643 assert(link
->network
->dhcp
& ADDRESS_FAMILY_IPV4
);
645 /* check if the kernel has promote_secondaries enabled for our
646 * interface. If it is not globally enabled or enabled for the
647 * specific interface we must either enable it.
649 if (!(promote_secondaries_enabled("all") || promote_secondaries_enabled(link
->ifname
))) {
650 char *promote_secondaries_path
= NULL
;
652 log_link_debug(link
, "promote_secondaries is unset, setting it");
653 promote_secondaries_path
= strjoina("net/ipv4/conf/", link
->ifname
, "/promote_secondaries");
654 r
= sysctl_write(promote_secondaries_path
, "1");
656 log_link_warning_errno(link
, r
, "cannot set sysctl %s to 1", promote_secondaries_path
);
663 int dhcp4_configure(Link
*link
) {
667 assert(link
->network
);
668 assert(link
->network
->dhcp
& ADDRESS_FAMILY_IPV4
);
670 if (!link
->dhcp_client
) {
671 r
= sd_dhcp_client_new(&link
->dhcp_client
, link
->network
->dhcp_anonymize
);
676 r
= sd_dhcp_client_attach_event(link
->dhcp_client
, NULL
, 0);
680 r
= sd_dhcp_client_set_mac(link
->dhcp_client
,
681 (const uint8_t *) &link
->mac
,
682 sizeof (link
->mac
), ARPHRD_ETHER
);
686 r
= sd_dhcp_client_set_ifindex(link
->dhcp_client
, link
->ifindex
);
690 r
= sd_dhcp_client_set_callback(link
->dhcp_client
, dhcp4_handler
, link
);
694 r
= sd_dhcp_client_set_request_broadcast(link
->dhcp_client
,
695 link
->network
->dhcp_broadcast
);
700 r
= sd_dhcp_client_set_mtu(link
->dhcp_client
, link
->mtu
);
705 if (link
->network
->dhcp_use_mtu
) {
706 r
= sd_dhcp_client_set_request_option(link
->dhcp_client
,
707 SD_DHCP_OPTION_INTERFACE_MTU
);
712 /* NOTE: even if this variable is called "use", it also "sends" PRL
713 * options, maybe there should be a different configuration variable
714 * to send or not route options?. */
715 /* NOTE: when using Anonymize=yes, routes PRL options are sent
716 * by default, so they don't need to be added here. */
717 if (link
->network
->dhcp_use_routes
&& !link
->network
->dhcp_anonymize
) {
718 r
= sd_dhcp_client_set_request_option(link
->dhcp_client
,
719 SD_DHCP_OPTION_STATIC_ROUTE
);
722 r
= sd_dhcp_client_set_request_option(link
->dhcp_client
,
723 SD_DHCP_OPTION_CLASSLESS_STATIC_ROUTE
);
728 if (link
->network
->dhcp_use_ntp
) {
729 r
= sd_dhcp_client_set_request_option(link
->dhcp_client
, SD_DHCP_OPTION_NTP_SERVER
);
734 if (link
->network
->dhcp_use_timezone
) {
735 r
= sd_dhcp_client_set_request_option(link
->dhcp_client
, SD_DHCP_OPTION_NEW_TZDB_TIMEZONE
);
740 r
= dhcp4_set_hostname(link
);
744 if (link
->network
->dhcp_vendor_class_identifier
) {
745 r
= sd_dhcp_client_set_vendor_class_identifier(link
->dhcp_client
,
746 link
->network
->dhcp_vendor_class_identifier
);
751 if (link
->network
->dhcp_user_class
) {
752 r
= sd_dhcp_client_set_user_class(link
->dhcp_client
, (const char **) link
->network
->dhcp_user_class
);
757 if (link
->network
->dhcp_client_port
) {
758 r
= sd_dhcp_client_set_client_port(link
->dhcp_client
, link
->network
->dhcp_client_port
);
763 switch (link
->network
->dhcp_client_identifier
) {
764 case DHCP_CLIENT_ID_DUID
: {
765 /* If configured, apply user specified DUID and/or IAID */
766 const DUID
*duid
= link_duid(link
);
768 r
= sd_dhcp_client_set_iaid_duid(link
->dhcp_client
,
771 duid
->raw_data_len
> 0 ? duid
->raw_data
: NULL
,
777 case DHCP_CLIENT_ID_DUID_ONLY
: {
778 /* If configured, apply user specified DUID */
779 const DUID
*duid
= link_duid(link
);
781 r
= sd_dhcp_client_set_duid(link
->dhcp_client
,
783 duid
->raw_data_len
> 0 ? duid
->raw_data
: NULL
,
789 case DHCP_CLIENT_ID_MAC
:
790 r
= sd_dhcp_client_set_client_id(link
->dhcp_client
,
792 (const uint8_t *) &link
->mac
,
798 assert_not_reached("Unknown client identifier type.");