1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
3 #include <netinet/in.h>
4 #include <netinet/ip.h>
6 #include <linux/if_arp.h>
8 #include "alloc-util.h"
9 #include "dhcp-client-internal.h"
10 #include "hostname-setup.h"
11 #include "hostname-util.h"
12 #include "parse-util.h"
13 #include "network-internal.h"
14 #include "networkd-address.h"
15 #include "networkd-dhcp-prefix-delegation.h"
16 #include "networkd-dhcp4-bus.h"
17 #include "networkd-dhcp4.h"
18 #include "networkd-ipv4acd.h"
19 #include "networkd-link.h"
20 #include "networkd-manager.h"
21 #include "networkd-network.h"
22 #include "networkd-nexthop.h"
23 #include "networkd-queue.h"
24 #include "networkd-route.h"
25 #include "networkd-setlink.h"
26 #include "networkd-state-file.h"
27 #include "string-table.h"
29 #include "sysctl-util.h"
31 void network_adjust_dhcp4(Network
*network
) {
34 if (!FLAGS_SET(network
->dhcp
, ADDRESS_FAMILY_IPV4
))
37 if (network
->dhcp_use_gateway
< 0)
38 network
->dhcp_use_gateway
= network
->dhcp_use_routes
;
40 /* RFC7844 section 3.: MAY contain the Client Identifier option
41 * Section 3.5: clients MUST use client identifiers based solely on the link-layer address
42 * NOTE: Using MAC, as it does not reveal extra information, and some servers might not answer
43 * if this option is not sent */
44 if (network
->dhcp_anonymize
&&
45 network
->dhcp_client_identifier
>= 0 &&
46 network
->dhcp_client_identifier
!= DHCP_CLIENT_ID_MAC
) {
47 log_warning("%s: ClientIdentifier= is set, although Anonymize=yes. Using ClientIdentifier=mac.",
49 network
->dhcp_client_identifier
= DHCP_CLIENT_ID_MAC
;
52 if (network
->dhcp_client_identifier
< 0)
53 network
->dhcp_client_identifier
= network
->dhcp_anonymize
? DHCP_CLIENT_ID_MAC
: DHCP_CLIENT_ID_DUID
;
55 /* By default, RapidCommit= is enabled when Anonymize=no and neither AllowList= nor DenyList= is specified. */
56 if (network
->dhcp_use_rapid_commit
< 0)
57 network
->dhcp_use_rapid_commit
=
58 !network
->dhcp_anonymize
&&
59 set_isempty(network
->dhcp_allow_listed_ip
) &&
60 set_isempty(network
->dhcp_deny_listed_ip
);
63 static int dhcp4_prefix_covers(
65 const struct in_addr
*in_prefix
,
66 uint8_t in_prefixlen
) {
68 struct in_addr prefix
;
73 assert(link
->dhcp_lease
);
76 /* Return true if the input address or address range is in the assigned network.
77 * E.g. if the DHCP server provides 192.168.0.100/24, then this returns true for the address or
78 * address range in 192.168.0.0/24, and returns false otherwise. */
80 r
= sd_dhcp_lease_get_prefix(link
->dhcp_lease
, &prefix
, &prefixlen
);
84 return in4_addr_prefix_covers_full(&prefix
, prefixlen
, in_prefix
, in_prefixlen
);
87 static int dhcp4_get_router(Link
*link
, struct in_addr
*ret
) {
88 const struct in_addr
*routers
;
92 assert(link
->dhcp_lease
);
95 r
= sd_dhcp_lease_get_router(link
->dhcp_lease
, &routers
);
99 /* The router option may provide multiple routers, We only use the first non-null address. */
101 FOREACH_ARRAY(router
, routers
, r
) {
102 if (in4_addr_is_null(router
))
112 static int dhcp4_get_classless_static_or_static_routes(Link
*link
, sd_dhcp_route
***ret_routes
, size_t *ret_num
) {
113 _cleanup_free_ sd_dhcp_route
**routes
= NULL
;
117 assert(link
->dhcp_lease
);
119 /* If the DHCP server returns both a Classless Static Routes option and a Static Routes option,
120 * the DHCP client MUST ignore the Static Routes option. */
122 r
= sd_dhcp_lease_get_classless_routes(link
->dhcp_lease
, &routes
);
126 *ret_routes
= TAKE_PTR(routes
);
129 return 1; /* classless */
130 } else if (r
!= -ENODATA
)
133 r
= sd_dhcp_lease_get_static_routes(link
->dhcp_lease
, &routes
);
139 *ret_routes
= TAKE_PTR(routes
);
142 return 0; /* static */
145 static int dhcp4_find_gateway_for_destination(
147 const struct in_addr
*destination
,
148 uint8_t prefixlength
,
150 struct in_addr
*ret
) {
152 _cleanup_free_ sd_dhcp_route
**routes
= NULL
;
154 bool is_classless
, reachable
;
155 uint8_t max_prefixlen
= UINT8_MAX
;
160 assert(link
->dhcp_lease
);
164 /* This tries to find the most suitable gateway for an address or address range.
165 * E.g. if the server provides the default gateway 192.168.0.1 and a classless static route for
166 * 8.0.0.0/8 with gateway 192.168.0.2, then this returns 192.168.0.2 for 8.8.8.8/32, and 192.168.0.1
167 * for 9.9.9.9/32. If 'allow_null' flag is set, and the input address or address range is in the
168 * assigned network, then the default gateway will be ignored and the null address will be returned
169 * unless a matching non-default gateway found. */
171 r
= dhcp4_prefix_covers(link
, destination
, prefixlength
);
176 r
= dhcp4_get_classless_static_or_static_routes(link
, &routes
, &n_routes
);
177 if (r
< 0 && r
!= -ENODATA
)
179 is_classless
= r
> 0;
181 /* First, find most suitable gateway. */
182 FOREACH_ARRAY(e
, routes
, n_routes
) {
186 r
= sd_dhcp_route_get_destination(*e
, &dst
);
190 r
= sd_dhcp_route_get_destination_prefix_length(*e
, &len
);
194 r
= in4_addr_prefix_covers_full(&dst
, len
, destination
, prefixlength
);
200 if (max_prefixlen
!= UINT8_MAX
&& max_prefixlen
> len
)
203 r
= sd_dhcp_route_get_gateway(*e
, &gw
);
210 /* Found a suitable gateway in classless static routes or static routes. */
211 if (max_prefixlen
!= UINT8_MAX
) {
212 if (max_prefixlen
== 0 && reachable
&& allow_null
)
213 /* Do not return the default gateway, if the destination is in the assigned network. */
214 *ret
= (struct in_addr
) {};
220 /* When the destination is in the assigned network, return the null address if allowed. */
221 if (reachable
&& allow_null
) {
222 *ret
= (struct in_addr
) {};
226 /* According to RFC 3442: If the DHCP server returns both a Classless Static Routes option and
227 * a Router option, the DHCP client MUST ignore the Router option. */
229 r
= dhcp4_get_router(link
, ret
);
237 return -EHOSTUNREACH
; /* Not in the same network, cannot reach the destination. */
240 return -ENODATA
; /* No matching gateway found. */
243 static int dhcp4_remove_address_and_routes(Link
*link
, bool only_marked
) {
249 assert(link
->manager
);
251 SET_FOREACH(route
, link
->manager
->routes
) {
252 if (route
->source
!= NETWORK_CONFIG_SOURCE_DHCP4
)
254 if (route
->nexthop
.ifindex
!= 0 && route
->nexthop
.ifindex
!= link
->ifindex
)
256 if (only_marked
&& !route_is_marked(route
))
259 RET_GATHER(ret
, route_remove_and_cancel(route
, link
->manager
));
262 SET_FOREACH(address
, link
->addresses
) {
263 if (address
->source
!= NETWORK_CONFIG_SOURCE_DHCP4
)
265 if (only_marked
&& !address_is_marked(address
))
268 RET_GATHER(ret
, address_remove_and_cancel(address
, link
));
274 static int dhcp4_address_get(Link
*link
, Address
**ret
) {
279 SET_FOREACH(address
, link
->addresses
) {
280 if (address
->source
!= NETWORK_CONFIG_SOURCE_DHCP4
)
282 if (address_is_marked(address
))
293 static int dhcp4_address_ready_callback(Address
*address
) {
295 assert(address
->link
);
297 /* Do not call this again. */
298 address
->callback
= NULL
;
300 return dhcp4_check_ready(address
->link
);
303 int dhcp4_check_ready(Link
*link
) {
309 if (link
->dhcp4_messages
> 0) {
310 log_link_debug(link
, "%s(): DHCPv4 address and routes are not set.", __func__
);
314 if (dhcp4_address_get(link
, &address
) < 0) {
315 log_link_debug(link
, "%s(): DHCPv4 address is not set.", __func__
);
319 if (!address_is_ready(address
)) {
320 log_link_debug(link
, "%s(): DHCPv4 address is not ready.", __func__
);
321 address
->callback
= dhcp4_address_ready_callback
;
325 link
->dhcp4_configured
= true;
326 log_link_debug(link
, "DHCPv4 address and routes set.");
328 /* New address and routes are configured now. Let's release old lease. */
329 r
= dhcp4_remove_address_and_routes(link
, /* only_marked = */ true);
333 r
= sd_ipv4ll_stop(link
->ipv4ll
);
335 return log_link_warning_errno(link
, r
, "Failed to drop IPv4 link-local address: %m");
337 link_check_ready(link
);
341 static int dhcp4_route_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, Request
*req
, Link
*link
, Route
*route
) {
347 r
= route_configure_handler_internal(rtnl
, m
, link
, route
, "Could not set DHCPv4 route");
351 r
= dhcp4_check_ready(link
);
353 link_enter_failed(link
);
358 static int dhcp4_request_route(Route
*route
, Link
*link
) {
359 struct in_addr server
;
365 assert(link
->manager
);
366 assert(link
->network
);
367 assert(link
->dhcp_lease
);
369 r
= sd_dhcp_lease_get_server_identifier(link
->dhcp_lease
, &server
);
371 return log_link_debug_errno(link
, r
, "Failed to get DHCP server IP address: %m");
373 route
->source
= NETWORK_CONFIG_SOURCE_DHCP4
;
374 route
->provider
.in
= server
;
375 route
->family
= AF_INET
;
376 if (!route
->protocol_set
)
377 route
->protocol
= RTPROT_DHCP
;
378 if (!route
->priority_set
)
379 route
->priority
= link
->network
->dhcp_route_metric
;
380 if (!route
->table_set
)
381 route
->table
= link_get_dhcp4_route_table(link
);
382 r
= route_metric_set(&route
->metric
, RTAX_MTU
, link
->network
->dhcp_route_mtu
);
385 r
= route_metric_set(&route
->metric
, RTAX_INITCWND
, link
->network
->dhcp_initial_congestion_window
);
388 r
= route_metric_set(&route
->metric
, RTAX_INITRWND
, link
->network
->dhcp_advertised_receive_window
);
391 r
= route_metric_set(&route
->metric
, RTAX_QUICKACK
, link
->network
->dhcp_quickack
);
395 r
= route_adjust_nexthops(route
, link
);
399 if (route_get(link
->manager
, route
, &existing
) < 0) /* This is a new route. */
400 link
->dhcp4_configured
= false;
402 route_unmark(existing
);
404 return link_request_route(link
, route
, &link
->dhcp4_messages
, dhcp4_route_handler
);
407 static bool link_prefixroute(Link
*link
) {
408 return !link
->network
->dhcp_route_table_set
||
409 link
->network
->dhcp_route_table
== RT_TABLE_MAIN
;
412 static int dhcp4_request_prefix_route(Link
*link
) {
413 _cleanup_(route_unrefp
) Route
*route
= NULL
;
417 assert(link
->dhcp_lease
);
419 if (link_prefixroute(link
))
420 /* When true, the route will be created by kernel. See dhcp4_update_address(). */
423 r
= route_new(&route
);
427 route
->scope
= RT_SCOPE_LINK
;
429 r
= sd_dhcp_lease_get_prefix(link
->dhcp_lease
, &route
->dst
.in
, &route
->dst_prefixlen
);
433 r
= sd_dhcp_lease_get_address(link
->dhcp_lease
, &route
->prefsrc
.in
);
437 return dhcp4_request_route(route
, link
);
440 static int dhcp4_request_route_to_gateway(Link
*link
, const struct in_addr
*gw
) {
441 _cleanup_(route_unrefp
) Route
*route
= NULL
;
442 struct in_addr address
;
446 assert(link
->dhcp_lease
);
449 r
= sd_dhcp_lease_get_address(link
->dhcp_lease
, &address
);
453 r
= route_new(&route
);
458 route
->dst_prefixlen
= 32;
459 route
->prefsrc
.in
= address
;
460 route
->scope
= RT_SCOPE_LINK
;
462 return dhcp4_request_route(route
, link
);
465 static int dhcp4_request_route_auto(
468 const struct in_addr
*gw
) {
470 struct in_addr address
;
475 assert(link
->dhcp_lease
);
478 r
= sd_dhcp_lease_get_address(link
->dhcp_lease
, &address
);
482 if (in4_addr_is_localhost(&route
->dst
.in
)) {
483 if (in4_addr_is_set(gw
))
484 log_link_debug(link
, "DHCP: requested route destination "IPV4_ADDRESS_FMT_STR
"/%u is localhost, "
485 "ignoring gateway address "IPV4_ADDRESS_FMT_STR
,
486 IPV4_ADDRESS_FMT_VAL(route
->dst
.in
), route
->dst_prefixlen
, IPV4_ADDRESS_FMT_VAL(*gw
));
488 route
->scope
= RT_SCOPE_HOST
;
489 route
->nexthop
.family
= AF_UNSPEC
;
490 route
->nexthop
.gw
= IN_ADDR_NULL
;
491 route
->prefsrc
= IN_ADDR_NULL
;
493 } else if (in4_addr_equal(&route
->dst
.in
, &address
)) {
494 if (in4_addr_is_set(gw
))
495 log_link_debug(link
, "DHCP: requested route destination "IPV4_ADDRESS_FMT_STR
"/%u is equivalent to the acquired address, "
496 "ignoring gateway address "IPV4_ADDRESS_FMT_STR
,
497 IPV4_ADDRESS_FMT_VAL(route
->dst
.in
), route
->dst_prefixlen
, IPV4_ADDRESS_FMT_VAL(*gw
));
499 route
->scope
= RT_SCOPE_HOST
;
500 route
->nexthop
.family
= AF_UNSPEC
;
501 route
->nexthop
.gw
= IN_ADDR_NULL
;
502 route
->prefsrc
.in
= address
;
504 } else if (in4_addr_is_null(gw
)) {
505 r
= dhcp4_prefix_covers(link
, &route
->dst
.in
, route
->dst_prefixlen
);
508 if (r
== 0 && DEBUG_LOGGING
) {
509 struct in_addr prefix
;
512 r
= sd_dhcp_lease_get_prefix(link
->dhcp_lease
, &prefix
, &prefixlen
);
516 log_link_debug(link
, "DHCP: requested route destination "IPV4_ADDRESS_FMT_STR
"/%u is not in the assigned network "
517 IPV4_ADDRESS_FMT_STR
"/%u, but no gateway is specified, using 'link' scope.",
518 IPV4_ADDRESS_FMT_VAL(route
->dst
.in
), route
->dst_prefixlen
,
519 IPV4_ADDRESS_FMT_VAL(prefix
), prefixlen
);
522 route
->scope
= RT_SCOPE_LINK
;
523 route
->nexthop
.family
= AF_UNSPEC
;
524 route
->nexthop
.gw
= IN_ADDR_NULL
;
525 route
->prefsrc
.in
= address
;
528 r
= dhcp4_request_route_to_gateway(link
, gw
);
532 route
->scope
= RT_SCOPE_UNIVERSE
;
533 route
->nexthop
.family
= AF_INET
;
534 route
->nexthop
.gw
.in
= *gw
;
535 route
->prefsrc
.in
= address
;
538 return dhcp4_request_route(route
, link
);
541 static int dhcp4_request_classless_static_or_static_routes(Link
*link
) {
542 _cleanup_free_ sd_dhcp_route
**routes
= NULL
;
547 assert(link
->dhcp_lease
);
549 if (!link
->network
->dhcp_use_routes
)
552 r
= dhcp4_get_classless_static_or_static_routes(link
, &routes
, &n_routes
);
558 FOREACH_ARRAY(e
, routes
, n_routes
) {
559 _cleanup_(route_unrefp
) Route
*route
= NULL
;
562 r
= route_new(&route
);
566 r
= sd_dhcp_route_get_gateway(*e
, &gw
);
570 r
= sd_dhcp_route_get_destination(*e
, &route
->dst
.in
);
574 r
= sd_dhcp_route_get_destination_prefix_length(*e
, &route
->dst_prefixlen
);
578 r
= dhcp4_request_route_auto(route
, link
, &gw
);
586 static int dhcp4_request_default_gateway(Link
*link
) {
587 _cleanup_(route_unrefp
) Route
*route
= NULL
;
588 struct in_addr address
, router
;
592 assert(link
->dhcp_lease
);
594 if (!link
->network
->dhcp_use_gateway
)
597 /* According to RFC 3442: If the DHCP server returns both a Classless Static Routes option and
598 * a Router option, the DHCP client MUST ignore the Router option. */
599 if (link
->network
->dhcp_use_routes
&&
600 dhcp4_get_classless_static_or_static_routes(link
, NULL
, NULL
) > 0)
603 r
= sd_dhcp_lease_get_address(link
->dhcp_lease
, &address
);
607 r
= dhcp4_get_router(link
, &router
);
609 log_link_debug(link
, "DHCP: No valid router address received from DHCP server.");
615 /* The dhcp netmask may mask out the gateway. First, add an explicit route for the gateway host
616 * so that we can route no matter the netmask or existing kernel route tables. */
617 r
= dhcp4_request_route_to_gateway(link
, &router
);
621 r
= route_new(&route
);
625 /* Next, add a default gateway. */
626 route
->nexthop
.family
= AF_INET
;
627 route
->nexthop
.gw
.in
= router
;
628 route
->prefsrc
.in
= address
;
630 return dhcp4_request_route(route
, link
);
633 static int dhcp4_request_semi_static_routes(Link
*link
) {
638 assert(link
->dhcp_lease
);
639 assert(link
->network
);
641 HASHMAP_FOREACH(rt
, link
->network
->routes_by_section
) {
642 _cleanup_(route_unrefp
) Route
*route
= NULL
;
645 if (!rt
->gateway_from_dhcp_or_ra
)
648 if (rt
->nexthop
.family
!= AF_INET
)
651 assert(rt
->family
== AF_INET
);
653 r
= dhcp4_find_gateway_for_destination(link
, &rt
->dst
.in
, rt
->dst_prefixlen
, /* allow_null = */ false, &gw
);
654 if (IN_SET(r
, -EHOSTUNREACH
, -ENODATA
)) {
655 log_link_debug_errno(link
, r
, "DHCP: Cannot find suitable gateway for destination %s of semi-static route, ignoring: %m",
656 IN4_ADDR_PREFIX_TO_STRING(&rt
->dst
.in
, rt
->dst_prefixlen
));
662 r
= dhcp4_request_route_to_gateway(link
, &gw
);
666 r
= route_dup(rt
, NULL
, &route
);
670 route
->nexthop
.gw
.in
= gw
;
672 r
= dhcp4_request_route(route
, link
);
680 static int dhcp4_request_routes_to_servers(
682 const struct in_addr
*servers
,
688 assert(link
->dhcp_lease
);
689 assert(link
->network
);
690 assert(servers
|| n_servers
== 0);
692 FOREACH_ARRAY(dst
, servers
, n_servers
) {
693 _cleanup_(route_unrefp
) Route
*route
= NULL
;
696 if (in4_addr_is_null(dst
))
699 r
= dhcp4_find_gateway_for_destination(link
, dst
, 32, /* allow_null = */ true, &gw
);
700 if (r
== -EHOSTUNREACH
) {
701 log_link_debug_errno(link
, r
, "DHCP: Cannot find suitable gateway for destination %s, ignoring: %m",
702 IN4_ADDR_PREFIX_TO_STRING(dst
, 32));
708 r
= route_new(&route
);
712 route
->dst
.in
= *dst
;
713 route
->dst_prefixlen
= 32;
715 r
= dhcp4_request_route_auto(route
, link
, &gw
);
723 static int dhcp4_request_routes_to_dns(Link
*link
) {
724 const struct in_addr
*dns
;
728 assert(link
->dhcp_lease
);
729 assert(link
->network
);
731 if (!link
->network
->dhcp_use_dns
||
732 !link
->network
->dhcp_routes_to_dns
)
735 r
= sd_dhcp_lease_get_dns(link
->dhcp_lease
, &dns
);
736 if (IN_SET(r
, 0, -ENODATA
))
741 return dhcp4_request_routes_to_servers(link
, dns
, r
);
744 static int dhcp4_request_routes_to_ntp(Link
*link
) {
745 const struct in_addr
*ntp
;
749 assert(link
->dhcp_lease
);
750 assert(link
->network
);
752 if (!link
->network
->dhcp_use_ntp
||
753 !link
->network
->dhcp_routes_to_ntp
)
756 r
= sd_dhcp_lease_get_ntp(link
->dhcp_lease
, &ntp
);
757 if (IN_SET(r
, 0, -ENODATA
))
762 return dhcp4_request_routes_to_servers(link
, ntp
, r
);
765 static int dhcp4_request_routes(Link
*link
) {
769 assert(link
->dhcp_lease
);
771 r
= dhcp4_request_prefix_route(link
);
773 return log_link_error_errno(link
, r
, "DHCP error: Could not request prefix route: %m");
775 r
= dhcp4_request_default_gateway(link
);
777 return log_link_error_errno(link
, r
, "DHCP error: Could not request default gateway: %m");
779 r
= dhcp4_request_classless_static_or_static_routes(link
);
781 return log_link_error_errno(link
, r
, "DHCP error: Could not request static routes: %m");
783 r
= dhcp4_request_semi_static_routes(link
);
785 return log_link_error_errno(link
, r
, "DHCP error: Could not request routes with Gateway=_dhcp4 setting: %m");
787 r
= dhcp4_request_routes_to_dns(link
);
789 return log_link_error_errno(link
, r
, "DHCP error: Could not request routes to DNS servers: %m");
791 r
= dhcp4_request_routes_to_ntp(link
);
793 return log_link_error_errno(link
, r
, "DHCP error: Could not request routes to NTP servers: %m");
798 static int dhcp_reset_mtu(Link
*link
) {
803 if (!link
->network
->dhcp_use_mtu
)
806 r
= link_request_to_set_mtu(link
, link
->original_mtu
);
808 return log_link_error_errno(link
, r
, "DHCP error: Could not queue request to reset MTU: %m");
813 static int dhcp_reset_hostname(Link
*link
) {
814 const char *hostname
;
819 if (!link
->network
->dhcp_use_hostname
)
822 hostname
= link
->network
->dhcp_hostname
;
824 (void) sd_dhcp_lease_get_hostname(link
->dhcp_lease
, &hostname
);
829 /* If a hostname was set due to the lease, then unset it now. */
830 r
= manager_set_hostname(link
->manager
, NULL
);
832 return log_link_error_errno(link
, r
, "DHCP error: Failed to reset transient hostname: %m");
837 int dhcp4_lease_lost(Link
*link
) {
841 assert(link
->dhcp_lease
);
842 assert(link
->network
);
844 log_link_info(link
, "DHCP lease lost");
846 link
->dhcp4_configured
= false;
848 if (link
->network
->dhcp_use_6rd
&&
849 sd_dhcp_lease_has_6rd(link
->dhcp_lease
))
850 dhcp4_pd_prefix_lost(link
);
852 RET_GATHER(r
, dhcp4_remove_address_and_routes(link
, /* only_marked = */ false));
853 RET_GATHER(r
, dhcp_reset_mtu(link
));
854 RET_GATHER(r
, dhcp_reset_hostname(link
));
856 link
->dhcp_lease
= sd_dhcp_lease_unref(link
->dhcp_lease
);
859 /* If one of the above failed. Do not request nexthops and routes. */
863 r
= link_request_static_nexthops(link
, true);
867 return link_request_static_routes(link
, true);
870 static int dhcp4_address_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, Request
*req
, Link
*link
, Address
*address
) {
875 r
= address_configure_handler_internal(rtnl
, m
, link
, "Could not set DHCPv4 address");
879 r
= dhcp4_check_ready(link
);
881 link_enter_failed(link
);
886 static int dhcp4_request_address(Link
*link
, bool announce
) {
887 _cleanup_(address_unrefp
) Address
*addr
= NULL
;
888 struct in_addr address
, server
;
891 usec_t lifetime_usec
;
895 assert(link
->manager
);
896 assert(link
->network
);
897 assert(link
->dhcp_lease
);
899 r
= sd_dhcp_lease_get_address(link
->dhcp_lease
, &address
);
901 return log_link_warning_errno(link
, r
, "DHCP error: no address: %m");
903 r
= sd_dhcp_lease_get_prefix(link
->dhcp_lease
, NULL
, &prefixlen
);
905 return log_link_warning_errno(link
, r
, "DHCP error: no netmask: %m");
907 r
= sd_dhcp_lease_get_server_identifier(link
->dhcp_lease
, &server
);
909 return log_link_debug_errno(link
, r
, "DHCP error: failed to get DHCP server IP address: %m");
911 if (!FLAGS_SET(link
->network
->keep_configuration
, KEEP_CONFIGURATION_DHCP
)) {
912 r
= sd_dhcp_lease_get_lifetime_timestamp(link
->dhcp_lease
, CLOCK_BOOTTIME
, &lifetime_usec
);
914 return log_link_warning_errno(link
, r
, "DHCP error: failed to get lifetime: %m");
916 lifetime_usec
= USEC_INFINITY
;
919 const struct in_addr
*router
;
921 r
= sd_dhcp_lease_get_router(link
->dhcp_lease
, &router
);
922 if (r
< 0 && r
!= -ENODATA
)
923 return log_link_error_errno(link
, r
, "DHCP error: Could not get gateway: %m");
925 if (r
> 0 && in4_addr_is_set(&router
[0]))
927 LOG_LINK_INTERFACE(link
),
928 LOG_LINK_MESSAGE(link
, "DHCPv4 address "IPV4_ADDRESS_FMT_STR
"/%u, gateway "IPV4_ADDRESS_FMT_STR
" acquired from "IPV4_ADDRESS_FMT_STR
,
929 IPV4_ADDRESS_FMT_VAL(address
),
931 IPV4_ADDRESS_FMT_VAL(router
[0]),
932 IPV4_ADDRESS_FMT_VAL(server
)),
933 "ADDRESS="IPV4_ADDRESS_FMT_STR
, IPV4_ADDRESS_FMT_VAL(address
),
934 "PREFIXLEN=%u", prefixlen
,
935 "GATEWAY="IPV4_ADDRESS_FMT_STR
, IPV4_ADDRESS_FMT_VAL(router
[0]));
938 LOG_LINK_INTERFACE(link
),
939 LOG_LINK_MESSAGE(link
, "DHCPv4 address "IPV4_ADDRESS_FMT_STR
"/%u acquired from "IPV4_ADDRESS_FMT_STR
,
940 IPV4_ADDRESS_FMT_VAL(address
),
942 IPV4_ADDRESS_FMT_VAL(server
)),
943 "ADDRESS="IPV4_ADDRESS_FMT_STR
, IPV4_ADDRESS_FMT_VAL(address
),
944 "PREFIXLEN=%u", prefixlen
);
947 r
= address_new(&addr
);
951 addr
->source
= NETWORK_CONFIG_SOURCE_DHCP4
;
952 addr
->provider
.in
= server
;
953 addr
->family
= AF_INET
;
954 addr
->in_addr
.in
.s_addr
= address
.s_addr
;
955 addr
->lifetime_preferred_usec
= lifetime_usec
;
956 addr
->lifetime_valid_usec
= lifetime_usec
;
957 addr
->prefixlen
= prefixlen
;
958 r
= sd_dhcp_lease_get_broadcast(link
->dhcp_lease
, &addr
->broadcast
);
959 if (r
< 0 && r
!= -ENODATA
)
960 return log_link_warning_errno(link
, r
, "DHCP: failed to get broadcast address: %m");
961 SET_FLAG(addr
->flags
, IFA_F_NOPREFIXROUTE
, !link_prefixroute(link
));
962 addr
->route_metric
= link
->network
->dhcp_route_metric
;
963 addr
->duplicate_address_detection
= link
->network
->dhcp_send_decline
? ADDRESS_FAMILY_IPV4
: ADDRESS_FAMILY_NO
;
965 r
= free_and_strdup_warn(&addr
->label
, link
->network
->dhcp_label
);
969 r
= free_and_strdup_warn(&addr
->netlabel
, link
->network
->dhcp_netlabel
);
973 if (address_get(link
, addr
, &existing
) < 0) /* The address is new. */
974 link
->dhcp4_configured
= false;
976 address_unmark(existing
);
978 r
= link_request_address(link
, addr
, &link
->dhcp4_messages
,
979 dhcp4_address_handler
, NULL
);
981 return log_link_error_errno(link
, r
, "Failed to request DHCPv4 address: %m");
986 static int dhcp4_request_address_and_routes(Link
*link
, bool announce
) {
991 link_mark_addresses(link
, NETWORK_CONFIG_SOURCE_DHCP4
);
992 manager_mark_routes(link
->manager
, link
, NETWORK_CONFIG_SOURCE_DHCP4
);
994 r
= dhcp4_request_address(link
, announce
);
998 r
= dhcp4_request_routes(link
);
1002 if (!link
->dhcp4_configured
) {
1003 link_set_state(link
, LINK_STATE_CONFIGURING
);
1004 link_check_ready(link
);
1010 static int dhcp_lease_renew(sd_dhcp_client
*client
, Link
*link
) {
1011 _cleanup_(sd_dhcp_lease_unrefp
) sd_dhcp_lease
*old_lease
= NULL
;
1012 sd_dhcp_lease
*lease
;
1016 assert(link
->network
);
1019 r
= sd_dhcp_client_get_lease(client
, &lease
);
1021 return log_link_warning_errno(link
, r
, "DHCP error: no lease: %m");
1023 old_lease
= TAKE_PTR(link
->dhcp_lease
);
1024 link
->dhcp_lease
= sd_dhcp_lease_ref(lease
);
1027 if (link
->network
->dhcp_use_6rd
) {
1028 if (sd_dhcp_lease_has_6rd(link
->dhcp_lease
)) {
1029 r
= dhcp4_pd_prefix_acquired(link
);
1031 return log_link_warning_errno(link
, r
, "Failed to process 6rd option: %m");
1032 } else if (sd_dhcp_lease_has_6rd(old_lease
))
1033 dhcp4_pd_prefix_lost(link
);
1036 return dhcp4_request_address_and_routes(link
, false);
1039 static int dhcp_lease_acquired(sd_dhcp_client
*client
, Link
*link
) {
1040 sd_dhcp_lease
*lease
;
1046 r
= sd_dhcp_client_get_lease(client
, &lease
);
1048 return log_link_error_errno(link
, r
, "DHCP error: No lease: %m");
1050 sd_dhcp_lease_unref(link
->dhcp_lease
);
1051 link
->dhcp_lease
= sd_dhcp_lease_ref(lease
);
1054 if (link
->network
->dhcp_use_mtu
) {
1057 r
= sd_dhcp_lease_get_mtu(lease
, &mtu
);
1059 r
= link_request_to_set_mtu(link
, mtu
);
1061 log_link_error_errno(link
, r
, "Failed to set MTU to %" PRIu16
": %m", mtu
);
1065 if (link
->network
->dhcp_use_hostname
) {
1066 const char *dhcpname
= NULL
;
1067 _cleanup_free_
char *hostname
= NULL
;
1069 if (link
->network
->dhcp_hostname
)
1070 dhcpname
= link
->network
->dhcp_hostname
;
1072 (void) sd_dhcp_lease_get_hostname(lease
, &dhcpname
);
1075 r
= shorten_overlong(dhcpname
, &hostname
);
1077 log_link_warning_errno(link
, r
, "Unable to shorten overlong DHCP hostname '%s', ignoring: %m", dhcpname
);
1079 log_link_notice(link
, "Overlong DHCP hostname received, shortened from '%s' to '%s'", dhcpname
, hostname
);
1083 r
= manager_set_hostname(link
->manager
, hostname
);
1085 log_link_error_errno(link
, r
, "Failed to set transient hostname to '%s': %m", hostname
);
1089 if (link
->network
->dhcp_use_timezone
) {
1090 const char *tz
= NULL
;
1092 (void) sd_dhcp_lease_get_timezone(link
->dhcp_lease
, &tz
);
1095 r
= manager_set_timezone(link
->manager
, tz
);
1097 log_link_error_errno(link
, r
, "Failed to set timezone to '%s': %m", tz
);
1101 if (link
->network
->dhcp_use_6rd
&&
1102 sd_dhcp_lease_has_6rd(link
->dhcp_lease
)) {
1103 r
= dhcp4_pd_prefix_acquired(link
);
1105 return log_link_warning_errno(link
, r
, "Failed to process 6rd option: %m");
1108 return dhcp4_request_address_and_routes(link
, true);
1111 static int dhcp_lease_ip_change(sd_dhcp_client
*client
, Link
*link
) {
1114 r
= dhcp_lease_acquired(client
, link
);
1116 (void) dhcp4_lease_lost(link
);
1121 static int dhcp_server_is_filtered(Link
*link
, sd_dhcp_client
*client
) {
1122 sd_dhcp_lease
*lease
;
1123 struct in_addr addr
;
1127 assert(link
->network
);
1130 r
= sd_dhcp_client_get_lease(client
, &lease
);
1132 return log_link_error_errno(link
, r
, "Failed to get DHCP lease: %m");
1134 r
= sd_dhcp_lease_get_server_identifier(lease
, &addr
);
1136 return log_link_debug_errno(link
, r
, "Failed to get DHCP server IP address: %m");
1138 if (in4_address_is_filtered(&addr
, link
->network
->dhcp_allow_listed_ip
, link
->network
->dhcp_deny_listed_ip
)) {
1139 if (DEBUG_LOGGING
) {
1140 if (link
->network
->dhcp_allow_listed_ip
)
1141 log_link_debug(link
, "DHCPv4 server IP address "IPV4_ADDRESS_FMT_STR
" not found in allow-list, ignoring offer.",
1142 IPV4_ADDRESS_FMT_VAL(addr
));
1144 log_link_debug(link
, "DHCPv4 server IP address "IPV4_ADDRESS_FMT_STR
" found in deny-list, ignoring offer.",
1145 IPV4_ADDRESS_FMT_VAL(addr
));
1154 static int dhcp4_handler(sd_dhcp_client
*client
, int event
, void *userdata
) {
1155 Link
*link
= ASSERT_PTR(userdata
);
1158 assert(link
->network
);
1159 assert(link
->manager
);
1161 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
1165 case SD_DHCP_CLIENT_EVENT_STOP
:
1167 log_link_debug(link
, "DHCP client is stopped. Acquiring IPv4 link-local address");
1169 if (in4_addr_is_set(&link
->network
->ipv4ll_start_address
)) {
1170 r
= sd_ipv4ll_set_address(link
->ipv4ll
, &link
->network
->ipv4ll_start_address
);
1172 return log_link_warning_errno(link
, r
, "Could not set IPv4 link-local start address: %m");
1175 r
= sd_ipv4ll_start(link
->ipv4ll
);
1176 if (r
< 0 && r
!= -ESTALE
) /* On exit, we cannot and should not start sd-ipv4ll. */
1177 return log_link_warning_errno(link
, r
, "Could not acquire IPv4 link-local address: %m");
1180 if (FLAGS_SET(link
->network
->keep_configuration
, KEEP_CONFIGURATION_DHCP
)) {
1181 log_link_notice(link
, "DHCPv4 connection considered critical, ignoring request to reconfigure it.");
1185 if (link
->dhcp_lease
) {
1186 if (link
->network
->dhcp_send_release
) {
1187 r
= sd_dhcp_client_send_release(client
);
1189 log_link_full_errno(link
,
1190 ERRNO_IS_DISCONNECT(r
) ? LOG_DEBUG
: LOG_WARNING
,
1191 r
, "Failed to send DHCP RELEASE, ignoring: %m");
1194 r
= dhcp4_lease_lost(link
);
1196 link_enter_failed(link
);
1202 case SD_DHCP_CLIENT_EVENT_EXPIRED
:
1203 if (FLAGS_SET(link
->network
->keep_configuration
, KEEP_CONFIGURATION_DHCP
)) {
1204 log_link_notice(link
, "DHCPv4 connection considered critical, ignoring request to reconfigure it.");
1208 if (link
->dhcp_lease
) {
1209 r
= dhcp4_lease_lost(link
);
1211 link_enter_failed(link
);
1217 case SD_DHCP_CLIENT_EVENT_IP_CHANGE
:
1218 if (FLAGS_SET(link
->network
->keep_configuration
, KEEP_CONFIGURATION_DHCP
)) {
1219 log_link_notice(link
, "DHCPv4 connection considered critical, ignoring request to reconfigure it.");
1223 r
= dhcp_lease_ip_change(client
, link
);
1225 link_enter_failed(link
);
1230 case SD_DHCP_CLIENT_EVENT_RENEW
:
1231 r
= dhcp_lease_renew(client
, link
);
1233 link_enter_failed(link
);
1237 case SD_DHCP_CLIENT_EVENT_IP_ACQUIRE
:
1238 r
= dhcp_lease_acquired(client
, link
);
1240 link_enter_failed(link
);
1244 case SD_DHCP_CLIENT_EVENT_SELECTING
:
1245 r
= dhcp_server_is_filtered(link
, client
);
1247 link_enter_failed(link
);
1254 case SD_DHCP_CLIENT_EVENT_TRANSIENT_FAILURE
:
1255 if (link
->ipv4ll
&& !sd_ipv4ll_is_running(link
->ipv4ll
)) {
1256 log_link_debug(link
, "Problems acquiring DHCP lease, acquiring IPv4 link-local address");
1258 if (in4_addr_is_set(&link
->network
->ipv4ll_start_address
)) {
1259 r
= sd_ipv4ll_set_address(link
->ipv4ll
, &link
->network
->ipv4ll_start_address
);
1261 return log_link_warning_errno(link
, r
, "Could not set IPv4 link-local start address: %m");
1264 r
= sd_ipv4ll_start(link
->ipv4ll
);
1266 return log_link_warning_errno(link
, r
, "Could not acquire IPv4 link-local address: %m");
1272 log_link_warning_errno(link
, event
, "DHCP error: Client failed: %m");
1274 log_link_warning(link
, "DHCP unknown event: %i", event
);
1281 static int dhcp4_set_hostname(Link
*link
) {
1282 _cleanup_free_
char *hostname
= NULL
;
1288 if (!link
->network
->dhcp_send_hostname
)
1290 else if (link
->network
->dhcp_hostname
)
1291 hn
= link
->network
->dhcp_hostname
;
1293 r
= gethostname_strict(&hostname
);
1294 if (r
< 0 && r
!= -ENXIO
) /* ENXIO: no hostname set or hostname is "localhost" */
1295 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to get hostname: %m");
1300 r
= sd_dhcp_client_set_hostname(link
->dhcp_client
, hn
);
1301 if (r
== -EINVAL
&& hostname
)
1302 /* Ignore error when the machine's hostname is not suitable to send in DHCP packet. */
1303 log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set hostname from kernel hostname, ignoring: %m");
1305 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set hostname: %m");
1310 static int dhcp4_set_client_identifier(Link
*link
) {
1314 assert(link
->network
);
1315 assert(link
->dhcp_client
);
1317 switch (link
->network
->dhcp_client_identifier
) {
1318 case DHCP_CLIENT_ID_DUID
: {
1319 /* If configured, apply user specified DUID and IAID */
1320 const DUID
*duid
= link_get_dhcp4_duid(link
);
1322 if (duid
->raw_data_len
== 0)
1323 switch (duid
->type
) {
1325 r
= sd_dhcp_client_set_iaid_duid_llt(link
->dhcp_client
,
1326 link
->network
->dhcp_iaid_set
,
1327 link
->network
->dhcp_iaid
,
1331 r
= sd_dhcp_client_set_iaid_duid_ll(link
->dhcp_client
,
1332 link
->network
->dhcp_iaid_set
,
1333 link
->network
->dhcp_iaid
);
1336 r
= sd_dhcp_client_set_iaid_duid_en(link
->dhcp_client
,
1337 link
->network
->dhcp_iaid_set
,
1338 link
->network
->dhcp_iaid
);
1340 case DUID_TYPE_UUID
:
1341 r
= sd_dhcp_client_set_iaid_duid_uuid(link
->dhcp_client
,
1342 link
->network
->dhcp_iaid_set
,
1343 link
->network
->dhcp_iaid
);
1346 r
= sd_dhcp_client_set_iaid_duid_raw(link
->dhcp_client
,
1347 link
->network
->dhcp_iaid_set
,
1348 link
->network
->dhcp_iaid
,
1349 duid
->type
, NULL
, 0);
1352 r
= sd_dhcp_client_set_iaid_duid_raw(link
->dhcp_client
,
1353 link
->network
->dhcp_iaid_set
,
1354 link
->network
->dhcp_iaid
,
1355 duid
->type
, duid
->raw_data
, duid
->raw_data_len
);
1360 case DHCP_CLIENT_ID_MAC
: {
1361 const uint8_t *hw_addr
= link
->hw_addr
.bytes
;
1362 size_t hw_addr_len
= link
->hw_addr
.length
;
1364 if (link
->iftype
== ARPHRD_INFINIBAND
&& hw_addr_len
== INFINIBAND_ALEN
) {
1365 /* set_client_id expects only last 8 bytes of an IB address */
1366 hw_addr
+= INFINIBAND_ALEN
- 8;
1367 hw_addr_len
-= INFINIBAND_ALEN
- 8;
1370 r
= sd_dhcp_client_set_client_id(link
->dhcp_client
,
1375 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set client ID: %m");
1379 assert_not_reached();
1385 static int dhcp4_find_dynamic_address(Link
*link
, struct in_addr
*ret
) {
1389 assert(link
->network
);
1392 if (!FLAGS_SET(link
->network
->keep_configuration
, KEEP_CONFIGURATION_DHCP
))
1395 SET_FOREACH(a
, link
->addresses
) {
1396 if (a
->source
!= NETWORK_CONFIG_SOURCE_FOREIGN
)
1398 if (a
->family
!= AF_INET
)
1400 if (link_address_is_dynamic(link
, a
))
1407 *ret
= a
->in_addr
.in
;
1411 static int dhcp4_set_request_address(Link
*link
) {
1415 assert(link
->network
);
1416 assert(link
->dhcp_client
);
1418 a
= link
->network
->dhcp_request_address
;
1420 if (in4_addr_is_null(&a
))
1421 (void) dhcp4_find_dynamic_address(link
, &a
);
1423 if (in4_addr_is_null(&a
))
1426 log_link_debug(link
, "DHCPv4 CLIENT: requesting %s.", IN4_ADDR_TO_STRING(&a
));
1427 return sd_dhcp_client_set_request_address(link
->dhcp_client
, &a
);
1430 static bool link_needs_dhcp_broadcast(Link
*link
) {
1435 assert(link
->network
);
1437 /* Return the setting in DHCP[4].RequestBroadcast if specified. Otherwise return the device property
1438 * ID_NET_DHCP_BROADCAST setting, which may be set for interfaces requiring that the DHCPOFFER message
1439 * is being broadcast because they can't handle unicast messages while not fully configured.
1440 * If neither is set or a failure occurs, return false, which is the default for this flag.
1442 r
= link
->network
->dhcp_broadcast
;
1443 if (r
< 0 && link
->dev
&& sd_device_get_property_value(link
->dev
, "ID_NET_DHCP_BROADCAST", &val
) >= 0) {
1444 r
= parse_boolean(val
);
1446 log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to parse ID_NET_DHCP_BROADCAST, ignoring: %m");
1448 log_link_debug(link
, "DHCPv4 CLIENT: Detected ID_NET_DHCP_BROADCAST='%d'.", r
);
1454 static bool link_dhcp4_ipv6_only_mode(Link
*link
) {
1456 assert(link
->network
);
1458 /* If it is explicitly specified, then honor the setting. */
1459 if (link
->network
->dhcp_ipv6_only_mode
>= 0)
1460 return link
->network
->dhcp_ipv6_only_mode
;
1462 /* Defaults to false, until we support 464XLAT. See issue #30891. */
1466 static int dhcp4_configure(Link
*link
) {
1467 sd_dhcp_option
*send_option
;
1468 void *request_options
;
1472 assert(link
->network
);
1474 if (link
->dhcp_client
)
1475 return log_link_debug_errno(link
, SYNTHETIC_ERRNO(EBUSY
), "DHCPv4 client is already configured.");
1477 r
= sd_dhcp_client_new(&link
->dhcp_client
, link
->network
->dhcp_anonymize
);
1479 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to allocate DHCPv4 client: %m");
1481 r
= sd_dhcp_client_attach_event(link
->dhcp_client
, link
->manager
->event
, 0);
1483 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to attach event to DHCPv4 client: %m");
1485 r
= sd_dhcp_client_attach_device(link
->dhcp_client
, link
->dev
);
1487 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to attach device: %m");
1489 r
= sd_dhcp_client_set_rapid_commit(link
->dhcp_client
, link
->network
->dhcp_use_rapid_commit
);
1491 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set rapid commit: %m");
1493 r
= sd_dhcp_client_set_mac(link
->dhcp_client
,
1494 link
->hw_addr
.bytes
,
1495 link
->bcast_addr
.length
> 0 ? link
->bcast_addr
.bytes
: NULL
,
1496 link
->hw_addr
.length
, link
->iftype
);
1498 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set MAC address: %m");
1500 r
= sd_dhcp_client_set_ifindex(link
->dhcp_client
, link
->ifindex
);
1502 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set ifindex: %m");
1504 r
= sd_dhcp_client_set_callback(link
->dhcp_client
, dhcp4_handler
, link
);
1506 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set callback: %m");
1508 r
= sd_dhcp_client_set_request_broadcast(link
->dhcp_client
, link_needs_dhcp_broadcast(link
));
1510 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set request flag for broadcast: %m");
1512 r
= dhcp_client_set_state_callback(link
->dhcp_client
, dhcp_client_callback_bus
, link
);
1514 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set state change callback: %m");
1516 if (link
->mtu
> 0) {
1517 r
= sd_dhcp_client_set_mtu(link
->dhcp_client
, link
->mtu
);
1519 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set MTU: %m");
1522 if (!link
->network
->dhcp_anonymize
) {
1523 r
= dhcp4_set_request_address(link
);
1525 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set initial DHCPv4 address: %m");
1527 if (link
->network
->dhcp_use_mtu
) {
1528 r
= sd_dhcp_client_set_request_option(link
->dhcp_client
, SD_DHCP_OPTION_MTU_INTERFACE
);
1530 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set request flag for MTU: %m");
1533 if (link
->network
->dhcp_use_routes
) {
1534 r
= sd_dhcp_client_set_request_option(link
->dhcp_client
, SD_DHCP_OPTION_STATIC_ROUTE
);
1536 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set request flag for static route: %m");
1538 r
= sd_dhcp_client_set_request_option(link
->dhcp_client
, SD_DHCP_OPTION_CLASSLESS_STATIC_ROUTE
);
1540 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set request flag for classless static route: %m");
1543 if (link
->network
->dhcp_use_domains
!= DHCP_USE_DOMAINS_NO
) {
1544 r
= sd_dhcp_client_set_request_option(link
->dhcp_client
, SD_DHCP_OPTION_DOMAIN_SEARCH
);
1546 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set request flag for domain search list: %m");
1549 if (link
->network
->dhcp_use_ntp
) {
1550 r
= sd_dhcp_client_set_request_option(link
->dhcp_client
, SD_DHCP_OPTION_NTP_SERVER
);
1552 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set request flag for NTP server: %m");
1555 if (link
->network
->dhcp_use_sip
) {
1556 r
= sd_dhcp_client_set_request_option(link
->dhcp_client
, SD_DHCP_OPTION_SIP_SERVER
);
1558 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set request flag for SIP server: %m");
1560 if (link
->network
->dhcp_use_captive_portal
) {
1561 r
= sd_dhcp_client_set_request_option(link
->dhcp_client
, SD_DHCP_OPTION_DHCP_CAPTIVE_PORTAL
);
1563 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set request flag for captive portal: %m");
1566 if (link
->network
->dhcp_use_timezone
) {
1567 r
= sd_dhcp_client_set_request_option(link
->dhcp_client
, SD_DHCP_OPTION_TZDB_TIMEZONE
);
1569 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set request flag for timezone: %m");
1572 if (link
->network
->dhcp_use_6rd
) {
1573 r
= sd_dhcp_client_set_request_option(link
->dhcp_client
, SD_DHCP_OPTION_6RD
);
1575 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set request flag for 6rd: %m");
1578 if (link_dhcp4_ipv6_only_mode(link
)) {
1579 r
= sd_dhcp_client_set_request_option(link
->dhcp_client
, SD_DHCP_OPTION_IPV6_ONLY_PREFERRED
);
1581 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set request flag for IPv6-only preferred option: %m");
1584 SET_FOREACH(request_options
, link
->network
->dhcp_request_options
) {
1585 uint32_t option
= PTR_TO_UINT32(request_options
);
1587 r
= sd_dhcp_client_set_request_option(link
->dhcp_client
, option
);
1589 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set request flag for '%u': %m", option
);
1592 ORDERED_HASHMAP_FOREACH(send_option
, link
->network
->dhcp_client_send_options
) {
1593 r
= sd_dhcp_client_add_option(link
->dhcp_client
, send_option
);
1597 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set send option: %m");
1600 ORDERED_HASHMAP_FOREACH(send_option
, link
->network
->dhcp_client_send_vendor_options
) {
1601 r
= sd_dhcp_client_add_vendor_option(link
->dhcp_client
, send_option
);
1605 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set send option: %m");
1608 r
= dhcp4_set_hostname(link
);
1612 if (link
->network
->dhcp_vendor_class_identifier
) {
1613 r
= sd_dhcp_client_set_vendor_class_identifier(link
->dhcp_client
,
1614 link
->network
->dhcp_vendor_class_identifier
);
1616 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set vendor class identifier: %m");
1619 if (link
->network
->dhcp_mudurl
) {
1620 r
= sd_dhcp_client_set_mud_url(link
->dhcp_client
, link
->network
->dhcp_mudurl
);
1622 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set MUD URL: %m");
1625 if (link
->network
->dhcp_user_class
) {
1626 r
= sd_dhcp_client_set_user_class(link
->dhcp_client
, link
->network
->dhcp_user_class
);
1628 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set user class: %m");
1632 if (link
->network
->dhcp_client_port
> 0) {
1633 r
= sd_dhcp_client_set_client_port(link
->dhcp_client
, link
->network
->dhcp_client_port
);
1635 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set listen port: %m");
1638 if (link
->network
->dhcp_max_attempts
> 0) {
1639 r
= sd_dhcp_client_set_max_attempts(link
->dhcp_client
, link
->network
->dhcp_max_attempts
);
1641 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set max attempts: %m");
1644 if (link
->network
->dhcp_ip_service_type
>= 0) {
1645 r
= sd_dhcp_client_set_service_type(link
->dhcp_client
, link
->network
->dhcp_ip_service_type
);
1647 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set IP service type: %m");
1650 if (link
->network
->dhcp_socket_priority_set
) {
1651 r
= sd_dhcp_client_set_socket_priority(link
->dhcp_client
, link
->network
->dhcp_socket_priority
);
1653 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set socket priority: %m");
1656 if (link
->network
->dhcp_fallback_lease_lifetime_usec
> 0) {
1657 r
= sd_dhcp_client_set_fallback_lease_lifetime(link
->dhcp_client
, link
->network
->dhcp_fallback_lease_lifetime_usec
);
1659 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed set to lease lifetime: %m");
1662 return dhcp4_set_client_identifier(link
);
1665 int dhcp4_update_mac(Link
*link
) {
1671 if (!link
->dhcp_client
)
1674 restart
= sd_dhcp_client_is_running(link
->dhcp_client
);
1676 r
= sd_dhcp_client_stop(link
->dhcp_client
);
1680 r
= sd_dhcp_client_set_mac(link
->dhcp_client
,
1681 link
->hw_addr
.bytes
,
1682 link
->bcast_addr
.length
> 0 ? link
->bcast_addr
.bytes
: NULL
,
1683 link
->hw_addr
.length
, link
->iftype
);
1687 r
= dhcp4_set_client_identifier(link
);
1692 r
= dhcp4_start(link
);
1700 int dhcp4_update_ipv6_connectivity(Link
*link
) {
1706 if (!link
->network
->dhcp_ipv6_only_mode
)
1709 if (!link
->dhcp_client
)
1712 /* If the client is running, set the current connectivity. */
1713 if (sd_dhcp_client_is_running(link
->dhcp_client
))
1714 return sd_dhcp_client_set_ipv6_connectivity(link
->dhcp_client
, link_has_ipv6_connectivity(link
));
1716 /* If the client has been already stopped or not started yet, let's check the current connectivity
1717 * and start the client if necessary. */
1718 if (link_has_ipv6_connectivity(link
))
1721 return dhcp4_start_full(link
, /* set_ipv6_connectivity = */ false);
1724 int dhcp4_start_full(Link
*link
, bool set_ipv6_connectivity
) {
1728 assert(link
->network
);
1730 if (!link
->dhcp_client
)
1733 if (!link_has_carrier(link
))
1736 if (sd_dhcp_client_is_running(link
->dhcp_client
) > 0)
1739 r
= sd_dhcp_client_start(link
->dhcp_client
);
1743 if (set_ipv6_connectivity
) {
1744 r
= dhcp4_update_ipv6_connectivity(link
);
1752 int dhcp4_renew(Link
*link
) {
1755 if (!link
->dhcp_client
)
1758 /* The DHCPv4 client may have been stopped by the IPv6 only mode. Let's unconditionally restart the
1759 * client if it is not running. */
1760 if (!sd_dhcp_client_is_running(link
->dhcp_client
))
1761 return dhcp4_start(link
);
1763 /* The client may be waiting for IPv6 connectivity. Let's restart the client in that case. */
1764 if (dhcp_client_get_state(link
->dhcp_client
) != DHCP_STATE_BOUND
)
1765 return sd_dhcp_client_interrupt_ipv6_only_mode(link
->dhcp_client
);
1767 /* Otherwise, send a RENEW command. */
1768 return sd_dhcp_client_send_renew(link
->dhcp_client
);
1771 static int dhcp4_configure_duid(Link
*link
) {
1773 assert(link
->network
);
1775 if (link
->network
->dhcp_client_identifier
!= DHCP_CLIENT_ID_DUID
)
1778 return dhcp_configure_duid(link
, link_get_dhcp4_duid(link
));
1781 static int dhcp4_process_request(Request
*req
, Link
*link
, void *userdata
) {
1786 if (!link_is_ready_to_configure(link
, /* allow_unmanaged = */ false))
1789 r
= dhcp4_configure_duid(link
);
1793 r
= dhcp4_configure(link
);
1795 return log_link_warning_errno(link
, r
, "Failed to configure DHCPv4 client: %m");
1797 r
= dhcp4_start(link
);
1799 return log_link_warning_errno(link
, r
, "Failed to start DHCPv4 client: %m");
1801 log_link_debug(link
, "DHCPv4 client is configured%s.",
1802 r
> 0 ? ", acquiring DHCPv4 lease" : "");
1806 int link_request_dhcp4_client(Link
*link
) {
1811 if (!link_dhcp4_enabled(link
))
1814 if (link
->dhcp_client
)
1817 r
= link_queue_request(link
, REQUEST_TYPE_DHCP4_CLIENT
, dhcp4_process_request
, NULL
);
1819 return log_link_warning_errno(link
, r
, "Failed to request configuring of the DHCPv4 client: %m");
1821 log_link_debug(link
, "Requested configuring of the DHCPv4 client.");
1825 int config_parse_dhcp_max_attempts(
1827 const char *filename
,
1829 const char *section
,
1830 unsigned section_line
,
1837 Network
*network
= ASSERT_PTR(data
);
1844 if (isempty(rvalue
)) {
1845 network
->dhcp_max_attempts
= 0;
1849 if (streq(rvalue
, "infinity")) {
1850 network
->dhcp_max_attempts
= UINT64_MAX
;
1854 r
= safe_atou64(rvalue
, &a
);
1856 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
,
1857 "Failed to parse DHCP maximum attempts, ignoring: %s", rvalue
);
1862 log_syntax(unit
, LOG_WARNING
, filename
, line
, 0,
1863 "%s= must be positive integer or 'infinity', ignoring: %s", lvalue
, rvalue
);
1867 network
->dhcp_max_attempts
= a
;
1872 int config_parse_dhcp_ip_service_type(
1874 const char *filename
,
1876 const char *section
,
1877 unsigned section_line
,
1884 int *tos
= ASSERT_PTR(data
);
1890 if (isempty(rvalue
))
1891 *tos
= -1; /* use sd_dhcp_client's default (currently, CS6). */
1892 else if (streq(rvalue
, "none"))
1894 else if (streq(rvalue
, "CS4"))
1895 *tos
= IPTOS_CLASS_CS4
;
1896 else if (streq(rvalue
, "CS6"))
1897 *tos
= IPTOS_CLASS_CS6
;
1899 log_syntax(unit
, LOG_WARNING
, filename
, line
, 0,
1900 "Failed to parse %s=, ignoring assignment: %s", lvalue
, rvalue
);
1905 int config_parse_dhcp_socket_priority(
1907 const char *filename
,
1909 const char *section
,
1910 unsigned section_line
,
1917 Network
*network
= ASSERT_PTR(data
);
1923 if (isempty(rvalue
)) {
1924 network
->dhcp_socket_priority_set
= false;
1928 r
= safe_atoi(rvalue
, &a
);
1930 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
,
1931 "Failed to parse socket priority, ignoring: %s", rvalue
);
1935 network
->dhcp_socket_priority_set
= true;
1936 network
->dhcp_socket_priority
= a
;
1941 int config_parse_dhcp_fallback_lease_lifetime(
1943 const char *filename
,
1945 const char *section
,
1946 unsigned section_line
,
1953 Network
*network
= userdata
;
1961 if (isempty(rvalue
)) {
1962 network
->dhcp_fallback_lease_lifetime_usec
= 0;
1966 /* We accept only "forever" or "infinity". */
1967 if (!STR_IN_SET(rvalue
, "forever", "infinity")) {
1968 log_syntax(unit
, LOG_WARNING
, filename
, line
, 0,
1969 "Invalid LeaseLifetime= value, ignoring: %s", rvalue
);
1973 network
->dhcp_fallback_lease_lifetime_usec
= USEC_INFINITY
;
1978 int config_parse_dhcp_label(
1980 const char *filename
,
1982 const char *section
,
1983 unsigned section_line
,
1990 char **label
= ASSERT_PTR(data
);
1996 if (isempty(rvalue
)) {
1997 *label
= mfree(*label
);
2001 if (!address_label_valid(rvalue
)) {
2002 log_syntax(unit
, LOG_WARNING
, filename
, line
, 0,
2003 "Address label is too long or invalid, ignoring assignment: %s", rvalue
);
2007 return free_and_strdup_warn(label
, rvalue
);
2010 static const char* const dhcp_client_identifier_table
[_DHCP_CLIENT_ID_MAX
] = {
2011 [DHCP_CLIENT_ID_MAC
] = "mac",
2012 [DHCP_CLIENT_ID_DUID
] = "duid",
2015 DEFINE_PRIVATE_STRING_TABLE_LOOKUP_FROM_STRING(dhcp_client_identifier
, DHCPClientIdentifier
);
2016 DEFINE_CONFIG_PARSE_ENUM(config_parse_dhcp_client_identifier
, dhcp_client_identifier
, DHCPClientIdentifier
,
2017 "Failed to parse client identifier type");