HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/network/networkd-radv.c
Git blob: 1aafc0dd6d429cf83f1920807bb90fa69864085f
Lines 1001–1625 of 1,625
TAKE_PTR(p);
return 0;
}
int config_parse_prefix_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) {
_cleanup_(prefix_free_or_set_invalidp) Prefix *p = NULL;
Network *network = ASSERT_PTR(userdata);
int r;
assert(filename);
assert(section);
assert(lvalue);
assert(rvalue);
r = prefix_new_static(network, filename, section_line, &p);
if (r < 0)
return log_oom();
r = safe_atou32(rvalue, &p->route_metric);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse %s=, ignoring assignment: %s",
lvalue, rvalue);
return 0;
}
TAKE_PTR(p);
return 0;
}
int config_parse_prefix_token(
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_(prefix_free_or_set_invalidp) Prefix *p = NULL;
Network *network = ASSERT_PTR(userdata);
int r;
assert(filename);
assert(section);
assert(lvalue);
assert(rvalue);
r = prefix_new_static(network, filename, section_line, &p);
if (r < 0)
return log_oom();
r = config_parse_address_generation_type(unit, filename, line, section, section_line,
lvalue, ltype, rvalue, &p->tokens, userdata);
if (r < 0)
return r;
TAKE_PTR(p);
return 0;
}
int config_parse_route_prefix(
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_(route_prefix_free_or_set_invalidp) RoutePrefix *p = NULL;
Network *network = ASSERT_PTR(userdata);
union in_addr_union a;
int r;
assert(filename);
assert(section);
assert(lvalue);
assert(rvalue);
r = route_prefix_new_static(network, filename, section_line, &p);
if (r < 0)
return log_oom();
r = in_addr_prefix_from_string(rvalue, AF_INET6, &a, &p->route.prefixlen);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Route prefix is invalid, ignoring assignment: %s", rvalue);
return 0;
}
(void) in6_addr_mask(&a.in6, p->route.prefixlen);
p->route.address = a.in6;
TAKE_PTR(p);
return 0;
}
int config_parse_route_prefix_lifetime(
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_(route_prefix_free_or_set_invalidp) RoutePrefix *p = NULL;
Network *network = ASSERT_PTR(userdata);
usec_t usec;
int r;
assert(filename);
assert(section);
assert(lvalue);
assert(rvalue);
r = route_prefix_new_static(network, filename, section_line, &p);
if (r < 0)
return log_oom();
r = parse_sec(rvalue, &usec);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Route lifetime is invalid, ignoring assignment: %s", rvalue);
return 0;
}
if (usec != USEC_INFINITY && DIV_ROUND_UP(usec, USEC_PER_SEC) >= UINT32_MAX) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Lifetime is too long, ignoring assignment: %s", rvalue);
return 0;
}
p->route.lifetime = usec;
TAKE_PTR(p);
return 0;
}
int config_parse_route_prefix_preference(
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_(route_prefix_free_or_set_invalidp) RoutePrefix *p = NULL;
Network *network = ASSERT_PTR(userdata);
int r;
assert(filename);
r = route_prefix_new_static(network, filename, section_line, &p);
if (r < 0)
return log_oom();
r = config_parse_router_preference(unit, filename, line, section, section_line,
lvalue, ltype, rvalue, &p->route.preference, NULL);
if (r <= 0)
return r;
TAKE_PTR(p);
return 0;
}
int config_parse_pref64_prefix(
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_(prefix64_free_or_set_invalidp) Prefix64 *p = NULL;
Network *network = ASSERT_PTR(userdata);
union in_addr_union a;
uint8_t prefixlen;
int r;
assert(filename);
assert(section);
assert(lvalue);
assert(rvalue);
r = prefix64_new_static(network, filename, section_line, &p);
if (r < 0)
return log_oom();
r = in_addr_prefix_from_string(rvalue, AF_INET6, &a, &prefixlen);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"PREF64 prefix is invalid, ignoring assignment: %s", rvalue);
return 0;
}
if (!IN_SET(prefixlen, 96, 64, 56, 48, 40, 32)) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"PREF64 prefixlen is invalid, ignoring assignment: %s", rvalue);
return 0;
}
(void) in6_addr_mask(&a.in6, prefixlen);
p->prefix64.prefix = a.in6;
p->prefix64.prefixlen = prefixlen;
TAKE_PTR(p);
return 0;
}
int config_parse_pref64_prefix_lifetime(
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_(prefix64_free_or_set_invalidp) Prefix64 *p = NULL;
Network *network = ASSERT_PTR(userdata);
usec_t usec;
int r;
assert(filename);
assert(section);
assert(lvalue);
assert(rvalue);
r = prefix64_new_static(network, filename, section_line, &p);
if (r < 0)
return log_oom();
r = parse_sec(rvalue, &usec);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"PREF64 lifetime is invalid, ignoring assignment: %s", rvalue);
return 0;
}
if (usec == USEC_INFINITY || DIV_ROUND_UP(usec, 8 * USEC_PER_SEC) >= UINT64_C(1) << 13) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"PREF64 lifetime is too long, ignoring assignment: %s", rvalue);
return 0;
}
p->prefix64.lifetime = usec;
TAKE_PTR(p);
return 0;
}
int config_parse_radv_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 *n = data;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
if (isempty(rvalue)) {
n->n_router_dns = 0;
n->router_dns = mfree(n->router_dns);
return 0;
}
for (const char *p = rvalue;;) {
_cleanup_free_ char *w = NULL;
union in_addr_union a;
r = extract_first_word(&p, &w, NULL, 0);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to extract word, ignoring: %s", rvalue);
return 0;
}
if (r == 0)
return 0;
if (streq(w, "_link_local"))
a = IN_ADDR_NULL;
else {
r = in_addr_from_string(AF_INET6, w, &a);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse DNS server address, ignoring: %s", w);
continue;
}
if (in_addr_is_null(AF_INET6, &a)) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"DNS server address is null, ignoring: %s", w);
continue;
}
}
if (!GREEDY_REALLOC(n->router_dns, n->n_router_dns + 1))
return log_oom();
n->router_dns[n->n_router_dns++] = a.in6;
}
}
int config_parse_radv_search_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 *n = data;
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
if (isempty(rvalue)) {
n->router_search_domains = ordered_set_free(n->router_search_domains);
return 0;
}
for (const char *p = rvalue;;) {
_cleanup_free_ char *w = NULL, *idna = NULL;
r = extract_first_word(&p, &w, NULL, 0);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to extract word, ignoring: %s", rvalue);
return 0;
}
if (r == 0)
return 0;
r = dns_name_apply_idna(w, &idna);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to apply IDNA to domain name '%s', ignoring: %m", w);
continue;
} else if (r == 0)
/* transfer ownership to simplify subsequent operations */
idna = TAKE_PTR(w);
r = ordered_set_ensure_allocated(&n->router_search_domains, &string_hash_ops_free);
if (r < 0)
return log_oom();
r = ordered_set_consume(n->router_search_domains, TAKE_PTR(idna));
if (r < 0)
return log_oom();
}
}
static const char * const radv_prefix_delegation_table[_RADV_PREFIX_DELEGATION_MAX] = {
[RADV_PREFIX_DELEGATION_NONE] = "no",
[RADV_PREFIX_DELEGATION_STATIC] = "static",
[RADV_PREFIX_DELEGATION_DHCP6] = "dhcpv6",
[RADV_PREFIX_DELEGATION_BOTH] = "yes",
};
DEFINE_STRING_TABLE_LOOKUP_WITH_BOOLEAN(
radv_prefix_delegation,
RADVPrefixDelegation,
RADV_PREFIX_DELEGATION_BOTH);
int config_parse_router_prefix_delegation(
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) {
RADVPrefixDelegation val, *ra = ASSERT_PTR(data);
int r;
assert(filename);
assert(lvalue);
assert(rvalue);
if (streq(lvalue, "IPv6SendRA")) {
r = parse_boolean(rvalue);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Invalid %s= setting, ignoring assignment: %s", lvalue, rvalue);
return 0;
}
/* When IPv6SendRA= is enabled, only static prefixes are sent by default, and users
* need to explicitly enable DHCPPrefixDelegation=. */
*ra = r ? RADV_PREFIX_DELEGATION_STATIC : RADV_PREFIX_DELEGATION_NONE;
return 0;
}
/* For backward compatibility */
val = radv_prefix_delegation_from_string(rvalue);
if (val < 0) {
log_syntax(unit, LOG_WARNING, filename, line, val,
"Invalid %s= setting, ignoring assignment: %s", lvalue, rvalue);
return 0;
}
*ra = val;
return 0;
}
int config_parse_router_lifetime(
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) {
usec_t usec, *lifetime = ASSERT_PTR(data);
int r;
assert(filename);
assert(section);
assert(lvalue);
assert(rvalue);
if (isempty(rvalue)) {
*lifetime = RADV_DEFAULT_ROUTER_LIFETIME_USEC;
return 0;
}
r = parse_sec(rvalue, &usec);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse router lifetime, ignoring assignment: %s", rvalue);
return 0;
}
if (usec > 0) {
if (usec < RADV_MIN_ROUTER_LIFETIME_USEC) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Router lifetime %s is too short, using %s.",
FORMAT_TIMESPAN(usec, USEC_PER_SEC),
FORMAT_TIMESPAN(RADV_MIN_ROUTER_LIFETIME_USEC, USEC_PER_SEC));
usec = RADV_MIN_ROUTER_LIFETIME_USEC;
} else if (usec > RADV_MAX_ROUTER_LIFETIME_USEC) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Router lifetime %s is too large, using %s.",
FORMAT_TIMESPAN(usec, USEC_PER_SEC),
FORMAT_TIMESPAN(RADV_MAX_ROUTER_LIFETIME_USEC, USEC_PER_SEC));
usec = RADV_MAX_ROUTER_LIFETIME_USEC;
}
}
*lifetime = usec;
return 0;
}
int config_parse_router_uint32_msec_usec(
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) {
usec_t usec, *router_usec = ASSERT_PTR(data);
int r;
assert(filename);
assert(section);
assert(lvalue);
assert(rvalue);
if (isempty(rvalue)) {
*router_usec = 0;
return 0;
}
r = parse_sec(rvalue, &usec);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse %s=, ignoring assignment: %s", lvalue, rvalue);
return 0;
}
if (usec != USEC_INFINITY &&
usec > RADV_MAX_UINT32_MSEC_USEC) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Invalid [%s] %s=, ignoring assignment: %s", section, lvalue, rvalue);
return 0;
}
*router_usec = usec;
return 0;
}
int config_parse_router_preference(
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 *preference = ASSERT_PTR(data);
if (isempty(rvalue) || STR_IN_SET(rvalue, "medium", "normal", "default"))
*preference = SD_NDISC_PREFERENCE_MEDIUM;
else if (streq(rvalue, "high"))
*preference = SD_NDISC_PREFERENCE_HIGH;
else if (streq(rvalue, "low"))
*preference = SD_NDISC_PREFERENCE_LOW;
else
return log_syntax_parse_error(unit, filename, line, 0, lvalue, rvalue);
return 1;
}
int config_parse_router_home_agent_lifetime(
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) {
usec_t usec, *home_agent_lifetime_usec = ASSERT_PTR(data);
int r;
assert(filename);
assert(section);
assert(lvalue);
assert(rvalue);
if (isempty(rvalue)) {
*home_agent_lifetime_usec = 0;
return 0;
}
r = parse_sec(rvalue, &usec);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse %s=, ignoring assignment: %s", lvalue, rvalue);
return 0;
}
if (!timestamp_is_set(usec) ||
usec > RADV_HOME_AGENT_MAX_LIFETIME_USEC) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Invalid [%s] %s=, ignoring assignment: %s", section, lvalue, rvalue);
return 0;
}
*home_agent_lifetime_usec = usec;
return 0;
}