HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/network/networkd-radv.c

52,989 bytesGit mode 100644Download original fileLGPL-2.1-or-later

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;
}