2019-06-29 20:57:47 +02:00
|
|
|
/* SPDX-License-Identifier: LGPL-2.1+ */
|
|
|
|
|
2019-11-18 10:29:29 +01:00
|
|
|
#include "dhcp-internal.h"
|
2020-05-01 16:30:31 +02:00
|
|
|
#include "dhcp6-internal.h"
|
2019-11-18 10:29:29 +01:00
|
|
|
#include "escape.h"
|
2019-09-25 05:14:12 +02:00
|
|
|
#include "in-addr-util.h"
|
2019-06-29 20:57:47 +02:00
|
|
|
#include "networkd-dhcp-common.h"
|
|
|
|
#include "networkd-network.h"
|
|
|
|
#include "parse-util.h"
|
|
|
|
#include "string-table.h"
|
2019-07-24 13:26:31 +02:00
|
|
|
#include "strv.h"
|
2019-06-29 20:57:47 +02:00
|
|
|
|
|
|
|
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) {
|
|
|
|
|
2019-08-03 22:09:08 +02:00
|
|
|
AddressFamily *dhcp = data, s;
|
2019-06-29 20:57:47 +02:00
|
|
|
|
|
|
|
assert(filename);
|
|
|
|
assert(lvalue);
|
|
|
|
assert(rvalue);
|
|
|
|
assert(data);
|
|
|
|
|
|
|
|
/* Note that this is mostly like
|
2019-08-03 22:09:08 +02:00
|
|
|
* config_parse_address_family(), except that it
|
2019-06-29 20:57:47 +02:00
|
|
|
* understands some old names for the enum values */
|
|
|
|
|
2019-08-03 22:09:08 +02:00
|
|
|
s = address_family_from_string(rvalue);
|
2019-06-29 20:57:47 +02:00
|
|
|
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.",
|
2019-08-03 22:09:08 +02:00
|
|
|
rvalue, address_family_to_string(s));
|
2019-06-29 20:57:47 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
*dhcp = s;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-06-01 06:08:43 +02:00
|
|
|
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 = data;
|
|
|
|
uint32_t metric;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(filename);
|
|
|
|
assert(lvalue);
|
|
|
|
assert(rvalue);
|
|
|
|
assert(data);
|
|
|
|
|
|
|
|
r = safe_atou32(rvalue, &metric);
|
|
|
|
if (r < 0) {
|
|
|
|
log_syntax(unit, LOG_ERR, filename, line, r,
|
|
|
|
"Failed to parse RouteMetric=%s, ignoring assignment: %m", rvalue);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (streq_ptr(section, "DHCPv4")) {
|
|
|
|
network->dhcp_route_metric = metric;
|
|
|
|
network->dhcp_route_metric_set = true;
|
|
|
|
} else if (streq_ptr(section, "DHCPv6")) {
|
|
|
|
network->dhcp6_route_metric = metric;
|
|
|
|
network->dhcp6_route_metric_set = true;
|
|
|
|
} else { /* [DHCP] section */
|
|
|
|
if (!network->dhcp_route_metric_set)
|
|
|
|
network->dhcp_route_metric = metric;
|
|
|
|
if (!network->dhcp6_route_metric_set)
|
|
|
|
network->dhcp6_route_metric = metric;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-07-10 10:33:05 +02:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2020-06-01 06:08:43 +02:00
|
|
|
if (streq_ptr(section, "DHCPv4")) {
|
|
|
|
network->dhcp_use_dns = r;
|
|
|
|
network->dhcp_use_dns_set = true;
|
|
|
|
} else if (streq_ptr(section, "DHCPv6")) {
|
|
|
|
network->dhcp6_use_dns = r;
|
|
|
|
network->dhcp6_use_dns_set = true;
|
|
|
|
} else { /* [DHCP] section */
|
|
|
|
if (!network->dhcp_use_dns_set)
|
|
|
|
network->dhcp_use_dns = r;
|
|
|
|
if (!network->dhcp6_use_dns_set)
|
|
|
|
network->dhcp6_use_dns = r;
|
|
|
|
}
|
2019-07-10 10:33:05 +02:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2020-06-01 06:08:43 +02:00
|
|
|
if (streq_ptr(section, "DHCPv4")) {
|
|
|
|
network->dhcp_use_ntp = r;
|
|
|
|
network->dhcp_use_ntp_set = true;
|
|
|
|
} else if (streq_ptr(section, "DHCPv6")) {
|
|
|
|
network->dhcp6_use_ntp = r;
|
|
|
|
network->dhcp6_use_ntp_set = true;
|
|
|
|
} else { /* [DHCP] section */
|
|
|
|
if (!network->dhcp_use_ntp_set)
|
|
|
|
network->dhcp_use_ntp = r;
|
|
|
|
if (!network->dhcp6_use_ntp_set)
|
|
|
|
network->dhcp6_use_ntp = r;
|
|
|
|
}
|
2019-07-10 10:33:05 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-06-29 20:57:47 +02:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2019-07-24 13:26:31 +02:00
|
|
|
if (STRPTR_IN_SET(section, "DHCP", "DHCPv4")) {
|
2019-06-29 20:57:47 +02:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2020-05-18 14:49:47 +02:00
|
|
|
int config_parse_dhcp_user_class(
|
2020-03-30 16:31:10 +02:00
|
|
|
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) {
|
|
|
|
|
2020-05-18 14:49:47 +02:00
|
|
|
char ***l = data;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(l);
|
|
|
|
assert(lvalue);
|
|
|
|
assert(rvalue);
|
|
|
|
|
|
|
|
if (isempty(rvalue)) {
|
|
|
|
*l = strv_free(*l);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
_cleanup_free_ char *w = NULL;
|
|
|
|
|
|
|
|
r = extract_first_word(&rvalue, &w, NULL, EXTRACT_CUNESCAPE|EXTRACT_UNQUOTE);
|
|
|
|
if (r == -ENOMEM)
|
|
|
|
return log_oom();
|
|
|
|
if (r < 0) {
|
|
|
|
log_syntax(unit, LOG_ERR, filename, line, r,
|
|
|
|
"Failed to split user classes option, ignoring: %s", rvalue);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (r == 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (ltype == AF_INET) {
|
|
|
|
if (strlen(w) > UINT8_MAX) {
|
|
|
|
log_syntax(unit, LOG_ERR, filename, line, 0,
|
|
|
|
"%s length is not in the range 1-255, ignoring.", w);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (strlen(w) > UINT16_MAX) {
|
|
|
|
log_syntax(unit, LOG_ERR, filename, line, 0,
|
|
|
|
"%s length is not in the range 1-65535, ignoring.", w);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
r = strv_push(l, w);
|
|
|
|
if (r < 0)
|
|
|
|
return log_oom();
|
|
|
|
|
|
|
|
w = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-05-17 17:14:47 +02:00
|
|
|
int config_parse_dhcp_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 = data;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(l);
|
|
|
|
assert(lvalue);
|
|
|
|
assert(rvalue);
|
|
|
|
|
|
|
|
if (isempty(rvalue)) {
|
|
|
|
*l = strv_free(*l);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
_cleanup_free_ char *w = NULL;
|
|
|
|
|
|
|
|
r = extract_first_word(&rvalue, &w, NULL, EXTRACT_CUNESCAPE|EXTRACT_UNQUOTE);
|
|
|
|
if (r == -ENOMEM)
|
|
|
|
return log_oom();
|
|
|
|
if (r < 0) {
|
|
|
|
log_syntax(unit, LOG_ERR, filename, line, r,
|
|
|
|
"Failed to split vendor classes option, ignoring: %s", rvalue);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (r == 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (strlen(w) > UINT8_MAX) {
|
|
|
|
log_syntax(unit, LOG_ERR, filename, line, 0,
|
|
|
|
"%s length is not in the range 1-255, ignoring.", w);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
r = strv_push(l, w);
|
|
|
|
if (r < 0)
|
|
|
|
return log_oom();
|
|
|
|
|
|
|
|
w = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-11-18 10:29:29 +01:00
|
|
|
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) {
|
|
|
|
|
2020-05-01 16:30:31 +02:00
|
|
|
_cleanup_(sd_dhcp_option_unrefp) sd_dhcp_option *opt4 = NULL, *old4 = NULL;
|
|
|
|
_cleanup_(sd_dhcp6_option_unrefp) sd_dhcp6_option *opt6 = NULL, *old6 = NULL;
|
2020-05-26 10:46:54 +02:00
|
|
|
uint32_t uint32_data, enterprise_identifier = 0;
|
2019-11-18 10:29:29 +01:00
|
|
|
_cleanup_free_ char *word = NULL, *q = NULL;
|
2019-12-08 11:54:20 +01:00
|
|
|
OrderedHashmap **options = data;
|
2020-05-26 10:46:54 +02:00
|
|
|
uint16_t u16, uint16_data;
|
2019-11-18 10:29:29 +01:00
|
|
|
union in_addr_union addr;
|
|
|
|
DHCPOptionDataType type;
|
2020-05-01 16:30:31 +02:00
|
|
|
uint8_t u8, uint8_data;
|
2019-11-18 10:29:29 +01:00
|
|
|
const void *udata;
|
|
|
|
const char *p;
|
|
|
|
ssize_t sz;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(filename);
|
|
|
|
assert(lvalue);
|
|
|
|
assert(rvalue);
|
|
|
|
assert(data);
|
|
|
|
|
|
|
|
if (isempty(rvalue)) {
|
|
|
|
*options = ordered_hashmap_free(*options);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
p = rvalue;
|
2020-05-26 10:46:54 +02:00
|
|
|
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_ERR, 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_ERR, filename, line, r,
|
|
|
|
"Failed to parse DHCPv6 enterprise identifier data, ignoring assignment: %s", p);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
word = mfree(word);
|
|
|
|
}
|
|
|
|
|
2019-11-18 10:29:29 +01:00
|
|
|
r = extract_first_word(&p, &word, ":", 0);
|
|
|
|
if (r == -ENOMEM)
|
|
|
|
return log_oom();
|
2020-05-26 10:46:54 +02:00
|
|
|
if (r <= 0 || isempty(p)) {
|
2019-11-18 10:29:29 +01:00
|
|
|
log_syntax(unit, LOG_ERR, filename, line, r,
|
|
|
|
"Invalid DHCP option, ignoring assignment: %s", rvalue);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-05-01 16:30:31 +02:00
|
|
|
if (ltype == AF_INET6) {
|
|
|
|
r = safe_atou16(word, &u16);
|
|
|
|
if (r < 0) {
|
|
|
|
log_syntax(unit, LOG_ERR, filename, line, r,
|
|
|
|
"Invalid DHCP option, ignoring assignment: %s", rvalue);
|
|
|
|
return 0;
|
|
|
|
}
|
2020-05-18 14:49:47 +02:00
|
|
|
if (u16 < 1 || u16 >= UINT16_MAX) {
|
2020-05-01 16:30:31 +02:00
|
|
|
log_syntax(unit, LOG_ERR, 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_ERR, filename, line, r,
|
|
|
|
"Invalid DHCP option, ignoring assignment: %s", rvalue);
|
|
|
|
return 0;
|
|
|
|
}
|
2020-05-19 11:16:57 +02:00
|
|
|
if (u8 < 1 || u8 >= UINT8_MAX) {
|
2020-05-01 16:30:31 +02:00
|
|
|
log_syntax(unit, LOG_ERR, filename, line, 0,
|
|
|
|
"Invalid DHCP option, valid range is 1-254, ignoring assignment: %s", rvalue);
|
|
|
|
return 0;
|
|
|
|
}
|
2019-11-18 10:29:29 +01:00
|
|
|
}
|
|
|
|
|
2019-11-28 16:37:44 +01:00
|
|
|
word = mfree(word);
|
2019-11-18 10:29:29 +01:00
|
|
|
r = extract_first_word(&p, &word, ":", 0);
|
|
|
|
if (r == -ENOMEM)
|
|
|
|
return log_oom();
|
network: Fix crash when SendOption= is invalid
```
p11-kit-0.23.20-1.fc32.x86_64 pam-1.3.1-26.fc33.x86_64 xz-libs-5.2.5-1.fc33.x86_64 zlib-1.2.11-21.fc32.x86_64
(gdb) bt
lvalue=0x560e10 "SendOption", ltype=2, rvalue=0x560e1b "11:string", data=0x561e20, userdata=0x561cd0) at ../src/network/networkd-dhcp-common.c:580
table=0x4392e0 <network_network_gperf_lookup>, section=0x560ef0 "DHCPv4", section_line=14, lvalue=0x560e10 "SendOption", rvalue=0x560e1b "11:string", flags=CONFIG_PARSE_WARN,
userdata=0x561cd0) at ../src/shared/conf-parser.c:132
lookup=0x7ffff7d2f76d <config_item_perf_lookup>, table=0x4392e0 <network_network_gperf_lookup>, flags=CONFIG_PARSE_WARN, section=0x7fffffffc9f8, section_line=0x7fffffffc9a0,
section_ignored=0x7fffffffc99d, l=0x560e10 "SendOption", userdata=0x561cd0) at ../src/shared/conf-parser.c:270
lookup=0x7ffff7d2f76d <config_item_perf_lookup>, table=0x4392e0 <network_network_gperf_lookup>, flags=CONFIG_PARSE_WARN, userdata=0x561cd0) at ../src/shared/conf-parser.c:395
lookup=0x7ffff7d2f76d <config_item_perf_lookup>, table=0x4392e0 <network_network_gperf_lookup>, flags=CONFIG_PARSE_WARN, userdata=0x561cd0) at ../src/shared/conf-parser.c:452
dropin_dirname=0x7fffffffcbd0 "veth99.network.d", sections=0x4f3a18 "Match", lookup=0x7ffff7d2f76d <config_item_perf_lookup>, table=0x4392e0 <network_network_gperf_lookup>,
flags=CONFIG_PARSE_WARN, userdata=0x561cd0) at ../src/shared/conf-parser.c:511
(gdb) q
A debugging session is active.
Inferior 1 [process 118718] will be killed.
```
```
$ printf '[DHCPv4]\nSendOption=1:uint8' >crash
$ ./out/fuzz-network-parser ./crash
INFO: Seed: 1158717610
INFO: Loaded 2 modules (199728 inline 8-bit counters): 136668 [0x7faf3e91a930, 0x7faf3e93bf0c), 63060 [0xadf190, 0xaee7e4),
INFO: Loaded 2 PC tables (199728 PCs): 136668 [0x7faf3e93bf10,0x7faf3eb51cd0), 63060 [0xaee7e8,0xbe4d28),
./out/fuzz-network-parser: Running 1 inputs 1 time(s) each.
Running: ./crash
Assertion 's' failed at src/basic/parse-util.c:458, function int safe_atou8(const char *, uint8_t *)(). Aborting.
==5588== ERROR: libFuzzer: deadly signal
#0 0x51811e in __sanitizer_print_stack_trace (/home/vagrant/systemd/out/fuzz-network-parser+0x51811e)
#1 0x46b921 in fuzzer::PrintStackTrace() (/home/vagrant/systemd/out/fuzz-network-parser+0x46b921)
#2 0x44ded6 in fuzzer::Fuzzer::CrashCallback() (.part.0) (/home/vagrant/systemd/out/fuzz-network-parser+0x44ded6)
#3 0x44df9d in fuzzer::Fuzzer::StaticCrashSignalCallback() (/home/vagrant/systemd/out/fuzz-network-parser+0x44df9d)
#4 0x7faf3d6d7b1f (/lib64/libpthread.so.0+0x14b1f)
#5 0x7faf3d3c2624 in raise (/lib64/libc.so.6+0x3c624)
#6 0x7faf3d3ab8d8 in abort (/lib64/libc.so.6+0x258d8)
#7 0x7faf3e12593a in log_assert_failed_realm /home/vagrant/systemd/build/../src/basic/log.c:819:9
#8 0x7faf3e140ce1 in safe_atou8 /home/vagrant/systemd/build/../src/basic/parse-util.c:458:9
#9 0x68089c in config_parse_dhcp_send_option /home/vagrant/systemd/build/../src/network/networkd-dhcp-common.c:517:21
#10 0x7faf3debed4e in next_assignment /home/vagrant/systemd/build/../src/shared/conf-parser.c:132:32
#11 0x7faf3deb7783 in parse_line /home/vagrant/systemd/build/../src/shared/conf-parser.c:270:16
#12 0x7faf3deb606c in config_parse /home/vagrant/systemd/build/../src/shared/conf-parser.c:395:21
#13 0x7faf3deb85ee in config_parse_many_files /home/vagrant/systemd/build/../src/shared/conf-parser.c:452:21
#14 0x7faf3deb8c57 in config_parse_many /home/vagrant/systemd/build/../src/shared/conf-parser.c:511:16
#15 0x57c2eb in network_load_one /home/vagrant/systemd/build/../src/network/networkd-network.c:470:13
#16 0x543490 in LLVMFuzzerTestOneInput /home/vagrant/systemd/build/../src/network/fuzz-network-parser.c:26:16
#17 0x44e3e8 in fuzzer::Fuzzer::ExecuteCallback(unsigned char const*, unsigned long) (/home/vagrant/systemd/out/fuzz-network-parser+0x44e3e8)
#18 0x433505 in fuzzer::RunOneTest(fuzzer::Fuzzer*, char const*, unsigned long) (/home/vagrant/systemd/out/fuzz-network-parser+0x433505)
#19 0x43c449 in fuzzer::FuzzerDriver(int*, char***, int (*)(unsigned char const*, unsigned long)) (/home/vagrant/systemd/out/fuzz-network-parser+0x43c449)
#20 0x42c4a6 in main (/home/vagrant/systemd/out/fuzz-network-parser+0x42c4a6)
#21 0x7faf3d3ad1a2 in __libc_start_main (/lib64/libc.so.6+0x271a2)
#22 0x42c4fd in _start (/home/vagrant/systemd/out/fuzz-network-parser+0x42c4fd)
NOTE: libFuzzer has rudimentary signal handlers.
Combine libFuzzer with AddressSanitizer or similar for better crash reports.
SUMMARY: libFuzzer: deadly signal
```
2020-05-22 11:55:44 +02:00
|
|
|
if (r <= 0 || isempty(p)) {
|
2019-11-18 10:29:29 +01:00
|
|
|
log_syntax(unit, LOG_ERR, 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_ERR, filename, line, 0,
|
|
|
|
"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_ERR, filename, line, r,
|
2020-05-01 16:30:31 +02:00
|
|
|
"Failed to parse DHCP uint8 data, ignoring assignment: %s", p);
|
2019-11-18 10:29:29 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
udata = &uint8_data;
|
|
|
|
sz = sizeof(uint8_t);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case DHCP_OPTION_DATA_UINT16:{
|
|
|
|
r = safe_atou16(p, &uint16_data);
|
|
|
|
if (r < 0) {
|
|
|
|
log_syntax(unit, LOG_ERR, filename, line, r,
|
2020-05-01 16:30:31 +02:00
|
|
|
"Failed to parse DHCP uint16 data, ignoring assignment: %s", p);
|
2019-11-18 10:29:29 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
udata = &uint16_data;
|
|
|
|
sz = sizeof(uint16_t);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case DHCP_OPTION_DATA_UINT32: {
|
|
|
|
r = safe_atou32(p, &uint32_data);
|
|
|
|
if (r < 0) {
|
|
|
|
log_syntax(unit, LOG_ERR, filename, line, r,
|
2020-05-01 16:30:31 +02:00
|
|
|
"Failed to parse DHCP uint32 data, ignoring assignment: %s", p);
|
2019-11-18 10:29:29 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
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_ERR, filename, line, r,
|
2020-05-01 16:30:31 +02:00
|
|
|
"Failed to parse DHCP ipv4address data, ignoring assignment: %s", p);
|
2019-11-18 10:29:29 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
udata = &addr.in;
|
|
|
|
sz = sizeof(addr.in.s_addr);
|
|
|
|
break;
|
|
|
|
}
|
2020-05-01 16:30:31 +02:00
|
|
|
case DHCP_OPTION_DATA_IPV6ADDRESS: {
|
|
|
|
r = in_addr_from_string(AF_INET6, p, &addr);
|
|
|
|
if (r < 0) {
|
|
|
|
log_syntax(unit, LOG_ERR, 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;
|
|
|
|
}
|
2019-11-18 10:29:29 +01:00
|
|
|
case DHCP_OPTION_DATA_STRING:
|
2020-01-27 10:11:08 +01:00
|
|
|
sz = cunescape(p, UNESCAPE_ACCEPT_NUL, &q);
|
2019-11-18 10:29:29 +01:00
|
|
|
if (sz < 0) {
|
|
|
|
log_syntax(unit, LOG_ERR, filename, line, sz,
|
2020-05-01 16:30:31 +02:00
|
|
|
"Failed to decode DHCP option data, ignoring assignment: %s", p);
|
2019-11-18 10:29:29 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
udata = q;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2020-05-01 16:30:31 +02:00
|
|
|
if (ltype == AF_INET6) {
|
2020-05-26 10:46:54 +02:00
|
|
|
r = sd_dhcp6_option_new(u16, udata, sz, enterprise_identifier, &opt6);
|
2020-05-01 16:30:31 +02:00
|
|
|
if (r < 0) {
|
|
|
|
log_syntax(unit, LOG_ERR, filename, line, r,
|
|
|
|
"Failed to store DHCP option '%s', ignoring assignment: %m", rvalue);
|
|
|
|
return 0;
|
|
|
|
}
|
2019-11-18 10:29:29 +01:00
|
|
|
|
2020-05-01 16:30:31 +02:00
|
|
|
r = ordered_hashmap_ensure_allocated(options, &dhcp6_option_hash_ops);
|
|
|
|
if (r < 0)
|
|
|
|
return log_oom();
|
2019-11-18 10:29:29 +01:00
|
|
|
|
2020-05-01 16:30:31 +02:00
|
|
|
/* 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_ERR, 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_ERR, filename, line, r,
|
|
|
|
"Failed to store DHCP option '%s', ignoring assignment: %m", rvalue);
|
|
|
|
return 0;
|
|
|
|
}
|
2019-11-18 10:29:29 +01:00
|
|
|
|
2020-05-01 16:30:31 +02:00
|
|
|
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_ERR, filename, line, r,
|
|
|
|
"Failed to store DHCP option '%s', ignoring assignment: %m", rvalue);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
TAKE_PTR(opt4);
|
|
|
|
}
|
2019-11-18 10:29:29 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-04-23 14:31:47 +02:00
|
|
|
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 = data;
|
|
|
|
const char *p;
|
|
|
|
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 (p = rvalue;;) {
|
|
|
|
_cleanup_free_ char *n = NULL;
|
|
|
|
uint32_t i;
|
|
|
|
|
|
|
|
r = extract_first_word(&p, &n, NULL, 0);
|
|
|
|
if (r < 0) {
|
|
|
|
log_syntax(unit, LOG_ERR, 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_ERR, filename, line, r,
|
|
|
|
"DHCP request option is invalid, ignoring assignment: %s", n);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2020-05-19 11:16:57 +02:00
|
|
|
if (i < 1 || i >= UINT8_MAX) {
|
2020-04-23 14:31:47 +02:00
|
|
|
log_syntax(unit, LOG_ERR, filename, line, r,
|
|
|
|
"DHCP request option is invalid, valid range is 1-254, ignoring assignment: %s", n);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ltype == AF_INET)
|
|
|
|
r = set_ensure_allocated(&network->dhcp_request_options, NULL);
|
|
|
|
else
|
|
|
|
r = set_ensure_allocated(&network->dhcp6_request_options, NULL);
|
|
|
|
if (r < 0)
|
|
|
|
return log_oom();
|
|
|
|
|
|
|
|
if (ltype == AF_INET)
|
|
|
|
r = set_put(network->dhcp_request_options, UINT32_TO_PTR(i));
|
|
|
|
else
|
|
|
|
r = set_put(network->dhcp6_request_options, UINT32_TO_PTR(i));
|
|
|
|
if (r < 0)
|
|
|
|
log_syntax(unit, LOG_ERR, filename, line, r,
|
|
|
|
"Failed to store DHCP request option '%s', ignoring assignment: %m", n);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-06-29 20:57:47 +02:00
|
|
|
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);
|
2019-11-17 14:59:58 +01:00
|
|
|
|
|
|
|
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",
|
2020-05-01 16:30:31 +02:00
|
|
|
[DHCP_OPTION_DATA_IPV6ADDRESS] = "ipv6address",
|
2019-11-17 14:59:58 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
DEFINE_STRING_TABLE_LOOKUP(dhcp_option_data_type, DHCPOptionDataType);
|