1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
3 #include <netinet/in.h>
4 #include <linux/if_arp.h>
7 #include "bus-locator.h"
8 #include "dhcp-option.h"
9 #include "dhcp6-internal.h"
11 #include "hexdecoct.h"
12 #include "in-addr-prefix-util.h"
13 #include "networkd-dhcp-common.h"
14 #include "networkd-link.h"
15 #include "networkd-manager.h"
16 #include "networkd-network.h"
17 #include "networkd-route-util.h"
18 #include "parse-util.h"
19 #include "socket-util.h"
20 #include "string-table.h"
24 static uint32_t link_get_vrf_table(Link
*link
) {
26 assert(link
->network
);
28 return link
->network
->vrf
? VRF(link
->network
->vrf
)->table
: RT_TABLE_MAIN
;
31 uint32_t link_get_dhcp4_route_table(Link
*link
) {
33 assert(link
->network
);
35 /* When the interface is part of an VRF use the VRFs routing table, unless
36 * another table is explicitly specified. */
38 if (link
->network
->dhcp_route_table_set
)
39 return link
->network
->dhcp_route_table
;
40 return link_get_vrf_table(link
);
43 uint32_t link_get_ndisc_route_table(Link
*link
) {
45 assert(link
->network
);
47 if (link
->network
->ndisc_route_table_set
)
48 return link
->network
->ndisc_route_table
;
49 return link_get_vrf_table(link
);
52 bool link_dhcp_enabled(Link
*link
, int family
) {
54 assert(IN_SET(family
, AF_INET
, AF_INET6
));
56 /* Currently, sd-dhcp-client supports only ethernet and infiniband. */
57 if (family
== AF_INET
&& !IN_SET(link
->iftype
, ARPHRD_ETHER
, ARPHRD_INFINIBAND
))
60 if (family
== AF_INET6
&& !socket_ipv6_is_supported())
63 if (link
->flags
& IFF_LOOPBACK
)
66 if (link
->iftype
== ARPHRD_CAN
)
72 return link
->network
->dhcp
& (family
== AF_INET
? ADDRESS_FAMILY_IPV4
: ADDRESS_FAMILY_IPV6
);
75 void network_adjust_dhcp(Network
*network
) {
77 assert(network
->dhcp
>= 0);
79 if (network
->dhcp
== ADDRESS_FAMILY_NO
)
82 /* Bonding slave does not support addressing. */
84 log_warning("%s: Cannot enable DHCP= when Bond= is specified, disabling DHCP=.",
86 network
->dhcp
= ADDRESS_FAMILY_NO
;
90 if (!FLAGS_SET(network
->link_local
, ADDRESS_FAMILY_IPV6
) &&
91 FLAGS_SET(network
->dhcp
, ADDRESS_FAMILY_IPV6
)) {
92 log_warning("%s: DHCPv6 client is enabled but IPv6 link-local addressing is disabled. "
93 "Disabling DHCPv6 client.", network
->filename
);
94 SET_FLAG(network
->dhcp
, ADDRESS_FAMILY_IPV6
, false);
97 network_adjust_dhcp4(network
);
100 static bool duid_needs_product_uuid(const DUID
*duid
) {
103 return duid
->type
== DUID_TYPE_UUID
&& duid
->raw_data_len
== 0;
106 static const struct DUID fallback_duid
= { .type
= DUID_TYPE_EN
};
108 const DUID
*link_get_duid(Link
*link
, int family
) {
112 assert(IN_SET(family
, AF_INET
, AF_INET6
));
115 duid
= family
== AF_INET
? &link
->network
->dhcp_duid
: &link
->network
->dhcp6_duid
;
116 if (duid
->type
!= _DUID_TYPE_INVALID
) {
117 if (duid_needs_product_uuid(duid
))
118 return &link
->manager
->duid_product_uuid
;
124 duid
= family
== AF_INET
? &link
->manager
->dhcp_duid
: &link
->manager
->dhcp6_duid
;
125 if (link
->hw_addr
.length
== 0 && IN_SET(duid
->type
, DUID_TYPE_LLT
, DUID_TYPE_LL
))
126 /* Fallback to DUID that works without MAC address.
127 * This is useful for tunnel devices without MAC address. */
128 return &fallback_duid
;
133 static int get_product_uuid_handler(sd_bus_message
*m
, void *userdata
, sd_bus_error
*ret_error
) {
134 Manager
*manager
= ASSERT_PTR(userdata
);
135 const sd_bus_error
*e
;
142 /* To avoid calling GetProductUUID() bus method so frequently, set the flag below
143 * even if the method fails. */
144 manager
->has_product_uuid
= true;
146 e
= sd_bus_message_get_error(m
);
148 r
= sd_bus_error_get_errno(e
);
149 log_warning_errno(r
, "Could not get product UUID. Falling back to use machine-app-specific ID as DUID-UUID: %s",
150 bus_error_message(e
, r
));
154 r
= sd_bus_message_read_array(m
, 'y', &a
, &sz
);
156 log_warning_errno(r
, "Failed to get product UUID. Falling back to use machine-app-specific ID as DUID-UUID: %m");
160 if (sz
!= sizeof(sd_id128_t
)) {
161 log_warning("Invalid product UUID. Falling back to use machine-app-specific ID as DUID-UUID.");
165 log_debug("Successfully obtained product UUID");
167 memcpy(&manager
->duid_product_uuid
.raw_data
, a
, sz
);
168 manager
->duid_product_uuid
.raw_data_len
= sz
;
173 int manager_request_product_uuid(Manager
*m
) {
174 static bool bus_method_is_called
= false;
179 if (bus_method_is_called
)
182 if (sd_bus_is_ready(m
->bus
) <= 0 && !m
->product_uuid_requested
) {
183 log_debug("Not connected to system bus, requesting product UUID later.");
184 m
->product_uuid_requested
= true;
188 m
->product_uuid_requested
= false;
190 r
= bus_call_method_async(
195 get_product_uuid_handler
,
200 return log_warning_errno(r
, "Failed to get product UUID: %m");
202 log_debug("Requesting product UUID.");
204 bus_method_is_called
= true;
209 int dhcp_configure_duid(Link
*link
, const DUID
*duid
) {
214 assert(link
->manager
);
219 if (!duid_needs_product_uuid(duid
))
222 if (m
->has_product_uuid
)
225 r
= manager_request_product_uuid(m
);
227 log_link_warning_errno(link
, r
,
228 "Failed to get product UUID. Falling back to use machine-app-specific ID as DUID-UUID: %m");
230 m
->has_product_uuid
= true; /* Do not request UUID again on failure. */
237 bool address_is_filtered(int family
, const union in_addr_union
*address
, uint8_t prefixlen
, Set
*allow_list
, Set
*deny_list
) {
238 struct in_addr_prefix
*p
;
240 assert(IN_SET(family
, AF_INET
, AF_INET6
));
244 SET_FOREACH(p
, allow_list
)
245 if (p
->family
== family
&&
246 p
->prefixlen
<= prefixlen
&&
247 in_addr_prefix_covers(family
, &p
->address
, p
->prefixlen
, address
) > 0)
253 SET_FOREACH(p
, deny_list
)
254 if (p
->family
== family
&&
255 in_addr_prefix_intersect(family
, &p
->address
, p
->prefixlen
, address
, prefixlen
) > 0)
261 int link_get_captive_portal(Link
*link
, const char **ret
) {
262 const char *dhcp4_cp
= NULL
, *dhcp6_cp
= NULL
, *ndisc_cp
= NULL
;
267 if (!link
->network
) {
272 if (link
->network
->dhcp_use_captive_portal
&& link
->dhcp_lease
) {
273 r
= sd_dhcp_lease_get_captive_portal(link
->dhcp_lease
, &dhcp4_cp
);
274 if (r
< 0 && r
!= -ENODATA
)
278 if (link
->network
->dhcp6_use_captive_portal
&& link
->dhcp6_lease
) {
279 r
= sd_dhcp6_lease_get_captive_portal(link
->dhcp6_lease
, &dhcp6_cp
);
280 if (r
< 0 && r
!= -ENODATA
)
284 if (link
->network
->ndisc_use_captive_portal
) {
285 NDiscCaptivePortal
*cp
;
288 /* Use the captive portal with the longest lifetime. */
290 SET_FOREACH(cp
, link
->ndisc_captive_portals
) {
291 if (cp
->lifetime_usec
< usec
)
294 ndisc_cp
= cp
->captive_portal
;
295 usec
= cp
->lifetime_usec
;
298 if (set_size(link
->ndisc_captive_portals
) > 1)
299 log_link_debug(link
, "Multiple captive portals obtained by IPv6RA, using \"%s\" and ignoring others.",
304 if (dhcp6_cp
&& !streq(dhcp4_cp
, dhcp6_cp
))
305 log_link_debug(link
, "DHCPv6 captive portal (%s) does not match DHCPv4 (%s), ignoring DHCPv6 captive portal.",
308 if (ndisc_cp
&& !streq(dhcp4_cp
, ndisc_cp
))
309 log_link_debug(link
, "IPv6RA captive portal (%s) does not match DHCPv4 (%s), ignoring IPv6RA captive portal.",
317 if (ndisc_cp
&& !streq(dhcp6_cp
, ndisc_cp
))
318 log_link_debug(link
, "IPv6RA captive portal (%s) does not match DHCPv6 (%s), ignoring IPv6RA captive portal.",
329 int config_parse_dhcp(
331 const char *filename
,
334 unsigned section_line
,
341 AddressFamily
*dhcp
= data
, s
;
348 /* Note that this is mostly like
349 * config_parse_address_family(), except that it
350 * understands some old names for the enum values */
352 s
= address_family_from_string(rvalue
);
355 /* Previously, we had a slightly different enum here,
356 * support its values for compatibility. */
358 s
= dhcp_deprecated_address_family_from_string(rvalue
);
360 log_syntax(unit
, LOG_WARNING
, filename
, line
, s
,
361 "Failed to parse DHCP option, ignoring: %s", rvalue
);
365 log_syntax(unit
, LOG_WARNING
, filename
, line
, 0,
366 "DHCP=%s is deprecated, please use DHCP=%s instead.",
367 rvalue
, address_family_to_string(s
));
374 int config_parse_dhcp_route_metric(
376 const char *filename
,
379 unsigned section_line
,
386 Network
*network
= userdata
;
392 assert(IN_SET(ltype
, AF_UNSPEC
, AF_INET
));
396 r
= safe_atou32(rvalue
, &metric
);
398 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
,
399 "Failed to parse RouteMetric=%s, ignoring assignment: %m", rvalue
);
405 network
->dhcp_route_metric
= metric
;
406 network
->dhcp_route_metric_set
= true;
409 /* For backward compatibility. */
410 if (!network
->dhcp_route_metric_set
)
411 network
->dhcp_route_metric
= metric
;
412 if (!network
->ndisc_route_metric_set
) {
413 network
->ndisc_route_metric_high
= metric
;
414 network
->ndisc_route_metric_medium
= metric
;
415 network
->ndisc_route_metric_low
= metric
;
419 assert_not_reached();
425 int config_parse_ndisc_route_metric(
427 const char *filename
,
430 unsigned section_line
,
437 Network
*network
= ASSERT_PTR(userdata
);
438 uint32_t metric_high
, metric_medium
, metric_low
;
444 if (safe_atou32(rvalue
, &metric_low
) >= 0)
445 metric_high
= metric_medium
= metric_low
;
447 _cleanup_free_
char *high
= NULL
, *medium
= NULL
, *low
= NULL
;
448 const char *p
= rvalue
;
450 r
= extract_many_words(&p
, ":", EXTRACT_DONT_COALESCE_SEPARATORS
, &high
, &medium
, &low
);
453 if (r
!= 3 || !isempty(p
)) {
454 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
< 0 ? r
: 0,
455 "Failed to parse RouteTable=%s, ignoring assignment: %m", rvalue
);
459 r
= safe_atou32(high
, &metric_high
);
460 s
= safe_atou32(medium
, &metric_medium
);
461 t
= safe_atou32(low
, &metric_low
);
462 if (r
< 0 || s
< 0 || t
< 0) {
463 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
< 0 ? r
: s
< 0 ? s
: t
,
464 "Failed to parse RouteTable=%s, ignoring assignment: %m", rvalue
);
468 if (metric_high
>= metric_medium
|| metric_medium
>= metric_low
) {
469 log_syntax(unit
, LOG_WARNING
, filename
, line
, 0,
470 "Invalid RouteTable=%s, ignoring assignment: %m", rvalue
);
475 network
->ndisc_route_metric_high
= metric_high
;
476 network
->ndisc_route_metric_medium
= metric_medium
;
477 network
->ndisc_route_metric_low
= metric_low
;
478 network
->ndisc_route_metric_set
= true;
483 int config_parse_dhcp_send_hostname(
485 const char *filename
,
488 unsigned section_line
,
495 Network
*network
= userdata
;
500 assert(IN_SET(ltype
, AF_UNSPEC
, AF_INET
, AF_INET6
));
504 r
= parse_boolean(rvalue
);
506 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
,
507 "Failed to parse SendHostname=%s, ignoring assignment: %m", rvalue
);
513 network
->dhcp_send_hostname
= r
;
514 network
->dhcp_send_hostname_set
= true;
517 network
->dhcp6_send_hostname
= r
;
518 network
->dhcp6_send_hostname_set
= true;
521 /* For backward compatibility. */
522 if (!network
->dhcp_send_hostname_set
)
523 network
->dhcp_send_hostname
= r
;
524 if (!network
->dhcp6_send_hostname_set
)
525 network
->dhcp6_send_hostname
= r
;
528 assert_not_reached();
533 int config_parse_dhcp_use_dns(
535 const char *filename
,
538 unsigned section_line
,
545 Network
*network
= userdata
;
550 assert(IN_SET(ltype
, AF_UNSPEC
, AF_INET
, AF_INET6
));
554 r
= parse_boolean(rvalue
);
556 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
,
557 "Failed to parse UseDNS=%s, ignoring assignment: %m", rvalue
);
563 network
->dhcp_use_dns
= r
;
564 network
->dhcp_use_dns_set
= true;
567 network
->dhcp6_use_dns
= r
;
568 network
->dhcp6_use_dns_set
= true;
571 /* For backward compatibility. */
572 if (!network
->dhcp_use_dns_set
)
573 network
->dhcp_use_dns
= r
;
574 if (!network
->dhcp6_use_dns_set
)
575 network
->dhcp6_use_dns
= r
;
578 assert_not_reached();
584 int config_parse_dhcp_use_domains(
586 const char *filename
,
589 unsigned section_line
,
596 Network
*network
= userdata
;
601 assert(IN_SET(ltype
, AF_UNSPEC
, AF_INET
, AF_INET6
));
605 d
= dhcp_use_domains_from_string(rvalue
);
607 log_syntax(unit
, LOG_WARNING
, filename
, line
, d
,
608 "Failed to parse %s=%s, ignoring assignment: %m", lvalue
, rvalue
);
614 network
->dhcp_use_domains
= d
;
615 network
->dhcp_use_domains_set
= true;
618 network
->dhcp6_use_domains
= d
;
619 network
->dhcp6_use_domains_set
= true;
622 /* For backward compatibility. */
623 if (!network
->dhcp_use_domains_set
)
624 network
->dhcp_use_domains
= d
;
625 if (!network
->dhcp6_use_domains_set
)
626 network
->dhcp6_use_domains
= d
;
629 assert_not_reached();
635 int config_parse_dhcp_use_ntp(
637 const char *filename
,
640 unsigned section_line
,
647 Network
*network
= userdata
;
652 assert(IN_SET(ltype
, AF_UNSPEC
, AF_INET
, AF_INET6
));
656 r
= parse_boolean(rvalue
);
658 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
,
659 "Failed to parse UseNTP=%s, ignoring assignment: %m", rvalue
);
665 network
->dhcp_use_ntp
= r
;
666 network
->dhcp_use_ntp_set
= true;
669 network
->dhcp6_use_ntp
= r
;
670 network
->dhcp6_use_ntp_set
= true;
673 /* For backward compatibility. */
674 if (!network
->dhcp_use_ntp_set
)
675 network
->dhcp_use_ntp
= r
;
676 if (!network
->dhcp6_use_ntp_set
)
677 network
->dhcp6_use_ntp
= r
;
680 assert_not_reached();
686 int config_parse_dhcp_or_ra_route_table(
688 const char *filename
,
691 unsigned section_line
,
698 Network
*network
= ASSERT_PTR(userdata
);
704 assert(IN_SET(ltype
, AF_INET
, AF_INET6
));
707 r
= manager_get_route_table_from_string(network
->manager
, rvalue
, &rt
);
709 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
,
710 "Failed to parse RouteTable=%s, ignoring assignment: %m", rvalue
);
716 network
->dhcp_route_table
= rt
;
717 network
->dhcp_route_table_set
= true;
720 network
->ndisc_route_table
= rt
;
721 network
->ndisc_route_table_set
= true;
724 assert_not_reached();
730 int config_parse_iaid(
732 const char *filename
,
735 unsigned section_line
,
742 Network
*network
= ASSERT_PTR(userdata
);
749 assert(IN_SET(ltype
, AF_INET
, AF_INET6
));
751 r
= safe_atou32(rvalue
, &iaid
);
753 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
,
754 "Unable to read IAID, ignoring assignment: %s", rvalue
);
758 if (ltype
== AF_INET
) {
759 network
->dhcp_iaid
= iaid
;
760 network
->dhcp_iaid_set
= true;
761 if (!network
->dhcp6_iaid_set_explicitly
) {
762 /* Backward compatibility. Previously, IAID is shared by DHCPv4 and DHCPv6.
763 * If DHCPv6 IAID is not specified explicitly, then use DHCPv4 IAID for DHCPv6. */
764 network
->dhcp6_iaid
= iaid
;
765 network
->dhcp6_iaid_set
= true;
768 assert(ltype
== AF_INET6
);
769 network
->dhcp6_iaid
= iaid
;
770 network
->dhcp6_iaid_set
= true;
771 network
->dhcp6_iaid_set_explicitly
= true;
777 int config_parse_dhcp_user_or_vendor_class(
779 const char *filename
,
782 unsigned section_line
,
789 char ***l
= ASSERT_PTR(data
);
794 assert(IN_SET(ltype
, AF_INET
, AF_INET6
));
796 if (isempty(rvalue
)) {
801 for (const char *p
= rvalue
;;) {
802 _cleanup_free_
char *w
= NULL
;
805 r
= extract_first_word(&p
, &w
, NULL
, EXTRACT_CUNESCAPE
|EXTRACT_UNQUOTE
);
809 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
,
810 "Failed to split user classes option, ignoring: %s", rvalue
);
817 if (ltype
== AF_INET
) {
818 if (len
> UINT8_MAX
|| len
== 0) {
819 log_syntax(unit
, LOG_WARNING
, filename
, line
, 0,
820 "%s length is not in the range 1…255, ignoring.", w
);
824 if (len
> UINT16_MAX
|| len
== 0) {
825 log_syntax(unit
, LOG_WARNING
, filename
, line
, 0,
826 "%s length is not in the range 1…65535, ignoring.", w
);
831 r
= strv_consume(l
, TAKE_PTR(w
));
837 int config_parse_dhcp_send_option(
839 const char *filename
,
842 unsigned section_line
,
849 _cleanup_(sd_dhcp_option_unrefp
) sd_dhcp_option
*opt4
= NULL
;
850 _cleanup_(sd_dhcp6_option_unrefp
) sd_dhcp6_option
*opt6
= NULL
;
851 _unused_
_cleanup_(sd_dhcp_option_unrefp
) sd_dhcp_option
*old4
= NULL
;
852 _unused_
_cleanup_(sd_dhcp6_option_unrefp
) sd_dhcp6_option
*old6
= NULL
;
853 uint32_t uint32_data
, enterprise_identifier
= 0;
854 _cleanup_free_
char *word
= NULL
, *q
= NULL
;
855 OrderedHashmap
**options
= ASSERT_PTR(data
);
856 uint16_t u16
, uint16_data
;
857 union in_addr_union addr
;
858 DHCPOptionDataType type
;
859 uint8_t u8
, uint8_data
;
869 if (isempty(rvalue
)) {
870 *options
= ordered_hashmap_free(*options
);
875 if (ltype
== AF_INET6
&& streq(lvalue
, "SendVendorOption")) {
876 r
= extract_first_word(&p
, &word
, ":", 0);
879 if (r
<= 0 || isempty(p
)) {
880 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
,
881 "Invalid DHCP option, ignoring assignment: %s", rvalue
);
885 r
= safe_atou32(word
, &enterprise_identifier
);
887 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
,
888 "Failed to parse DHCPv6 enterprise identifier data, ignoring assignment: %s", p
);
894 r
= extract_first_word(&p
, &word
, ":", 0);
897 if (r
<= 0 || isempty(p
)) {
898 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
,
899 "Invalid DHCP option, ignoring assignment: %s", rvalue
);
903 if (ltype
== AF_INET6
) {
904 r
= safe_atou16(word
, &u16
);
906 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
,
907 "Invalid DHCP option, ignoring assignment: %s", rvalue
);
910 if (u16
< 1 || u16
>= UINT16_MAX
) {
911 log_syntax(unit
, LOG_WARNING
, filename
, line
, 0,
912 "Invalid DHCP option, valid range is 1-65535, ignoring assignment: %s", rvalue
);
916 r
= safe_atou8(word
, &u8
);
918 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
,
919 "Invalid DHCP option, ignoring assignment: %s", rvalue
);
922 if (u8
< 1 || u8
>= UINT8_MAX
) {
923 log_syntax(unit
, LOG_WARNING
, filename
, line
, 0,
924 "Invalid DHCP option, valid range is 1-254, ignoring assignment: %s", rvalue
);
930 r
= extract_first_word(&p
, &word
, ":", 0);
933 if (r
<= 0 || isempty(p
)) {
934 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
,
935 "Invalid DHCP option, ignoring assignment: %s", rvalue
);
939 type
= dhcp_option_data_type_from_string(word
);
941 log_syntax(unit
, LOG_WARNING
, filename
, line
, type
,
942 "Invalid DHCP option data type, ignoring assignment: %s", p
);
947 case DHCP_OPTION_DATA_UINT8
:{
948 r
= safe_atou8(p
, &uint8_data
);
950 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
,
951 "Failed to parse DHCP uint8 data, ignoring assignment: %s", p
);
956 sz
= sizeof(uint8_t);
959 case DHCP_OPTION_DATA_UINT16
:{
962 r
= safe_atou16(p
, &k
);
964 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
,
965 "Failed to parse DHCP uint16 data, ignoring assignment: %s", p
);
969 uint16_data
= htobe16(k
);
970 udata
= &uint16_data
;
971 sz
= sizeof(uint16_t);
974 case DHCP_OPTION_DATA_UINT32
: {
977 r
= safe_atou32(p
, &k
);
979 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
,
980 "Failed to parse DHCP uint32 data, ignoring assignment: %s", p
);
984 uint32_data
= htobe32(k
);
985 udata
= &uint32_data
;
986 sz
= sizeof(uint32_t);
990 case DHCP_OPTION_DATA_IPV4ADDRESS
: {
991 r
= in_addr_from_string(AF_INET
, p
, &addr
);
993 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
,
994 "Failed to parse DHCP ipv4address data, ignoring assignment: %s", p
);
999 sz
= sizeof(addr
.in
.s_addr
);
1002 case DHCP_OPTION_DATA_IPV6ADDRESS
: {
1003 r
= in_addr_from_string(AF_INET6
, p
, &addr
);
1005 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
,
1006 "Failed to parse DHCP ipv6address data, ignoring assignment: %s", p
);
1011 sz
= sizeof(addr
.in6
.s6_addr
);
1014 case DHCP_OPTION_DATA_STRING
:
1015 sz
= cunescape(p
, UNESCAPE_ACCEPT_NUL
, &q
);
1017 log_syntax(unit
, LOG_WARNING
, filename
, line
, sz
,
1018 "Failed to decode DHCP option data, ignoring assignment: %s", p
);
1028 if (ltype
== AF_INET6
) {
1029 r
= sd_dhcp6_option_new(u16
, udata
, sz
, enterprise_identifier
, &opt6
);
1031 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
,
1032 "Failed to store DHCP option '%s', ignoring assignment: %m", rvalue
);
1036 r
= ordered_hashmap_ensure_allocated(options
, &dhcp6_option_hash_ops
);
1040 /* Overwrite existing option */
1041 old6
= ordered_hashmap_get(*options
, UINT_TO_PTR(u16
));
1042 r
= ordered_hashmap_replace(*options
, UINT_TO_PTR(u16
), opt6
);
1044 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
,
1045 "Failed to store DHCP option '%s', ignoring assignment: %m", rvalue
);
1050 r
= sd_dhcp_option_new(u8
, udata
, sz
, &opt4
);
1052 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
,
1053 "Failed to store DHCP option '%s', ignoring assignment: %m", rvalue
);
1057 r
= ordered_hashmap_ensure_allocated(options
, &dhcp_option_hash_ops
);
1061 /* Overwrite existing option */
1062 old4
= ordered_hashmap_get(*options
, UINT_TO_PTR(u8
));
1063 r
= ordered_hashmap_replace(*options
, UINT_TO_PTR(u8
), opt4
);
1065 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
,
1066 "Failed to store DHCP option '%s', ignoring assignment: %m", rvalue
);
1074 int config_parse_dhcp_request_options(
1076 const char *filename
,
1078 const char *section
,
1079 unsigned section_line
,
1086 Network
*network
= userdata
;
1094 if (isempty(rvalue
)) {
1095 if (ltype
== AF_INET
)
1096 network
->dhcp_request_options
= set_free(network
->dhcp_request_options
);
1098 network
->dhcp6_request_options
= set_free(network
->dhcp6_request_options
);
1103 for (const char *p
= rvalue
;;) {
1104 _cleanup_free_
char *n
= NULL
;
1107 r
= extract_first_word(&p
, &n
, NULL
, 0);
1111 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
,
1112 "Failed to parse DHCP request option, ignoring assignment: %s",
1119 r
= safe_atou32(n
, &i
);
1121 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
,
1122 "DHCP request option is invalid, ignoring assignment: %s", n
);
1126 if (i
< 1 || i
>= UINT8_MAX
) {
1127 log_syntax(unit
, LOG_WARNING
, filename
, line
, 0,
1128 "DHCP request option is invalid, valid range is 1-254, ignoring assignment: %s", n
);
1132 r
= set_ensure_put(ltype
== AF_INET
? &network
->dhcp_request_options
: &network
->dhcp6_request_options
,
1133 NULL
, UINT32_TO_PTR(i
));
1135 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
,
1136 "Failed to store DHCP request option '%s', ignoring assignment: %m", n
);
1140 static const char* const dhcp_use_domains_table
[_DHCP_USE_DOMAINS_MAX
] = {
1141 [DHCP_USE_DOMAINS_NO
] = "no",
1142 [DHCP_USE_DOMAINS_ROUTE
] = "route",
1143 [DHCP_USE_DOMAINS_YES
] = "yes",
1146 DEFINE_STRING_TABLE_LOOKUP_WITH_BOOLEAN(dhcp_use_domains
, DHCPUseDomains
, DHCP_USE_DOMAINS_YES
);
1148 static const char * const dhcp_option_data_type_table
[_DHCP_OPTION_DATA_MAX
] = {
1149 [DHCP_OPTION_DATA_UINT8
] = "uint8",
1150 [DHCP_OPTION_DATA_UINT16
] = "uint16",
1151 [DHCP_OPTION_DATA_UINT32
] = "uint32",
1152 [DHCP_OPTION_DATA_STRING
] = "string",
1153 [DHCP_OPTION_DATA_IPV4ADDRESS
] = "ipv4address",
1154 [DHCP_OPTION_DATA_IPV6ADDRESS
] = "ipv6address",
1157 DEFINE_STRING_TABLE_LOOKUP(dhcp_option_data_type
, DHCPOptionDataType
);
1159 static const char* const duid_type_table
[_DUID_TYPE_MAX
] = {
1160 [DUID_TYPE_LLT
] = "link-layer-time",
1161 [DUID_TYPE_EN
] = "vendor",
1162 [DUID_TYPE_LL
] = "link-layer",
1163 [DUID_TYPE_UUID
] = "uuid",
1165 DEFINE_PRIVATE_STRING_TABLE_LOOKUP_FROM_STRING(duid_type
, DUIDType
);
1167 int config_parse_duid_type(
1169 const char *filename
,
1171 const char *section
,
1172 unsigned section_line
,
1179 _cleanup_free_
char *type_string
= NULL
;
1180 const char *p
= ASSERT_PTR(rvalue
);
1182 DUID
*duid
= ASSERT_PTR(data
);
1189 if (!force
&& duid
->set
)
1192 r
= extract_first_word(&p
, &type_string
, ":", 0);
1196 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
,
1197 "Invalid syntax, ignoring: %s", rvalue
);
1201 log_syntax(unit
, LOG_WARNING
, filename
, line
, 0,
1202 "Failed to extract DUID type from '%s', ignoring.", rvalue
);
1206 type
= duid_type_from_string(type_string
);
1210 r
= safe_atou16(type_string
, &t
);
1212 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
,
1213 "Failed to parse DUID type '%s', ignoring.", type_string
);
1218 assert(type
== t
); /* Check if type can store uint16_t. */
1224 if (type
!= DUID_TYPE_LLT
) {
1225 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
,
1226 "Invalid syntax, ignoring: %s", rvalue
);
1230 r
= parse_timestamp(p
, &u
);
1232 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
,
1233 "Failed to parse timestamp, ignoring: %s", p
);
1246 int config_parse_manager_duid_type(
1248 const char *filename
,
1250 const char *section
,
1251 unsigned section_line
,
1258 Manager
*manager
= ASSERT_PTR(userdata
);
1261 /* For backward compatibility. Setting both DHCPv4 and DHCPv6 DUID if they are not specified explicitly. */
1263 r
= config_parse_duid_type(unit
, filename
, line
, section
, section_line
, lvalue
, false, rvalue
, &manager
->dhcp_duid
, manager
);
1267 return config_parse_duid_type(unit
, filename
, line
, section
, section_line
, lvalue
, false, rvalue
, &manager
->dhcp6_duid
, manager
);
1270 int config_parse_network_duid_type(
1272 const char *filename
,
1274 const char *section
,
1275 unsigned section_line
,
1282 Network
*network
= ASSERT_PTR(userdata
);
1285 r
= config_parse_duid_type(unit
, filename
, line
, section
, section_line
, lvalue
, true, rvalue
, &network
->dhcp_duid
, network
);
1289 /* For backward compatibility, also set DHCPv6 DUID if not specified explicitly. */
1290 return config_parse_duid_type(unit
, filename
, line
, section
, section_line
, lvalue
, false, rvalue
, &network
->dhcp6_duid
, network
);
1293 int config_parse_duid_rawdata(
1295 const char *filename
,
1297 const char *section
,
1298 unsigned section_line
,
1305 uint8_t raw_data
[MAX_DUID_DATA_LEN
];
1308 DUID
*duid
= ASSERT_PTR(data
);
1314 if (!force
&& duid
->set
)
1317 /* RawData contains DUID in format "NN:NN:NN..." */
1318 for (const char *p
= rvalue
;;) {
1321 _cleanup_free_
char *cbyte
= NULL
;
1323 r
= extract_first_word(&p
, &cbyte
, ":", 0);
1327 log_syntax(unit
, LOG_WARNING
, filename
, line
, r
, "Failed to read DUID, ignoring assignment: %s.", rvalue
);
1333 if (count
>= MAX_DUID_DATA_LEN
) {
1334 log_syntax(unit
, LOG_WARNING
, filename
, line
, 0, "Max DUID length exceeded, ignoring assignment: %s.", rvalue
);
1338 len
= strlen(cbyte
);
1339 if (!IN_SET(len
, 1, 2)) {
1340 log_syntax(unit
, LOG_WARNING
, filename
, line
, 0, "Invalid length - DUID byte: %s, ignoring assignment: %s.", cbyte
, rvalue
);
1343 n1
= unhexchar(cbyte
[0]);
1345 n2
= unhexchar(cbyte
[1]);
1349 if (n1
< 0 || n2
< 0) {
1350 log_syntax(unit
, LOG_WARNING
, filename
, line
, 0, "Invalid DUID byte: %s. Ignoring assignment: %s.", cbyte
, rvalue
);
1354 byte
= ((uint8_t) n1
<< (4 * (len
-1))) | (uint8_t) n2
;
1355 raw_data
[count
++] = byte
;
1358 assert_cc(sizeof(raw_data
) == sizeof(duid
->raw_data
));
1359 memcpy(duid
->raw_data
, raw_data
, count
);
1360 duid
->raw_data_len
= count
;
1366 int config_parse_manager_duid_rawdata(
1368 const char *filename
,
1370 const char *section
,
1371 unsigned section_line
,
1378 Manager
*manager
= ASSERT_PTR(userdata
);
1381 /* For backward compatibility. Setting both DHCPv4 and DHCPv6 DUID if they are not specified explicitly. */
1383 r
= config_parse_duid_rawdata(unit
, filename
, line
, section
, section_line
, lvalue
, false, rvalue
, &manager
->dhcp_duid
, manager
);
1387 return config_parse_duid_rawdata(unit
, filename
, line
, section
, section_line
, lvalue
, false, rvalue
, &manager
->dhcp6_duid
, manager
);
1390 int config_parse_network_duid_rawdata(
1392 const char *filename
,
1394 const char *section
,
1395 unsigned section_line
,
1402 Network
*network
= ASSERT_PTR(userdata
);
1405 r
= config_parse_duid_rawdata(unit
, filename
, line
, section
, section_line
, lvalue
, true, rvalue
, &network
->dhcp_duid
, network
);
1409 /* For backward compatibility, also set DHCPv6 DUID if not specified explicitly. */
1410 return config_parse_duid_rawdata(unit
, filename
, line
, section
, section_line
, lvalue
, false, rvalue
, &network
->dhcp6_duid
, network
);
1413 int config_parse_uplink(
1415 const char *filename
,
1417 const char *section
,
1418 unsigned section_line
,
1425 Network
*network
= ASSERT_PTR(userdata
);
1426 bool accept_none
= true;
1435 if (streq(section
, "DHCPServer")) {
1436 index
= &network
->dhcp_server_uplink_index
;
1437 name
= &network
->dhcp_server_uplink_name
;
1438 } else if (streq(section
, "IPv6SendRA")) {
1439 index
= &network
->router_uplink_index
;
1440 name
= &network
->router_uplink_name
;
1441 } else if (STR_IN_SET(section
, "DHCPv6PrefixDelegation", "DHCPPrefixDelegation")) {
1442 index
= &network
->dhcp_pd_uplink_index
;
1443 name
= &network
->dhcp_pd_uplink_name
;
1444 accept_none
= false;
1446 assert_not_reached();
1448 if (isempty(rvalue
) || streq(rvalue
, ":auto")) {
1449 *index
= UPLINK_INDEX_AUTO
;
1450 *name
= mfree(*name
);
1454 if (accept_none
&& streq(rvalue
, ":none")) {
1455 *index
= UPLINK_INDEX_NONE
;
1456 *name
= mfree(*name
);
1460 if (!accept_none
&& streq(rvalue
, ":self")) {
1461 *index
= UPLINK_INDEX_SELF
;
1462 *name
= mfree(*name
);
1466 r
= parse_ifindex(rvalue
);
1469 *name
= mfree(*name
);
1473 if (!ifname_valid_full(rvalue
, IFNAME_VALID_ALTERNATIVE
)) {
1474 log_syntax(unit
, LOG_WARNING
, filename
, line
, 0,
1475 "Invalid interface name in %s=, ignoring assignment: %s", lvalue
, rvalue
);
1479 /* The interface name will be resolved later. */
1480 r
= free_and_strdup_warn(name
, rvalue
);
1484 /* Note, if uplink_name is set, then uplink_index will be ignored. So, the below does not mean
1485 * an uplink interface will be selected automatically. */
1486 *index
= UPLINK_INDEX_AUTO
;