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
) {
250 SET_FOREACH(route
, link
->routes
) {
251 if (route
->source
!= NETWORK_CONFIG_SOURCE_DHCP4
)
253 if (only_marked
&& !route_is_marked(route
))
256 RET_GATHER(ret
, route_remove(route
));
257 route_cancel_request(route
, link
);
260 SET_FOREACH(address
, link
->addresses
) {
261 if (address
->source
!= NETWORK_CONFIG_SOURCE_DHCP4
)
263 if (only_marked
&& !address_is_marked(address
))
266 RET_GATHER(ret
, address_remove_and_cancel(address
, link
));
272 static int dhcp4_address_get(Link
*link
, Address
**ret
) {
277 SET_FOREACH(address
, link
->addresses
) {
278 if (address
->source
!= NETWORK_CONFIG_SOURCE_DHCP4
)
280 if (address_is_marked(address
))
291 static int dhcp4_address_ready_callback(Address
*address
) {
293 assert(address
->link
);
295 /* Do not call this again. */
296 address
->callback
= NULL
;
298 return dhcp4_check_ready(address
->link
);
301 int dhcp4_check_ready(Link
*link
) {
307 if (link
->dhcp4_messages
> 0) {
308 log_link_debug(link
, "%s(): DHCPv4 address and routes are not set.", __func__
);
312 if (dhcp4_address_get(link
, &address
) < 0) {
313 log_link_debug(link
, "%s(): DHCPv4 address is not set.", __func__
);
317 if (!address_is_ready(address
)) {
318 log_link_debug(link
, "%s(): DHCPv4 address is not ready.", __func__
);
319 address
->callback
= dhcp4_address_ready_callback
;
323 link
->dhcp4_configured
= true;
324 log_link_debug(link
, "DHCPv4 address and routes set.");
326 /* New address and routes are configured now. Let's release old lease. */
327 r
= dhcp4_remove_address_and_routes(link
, /* only_marked = */ true);
331 r
= sd_ipv4ll_stop(link
->ipv4ll
);
333 return log_link_warning_errno(link
, r
, "Failed to drop IPv4 link-local address: %m");
335 link_check_ready(link
);
339 static int dhcp4_route_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, Request
*req
, Link
*link
, Route
*route
) {
345 r
= route_configure_handler_internal(rtnl
, m
, link
, route
, "Could not set DHCPv4 route");
349 r
= dhcp4_check_ready(link
);
351 link_enter_failed(link
);
356 static int dhcp4_request_route(Route
*route
, Link
*link
) {
357 struct in_addr server
;
363 assert(link
->network
);
364 assert(link
->dhcp_lease
);
366 r
= sd_dhcp_lease_get_server_identifier(link
->dhcp_lease
, &server
);
368 return log_link_debug_errno(link
, r
, "Failed to get DHCP server IP address: %m");
370 route
->source
= NETWORK_CONFIG_SOURCE_DHCP4
;
371 route
->provider
.in
= server
;
372 route
->family
= AF_INET
;
373 if (!route
->protocol_set
)
374 route
->protocol
= RTPROT_DHCP
;
375 if (!route
->priority_set
)
376 route
->priority
= link
->network
->dhcp_route_metric
;
377 if (!route
->table_set
)
378 route
->table
= link_get_dhcp4_route_table(link
);
379 r
= route_metric_set(&route
->metric
, RTAX_MTU
, link
->network
->dhcp_route_mtu
);
382 r
= route_metric_set(&route
->metric
, RTAX_INITCWND
, link
->network
->dhcp_initial_congestion_window
);
385 r
= route_metric_set(&route
->metric
, RTAX_INITRWND
, link
->network
->dhcp_advertised_receive_window
);
388 r
= route_metric_set(&route
->metric
, RTAX_QUICKACK
, link
->network
->dhcp_quickack
);
392 r
= route_adjust_nexthops(route
, link
);
396 if (route_get(NULL
, link
, route
, &existing
) < 0) /* This is a new route. */
397 link
->dhcp4_configured
= false;
399 route_unmark(existing
);
401 return link_request_route(link
, route
, &link
->dhcp4_messages
, dhcp4_route_handler
);
404 static bool link_prefixroute(Link
*link
) {
405 return !link
->network
->dhcp_route_table_set
||
406 link
->network
->dhcp_route_table
== RT_TABLE_MAIN
;
409 static int dhcp4_request_prefix_route(Link
*link
) {
410 _cleanup_(route_freep
) Route
*route
= NULL
;
414 assert(link
->dhcp_lease
);
416 if (link_prefixroute(link
))
417 /* When true, the route will be created by kernel. See dhcp4_update_address(). */
420 r
= route_new(&route
);
424 route
->scope
= RT_SCOPE_LINK
;
426 r
= sd_dhcp_lease_get_prefix(link
->dhcp_lease
, &route
->dst
.in
, &route
->dst_prefixlen
);
430 r
= sd_dhcp_lease_get_address(link
->dhcp_lease
, &route
->prefsrc
.in
);
434 return dhcp4_request_route(route
, link
);
437 static int dhcp4_request_route_to_gateway(Link
*link
, const struct in_addr
*gw
) {
438 _cleanup_(route_freep
) Route
*route
= NULL
;
439 struct in_addr address
;
443 assert(link
->dhcp_lease
);
446 r
= sd_dhcp_lease_get_address(link
->dhcp_lease
, &address
);
450 r
= route_new(&route
);
455 route
->dst_prefixlen
= 32;
456 route
->prefsrc
.in
= address
;
457 route
->scope
= RT_SCOPE_LINK
;
459 return dhcp4_request_route(route
, link
);
462 static int dhcp4_request_route_auto(
465 const struct in_addr
*gw
) {
467 struct in_addr address
;
472 assert(link
->dhcp_lease
);
475 r
= sd_dhcp_lease_get_address(link
->dhcp_lease
, &address
);
479 if (in4_addr_is_localhost(&route
->dst
.in
)) {
480 if (in4_addr_is_set(gw
))
481 log_link_debug(link
, "DHCP: requested route destination "IPV4_ADDRESS_FMT_STR
"/%u is localhost, "
482 "ignoring gateway address "IPV4_ADDRESS_FMT_STR
,
483 IPV4_ADDRESS_FMT_VAL(route
->dst
.in
), route
->dst_prefixlen
, IPV4_ADDRESS_FMT_VAL(*gw
));
485 route
->scope
= RT_SCOPE_HOST
;
486 route
->nexthop
.family
= AF_UNSPEC
;
487 route
->nexthop
.gw
= IN_ADDR_NULL
;
488 route
->prefsrc
= IN_ADDR_NULL
;
490 } else if (in4_addr_equal(&route
->dst
.in
, &address
)) {
491 if (in4_addr_is_set(gw
))
492 log_link_debug(link
, "DHCP: requested route destination "IPV4_ADDRESS_FMT_STR
"/%u is equivalent to the acquired address, "
493 "ignoring gateway address "IPV4_ADDRESS_FMT_STR
,
494 IPV4_ADDRESS_FMT_VAL(route
->dst
.in
), route
->dst_prefixlen
, IPV4_ADDRESS_FMT_VAL(*gw
));
496 route
->scope
= RT_SCOPE_HOST
;
497 route
->nexthop
.family
= AF_UNSPEC
;
498 route
->nexthop
.gw
= IN_ADDR_NULL
;
499 route
->prefsrc
.in
= address
;
501 } else if (in4_addr_is_null(gw
)) {
502 r
= dhcp4_prefix_covers(link
, &route
->dst
.in
, route
->dst_prefixlen
);
505 if (r
== 0 && DEBUG_LOGGING
) {
506 struct in_addr prefix
;
509 r
= sd_dhcp_lease_get_prefix(link
->dhcp_lease
, &prefix
, &prefixlen
);
513 log_link_debug(link
, "DHCP: requested route destination "IPV4_ADDRESS_FMT_STR
"/%u is not in the assigned network "
514 IPV4_ADDRESS_FMT_STR
"/%u, but no gateway is specified, using 'link' scope.",
515 IPV4_ADDRESS_FMT_VAL(route
->dst
.in
), route
->dst_prefixlen
,
516 IPV4_ADDRESS_FMT_VAL(prefix
), prefixlen
);
519 route
->scope
= RT_SCOPE_LINK
;
520 route
->nexthop
.family
= AF_UNSPEC
;
521 route
->nexthop
.gw
= IN_ADDR_NULL
;
522 route
->prefsrc
.in
= address
;
525 r
= dhcp4_request_route_to_gateway(link
, gw
);
529 route
->scope
= RT_SCOPE_UNIVERSE
;
530 route
->nexthop
.family
= AF_INET
;
531 route
->nexthop
.gw
.in
= *gw
;
532 route
->prefsrc
.in
= address
;
535 return dhcp4_request_route(route
, link
);
538 static int dhcp4_request_classless_static_or_static_routes(Link
*link
) {
539 _cleanup_free_ sd_dhcp_route
**routes
= NULL
;
544 assert(link
->dhcp_lease
);
546 if (!link
->network
->dhcp_use_routes
)
549 r
= dhcp4_get_classless_static_or_static_routes(link
, &routes
, &n_routes
);
555 FOREACH_ARRAY(e
, routes
, n_routes
) {
556 _cleanup_(route_freep
) Route
*route
= NULL
;
559 r
= route_new(&route
);
563 r
= sd_dhcp_route_get_gateway(*e
, &gw
);
567 r
= sd_dhcp_route_get_destination(*e
, &route
->dst
.in
);
571 r
= sd_dhcp_route_get_destination_prefix_length(*e
, &route
->dst_prefixlen
);
575 r
= dhcp4_request_route_auto(route
, link
, &gw
);
583 static int dhcp4_request_default_gateway(Link
*link
) {
584 _cleanup_(route_freep
) Route
*route
= NULL
;
585 struct in_addr address
, router
;
589 assert(link
->dhcp_lease
);
591 if (!link
->network
->dhcp_use_gateway
)
594 /* According to RFC 3442: If the DHCP server returns both a Classless Static Routes option and
595 * a Router option, the DHCP client MUST ignore the Router option. */
596 if (link
->network
->dhcp_use_routes
&&
597 dhcp4_get_classless_static_or_static_routes(link
, NULL
, NULL
) > 0)
600 r
= sd_dhcp_lease_get_address(link
->dhcp_lease
, &address
);
604 r
= dhcp4_get_router(link
, &router
);
606 log_link_debug(link
, "DHCP: No valid router address received from DHCP server.");
612 /* The dhcp netmask may mask out the gateway. First, add an explicit route for the gateway host
613 * so that we can route no matter the netmask or existing kernel route tables. */
614 r
= dhcp4_request_route_to_gateway(link
, &router
);
618 r
= route_new(&route
);
622 /* Next, add a default gateway. */
623 route
->nexthop
.family
= AF_INET
;
624 route
->nexthop
.gw
.in
= router
;
625 route
->prefsrc
.in
= address
;
627 return dhcp4_request_route(route
, link
);
630 static int dhcp4_request_semi_static_routes(Link
*link
) {
635 assert(link
->dhcp_lease
);
636 assert(link
->network
);
638 HASHMAP_FOREACH(rt
, link
->network
->routes_by_section
) {
639 _cleanup_(route_freep
) Route
*route
= NULL
;
642 if (!rt
->gateway_from_dhcp_or_ra
)
645 if (rt
->nexthop
.family
!= AF_INET
)
648 assert(rt
->family
== AF_INET
);
650 r
= dhcp4_find_gateway_for_destination(link
, &rt
->dst
.in
, rt
->dst_prefixlen
, /* allow_null = */ false, &gw
);
651 if (IN_SET(r
, -EHOSTUNREACH
, -ENODATA
)) {
652 log_link_debug_errno(link
, r
, "DHCP: Cannot find suitable gateway for destination %s of semi-static route, ignoring: %m",
653 IN4_ADDR_PREFIX_TO_STRING(&rt
->dst
.in
, rt
->dst_prefixlen
));
659 r
= dhcp4_request_route_to_gateway(link
, &gw
);
663 r
= route_dup(rt
, NULL
, &route
);
667 route
->nexthop
.gw
.in
= gw
;
669 r
= dhcp4_request_route(route
, link
);
677 static int dhcp4_request_routes_to_servers(
679 const struct in_addr
*servers
,
685 assert(link
->dhcp_lease
);
686 assert(link
->network
);
687 assert(servers
|| n_servers
== 0);
689 FOREACH_ARRAY(dst
, servers
, n_servers
) {
690 _cleanup_(route_freep
) Route
*route
= NULL
;
693 if (in4_addr_is_null(dst
))
696 r
= dhcp4_find_gateway_for_destination(link
, dst
, 32, /* allow_null = */ true, &gw
);
697 if (r
== -EHOSTUNREACH
) {
698 log_link_debug_errno(link
, r
, "DHCP: Cannot find suitable gateway for destination %s, ignoring: %m",
699 IN4_ADDR_PREFIX_TO_STRING(dst
, 32));
705 r
= route_new(&route
);
709 route
->dst
.in
= *dst
;
710 route
->dst_prefixlen
= 32;
712 r
= dhcp4_request_route_auto(route
, link
, &gw
);
720 static int dhcp4_request_routes_to_dns(Link
*link
) {
721 const struct in_addr
*dns
;
725 assert(link
->dhcp_lease
);
726 assert(link
->network
);
728 if (!link
->network
->dhcp_use_dns
||
729 !link
->network
->dhcp_routes_to_dns
)
732 r
= sd_dhcp_lease_get_dns(link
->dhcp_lease
, &dns
);
733 if (IN_SET(r
, 0, -ENODATA
))
738 return dhcp4_request_routes_to_servers(link
, dns
, r
);
741 static int dhcp4_request_routes_to_ntp(Link
*link
) {
742 const struct in_addr
*ntp
;
746 assert(link
->dhcp_lease
);
747 assert(link
->network
);
749 if (!link
->network
->dhcp_use_ntp
||
750 !link
->network
->dhcp_routes_to_ntp
)
753 r
= sd_dhcp_lease_get_ntp(link
->dhcp_lease
, &ntp
);
754 if (IN_SET(r
, 0, -ENODATA
))
759 return dhcp4_request_routes_to_servers(link
, ntp
, r
);
762 static int dhcp4_request_routes(Link
*link
) {
766 assert(link
->dhcp_lease
);
768 r
= dhcp4_request_prefix_route(link
);
770 return log_link_error_errno(link
, r
, "DHCP error: Could not request prefix route: %m");
772 r
= dhcp4_request_default_gateway(link
);
774 return log_link_error_errno(link
, r
, "DHCP error: Could not request default gateway: %m");
776 r
= dhcp4_request_classless_static_or_static_routes(link
);
778 return log_link_error_errno(link
, r
, "DHCP error: Could not request static routes: %m");
780 r
= dhcp4_request_semi_static_routes(link
);
782 return log_link_error_errno(link
, r
, "DHCP error: Could not request routes with Gateway=_dhcp4 setting: %m");
784 r
= dhcp4_request_routes_to_dns(link
);
786 return log_link_error_errno(link
, r
, "DHCP error: Could not request routes to DNS servers: %m");
788 r
= dhcp4_request_routes_to_ntp(link
);
790 return log_link_error_errno(link
, r
, "DHCP error: Could not request routes to NTP servers: %m");
795 static int dhcp_reset_mtu(Link
*link
) {
800 if (!link
->network
->dhcp_use_mtu
)
803 r
= link_request_to_set_mtu(link
, link
->original_mtu
);
805 return log_link_error_errno(link
, r
, "DHCP error: Could not queue request to reset MTU: %m");
810 static int dhcp_reset_hostname(Link
*link
) {
811 const char *hostname
;
816 if (!link
->network
->dhcp_use_hostname
)
819 hostname
= link
->network
->dhcp_hostname
;
821 (void) sd_dhcp_lease_get_hostname(link
->dhcp_lease
, &hostname
);
826 /* If a hostname was set due to the lease, then unset it now. */
827 r
= manager_set_hostname(link
->manager
, NULL
);
829 return log_link_error_errno(link
, r
, "DHCP error: Failed to reset transient hostname: %m");
834 int dhcp4_lease_lost(Link
*link
) {
838 assert(link
->dhcp_lease
);
839 assert(link
->network
);
841 log_link_info(link
, "DHCP lease lost");
843 link
->dhcp4_configured
= false;
845 if (link
->network
->dhcp_use_6rd
&&
846 sd_dhcp_lease_has_6rd(link
->dhcp_lease
))
847 dhcp4_pd_prefix_lost(link
);
849 RET_GATHER(r
, dhcp4_remove_address_and_routes(link
, /* only_marked = */ false));
850 RET_GATHER(r
, dhcp_reset_mtu(link
));
851 RET_GATHER(r
, dhcp_reset_hostname(link
));
853 link
->dhcp_lease
= sd_dhcp_lease_unref(link
->dhcp_lease
);
856 /* If one of the above failed. Do not request nexthops and routes. */
860 r
= link_request_static_nexthops(link
, true);
864 return link_request_static_routes(link
, true);
867 static int dhcp4_address_handler(sd_netlink
*rtnl
, sd_netlink_message
*m
, Request
*req
, Link
*link
, Address
*address
) {
872 r
= address_configure_handler_internal(rtnl
, m
, link
, "Could not set DHCPv4 address");
876 r
= dhcp4_check_ready(link
);
878 link_enter_failed(link
);
883 static int dhcp4_request_address(Link
*link
, bool announce
) {
884 _cleanup_(address_unrefp
) Address
*addr
= NULL
;
885 struct in_addr address
, server
;
888 usec_t lifetime_usec
;
892 assert(link
->manager
);
893 assert(link
->network
);
894 assert(link
->dhcp_lease
);
896 r
= sd_dhcp_lease_get_address(link
->dhcp_lease
, &address
);
898 return log_link_warning_errno(link
, r
, "DHCP error: no address: %m");
900 r
= sd_dhcp_lease_get_prefix(link
->dhcp_lease
, NULL
, &prefixlen
);
902 return log_link_warning_errno(link
, r
, "DHCP error: no netmask: %m");
904 r
= sd_dhcp_lease_get_server_identifier(link
->dhcp_lease
, &server
);
906 return log_link_debug_errno(link
, r
, "DHCP error: failed to get DHCP server IP address: %m");
908 if (!FLAGS_SET(link
->network
->keep_configuration
, KEEP_CONFIGURATION_DHCP
)) {
909 r
= sd_dhcp_lease_get_lifetime_timestamp(link
->dhcp_lease
, CLOCK_BOOTTIME
, &lifetime_usec
);
911 return log_link_warning_errno(link
, r
, "DHCP error: failed to get lifetime: %m");
913 lifetime_usec
= USEC_INFINITY
;
916 const struct in_addr
*router
;
918 r
= sd_dhcp_lease_get_router(link
->dhcp_lease
, &router
);
919 if (r
< 0 && r
!= -ENODATA
)
920 return log_link_error_errno(link
, r
, "DHCP error: Could not get gateway: %m");
922 if (r
> 0 && in4_addr_is_set(&router
[0]))
924 LOG_LINK_INTERFACE(link
),
925 LOG_LINK_MESSAGE(link
, "DHCPv4 address "IPV4_ADDRESS_FMT_STR
"/%u, gateway "IPV4_ADDRESS_FMT_STR
" acquired from "IPV4_ADDRESS_FMT_STR
,
926 IPV4_ADDRESS_FMT_VAL(address
),
928 IPV4_ADDRESS_FMT_VAL(router
[0]),
929 IPV4_ADDRESS_FMT_VAL(server
)),
930 "ADDRESS="IPV4_ADDRESS_FMT_STR
, IPV4_ADDRESS_FMT_VAL(address
),
931 "PREFIXLEN=%u", prefixlen
,
932 "GATEWAY="IPV4_ADDRESS_FMT_STR
, IPV4_ADDRESS_FMT_VAL(router
[0]));
935 LOG_LINK_INTERFACE(link
),
936 LOG_LINK_MESSAGE(link
, "DHCPv4 address "IPV4_ADDRESS_FMT_STR
"/%u acquired from "IPV4_ADDRESS_FMT_STR
,
937 IPV4_ADDRESS_FMT_VAL(address
),
939 IPV4_ADDRESS_FMT_VAL(server
)),
940 "ADDRESS="IPV4_ADDRESS_FMT_STR
, IPV4_ADDRESS_FMT_VAL(address
),
941 "PREFIXLEN=%u", prefixlen
);
944 r
= address_new(&addr
);
948 addr
->source
= NETWORK_CONFIG_SOURCE_DHCP4
;
949 addr
->provider
.in
= server
;
950 addr
->family
= AF_INET
;
951 addr
->in_addr
.in
.s_addr
= address
.s_addr
;
952 addr
->lifetime_preferred_usec
= lifetime_usec
;
953 addr
->lifetime_valid_usec
= lifetime_usec
;
954 addr
->prefixlen
= prefixlen
;
955 r
= sd_dhcp_lease_get_broadcast(link
->dhcp_lease
, &addr
->broadcast
);
956 if (r
< 0 && r
!= -ENODATA
)
957 return log_link_warning_errno(link
, r
, "DHCP: failed to get broadcast address: %m");
958 SET_FLAG(addr
->flags
, IFA_F_NOPREFIXROUTE
, !link_prefixroute(link
));
959 addr
->route_metric
= link
->network
->dhcp_route_metric
;
960 addr
->duplicate_address_detection
= link
->network
->dhcp_send_decline
? ADDRESS_FAMILY_IPV4
: ADDRESS_FAMILY_NO
;
962 r
= free_and_strdup_warn(&addr
->label
, link
->network
->dhcp_label
);
966 r
= free_and_strdup_warn(&addr
->netlabel
, link
->network
->dhcp_netlabel
);
970 if (address_get(link
, addr
, &existing
) < 0) /* The address is new. */
971 link
->dhcp4_configured
= false;
973 address_unmark(existing
);
975 r
= link_request_address(link
, addr
, &link
->dhcp4_messages
,
976 dhcp4_address_handler
, NULL
);
978 return log_link_error_errno(link
, r
, "Failed to request DHCPv4 address: %m");
983 static int dhcp4_request_address_and_routes(Link
*link
, bool announce
) {
988 link_mark_addresses(link
, NETWORK_CONFIG_SOURCE_DHCP4
);
989 link_mark_routes(link
, NETWORK_CONFIG_SOURCE_DHCP4
);
991 r
= dhcp4_request_address(link
, announce
);
995 r
= dhcp4_request_routes(link
);
999 if (!link
->dhcp4_configured
) {
1000 link_set_state(link
, LINK_STATE_CONFIGURING
);
1001 link_check_ready(link
);
1007 static int dhcp_lease_renew(sd_dhcp_client
*client
, Link
*link
) {
1008 _cleanup_(sd_dhcp_lease_unrefp
) sd_dhcp_lease
*old_lease
= NULL
;
1009 sd_dhcp_lease
*lease
;
1013 assert(link
->network
);
1016 r
= sd_dhcp_client_get_lease(client
, &lease
);
1018 return log_link_warning_errno(link
, r
, "DHCP error: no lease: %m");
1020 old_lease
= TAKE_PTR(link
->dhcp_lease
);
1021 link
->dhcp_lease
= sd_dhcp_lease_ref(lease
);
1024 if (link
->network
->dhcp_use_6rd
) {
1025 if (sd_dhcp_lease_has_6rd(link
->dhcp_lease
)) {
1026 r
= dhcp4_pd_prefix_acquired(link
);
1028 return log_link_warning_errno(link
, r
, "Failed to process 6rd option: %m");
1029 } else if (sd_dhcp_lease_has_6rd(old_lease
))
1030 dhcp4_pd_prefix_lost(link
);
1033 return dhcp4_request_address_and_routes(link
, false);
1036 static int dhcp_lease_acquired(sd_dhcp_client
*client
, Link
*link
) {
1037 sd_dhcp_lease
*lease
;
1043 r
= sd_dhcp_client_get_lease(client
, &lease
);
1045 return log_link_error_errno(link
, r
, "DHCP error: No lease: %m");
1047 sd_dhcp_lease_unref(link
->dhcp_lease
);
1048 link
->dhcp_lease
= sd_dhcp_lease_ref(lease
);
1051 if (link
->network
->dhcp_use_mtu
) {
1054 r
= sd_dhcp_lease_get_mtu(lease
, &mtu
);
1056 r
= link_request_to_set_mtu(link
, mtu
);
1058 log_link_error_errno(link
, r
, "Failed to set MTU to %" PRIu16
": %m", mtu
);
1062 if (link
->network
->dhcp_use_hostname
) {
1063 const char *dhcpname
= NULL
;
1064 _cleanup_free_
char *hostname
= NULL
;
1066 if (link
->network
->dhcp_hostname
)
1067 dhcpname
= link
->network
->dhcp_hostname
;
1069 (void) sd_dhcp_lease_get_hostname(lease
, &dhcpname
);
1072 r
= shorten_overlong(dhcpname
, &hostname
);
1074 log_link_warning_errno(link
, r
, "Unable to shorten overlong DHCP hostname '%s', ignoring: %m", dhcpname
);
1076 log_link_notice(link
, "Overlong DHCP hostname received, shortened from '%s' to '%s'", dhcpname
, hostname
);
1080 r
= manager_set_hostname(link
->manager
, hostname
);
1082 log_link_error_errno(link
, r
, "Failed to set transient hostname to '%s': %m", hostname
);
1086 if (link
->network
->dhcp_use_timezone
) {
1087 const char *tz
= NULL
;
1089 (void) sd_dhcp_lease_get_timezone(link
->dhcp_lease
, &tz
);
1092 r
= manager_set_timezone(link
->manager
, tz
);
1094 log_link_error_errno(link
, r
, "Failed to set timezone to '%s': %m", tz
);
1098 if (link
->network
->dhcp_use_6rd
&&
1099 sd_dhcp_lease_has_6rd(link
->dhcp_lease
)) {
1100 r
= dhcp4_pd_prefix_acquired(link
);
1102 return log_link_warning_errno(link
, r
, "Failed to process 6rd option: %m");
1105 return dhcp4_request_address_and_routes(link
, true);
1108 static int dhcp_lease_ip_change(sd_dhcp_client
*client
, Link
*link
) {
1111 r
= dhcp_lease_acquired(client
, link
);
1113 (void) dhcp4_lease_lost(link
);
1118 static int dhcp_server_is_filtered(Link
*link
, sd_dhcp_client
*client
) {
1119 sd_dhcp_lease
*lease
;
1120 struct in_addr addr
;
1124 assert(link
->network
);
1127 r
= sd_dhcp_client_get_lease(client
, &lease
);
1129 return log_link_error_errno(link
, r
, "Failed to get DHCP lease: %m");
1131 r
= sd_dhcp_lease_get_server_identifier(lease
, &addr
);
1133 return log_link_debug_errno(link
, r
, "Failed to get DHCP server IP address: %m");
1135 if (in4_address_is_filtered(&addr
, link
->network
->dhcp_allow_listed_ip
, link
->network
->dhcp_deny_listed_ip
)) {
1136 if (DEBUG_LOGGING
) {
1137 if (link
->network
->dhcp_allow_listed_ip
)
1138 log_link_debug(link
, "DHCPv4 server IP address "IPV4_ADDRESS_FMT_STR
" not found in allow-list, ignoring offer.",
1139 IPV4_ADDRESS_FMT_VAL(addr
));
1141 log_link_debug(link
, "DHCPv4 server IP address "IPV4_ADDRESS_FMT_STR
" found in deny-list, ignoring offer.",
1142 IPV4_ADDRESS_FMT_VAL(addr
));
1151 static int dhcp4_handler(sd_dhcp_client
*client
, int event
, void *userdata
) {
1152 Link
*link
= ASSERT_PTR(userdata
);
1155 assert(link
->network
);
1156 assert(link
->manager
);
1158 if (IN_SET(link
->state
, LINK_STATE_FAILED
, LINK_STATE_LINGER
))
1162 case SD_DHCP_CLIENT_EVENT_STOP
:
1164 log_link_debug(link
, "DHCP client is stopped. Acquiring IPv4 link-local address");
1166 if (in4_addr_is_set(&link
->network
->ipv4ll_start_address
)) {
1167 r
= sd_ipv4ll_set_address(link
->ipv4ll
, &link
->network
->ipv4ll_start_address
);
1169 return log_link_warning_errno(link
, r
, "Could not set IPv4 link-local start address: %m");
1172 r
= sd_ipv4ll_start(link
->ipv4ll
);
1173 if (r
< 0 && r
!= -ESTALE
) /* On exit, we cannot and should not start sd-ipv4ll. */
1174 return log_link_warning_errno(link
, r
, "Could not acquire IPv4 link-local address: %m");
1177 if (FLAGS_SET(link
->network
->keep_configuration
, KEEP_CONFIGURATION_DHCP
)) {
1178 log_link_notice(link
, "DHCPv4 connection considered critical, ignoring request to reconfigure it.");
1182 if (link
->dhcp_lease
) {
1183 if (link
->network
->dhcp_send_release
) {
1184 r
= sd_dhcp_client_send_release(client
);
1186 log_link_full_errno(link
,
1187 ERRNO_IS_DISCONNECT(r
) ? LOG_DEBUG
: LOG_WARNING
,
1188 r
, "Failed to send DHCP RELEASE, ignoring: %m");
1191 r
= dhcp4_lease_lost(link
);
1193 link_enter_failed(link
);
1199 case SD_DHCP_CLIENT_EVENT_EXPIRED
:
1200 if (FLAGS_SET(link
->network
->keep_configuration
, KEEP_CONFIGURATION_DHCP
)) {
1201 log_link_notice(link
, "DHCPv4 connection considered critical, ignoring request to reconfigure it.");
1205 if (link
->dhcp_lease
) {
1206 r
= dhcp4_lease_lost(link
);
1208 link_enter_failed(link
);
1214 case SD_DHCP_CLIENT_EVENT_IP_CHANGE
:
1215 if (FLAGS_SET(link
->network
->keep_configuration
, KEEP_CONFIGURATION_DHCP
)) {
1216 log_link_notice(link
, "DHCPv4 connection considered critical, ignoring request to reconfigure it.");
1220 r
= dhcp_lease_ip_change(client
, link
);
1222 link_enter_failed(link
);
1227 case SD_DHCP_CLIENT_EVENT_RENEW
:
1228 r
= dhcp_lease_renew(client
, link
);
1230 link_enter_failed(link
);
1234 case SD_DHCP_CLIENT_EVENT_IP_ACQUIRE
:
1235 r
= dhcp_lease_acquired(client
, link
);
1237 link_enter_failed(link
);
1241 case SD_DHCP_CLIENT_EVENT_SELECTING
:
1242 r
= dhcp_server_is_filtered(link
, client
);
1244 link_enter_failed(link
);
1251 case SD_DHCP_CLIENT_EVENT_TRANSIENT_FAILURE
:
1252 if (link
->ipv4ll
&& !sd_ipv4ll_is_running(link
->ipv4ll
)) {
1253 log_link_debug(link
, "Problems acquiring DHCP lease, acquiring IPv4 link-local address");
1255 if (in4_addr_is_set(&link
->network
->ipv4ll_start_address
)) {
1256 r
= sd_ipv4ll_set_address(link
->ipv4ll
, &link
->network
->ipv4ll_start_address
);
1258 return log_link_warning_errno(link
, r
, "Could not set IPv4 link-local start address: %m");
1261 r
= sd_ipv4ll_start(link
->ipv4ll
);
1263 return log_link_warning_errno(link
, r
, "Could not acquire IPv4 link-local address: %m");
1269 log_link_warning_errno(link
, event
, "DHCP error: Client failed: %m");
1271 log_link_warning(link
, "DHCP unknown event: %i", event
);
1278 static int dhcp4_set_hostname(Link
*link
) {
1279 _cleanup_free_
char *hostname
= NULL
;
1285 if (!link
->network
->dhcp_send_hostname
)
1287 else if (link
->network
->dhcp_hostname
)
1288 hn
= link
->network
->dhcp_hostname
;
1290 r
= gethostname_strict(&hostname
);
1291 if (r
< 0 && r
!= -ENXIO
) /* ENXIO: no hostname set or hostname is "localhost" */
1292 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to get hostname: %m");
1297 r
= sd_dhcp_client_set_hostname(link
->dhcp_client
, hn
);
1298 if (r
== -EINVAL
&& hostname
)
1299 /* Ignore error when the machine's hostname is not suitable to send in DHCP packet. */
1300 log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set hostname from kernel hostname, ignoring: %m");
1302 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set hostname: %m");
1307 static int dhcp4_set_client_identifier(Link
*link
) {
1311 assert(link
->network
);
1312 assert(link
->dhcp_client
);
1314 switch (link
->network
->dhcp_client_identifier
) {
1315 case DHCP_CLIENT_ID_DUID
: {
1316 /* If configured, apply user specified DUID and IAID */
1317 const DUID
*duid
= link_get_dhcp4_duid(link
);
1319 if (duid
->raw_data_len
== 0)
1320 switch (duid
->type
) {
1322 r
= sd_dhcp_client_set_iaid_duid_llt(link
->dhcp_client
,
1323 link
->network
->dhcp_iaid_set
,
1324 link
->network
->dhcp_iaid
,
1328 r
= sd_dhcp_client_set_iaid_duid_ll(link
->dhcp_client
,
1329 link
->network
->dhcp_iaid_set
,
1330 link
->network
->dhcp_iaid
);
1333 r
= sd_dhcp_client_set_iaid_duid_en(link
->dhcp_client
,
1334 link
->network
->dhcp_iaid_set
,
1335 link
->network
->dhcp_iaid
);
1337 case DUID_TYPE_UUID
:
1338 r
= sd_dhcp_client_set_iaid_duid_uuid(link
->dhcp_client
,
1339 link
->network
->dhcp_iaid_set
,
1340 link
->network
->dhcp_iaid
);
1343 r
= sd_dhcp_client_set_iaid_duid_raw(link
->dhcp_client
,
1344 link
->network
->dhcp_iaid_set
,
1345 link
->network
->dhcp_iaid
,
1346 duid
->type
, NULL
, 0);
1349 r
= sd_dhcp_client_set_iaid_duid_raw(link
->dhcp_client
,
1350 link
->network
->dhcp_iaid_set
,
1351 link
->network
->dhcp_iaid
,
1352 duid
->type
, duid
->raw_data
, duid
->raw_data_len
);
1357 case DHCP_CLIENT_ID_MAC
: {
1358 const uint8_t *hw_addr
= link
->hw_addr
.bytes
;
1359 size_t hw_addr_len
= link
->hw_addr
.length
;
1361 if (link
->iftype
== ARPHRD_INFINIBAND
&& hw_addr_len
== INFINIBAND_ALEN
) {
1362 /* set_client_id expects only last 8 bytes of an IB address */
1363 hw_addr
+= INFINIBAND_ALEN
- 8;
1364 hw_addr_len
-= INFINIBAND_ALEN
- 8;
1367 r
= sd_dhcp_client_set_client_id(link
->dhcp_client
,
1372 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set client ID: %m");
1376 assert_not_reached();
1382 static int dhcp4_find_dynamic_address(Link
*link
, struct in_addr
*ret
) {
1386 assert(link
->network
);
1389 if (!FLAGS_SET(link
->network
->keep_configuration
, KEEP_CONFIGURATION_DHCP
))
1392 SET_FOREACH(a
, link
->addresses
) {
1393 if (a
->source
!= NETWORK_CONFIG_SOURCE_FOREIGN
)
1395 if (a
->family
!= AF_INET
)
1397 if (link_address_is_dynamic(link
, a
))
1404 *ret
= a
->in_addr
.in
;
1408 static int dhcp4_set_request_address(Link
*link
) {
1412 assert(link
->network
);
1413 assert(link
->dhcp_client
);
1415 a
= link
->network
->dhcp_request_address
;
1417 if (in4_addr_is_null(&a
))
1418 (void) dhcp4_find_dynamic_address(link
, &a
);
1420 if (in4_addr_is_null(&a
))
1423 log_link_debug(link
, "DHCPv4 CLIENT: requesting %s.", IN4_ADDR_TO_STRING(&a
));
1424 return sd_dhcp_client_set_request_address(link
->dhcp_client
, &a
);
1427 static bool link_needs_dhcp_broadcast(Link
*link
) {
1432 assert(link
->network
);
1434 /* Return the setting in DHCP[4].RequestBroadcast if specified. Otherwise return the device property
1435 * ID_NET_DHCP_BROADCAST setting, which may be set for interfaces requiring that the DHCPOFFER message
1436 * is being broadcast because they can't handle unicast messages while not fully configured.
1437 * If neither is set or a failure occurs, return false, which is the default for this flag.
1439 r
= link
->network
->dhcp_broadcast
;
1440 if (r
< 0 && link
->dev
&& sd_device_get_property_value(link
->dev
, "ID_NET_DHCP_BROADCAST", &val
) >= 0) {
1441 r
= parse_boolean(val
);
1443 log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to parse ID_NET_DHCP_BROADCAST, ignoring: %m");
1445 log_link_debug(link
, "DHCPv4 CLIENT: Detected ID_NET_DHCP_BROADCAST='%d'.", r
);
1451 static bool link_dhcp4_ipv6_only_mode(Link
*link
) {
1453 assert(link
->network
);
1455 if (link
->network
->dhcp_ipv6_only_mode
>= 0)
1456 return link
->network
->dhcp_ipv6_only_mode
;
1458 return link_dhcp6_enabled(link
) || link_ipv6_accept_ra_enabled(link
);
1461 static int dhcp4_configure(Link
*link
) {
1462 sd_dhcp_option
*send_option
;
1463 void *request_options
;
1467 assert(link
->network
);
1469 if (link
->dhcp_client
)
1470 return log_link_debug_errno(link
, SYNTHETIC_ERRNO(EBUSY
), "DHCPv4 client is already configured.");
1472 r
= sd_dhcp_client_new(&link
->dhcp_client
, link
->network
->dhcp_anonymize
);
1474 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to allocate DHCPv4 client: %m");
1476 r
= sd_dhcp_client_attach_event(link
->dhcp_client
, link
->manager
->event
, 0);
1478 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to attach event to DHCPv4 client: %m");
1480 r
= sd_dhcp_client_attach_device(link
->dhcp_client
, link
->dev
);
1482 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to attach device: %m");
1484 r
= sd_dhcp_client_set_rapid_commit(link
->dhcp_client
, link
->network
->dhcp_use_rapid_commit
);
1486 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set rapid commit: %m");
1488 r
= sd_dhcp_client_set_mac(link
->dhcp_client
,
1489 link
->hw_addr
.bytes
,
1490 link
->bcast_addr
.length
> 0 ? link
->bcast_addr
.bytes
: NULL
,
1491 link
->hw_addr
.length
, link
->iftype
);
1493 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set MAC address: %m");
1495 r
= sd_dhcp_client_set_ifindex(link
->dhcp_client
, link
->ifindex
);
1497 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set ifindex: %m");
1499 r
= sd_dhcp_client_set_callback(link
->dhcp_client
, dhcp4_handler
, link
);
1501 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set callback: %m");
1503 r
= sd_dhcp_client_set_request_broadcast(link
->dhcp_client
, link_needs_dhcp_broadcast(link
));
1505 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set request flag for broadcast: %m");
1507 r
= dhcp_client_set_state_callback(link
->dhcp_client
, dhcp_client_callback_bus
, link
);
1509 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set state change callback: %m");
1511 if (link
->mtu
> 0) {
1512 r
= sd_dhcp_client_set_mtu(link
->dhcp_client
, link
->mtu
);
1514 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set MTU: %m");
1517 if (!link
->network
->dhcp_anonymize
) {
1518 r
= dhcp4_set_request_address(link
);
1520 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set initial DHCPv4 address: %m");
1522 if (link
->network
->dhcp_use_mtu
) {
1523 r
= sd_dhcp_client_set_request_option(link
->dhcp_client
, SD_DHCP_OPTION_MTU_INTERFACE
);
1525 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set request flag for MTU: %m");
1528 if (link
->network
->dhcp_use_routes
) {
1529 r
= sd_dhcp_client_set_request_option(link
->dhcp_client
, SD_DHCP_OPTION_STATIC_ROUTE
);
1531 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set request flag for static route: %m");
1533 r
= sd_dhcp_client_set_request_option(link
->dhcp_client
, SD_DHCP_OPTION_CLASSLESS_STATIC_ROUTE
);
1535 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set request flag for classless static route: %m");
1538 if (link
->network
->dhcp_use_domains
!= DHCP_USE_DOMAINS_NO
) {
1539 r
= sd_dhcp_client_set_request_option(link
->dhcp_client
, SD_DHCP_OPTION_DOMAIN_SEARCH
);
1541 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set request flag for domain search list: %m");
1544 if (link
->network
->dhcp_use_ntp
) {
1545 r
= sd_dhcp_client_set_request_option(link
->dhcp_client
, SD_DHCP_OPTION_NTP_SERVER
);
1547 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set request flag for NTP server: %m");
1550 if (link
->network
->dhcp_use_sip
) {
1551 r
= sd_dhcp_client_set_request_option(link
->dhcp_client
, SD_DHCP_OPTION_SIP_SERVER
);
1553 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set request flag for SIP server: %m");
1555 if (link
->network
->dhcp_use_captive_portal
) {
1556 r
= sd_dhcp_client_set_request_option(link
->dhcp_client
, SD_DHCP_OPTION_DHCP_CAPTIVE_PORTAL
);
1558 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set request flag for captive portal: %m");
1561 if (link
->network
->dhcp_use_timezone
) {
1562 r
= sd_dhcp_client_set_request_option(link
->dhcp_client
, SD_DHCP_OPTION_TZDB_TIMEZONE
);
1564 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set request flag for timezone: %m");
1567 if (link
->network
->dhcp_use_6rd
) {
1568 r
= sd_dhcp_client_set_request_option(link
->dhcp_client
, SD_DHCP_OPTION_6RD
);
1570 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set request flag for 6rd: %m");
1573 if (link_dhcp4_ipv6_only_mode(link
)) {
1574 r
= sd_dhcp_client_set_request_option(link
->dhcp_client
, SD_DHCP_OPTION_IPV6_ONLY_PREFERRED
);
1576 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set request flag for IPv6-only preferred option: %m");
1579 SET_FOREACH(request_options
, link
->network
->dhcp_request_options
) {
1580 uint32_t option
= PTR_TO_UINT32(request_options
);
1582 r
= sd_dhcp_client_set_request_option(link
->dhcp_client
, option
);
1584 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set request flag for '%u': %m", option
);
1587 ORDERED_HASHMAP_FOREACH(send_option
, link
->network
->dhcp_client_send_options
) {
1588 r
= sd_dhcp_client_add_option(link
->dhcp_client
, send_option
);
1592 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set send option: %m");
1595 ORDERED_HASHMAP_FOREACH(send_option
, link
->network
->dhcp_client_send_vendor_options
) {
1596 r
= sd_dhcp_client_add_vendor_option(link
->dhcp_client
, send_option
);
1600 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set send option: %m");
1603 r
= dhcp4_set_hostname(link
);
1607 if (link
->network
->dhcp_vendor_class_identifier
) {
1608 r
= sd_dhcp_client_set_vendor_class_identifier(link
->dhcp_client
,
1609 link
->network
->dhcp_vendor_class_identifier
);
1611 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set vendor class identifier: %m");
1614 if (link
->network
->dhcp_mudurl
) {
1615 r
= sd_dhcp_client_set_mud_url(link
->dhcp_client
, link
->network
->dhcp_mudurl
);
1617 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set MUD URL: %m");
1620 if (link
->network
->dhcp_user_class
) {
1621 r
= sd_dhcp_client_set_user_class(link
->dhcp_client
, link
->network
->dhcp_user_class
);
1623 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set user class: %m");
1627 if (link
->network
->dhcp_client_port
> 0) {
1628 r
= sd_dhcp_client_set_client_port(link
->dhcp_client
, link
->network
->dhcp_client_port
);
1630 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set listen port: %m");
1633 if (link
->network
->dhcp_max_attempts
> 0) {
1634 r
= sd_dhcp_client_set_max_attempts(link
->dhcp_client
, link
->network
->dhcp_max_attempts
);
1636 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set max attempts: %m");
1639 if (link
->network
->dhcp_ip_service_type
>= 0) {
1640 r
= sd_dhcp_client_set_service_type(link
->dhcp_client
, link
->network
->dhcp_ip_service_type
);
1642 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set IP service type: %m");
1645 if (link
->network
->dhcp_socket_priority_set
) {
1646 r
= sd_dhcp_client_set_socket_priority(link
->dhcp_client
, link
->network
->dhcp_socket_priority
);
1648 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed to set socket priority: %m");
1651 if (link
->network
->dhcp_fallback_lease_lifetime_usec
> 0) {
1652 r
= sd_dhcp_client_set_fallback_lease_lifetime(link
->dhcp_client
, link
->network
->dhcp_fallback_lease_lifetime_usec
);
1654 return log_link_debug_errno(link
, r
, "DHCPv4 CLIENT: Failed set to lease lifetime: %m");
1657 return dhcp4_set_client_identifier(link
);
1660 int dhcp4_update_mac(Link
*link
) {
1666 if (!link
->dhcp_client
)
1669 restart
= sd_dhcp_client_is_running(link
->dhcp_client
);
1671 r
= sd_dhcp_client_stop(link
->dhcp_client
);
1675 r
= sd_dhcp_client_set_mac(link
->dhcp_client
,
1676 link
->hw_addr
.bytes
,
1677 link
->bcast_addr
.length
> 0 ? link
->bcast_addr
.bytes
: NULL
,
1678 link
->hw_addr
.length
, link
->iftype
);
1682 r
= dhcp4_set_client_identifier(link
);
1687 r
= dhcp4_start(link
);
1695 int dhcp4_update_ipv6_connectivity(Link
*link
) {
1701 if (!link
->network
->dhcp_ipv6_only_mode
)
1704 if (!link
->dhcp_client
)
1707 /* If the client is running, set the current connectivity. */
1708 if (sd_dhcp_client_is_running(link
->dhcp_client
))
1709 return sd_dhcp_client_set_ipv6_connectivity(link
->dhcp_client
, link_has_ipv6_connectivity(link
));
1711 /* If the client has been already stopped or not started yet, let's check the current connectivity
1712 * and start the client if necessary. */
1713 if (link_has_ipv6_connectivity(link
))
1716 return dhcp4_start_full(link
, /* set_ipv6_connectivity = */ false);
1719 int dhcp4_start_full(Link
*link
, bool set_ipv6_connectivity
) {
1723 assert(link
->network
);
1725 if (!link
->dhcp_client
)
1728 if (!link_has_carrier(link
))
1731 if (sd_dhcp_client_is_running(link
->dhcp_client
) > 0)
1734 r
= sd_dhcp_client_start(link
->dhcp_client
);
1738 if (set_ipv6_connectivity
) {
1739 r
= dhcp4_update_ipv6_connectivity(link
);
1747 int dhcp4_renew(Link
*link
) {
1750 if (!link
->dhcp_client
)
1753 /* The DHCPv4 client may have been stopped by the IPv6 only mode. Let's unconditionally restart the
1754 * client if it is not running. */
1755 if (!sd_dhcp_client_is_running(link
->dhcp_client
))
1756 return dhcp4_start(link
);
1758 /* The client may be waiting for IPv6 connectivity. Let's restart the client in that case. */
1759 if (dhcp_client_get_state(link
->dhcp_client
) != DHCP_STATE_BOUND
)
1760 return sd_dhcp_client_interrupt_ipv6_only_mode(link
->dhcp_client
);
1762 /* Otherwise, send a RENEW command. */
1763 return sd_dhcp_client_send_renew(link
->dhcp_client
);
1766 static int dhcp4_configure_duid(Link
*link
) {
1768 assert(link
->network
);
1770 if (link
->network
->dhcp_client_identifier
!= DHCP_CLIENT_ID_DUID
)
1773 return dhcp_configure_duid(link
, link_get_dhcp4_duid(link
));
1776 static int dhcp4_process_request(Request
*req
, Link
*link
, void *userdata
) {
1781 if (!link_is_ready_to_configure(link
, /* allow_unmanaged = */ false))
1784 r
= dhcp4_configure_duid(link
);
1788 r
= dhcp4_configure(link
);
1790 return log_link_warning_errno(link
, r
, "Failed to configure DHCPv4 client: %m");
1792 r
= dhcp4_start(link
);
1794 return log_link_warning_errno(link
, r
, "Failed to start DHCPv4 client: %m");
1796 log_link_debug(link
, "DHCPv4 client is configured%s.",
1797 r
> 0 ? ", acquiring DHCPv4 lease" : "");
1801 int link_request_dhcp4_client(Link
*link
) {
1806 if (!link_dhcp4_enabled(link
))
1809 if (link
->dhcp_client
)
1812 r
= link_queue_request(link
, REQUEST_TYPE_DHCP4_CLIENT
, dhcp4_process_request
, NULL
);
1814 return log_link_warning_errno(link
, r
, "Failed to request configuring of the DHCPv4 client: %m");
1816 log_link_debug(link
, "Requested configuring of the DHCPv4 client.");
1820 int config_parse_dhcp_max_attempts(
1822 const char *filename
,
1824 const char *section
,
1825 unsigned section_line
,
1832 Network
*network
= ASSERT_PTR(data
);
1839 if (isempty(rvalue
)) {
1840 network
->dhcp_max_attempts
= 0;
1844 if (streq(rvalue
, "infinity")) {
1845 network
->dhcp_max_attempts
= UINT64_MAX
;
1849 r
= safe_atou64(rvalue
, &a
);
1851 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
,
1852 "Failed to parse DHCP maximum attempts, ignoring: %s", rvalue
);
1857 log_syntax(unit
, LOG_WARNING
, filename
, line
, 0,
1858 "%s= must be positive integer or 'infinity', ignoring: %s", lvalue
, rvalue
);
1862 network
->dhcp_max_attempts
= a
;
1867 int config_parse_dhcp_ip_service_type(
1869 const char *filename
,
1871 const char *section
,
1872 unsigned section_line
,
1879 int *tos
= ASSERT_PTR(data
);
1885 if (isempty(rvalue
))
1886 *tos
= -1; /* use sd_dhcp_client's default (currently, CS6). */
1887 else if (streq(rvalue
, "none"))
1889 else if (streq(rvalue
, "CS4"))
1890 *tos
= IPTOS_CLASS_CS4
;
1891 else if (streq(rvalue
, "CS6"))
1892 *tos
= IPTOS_CLASS_CS6
;
1894 log_syntax(unit
, LOG_WARNING
, filename
, line
, 0,
1895 "Failed to parse %s=, ignoring assignment: %s", lvalue
, rvalue
);
1900 int config_parse_dhcp_socket_priority(
1902 const char *filename
,
1904 const char *section
,
1905 unsigned section_line
,
1912 Network
*network
= ASSERT_PTR(data
);
1918 if (isempty(rvalue
)) {
1919 network
->dhcp_socket_priority_set
= false;
1923 r
= safe_atoi(rvalue
, &a
);
1925 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
,
1926 "Failed to parse socket priority, ignoring: %s", rvalue
);
1930 network
->dhcp_socket_priority_set
= true;
1931 network
->dhcp_socket_priority
= a
;
1936 int config_parse_dhcp_fallback_lease_lifetime(
1938 const char *filename
,
1940 const char *section
,
1941 unsigned section_line
,
1948 Network
*network
= userdata
;
1956 if (isempty(rvalue
)) {
1957 network
->dhcp_fallback_lease_lifetime_usec
= 0;
1961 /* We accept only "forever" or "infinity". */
1962 if (!STR_IN_SET(rvalue
, "forever", "infinity")) {
1963 log_syntax(unit
, LOG_WARNING
, filename
, line
, 0,
1964 "Invalid LeaseLifetime= value, ignoring: %s", rvalue
);
1968 network
->dhcp_fallback_lease_lifetime_usec
= USEC_INFINITY
;
1973 int config_parse_dhcp_label(
1975 const char *filename
,
1977 const char *section
,
1978 unsigned section_line
,
1985 char **label
= ASSERT_PTR(data
);
1991 if (isempty(rvalue
)) {
1992 *label
= mfree(*label
);
1996 if (!address_label_valid(rvalue
)) {
1997 log_syntax(unit
, LOG_WARNING
, filename
, line
, 0,
1998 "Address label is too long or invalid, ignoring assignment: %s", rvalue
);
2002 return free_and_strdup_warn(label
, rvalue
);
2005 static const char* const dhcp_client_identifier_table
[_DHCP_CLIENT_ID_MAX
] = {
2006 [DHCP_CLIENT_ID_MAC
] = "mac",
2007 [DHCP_CLIENT_ID_DUID
] = "duid",
2010 DEFINE_PRIVATE_STRING_TABLE_LOOKUP_FROM_STRING(dhcp_client_identifier
, DHCPClientIdentifier
);
2011 DEFINE_CONFIG_PARSE_ENUM(config_parse_dhcp_client_identifier
, dhcp_client_identifier
, DHCPClientIdentifier
,
2012 "Failed to parse client identifier type");