[thirdparty/systemd.git] / src / network / networkd-dhcp-common.c

/* SPDX-License-Identifier: LGPL-2.1+ */

#include "networkd-dhcp-common.h"
#include "networkd-network.h"
#include "parse-util.h"
#include "string-table.h"
#include "strv.h"

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. */

                if (streq(rvalue, "none"))
                        s = ADDRESS_FAMILY_NO;
                else if (streq(rvalue, "v4"))
                        s = ADDRESS_FAMILY_IPV4;
                else if (streq(rvalue, "v6"))
                        s = ADDRESS_FAMILY_IPV6;
                else if (streq(rvalue, "both"))
                        s = ADDRESS_FAMILY_YES;
                else {
                        log_syntax(unit, LOG_ERR, filename, line, 0,
                                   "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_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 = data;
        int r;

        assert(filename);
        assert(lvalue);
        assert(rvalue);
        assert(data);

        r = parse_boolean(rvalue);
        if (r < 0) {
                log_syntax(unit, LOG_ERR, filename, line, r,
                           "Failed to parse UseDNS=%s, ignoring assignment: %m", rvalue);
                return 0;
        }

        network->dhcp_use_dns = r;
        network->dhcp6_use_dns = r;

        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 = data;
        int r;

        assert(filename);
        assert(lvalue);
        assert(rvalue);
        assert(data);

        r = parse_boolean(rvalue);
        if (r < 0) {
                log_syntax(unit, LOG_ERR, filename, line, r,
                           "Failed to parse UseNTP=%s, ignoring assignment: %m", rvalue);
                return 0;
        }

        network->dhcp_use_ntp = r;
        network->dhcp6_use_ntp = r;

        return 0;
}

int config_parse_section_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 = data;
        uint32_t rt;
        int r;

        assert(filename);
        assert(lvalue);
        assert(rvalue);
        assert(data);

        r = safe_atou32(rvalue, &rt);
        if (r < 0) {
                log_syntax(unit, LOG_ERR, filename, line, r,
                           "Failed to parse RouteTable=%s, ignoring assignment: %m", rvalue);
                return 0;
        }

        if (STRPTR_IN_SET(section, "DHCP", "DHCPv4")) {
                network->dhcp_route_table = rt;
                network->dhcp_route_table_set = true;
        } else { /* section is IPv6AcceptRA */
                network->ipv6_accept_ra_route_table = rt;
                network->ipv6_accept_ra_route_table_set = true;
        }

        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 = data;
        uint32_t iaid;
        int r;

        assert(filename);
        assert(lvalue);
        assert(rvalue);
        assert(network);

        r = safe_atou32(rvalue, &iaid);
        if (r < 0) {
                log_syntax(unit, LOG_ERR, filename, line, r,
                           "Unable to read IAID, ignoring assignment: %s", rvalue);
                return 0;
        }

        network->iaid = iaid;
        network->iaid_set = true;

        return 0;
}

DEFINE_CONFIG_PARSE_ENUM(config_parse_dhcp_use_domains, dhcp_use_domains, DHCPUseDomains,
                         "Failed to parse DHCP use domains setting");

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);
Commit	Line	Data
ca5ad760 YW	1	/* SPDX-License-Identifier: LGPL-2.1+ */
	2
	3	#include "networkd-dhcp-common.h"
	4	#include "networkd-network.h"
	5	#include "parse-util.h"
	6	#include "string-table.h"
426588bc	7	#include "strv.h"
ca5ad760 YW	8
	9	int config_parse_dhcp(
	10	const char* unit,
	11	const char *filename,
	12	unsigned line,
	13	const char *section,
	14	unsigned section_line,
	15	const char *lvalue,
	16	int ltype,
	17	const char *rvalue,
	18	void *data,
	19	void *userdata) {
	20
2d792895	21	AddressFamily *dhcp = data, s;
ca5ad760 YW	22
	23	assert(filename);
	24	assert(lvalue);
	25	assert(rvalue);
	26	assert(data);
	27
	28	/* Note that this is mostly like
2d792895	29	* config_parse_address_family(), except that it
ca5ad760 YW	30	* understands some old names for the enum values */
ca5ad760 YW	31
2d792895	32	s = address_family_from_string(rvalue);
ca5ad760 YW	33	if (s < 0) {
	34
	35	/* Previously, we had a slightly different enum here,
	36	* support its values for compatibility. */
	37
	38	if (streq(rvalue, "none"))
	39	s = ADDRESS_FAMILY_NO;
	40	else if (streq(rvalue, "v4"))
	41	s = ADDRESS_FAMILY_IPV4;
	42	else if (streq(rvalue, "v6"))
	43	s = ADDRESS_FAMILY_IPV6;
	44	else if (streq(rvalue, "both"))
	45	s = ADDRESS_FAMILY_YES;
	46	else {
	47	log_syntax(unit, LOG_ERR, filename, line, 0,
	48	"Failed to parse DHCP option, ignoring: %s", rvalue);
	49	return 0;
	50	}
	51
	52	log_syntax(unit, LOG_WARNING, filename, line, 0,
	53	"DHCP=%s is deprecated, please use DHCP=%s instead.",
2d792895	54	rvalue, address_family_to_string(s));
ca5ad760 YW	55	}
	56
	57	*dhcp = s;
	58	return 0;
	59	}
	60
