As it is also used for NDisc.
void *userdata) {
Network *network = userdata;
- DHCPUseDomains d;
+ UseDomains d;
assert(filename);
assert(lvalue);
assert(rvalue);
assert(data);
- d = dhcp_use_domains_from_string(rvalue);
+ d = 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;
}
-DEFINE_CONFIG_PARSE_ENUM(config_parse_default_dhcp_use_domains, dhcp_use_domains, DHCPUseDomains, "Failed to parse UseDomains=")
-
int config_parse_dhcp_use_ntp(
const char* unit,
const char *filename,
}
}
-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",
+static const char* const use_domains_table[_USE_DOMAINS_MAX] = {
+ [USE_DOMAINS_NO] = "no",
+ [USE_DOMAINS_ROUTE] = "route",
+ [USE_DOMAINS_YES] = "yes",
};
-DEFINE_STRING_TABLE_LOOKUP_WITH_BOOLEAN(dhcp_use_domains, DHCPUseDomains, DHCP_USE_DOMAINS_YES);
+DEFINE_STRING_TABLE_LOOKUP_WITH_BOOLEAN(use_domains, UseDomains, USE_DOMAINS_YES);
+DEFINE_CONFIG_PARSE_ENUM(config_parse_use_domains, use_domains, UseDomains, "Failed to parse UseDomains=")
static const char * const dhcp_option_data_type_table[_DHCP_OPTION_DATA_MAX] = {
[DHCP_OPTION_DATA_UINT8] = "uint8",
typedef struct Manager Manager;
typedef struct Network Network;
-typedef enum DHCPUseDomains {
- DHCP_USE_DOMAINS_NO,
- DHCP_USE_DOMAINS_YES,
- DHCP_USE_DOMAINS_ROUTE,
- _DHCP_USE_DOMAINS_MAX,
- _DHCP_USE_DOMAINS_INVALID = -EINVAL,
-} DHCPUseDomains;
+typedef enum UseDomains {
+ USE_DOMAINS_NO,
+ USE_DOMAINS_YES,
+ USE_DOMAINS_ROUTE,
+ _USE_DOMAINS_MAX,
+ _USE_DOMAINS_INVALID = -EINVAL,
+} UseDomains;
typedef enum DHCPOptionDataType {
DHCP_OPTION_DATA_UINT8,
int link_get_captive_portal(Link *link, const char **ret);
-const char* dhcp_use_domains_to_string(DHCPUseDomains p) _const_;
-DHCPUseDomains dhcp_use_domains_from_string(const char *s) _pure_;
+const char* use_domains_to_string(UseDomains p) _const_;
+UseDomains use_domains_from_string(const char *s) _pure_;
const char *dhcp_option_data_type_to_string(DHCPOptionDataType d) _const_;
DHCPOptionDataType dhcp_option_data_type_from_string(const char *d) _pure_;
CONFIG_PARSER_PROTOTYPE(config_parse_dhcp_send_hostname);
CONFIG_PARSER_PROTOTYPE(config_parse_dhcp_use_dns);
CONFIG_PARSER_PROTOTYPE(config_parse_dhcp_use_domains);
-CONFIG_PARSER_PROTOTYPE(config_parse_default_dhcp_use_domains);
+CONFIG_PARSER_PROTOTYPE(config_parse_use_domains);
CONFIG_PARSER_PROTOTYPE(config_parse_dhcp_use_ntp);
CONFIG_PARSER_PROTOTYPE(config_parse_iaid);
CONFIG_PARSER_PROTOTYPE(config_parse_dhcp_or_ra_route_table);
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set request flag for classless static route: %m");
}
- if (link->network->dhcp_use_domains != DHCP_USE_DOMAINS_NO) {
+ if (link->network->dhcp_use_domains > 0) {
r = sd_dhcp_client_set_request_option(link->dhcp_client, SD_DHCP_OPTION_DOMAIN_SEARCH);
if (r < 0)
return log_link_debug_errno(link, r, "DHCPv4 CLIENT: Failed to set request flag for domain search list: %m");
Network.IPv4Forwarding, config_parse_tristate, 0, offsetof(Manager, ip_forwarding[0])
Network.IPv6Forwarding, config_parse_tristate, 0, offsetof(Manager, ip_forwarding[1])
Network.IPv6PrivacyExtensions, config_parse_ipv6_privacy_extensions, 0, offsetof(Manager, ipv6_privacy_extensions)
-DHCPv4.UseDomains, config_parse_default_dhcp_use_domains, 0, offsetof(Manager, dhcp_use_domains)
+DHCPv4.UseDomains, config_parse_use_domains, 0, offsetof(Manager, dhcp_use_domains)
DHCPv4.DUIDType, config_parse_duid_type, 0, offsetof(Manager, dhcp_duid)
DHCPv4.DUIDRawData, config_parse_duid_rawdata, 0, offsetof(Manager, dhcp_duid)
-DHCPv6.UseDomains, config_parse_default_dhcp_use_domains, 0, offsetof(Manager, dhcp6_use_domains)
+DHCPv6.UseDomains, config_parse_use_domains, 0, offsetof(Manager, dhcp6_use_domains)
DHCPv6.DUIDType, config_parse_duid_type, 0, offsetof(Manager, dhcp6_duid)
DHCPv6.DUIDRawData, config_parse_duid_rawdata, 0, offsetof(Manager, dhcp6_duid)
DHCPServer.PersistLeases, config_parse_bool, 0, offsetof(Manager, dhcp_server_persist_leases)
static int domains_append_json(Link *link, bool is_route, JsonVariant **v) {
_cleanup_(json_variant_unrefp) JsonVariant *array = NULL;
OrderedSet *link_domains, *network_domains;
- DHCPUseDomains use_domains;
+ UseDomains use_domains;
union in_addr_union s;
char **domains;
const char *domain;
link_domains = is_route ? link->route_domains : link->search_domains;
network_domains = is_route ? link->network->route_domains : link->network->search_domains;
- use_domains = is_route ? DHCP_USE_DOMAINS_ROUTE : DHCP_USE_DOMAINS_YES;
+ use_domains = is_route ? USE_DOMAINS_ROUTE : USE_DOMAINS_YES;
ORDERED_SET_FOREACH(domain, link_domains ?: network_domains) {
r = domain_append_json(AF_UNSPEC, domain,
OrderedSet *address_pools;
Set *dhcp_pd_subnet_ids;
- DHCPUseDomains dhcp_use_domains;
- DHCPUseDomains dhcp6_use_domains;
+ UseDomains dhcp_use_domains;
+ UseDomains dhcp6_use_domains;
DUID dhcp_duid;
DUID dhcp6_duid;
assert(link->network);
assert(rt);
- if (link->network->ndisc_use_domains == DHCP_USE_DOMAINS_NO)
+ if (link->network->ndisc_use_domains == USE_DOMAINS_NO)
return 0;
r = sd_ndisc_router_get_sender_address(rt, &router);
DEFINE_PRIVATE_STRING_TABLE_LOOKUP_FROM_STRING_WITH_BOOLEAN(ndisc_start_dhcp6_client, IPv6AcceptRAStartDHCP6Client, IPV6_ACCEPT_RA_START_DHCP6_CLIENT_YES);
-DEFINE_CONFIG_PARSE_ENUM(config_parse_ndisc_use_domains, dhcp_use_domains, DHCPUseDomains,
- "Failed to parse UseDomains= setting");
DEFINE_CONFIG_PARSE_ENUM(config_parse_ndisc_start_dhcp6_client, ndisc_start_dhcp6_client, IPv6AcceptRAStartDHCP6Client,
"Failed to parse DHCPv6Client= setting");
int ndisc_reconfigure_address(Address *address, Link *link);
CONFIG_PARSER_PROTOTYPE(config_parse_ndisc_start_dhcp6_client);
-CONFIG_PARSER_PROTOTYPE(config_parse_ndisc_use_domains);
IPv6AcceptRA.UseOnLinkPrefix, config_parse_bool, 0, offsetof(Network, ndisc_use_onlink_prefix)
IPv6AcceptRA.UsePREF64, config_parse_bool, 0, offsetof(Network, ndisc_use_pref64)
IPv6AcceptRA.UseDNS, config_parse_bool, 0, offsetof(Network, ndisc_use_dns)
-IPv6AcceptRA.UseDomains, config_parse_ndisc_use_domains, 0, offsetof(Network, ndisc_use_domains)
+IPv6AcceptRA.UseDomains, config_parse_use_domains, 0, offsetof(Network, ndisc_use_domains)
IPv6AcceptRA.UseMTU, config_parse_bool, 0, offsetof(Network, ndisc_use_mtu)
IPv6AcceptRA.UseHopLimit, config_parse_bool, 0, offsetof(Network, ndisc_use_hop_limit)
IPv6AcceptRA.UseReachableTime, config_parse_bool, 0, offsetof(Network, ndisc_use_reachable_time)
bool dhcp_use_6rd;
bool dhcp_send_release;
bool dhcp_send_decline;
- DHCPUseDomains dhcp_use_domains;
+ UseDomains dhcp_use_domains;
bool dhcp_use_domains_set;
Set *dhcp_deny_listed_ip;
Set *dhcp_allow_listed_ip;
bool dhcp6_use_ntp_set;
bool dhcp6_use_captive_portal;
bool dhcp6_use_rapid_commit;
- DHCPUseDomains dhcp6_use_domains;
+ UseDomains dhcp6_use_domains;
bool dhcp6_use_domains_set;
uint32_t dhcp6_iaid;
bool dhcp6_iaid_set;
bool ndisc_use_pref64;
bool active_slave;
bool primary_slave;
- DHCPUseDomains ndisc_use_domains;
+ UseDomains ndisc_use_domains;
IPv6AcceptRAStartDHCP6Client ndisc_start_dhcp6_client;
uint32_t ndisc_route_table;
bool ndisc_route_table_set;
static int link_put_domains(Link *link, bool is_route, OrderedSet **s) {
OrderedSet *link_domains, *network_domains;
- DHCPUseDomains use_domains;
+ UseDomains use_domains;
int r;
assert(link);
link_domains = is_route ? link->route_domains : link->search_domains;
network_domains = is_route ? link->network->route_domains : link->network->search_domains;
- use_domains = is_route ? DHCP_USE_DOMAINS_ROUTE : DHCP_USE_DOMAINS_YES;
+ use_domains = is_route ? USE_DOMAINS_ROUTE : USE_DOMAINS_YES;
if (link_domains)
return ordered_set_put_string_set(s, link_domains);
fputc('\n', f);
}
-static void link_save_domains(Link *link, FILE *f, OrderedSet *static_domains, DHCPUseDomains use_domains) {
+static void link_save_domains(Link *link, FILE *f, OrderedSet *static_domains, UseDomains use_domains) {
bool space = false;
const char *p;
ORDERED_SET_FOREACH(p, static_domains)
fputs_with_separator(f, p, NULL, &space);
- if (use_domains == DHCP_USE_DOMAINS_NO)
+ if (use_domains == USE_DOMAINS_NO)
return;
if (link->dhcp_lease && link->network->dhcp_use_domains == use_domains) {
fputs("DOMAINS=", f);
if (link->search_domains)
- link_save_domains(link, f, link->search_domains, DHCP_USE_DOMAINS_NO);
+ link_save_domains(link, f, link->search_domains, USE_DOMAINS_NO);
else
- link_save_domains(link, f, link->network->search_domains, DHCP_USE_DOMAINS_YES);
+ link_save_domains(link, f, link->network->search_domains, USE_DOMAINS_YES);
fputc('\n', f);
/************************************************************/
fputs("ROUTE_DOMAINS=", f);
if (link->route_domains)
- link_save_domains(link, f, link->route_domains, DHCP_USE_DOMAINS_NO);
+ link_save_domains(link, f, link->route_domains, USE_DOMAINS_NO);
else
- link_save_domains(link, f, link->network->route_domains, DHCP_USE_DOMAINS_ROUTE);
+ link_save_domains(link, f, link->network->route_domains, USE_DOMAINS_ROUTE);
fputc('\n', f);
/************************************************************/
test_table(bond_xmit_hash_policy, NETDEV_BOND_XMIT_HASH_POLICY);
test_table(dhcp6_message_status, DHCP6_STATUS);
test_table_sparse(dhcp6_message_type, DHCP6_MESSAGE_TYPE); /* enum starts from 1 */
- test_table(dhcp_use_domains, DHCP_USE_DOMAINS);
+ test_table(use_domains, USE_DOMAINS);
test_table(duplex, DUP);
test_table(ip6tnl_mode, NETDEV_IP6_TNL_MODE);
test_table(ipv6_privacy_extensions, IPV6_PRIVACY_EXTENSIONS);