/* SPDX-License-Identifier: LGPL-2.1-or-later */ #include #include #include "bus-error.h" #include "bus-locator.h" #include "dhcp-identifier.h" #include "dhcp-option.h" #include "dhcp6-internal.h" #include "escape.h" #include "hexdecoct.h" #include "in-addr-prefix-util.h" #include "networkd-dhcp-common.h" #include "networkd-link.h" #include "networkd-manager.h" #include "networkd-network.h" #include "networkd-route-util.h" #include "parse-util.h" #include "socket-util.h" #include "string-table.h" #include "strv.h" #include "vrf.h" static uint32_t link_get_vrf_table(Link *link) { assert(link); assert(link->network); return link->network->vrf ? VRF(link->network->vrf)->table : RT_TABLE_MAIN; } uint32_t link_get_dhcp4_route_table(Link *link) { assert(link); assert(link->network); /* When the interface is part of an VRF use the VRFs routing table, unless * another table is explicitly specified. */ if (link->network->dhcp_route_table_set) return link->network->dhcp_route_table; return link_get_vrf_table(link); } uint32_t link_get_ipv6_accept_ra_route_table(Link *link) { assert(link); assert(link->network); if (link->network->ipv6_accept_ra_route_table_set) return link->network->ipv6_accept_ra_route_table; return link_get_vrf_table(link); } bool link_dhcp_enabled(Link *link, int family) { assert(link); assert(IN_SET(family, AF_INET, AF_INET6)); /* Currently, sd-dhcp-client supports only ethernet and infiniband. */ if (family == AF_INET && !IN_SET(link->iftype, ARPHRD_ETHER, ARPHRD_INFINIBAND)) return false; if (family == AF_INET6 && !socket_ipv6_is_supported()) return false; if (link->flags & IFF_LOOPBACK) return false; if (link->iftype == ARPHRD_CAN) return false; if (!link->network) return false; return link->network->dhcp & (family == AF_INET ? ADDRESS_FAMILY_IPV4 : ADDRESS_FAMILY_IPV6); } void network_adjust_dhcp(Network *network) { assert(network); assert(network->dhcp >= 0); if (network->dhcp == ADDRESS_FAMILY_NO) return; /* Bonding slave does not support addressing. */ if (network->bond) { log_warning("%s: Cannot enable DHCP= when Bond= is specified, disabling DHCP=.", network->filename); network->dhcp = ADDRESS_FAMILY_NO; return; } if (!FLAGS_SET(network->link_local, ADDRESS_FAMILY_IPV6) && FLAGS_SET(network->dhcp, ADDRESS_FAMILY_IPV6)) { log_warning("%s: DHCPv6 client is enabled but IPv6 link-local addressing is disabled. " "Disabling DHCPv6 client.", network->filename); SET_FLAG(network->dhcp, ADDRESS_FAMILY_IPV6, false); } network_adjust_dhcp4(network); } static bool duid_needs_product_uuid(const DUID *duid) { assert(duid); return duid->type == DUID_TYPE_UUID && duid->raw_data_len == 0; } static const struct DUID fallback_duid = { .type = DUID_TYPE_EN }; const DUID *link_get_duid(Link *link, int family) { const DUID *duid; assert(link); assert(IN_SET(family, AF_INET, AF_INET6)); if (link->network) { duid = family == AF_INET ? &link->network->dhcp_duid : &link->network->dhcp6_duid; if (duid->type != _DUID_TYPE_INVALID) { if (duid_needs_product_uuid(duid)) return &link->manager->duid_product_uuid; else return duid; } } duid = family == AF_INET ? &link->manager->dhcp_duid : &link->manager->dhcp6_duid; if (link->hw_addr.length == 0 && IN_SET(duid->type, DUID_TYPE_LLT, DUID_TYPE_LL)) /* Fallback to DUID that works without MAC address. * This is useful for tunnel devices without MAC address. */ return &fallback_duid; return duid; } static int get_product_uuid_handler(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) { Manager *manager = ASSERT_PTR(userdata); const sd_bus_error *e; const void *a; size_t sz; int r; assert(m); /* To avoid calling GetProductUUID() bus method so frequently, set the flag below * even if the method fails. */ manager->has_product_uuid = true; e = sd_bus_message_get_error(m); if (e) { r = sd_bus_error_get_errno(e); log_warning_errno(r, "Could not get product UUID. Falling back to use machine-app-specific ID as DUID-UUID: %s", bus_error_message(e, r)); return 0; } r = sd_bus_message_read_array(m, 'y', &a, &sz); if (r < 0) { log_warning_errno(r, "Failed to get product UUID. Falling back to use machine-app-specific ID as DUID-UUID: %m"); return 0; } if (sz != sizeof(sd_id128_t)) { log_warning("Invalid product UUID. Falling back to use machine-app-specific ID as DUID-UUID."); return 0; } log_debug("Successfully obtained product UUID"); memcpy(&manager->duid_product_uuid.raw_data, a, sz); manager->duid_product_uuid.raw_data_len = sz; return 0; } int manager_request_product_uuid(Manager *m) { static bool bus_method_is_called = false; int r; assert(m); if (bus_method_is_called) return 0; if (sd_bus_is_ready(m->bus) <= 0 && !m->product_uuid_requested) { log_debug("Not connected to system bus, requesting product UUID later."); m->product_uuid_requested = true; return 0; } m->product_uuid_requested = false; r = bus_call_method_async( m->bus, NULL, bus_hostname, "GetProductUUID", get_product_uuid_handler, m, "b", false); if (r < 0) return log_warning_errno(r, "Failed to get product UUID: %m"); log_debug("Requesting product UUID."); bus_method_is_called = true; return 0; } int dhcp_configure_duid(Link *link, const DUID *duid) { Manager *m; int r; assert(link); assert(link->manager); assert(duid); m = link->manager; if (!duid_needs_product_uuid(duid)) return 1; if (m->has_product_uuid) return 1; r = manager_request_product_uuid(m); if (r < 0) { log_link_warning_errno(link, r, "Failed to get product UUID. Falling back to use machine-app-specific ID as DUID-UUID: %m"); m->has_product_uuid = true; /* Do not request UUID again on failure. */ return 1; } return 0; } bool address_is_filtered(int family, const union in_addr_union *address, uint8_t prefixlen, Set *allow_list, Set *deny_list) { struct in_addr_prefix *p; assert(IN_SET(family, AF_INET, AF_INET6)); assert(address); if (allow_list) { SET_FOREACH(p, allow_list) if (p->family == family && p->prefixlen <= prefixlen && in_addr_prefix_covers(family, &p->address, p->prefixlen, address) > 0) return false; return true; } SET_FOREACH(p, deny_list) if (p->family == family && in_addr_prefix_intersect(family, &p->address, p->prefixlen, address, prefixlen) > 0) return true; return false; } int link_get_captive_portal(Link *link, const char **ret) { const char *dhcp4_cp = NULL, *dhcp6_cp = NULL, *ndisc_cp = NULL; int r; assert(link); if (!link->network) { *ret = NULL; return 0; } if (link->network->dhcp_use_captive_portal && link->dhcp_lease) { r = sd_dhcp_lease_get_captive_portal(link->dhcp_lease, &dhcp4_cp); if (r < 0 && r != -ENODATA) return r; } if (link->network->dhcp6_use_captive_portal && link->dhcp6_lease) { r = sd_dhcp6_lease_get_captive_portal(link->dhcp6_lease, &dhcp6_cp); if (r < 0 && r != -ENODATA) return r; } if (link->network->ipv6_accept_ra_use_captive_portal) { NDiscCaptivePortal *cp; usec_t usec = 0; /* Use the captive portal with the longest lifetime. */ SET_FOREACH(cp, link->ndisc_captive_portals) { if (cp->lifetime_usec < usec) continue; ndisc_cp = cp->captive_portal; usec = cp->lifetime_usec; } if (set_size(link->ndisc_captive_portals) > 1) log_link_debug(link, "Multiple captive portals obtained by IPv6RA, using \"%s\" and ignoring others.", ndisc_cp); } if (dhcp4_cp) { if (dhcp6_cp && !streq(dhcp4_cp, dhcp6_cp)) log_link_debug(link, "DHCPv6 captive portal (%s) does not match DHCPv4 (%s), ignoring DHCPv6 captive portal.", dhcp6_cp, dhcp4_cp); if (ndisc_cp && !streq(dhcp4_cp, ndisc_cp)) log_link_debug(link, "IPv6RA captive portal (%s) does not match DHCPv4 (%s), ignoring IPv6RA captive portal.", ndisc_cp, dhcp4_cp); *ret = dhcp4_cp; return 1; } if (dhcp6_cp) { if (ndisc_cp && !streq(dhcp6_cp, ndisc_cp)) log_link_debug(link, "IPv6RA captive portal (%s) does not match DHCPv6 (%s), ignoring IPv6RA captive portal.", ndisc_cp, dhcp6_cp); *ret = dhcp6_cp; return 1; } *ret = ndisc_cp; return !!ndisc_cp; } int config_parse_dhcp( const char* unit, const char *filename, unsigned line, const char *section, unsigned section_line, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata) { AddressFamily *dhcp = data, s; assert(filename); assert(lvalue); assert(rvalue); assert(data); /* Note that this is mostly like * config_parse_address_family(), except that it * understands some old names for the enum values */ s = address_family_from_string(rvalue); if (s < 0) { /* Previously, we had a slightly different enum here, * support its values for compatibility. */ s = dhcp_deprecated_address_family_from_string(rvalue); if (s < 0) { log_syntax(unit, LOG_WARNING, filename, line, s, "Failed to parse DHCP option, ignoring: %s", rvalue); return 0; } log_syntax(unit, LOG_WARNING, filename, line, 0, "DHCP=%s is deprecated, please use DHCP=%s instead.", rvalue, address_family_to_string(s)); } *dhcp = s; return 0; } int config_parse_dhcp_route_metric( const char* unit, const char *filename, unsigned line, const char *section, unsigned section_line, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata) { Network *network = userdata; uint32_t metric; int r; assert(filename); assert(lvalue); assert(IN_SET(ltype, AF_UNSPEC, AF_INET)); assert(rvalue); assert(data); r = safe_atou32(rvalue, &metric); if (r < 0) { log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse RouteMetric=%s, ignoring assignment: %m", rvalue); return 0; } switch (ltype) { case AF_INET: network->dhcp_route_metric = metric; network->dhcp_route_metric_set = true; break; case AF_UNSPEC: /* For backward compatibility. */ if (!network->dhcp_route_metric_set) network->dhcp_route_metric = metric; if (!network->ipv6_accept_ra_route_metric_set) { network->ipv6_accept_ra_route_metric_high = metric; network->ipv6_accept_ra_route_metric_medium = metric; network->ipv6_accept_ra_route_metric_low = metric; } break; default: assert_not_reached(); } return 0; } int config_parse_ipv6_accept_ra_route_metric( const char *unit, const char *filename, unsigned line, const char *section, unsigned section_line, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata) { Network *network = ASSERT_PTR(userdata); uint32_t metric_high, metric_medium, metric_low; int r, s, t; assert(filename); assert(rvalue); if (safe_atou32(rvalue, &metric_low) >= 0) metric_high = metric_medium = metric_low; else { _cleanup_free_ char *high = NULL, *medium = NULL, *low = NULL; const char *p = rvalue; r = extract_many_words(&p, ":", EXTRACT_DONT_COALESCE_SEPARATORS, &high, &medium, &low, NULL); if (r == -ENOMEM) return log_oom(); if (r != 3 || !isempty(p)) { log_syntax(unit, LOG_WARNING, filename, line, r < 0 ? r : 0, "Failed to parse RouteTable=%s, ignoring assignment: %m", rvalue); return 0; } r = safe_atou32(high, &metric_high); s = safe_atou32(medium, &metric_medium); t = safe_atou32(low, &metric_low); if (r < 0 || s < 0 || t < 0) { log_syntax(unit, LOG_WARNING, filename, line, r < 0 ? r : s < 0 ? s : t, "Failed to parse RouteTable=%s, ignoring assignment: %m", rvalue); return 0; } if (metric_high >= metric_medium || metric_medium >= metric_low) { log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid RouteTable=%s, ignoring assignment: %m", rvalue); return 0; } } network->ipv6_accept_ra_route_metric_high = metric_high; network->ipv6_accept_ra_route_metric_medium = metric_medium; network->ipv6_accept_ra_route_metric_low = metric_low; network->ipv6_accept_ra_route_metric_set = true; return 0; } int config_parse_dhcp_send_hostname( const char* unit, const char *filename, unsigned line, const char *section, unsigned section_line, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata) { Network *network = userdata; int r; assert(filename); assert(lvalue); assert(IN_SET(ltype, AF_UNSPEC, AF_INET, AF_INET6)); assert(rvalue); assert(data); r = parse_boolean(rvalue); if (r < 0) { log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse SendHostname=%s, ignoring assignment: %m", rvalue); return 0; } switch (ltype) { case AF_INET: network->dhcp_send_hostname = r; network->dhcp_send_hostname_set = true; break; case AF_INET6: network->dhcp6_send_hostname = r; network->dhcp6_send_hostname_set = true; break; case AF_UNSPEC: /* For backward compatibility. */ if (!network->dhcp_send_hostname_set) network->dhcp_send_hostname = r; if (!network->dhcp6_send_hostname_set) network->dhcp6_send_hostname = r; break; default: assert_not_reached(); } return 0; } int config_parse_dhcp_use_dns( const char* unit, const char *filename, unsigned line, const char *section, unsigned section_line, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata) { Network *network = userdata; int r; assert(filename); assert(lvalue); assert(IN_SET(ltype, AF_UNSPEC, AF_INET, AF_INET6)); assert(rvalue); assert(data); r = parse_boolean(rvalue); if (r < 0) { log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse UseDNS=%s, ignoring assignment: %m", rvalue); return 0; } switch (ltype) { case AF_INET: network->dhcp_use_dns = r; network->dhcp_use_dns_set = true; break; case AF_INET6: network->dhcp6_use_dns = r; network->dhcp6_use_dns_set = true; break; case AF_UNSPEC: /* For backward compatibility. */ if (!network->dhcp_use_dns_set) network->dhcp_use_dns = r; if (!network->dhcp6_use_dns_set) network->dhcp6_use_dns = r; break; default: assert_not_reached(); } return 0; } int config_parse_dhcp_use_domains( const char* unit, const char *filename, unsigned line, const char *section, unsigned section_line, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata) { Network *network = userdata; DHCPUseDomains d; assert(filename); assert(lvalue); assert(IN_SET(ltype, AF_UNSPEC, AF_INET, AF_INET6)); assert(rvalue); assert(data); d = dhcp_use_domains_from_string(rvalue); if (d < 0) { log_syntax(unit, LOG_WARNING, filename, line, d, "Failed to parse %s=%s, ignoring assignment: %m", lvalue, rvalue); return 0; } switch (ltype) { case AF_INET: network->dhcp_use_domains = d; network->dhcp_use_domains_set = true; break; case AF_INET6: network->dhcp6_use_domains = d; network->dhcp6_use_domains_set = true; break; case AF_UNSPEC: /* For backward compatibility. */ if (!network->dhcp_use_domains_set) network->dhcp_use_domains = d; if (!network->dhcp6_use_domains_set) network->dhcp6_use_domains = d; break; default: assert_not_reached(); } return 0; } int config_parse_dhcp_use_ntp( const char* unit, const char *filename, unsigned line, const char *section, unsigned section_line, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata) { Network *network = userdata; int r; assert(filename); assert(lvalue); assert(IN_SET(ltype, AF_UNSPEC, AF_INET, AF_INET6)); assert(rvalue); assert(data); r = parse_boolean(rvalue); if (r < 0) { log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse UseNTP=%s, ignoring assignment: %m", rvalue); return 0; } switch (ltype) { case AF_INET: network->dhcp_use_ntp = r; network->dhcp_use_ntp_set = true; break; case AF_INET6: network->dhcp6_use_ntp = r; network->dhcp6_use_ntp_set = true; break; case AF_UNSPEC: /* For backward compatibility. */ if (!network->dhcp_use_ntp_set) network->dhcp_use_ntp = r; if (!network->dhcp6_use_ntp_set) network->dhcp6_use_ntp = r; break; default: assert_not_reached(); } return 0; } int config_parse_dhcp_or_ra_route_table( const char *unit, const char *filename, unsigned line, const char *section, unsigned section_line, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata) { Network *network = ASSERT_PTR(userdata); uint32_t rt; int r; assert(filename); assert(lvalue); assert(IN_SET(ltype, AF_INET, AF_INET6)); assert(rvalue); r = manager_get_route_table_from_string(network->manager, rvalue, &rt); if (r < 0) { log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse RouteTable=%s, ignoring assignment: %m", rvalue); return 0; } switch (ltype) { case AF_INET: network->dhcp_route_table = rt; network->dhcp_route_table_set = true; break; case AF_INET6: network->ipv6_accept_ra_route_table = rt; network->ipv6_accept_ra_route_table_set = true; break; default: assert_not_reached(); } return 0; } int config_parse_iaid( const char *unit, const char *filename, unsigned line, const char *section, unsigned section_line, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata) { Network *network = ASSERT_PTR(userdata); uint32_t iaid; int r; assert(filename); assert(lvalue); assert(rvalue); assert(IN_SET(ltype, AF_INET, AF_INET6)); r = safe_atou32(rvalue, &iaid); if (r < 0) { log_syntax(unit, LOG_WARNING, filename, line, r, "Unable to read IAID, ignoring assignment: %s", rvalue); return 0; } if (ltype == AF_INET) { network->dhcp_iaid = iaid; network->dhcp_iaid_set = true; if (!network->dhcp6_iaid_set_explicitly) { /* Backward compatibility. Previously, IAID is shared by DHCPv4 and DHCPv6. * If DHCPv6 IAID is not specified explicitly, then use DHCPv4 IAID for DHCPv6. */ network->dhcp6_iaid = iaid; network->dhcp6_iaid_set = true; } } else { assert(ltype == AF_INET6); network->dhcp6_iaid = iaid; network->dhcp6_iaid_set = true; network->dhcp6_iaid_set_explicitly = true; } return 0; } int config_parse_dhcp_user_or_vendor_class( const char *unit, const char *filename, unsigned line, const char *section, unsigned section_line, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata) { char ***l = ASSERT_PTR(data); int r; assert(lvalue); assert(rvalue); assert(IN_SET(ltype, AF_INET, AF_INET6)); if (isempty(rvalue)) { *l = strv_free(*l); return 0; } for (const char *p = rvalue;;) { _cleanup_free_ char *w = NULL; size_t len; r = extract_first_word(&p, &w, NULL, EXTRACT_CUNESCAPE|EXTRACT_UNQUOTE); if (r == -ENOMEM) return log_oom(); if (r < 0) { log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to split user classes option, ignoring: %s", rvalue); return 0; } if (r == 0) return 0; len = strlen(w); if (ltype == AF_INET) { if (len > UINT8_MAX || len == 0) { log_syntax(unit, LOG_WARNING, filename, line, 0, "%s length is not in the range 1…255, ignoring.", w); continue; } } else { if (len > UINT16_MAX || len == 0) { log_syntax(unit, LOG_WARNING, filename, line, 0, "%s length is not in the range 1…65535, ignoring.", w); continue; } } r = strv_consume(l, TAKE_PTR(w)); if (r < 0) return log_oom(); } } int config_parse_dhcp_send_option( const char *unit, const char *filename, unsigned line, const char *section, unsigned section_line, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata) { _cleanup_(sd_dhcp_option_unrefp) sd_dhcp_option *opt4 = NULL; _cleanup_(sd_dhcp6_option_unrefp) sd_dhcp6_option *opt6 = NULL; _unused_ _cleanup_(sd_dhcp_option_unrefp) sd_dhcp_option *old4 = NULL; _unused_ _cleanup_(sd_dhcp6_option_unrefp) sd_dhcp6_option *old6 = NULL; uint32_t uint32_data, enterprise_identifier = 0; _cleanup_free_ char *word = NULL, *q = NULL; OrderedHashmap **options = ASSERT_PTR(data); uint16_t u16, uint16_data; union in_addr_union addr; DHCPOptionDataType type; uint8_t u8, uint8_data; const void *udata; const char *p; ssize_t sz; int r; assert(filename); assert(lvalue); assert(rvalue); if (isempty(rvalue)) { *options = ordered_hashmap_free(*options); return 0; } p = rvalue; if (ltype == AF_INET6 && streq(lvalue, "SendVendorOption")) { r = extract_first_word(&p, &word, ":", 0); if (r == -ENOMEM) return log_oom(); if (r <= 0 || isempty(p)) { log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid DHCP option, ignoring assignment: %s", rvalue); return 0; } r = safe_atou32(word, &enterprise_identifier); if (r < 0) { log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse DHCPv6 enterprise identifier data, ignoring assignment: %s", p); return 0; } word = mfree(word); } r = extract_first_word(&p, &word, ":", 0); if (r == -ENOMEM) return log_oom(); if (r <= 0 || isempty(p)) { log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid DHCP option, ignoring assignment: %s", rvalue); return 0; } if (ltype == AF_INET6) { r = safe_atou16(word, &u16); if (r < 0) { log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid DHCP option, ignoring assignment: %s", rvalue); return 0; } if (u16 < 1 || u16 >= UINT16_MAX) { log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid DHCP option, valid range is 1-65535, ignoring assignment: %s", rvalue); return 0; } } else { r = safe_atou8(word, &u8); if (r < 0) { log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid DHCP option, ignoring assignment: %s", rvalue); return 0; } if (u8 < 1 || u8 >= UINT8_MAX) { log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid DHCP option, valid range is 1-254, ignoring assignment: %s", rvalue); return 0; } } word = mfree(word); r = extract_first_word(&p, &word, ":", 0); if (r == -ENOMEM) return log_oom(); if (r <= 0 || isempty(p)) { log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid DHCP option, ignoring assignment: %s", rvalue); return 0; } type = dhcp_option_data_type_from_string(word); if (type < 0) { log_syntax(unit, LOG_WARNING, filename, line, type, "Invalid DHCP option data type, ignoring assignment: %s", p); return 0; } switch (type) { case DHCP_OPTION_DATA_UINT8:{ r = safe_atou8(p, &uint8_data); if (r < 0) { log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse DHCP uint8 data, ignoring assignment: %s", p); return 0; } udata = &uint8_data; sz = sizeof(uint8_t); break; } case DHCP_OPTION_DATA_UINT16:{ uint16_t k; r = safe_atou16(p, &k); if (r < 0) { log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse DHCP uint16 data, ignoring assignment: %s", p); return 0; } uint16_data = htobe16(k); udata = &uint16_data; sz = sizeof(uint16_t); break; } case DHCP_OPTION_DATA_UINT32: { uint32_t k; r = safe_atou32(p, &k); if (r < 0) { log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse DHCP uint32 data, ignoring assignment: %s", p); return 0; } uint32_data = htobe32(k); udata = &uint32_data; sz = sizeof(uint32_t); break; } case DHCP_OPTION_DATA_IPV4ADDRESS: { r = in_addr_from_string(AF_INET, p, &addr); if (r < 0) { log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse DHCP ipv4address data, ignoring assignment: %s", p); return 0; } udata = &addr.in; sz = sizeof(addr.in.s_addr); break; } case DHCP_OPTION_DATA_IPV6ADDRESS: { r = in_addr_from_string(AF_INET6, p, &addr); if (r < 0) { log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse DHCP ipv6address data, ignoring assignment: %s", p); return 0; } udata = &addr.in6; sz = sizeof(addr.in6.s6_addr); break; } case DHCP_OPTION_DATA_STRING: sz = cunescape(p, UNESCAPE_ACCEPT_NUL, &q); if (sz < 0) { log_syntax(unit, LOG_WARNING, filename, line, sz, "Failed to decode DHCP option data, ignoring assignment: %s", p); return 0; } udata = q; break; default: return -EINVAL; } if (ltype == AF_INET6) { r = sd_dhcp6_option_new(u16, udata, sz, enterprise_identifier, &opt6); if (r < 0) { log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to store DHCP option '%s', ignoring assignment: %m", rvalue); return 0; } r = ordered_hashmap_ensure_allocated(options, &dhcp6_option_hash_ops); if (r < 0) return log_oom(); /* Overwrite existing option */ old6 = ordered_hashmap_get(*options, UINT_TO_PTR(u16)); r = ordered_hashmap_replace(*options, UINT_TO_PTR(u16), opt6); if (r < 0) { log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to store DHCP option '%s', ignoring assignment: %m", rvalue); return 0; } TAKE_PTR(opt6); } else { r = sd_dhcp_option_new(u8, udata, sz, &opt4); if (r < 0) { log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to store DHCP option '%s', ignoring assignment: %m", rvalue); return 0; } r = ordered_hashmap_ensure_allocated(options, &dhcp_option_hash_ops); if (r < 0) return log_oom(); /* Overwrite existing option */ old4 = ordered_hashmap_get(*options, UINT_TO_PTR(u8)); r = ordered_hashmap_replace(*options, UINT_TO_PTR(u8), opt4); if (r < 0) { log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to store DHCP option '%s', ignoring assignment: %m", rvalue); return 0; } TAKE_PTR(opt4); } return 0; } int config_parse_dhcp_request_options( const char *unit, const char *filename, unsigned line, const char *section, unsigned section_line, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata) { Network *network = userdata; int r; assert(filename); assert(lvalue); assert(rvalue); assert(data); if (isempty(rvalue)) { if (ltype == AF_INET) network->dhcp_request_options = set_free(network->dhcp_request_options); else network->dhcp6_request_options = set_free(network->dhcp6_request_options); return 0; } for (const char *p = rvalue;;) { _cleanup_free_ char *n = NULL; uint32_t i; r = extract_first_word(&p, &n, NULL, 0); if (r == -ENOMEM) return log_oom(); if (r < 0) { log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse DHCP request option, ignoring assignment: %s", rvalue); return 0; } if (r == 0) return 0; r = safe_atou32(n, &i); if (r < 0) { log_syntax(unit, LOG_WARNING, filename, line, r, "DHCP request option is invalid, ignoring assignment: %s", n); continue; } if (i < 1 || i >= UINT8_MAX) { log_syntax(unit, LOG_WARNING, filename, line, 0, "DHCP request option is invalid, valid range is 1-254, ignoring assignment: %s", n); continue; } r = set_ensure_put(ltype == AF_INET ? &network->dhcp_request_options : &network->dhcp6_request_options, NULL, UINT32_TO_PTR(i)); if (r < 0) log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to store DHCP request option '%s', ignoring assignment: %m", n); } } static const char* const dhcp_use_domains_table[_DHCP_USE_DOMAINS_MAX] = { [DHCP_USE_DOMAINS_NO] = "no", [DHCP_USE_DOMAINS_ROUTE] = "route", [DHCP_USE_DOMAINS_YES] = "yes", }; DEFINE_STRING_TABLE_LOOKUP_WITH_BOOLEAN(dhcp_use_domains, DHCPUseDomains, DHCP_USE_DOMAINS_YES); static const char * const dhcp_option_data_type_table[_DHCP_OPTION_DATA_MAX] = { [DHCP_OPTION_DATA_UINT8] = "uint8", [DHCP_OPTION_DATA_UINT16] = "uint16", [DHCP_OPTION_DATA_UINT32] = "uint32", [DHCP_OPTION_DATA_STRING] = "string", [DHCP_OPTION_DATA_IPV4ADDRESS] = "ipv4address", [DHCP_OPTION_DATA_IPV6ADDRESS] = "ipv6address", }; DEFINE_STRING_TABLE_LOOKUP(dhcp_option_data_type, DHCPOptionDataType); static const char* const duid_type_table[_DUID_TYPE_MAX] = { [DUID_TYPE_LLT] = "link-layer-time", [DUID_TYPE_EN] = "vendor", [DUID_TYPE_LL] = "link-layer", [DUID_TYPE_UUID] = "uuid", }; DEFINE_PRIVATE_STRING_TABLE_LOOKUP_FROM_STRING(duid_type, DUIDType); int config_parse_duid_type( const char *unit, const char *filename, unsigned line, const char *section, unsigned section_line, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata) { _cleanup_free_ char *type_string = NULL; const char *p = ASSERT_PTR(rvalue); bool force = ltype; DUID *duid = ASSERT_PTR(data); DUIDType type; int r; assert(filename); assert(lvalue); if (!force && duid->set) return 0; r = extract_first_word(&p, &type_string, ":", 0); if (r == -ENOMEM) return log_oom(); if (r < 0) { log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid syntax, ignoring: %s", rvalue); return 0; } if (r == 0) { log_syntax(unit, LOG_WARNING, filename, line, 0, "Failed to extract DUID type from '%s', ignoring.", rvalue); return 0; } type = duid_type_from_string(type_string); if (type < 0) { uint16_t t; r = safe_atou16(type_string, &t); if (r < 0) { log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse DUID type '%s', ignoring.", type_string); return 0; } type = t; assert(type == t); /* Check if type can store uint16_t. */ } if (!isempty(p)) { usec_t u; if (type != DUID_TYPE_LLT) { log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid syntax, ignoring: %s", rvalue); return 0; } r = parse_timestamp(p, &u); if (r < 0) { log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse timestamp, ignoring: %s", p); return 0; } duid->llt_time = u; } duid->type = type; duid->set = force; return 0; } int config_parse_manager_duid_type( const char *unit, const char *filename, unsigned line, const char *section, unsigned section_line, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata) { Manager *manager = ASSERT_PTR(userdata); int r; /* For backward compatibility. Setting both DHCPv4 and DHCPv6 DUID if they are not specified explicitly. */ r = config_parse_duid_type(unit, filename, line, section, section_line, lvalue, false, rvalue, &manager->dhcp_duid, manager); if (r < 0) return r; return config_parse_duid_type(unit, filename, line, section, section_line, lvalue, false, rvalue, &manager->dhcp6_duid, manager); } int config_parse_network_duid_type( const char *unit, const char *filename, unsigned line, const char *section, unsigned section_line, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata) { Network *network = ASSERT_PTR(userdata); int r; r = config_parse_duid_type(unit, filename, line, section, section_line, lvalue, true, rvalue, &network->dhcp_duid, network); if (r < 0) return r; /* For backward compatibility, also set DHCPv6 DUID if not specified explicitly. */ return config_parse_duid_type(unit, filename, line, section, section_line, lvalue, false, rvalue, &network->dhcp6_duid, network); } int config_parse_duid_rawdata( const char *unit, const char *filename, unsigned line, const char *section, unsigned section_line, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata) { uint8_t raw_data[MAX_DUID_DATA_LEN]; unsigned count = 0; bool force = ltype; DUID *duid = ASSERT_PTR(data); assert(filename); assert(lvalue); assert(rvalue); if (!force && duid->set) return 0; /* RawData contains DUID in format "NN:NN:NN..." */ for (const char *p = rvalue;;) { int n1, n2, len, r; uint32_t byte; _cleanup_free_ char *cbyte = NULL; r = extract_first_word(&p, &cbyte, ":", 0); if (r == -ENOMEM) return log_oom(); if (r < 0) { log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to read DUID, ignoring assignment: %s.", rvalue); return 0; } if (r == 0) break; if (count >= MAX_DUID_DATA_LEN) { log_syntax(unit, LOG_WARNING, filename, line, 0, "Max DUID length exceeded, ignoring assignment: %s.", rvalue); return 0; } len = strlen(cbyte); if (!IN_SET(len, 1, 2)) { log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid length - DUID byte: %s, ignoring assignment: %s.", cbyte, rvalue); return 0; } n1 = unhexchar(cbyte[0]); if (len == 2) n2 = unhexchar(cbyte[1]); else n2 = 0; if (n1 < 0 || n2 < 0) { log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid DUID byte: %s. Ignoring assignment: %s.", cbyte, rvalue); return 0; } byte = ((uint8_t) n1 << (4 * (len-1))) | (uint8_t) n2; raw_data[count++] = byte; } assert_cc(sizeof(raw_data) == sizeof(duid->raw_data)); memcpy(duid->raw_data, raw_data, count); duid->raw_data_len = count; duid->set = force; return 0; } int config_parse_manager_duid_rawdata( const char *unit, const char *filename, unsigned line, const char *section, unsigned section_line, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata) { Manager *manager = ASSERT_PTR(userdata); int r; /* For backward compatibility. Setting both DHCPv4 and DHCPv6 DUID if they are not specified explicitly. */ r = config_parse_duid_rawdata(unit, filename, line, section, section_line, lvalue, false, rvalue, &manager->dhcp_duid, manager); if (r < 0) return r; return config_parse_duid_rawdata(unit, filename, line, section, section_line, lvalue, false, rvalue, &manager->dhcp6_duid, manager); } int config_parse_network_duid_rawdata( const char *unit, const char *filename, unsigned line, const char *section, unsigned section_line, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata) { Network *network = ASSERT_PTR(userdata); int r; r = config_parse_duid_rawdata(unit, filename, line, section, section_line, lvalue, true, rvalue, &network->dhcp_duid, network); if (r < 0) return r; /* For backward compatibility, also set DHCPv6 DUID if not specified explicitly. */ return config_parse_duid_rawdata(unit, filename, line, section, section_line, lvalue, false, rvalue, &network->dhcp6_duid, network); } int config_parse_uplink( const char *unit, const char *filename, unsigned line, const char *section, unsigned section_line, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata) { Network *network = ASSERT_PTR(userdata); bool accept_none = true; int *index, r; char **name; assert(filename); assert(section); assert(lvalue); assert(rvalue); if (streq(section, "DHCPServer")) { index = &network->dhcp_server_uplink_index; name = &network->dhcp_server_uplink_name; } else if (streq(section, "IPv6SendRA")) { index = &network->router_uplink_index; name = &network->router_uplink_name; } else if (STR_IN_SET(section, "DHCPv6PrefixDelegation", "DHCPPrefixDelegation")) { index = &network->dhcp_pd_uplink_index; name = &network->dhcp_pd_uplink_name; accept_none = false; } else assert_not_reached(); if (isempty(rvalue) || streq(rvalue, ":auto")) { *index = UPLINK_INDEX_AUTO; *name = mfree(*name); return 0; } if (accept_none && streq(rvalue, ":none")) { *index = UPLINK_INDEX_NONE; *name = mfree(*name); return 0; } if (!accept_none && streq(rvalue, ":self")) { *index = UPLINK_INDEX_SELF; *name = mfree(*name); return 0; } r = parse_ifindex(rvalue); if (r > 0) { *index = r; *name = mfree(*name); return 0; } if (!ifname_valid_full(rvalue, IFNAME_VALID_ALTERNATIVE)) { log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid interface name in %s=, ignoring assignment: %s", lvalue, rvalue); return 0; } /* The interface name will be resolved later. */ r = free_and_strdup_warn(name, rvalue); if (r < 0) return r; /* Note, if uplink_name is set, then uplink_index will be ignored. So, the below does not mean * an uplink interface will be selected automatically. */ *index = UPLINK_INDEX_AUTO; return 0; }