4f7331a8 YW	61	int config_parse_dhcp_use_dns(
	62	const char* unit,
	63	const char *filename,
	64	unsigned line,
	65	const char *section,
	66	unsigned section_line,
	67	const char *lvalue,
	68	int ltype,
	69	const char *rvalue,
	70	void *data,
	71	void *userdata) {
	72
	73	Network *network = data;
	74	int r;
	75
	76	assert(filename);
	77	assert(lvalue);
	78	assert(rvalue);
	79	assert(data);
	80
	81	r = parse_boolean(rvalue);
	82	if (r < 0) {
	83	log_syntax(unit, LOG_ERR, filename, line, r,
	84	"Failed to parse UseDNS=%s, ignoring assignment: %m", rvalue);
	85	return 0;
	86	}
	87
	88	network->dhcp_use_dns = r;
	89	network->dhcp6_use_dns = r;
	90
	91	return 0;
	92	}
	93
	94	int config_parse_dhcp_use_ntp(
	95	const char* unit,
	96	const char *filename,
	97	unsigned line,
	98	const char *section,
	99	unsigned section_line,
	100	const char *lvalue,
	101	int ltype,
	102	const char *rvalue,
	103	void *data,
	104	void *userdata) {
	105
	106	Network *network = data;
	107	int r;
	108
	109	assert(filename);
	110	assert(lvalue);
	111	assert(rvalue);
	112	assert(data);
	113
	114	r = parse_boolean(rvalue);
	115	if (r < 0) {
	116	log_syntax(unit, LOG_ERR, filename, line, r,
	117	"Failed to parse UseNTP=%s, ignoring assignment: %m", rvalue);
	118	return 0;
	119	}
	120
	121	network->dhcp_use_ntp = r;
	122	network->dhcp6_use_ntp = r;
	123
	124	return 0;
125	}
126
ca5ad760 YW	127	int config_parse_section_route_table(
	128	const char *unit,
	129	const char *filename,
	130	unsigned line,
	131	const char *section,
	132	unsigned section_line,
	133	const char *lvalue,
	134	int ltype,
	135	const char *rvalue,
	136	void *data,
	137	void *userdata) {
	138
	139	Network *network = data;
	140	uint32_t rt;
	141	int r;
	142
	143	assert(filename);
	144	assert(lvalue);
	145	assert(rvalue);
	146	assert(data);
	147
	148	r = safe_atou32(rvalue, &rt);
	149	if (r < 0) {
	150	log_syntax(unit, LOG_ERR, filename, line, r,
	151	"Failed to parse RouteTable=%s, ignoring assignment: %m", rvalue);
	152	return 0;
	153	}
	154
426588bc	155	if (STRPTR_IN_SET(section, "DHCP", "DHCPv4")) {
ca5ad760 YW	156	network->dhcp_route_table = rt;
	157	network->dhcp_route_table_set = true;
	158	} else { /* section is IPv6AcceptRA */
	159	network->ipv6_accept_ra_route_table = rt;
	160	network->ipv6_accept_ra_route_table_set = true;
	161	}
	162
	163	return 0;
	164	}
	165
	166	int config_parse_iaid(const char *unit,
	167	const char *filename,
	168	unsigned line,
	169	const char *section,
	170	unsigned section_line,
	171	const char *lvalue,
	172	int ltype,
	173	const char *rvalue,
	174	void *data,
	175	void *userdata) {
	176	Network *network = data;
	177	uint32_t iaid;
	178	int r;
	179
	180	assert(filename);
	181	assert(lvalue);
	182	assert(rvalue);
	183	assert(network);
	184
	185	r = safe_atou32(rvalue, &iaid);
	186	if (r < 0) {
	187	log_syntax(unit, LOG_ERR, filename, line, r,
	188	"Unable to read IAID, ignoring assignment: %s", rvalue);
	189	return 0;
	190	}
	191
	192	network->iaid = iaid;
	193	network->iaid_set = true;
	194
	195	return 0;
	196	}
	197
	198	DEFINE_CONFIG_PARSE_ENUM(config_parse_dhcp_use_domains, dhcp_use_domains, DHCPUseDomains,
	199	"Failed to parse DHCP use domains setting");
	200
	201	static const char* const dhcp_use_domains_table[_DHCP_USE_DOMAINS_MAX] = {
	202	[DHCP_USE_DOMAINS_NO] = "no",
	203	[DHCP_USE_DOMAINS_ROUTE] = "route",
	204	[DHCP_USE_DOMAINS_YES] = "yes",
	205	};
	206
	207	DEFINE_STRING_TABLE_LOOKUP_WITH_BOOLEAN(dhcp_use_domains, DHCPUseDomains, DHCP_USE_DOMAINS_YES);