HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/network/networkd-nexthop.c
Git blob: 9a32a17050d05259769b1db060b4a08e34a56e7a
Lines 1001–1515 of 1,515
}
void link_forget_nexthops(Link *link) {
assert(link);
assert(link->manager);
assert(link->ifindex > 0);
assert(!link_is_up(link));
/* See comments in link_forget_routes(). */
/* Remove all IPv4 nexthops. */
NextHop *nexthop;
HASHMAP_FOREACH(nexthop, link->manager->nexthops_by_id) {
if (nexthop->ifindex != link->ifindex)
continue;
if (nexthop->family != AF_INET)
continue;
nexthop_forget(link->manager, nexthop, "Forgetting silently removed");
}
/* Remove all group nexthops their all members are removed in the above. */
HASHMAP_FOREACH(nexthop, link->manager->nexthops_by_id) {
if (hashmap_isempty(nexthop->group))
continue;
/* Update group members. */
struct nexthop_grp *nhg;
HASHMAP_FOREACH(nhg, nexthop->group) {
if (nexthop_get_by_id(nexthop->manager, nhg->id, NULL) >= 0)
continue;
assert_se(hashmap_remove(nexthop->group, UINT32_TO_PTR(nhg->id)) == nhg);
free(nhg);
}
if (!hashmap_isempty(nexthop->group))
continue; /* At least one group member still exists. */
nexthop_forget(link->manager, nexthop, "Forgetting silently removed");
}
}
static int nexthop_update_group(NextHop *nexthop, sd_netlink_message *message) {
_cleanup_hashmap_free_ Hashmap *h = NULL;
_cleanup_free_ struct nexthop_grp *group = NULL;
size_t size = 0, n_group;
int r;
assert(nexthop);
assert(message);
r = sd_netlink_message_read_data(message, NHA_GROUP, &size, (void**) &group);
if (r < 0 && r != -ENODATA)
return log_debug_errno(r, "rtnl: could not get NHA_GROUP attribute, ignoring: %m");
nexthop_detach_from_group_members(nexthop);
if (size % sizeof(struct nexthop_grp) != 0)
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL),
"rtnl: received nexthop message with invalid nexthop group size, ignoring.");
if ((uintptr_t) group % alignof(struct nexthop_grp) != 0)
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL),
"rtnl: received nexthop message with invalid alignment, ignoring.");
n_group = size / sizeof(struct nexthop_grp);
for (size_t i = 0; i < n_group; i++) {
_cleanup_free_ struct nexthop_grp *nhg = NULL;
if (group[i].id == 0) {
log_debug("rtnl: received nexthop message with invalid ID in group, ignoring.");
continue;
}
if (group[i].weight > 254) {
log_debug("rtnl: received nexthop message with invalid weight in group, ignoring.");
continue;
}
nhg = newdup(struct nexthop_grp, group + i, 1);
if (!nhg)
return log_oom();
r = hashmap_ensure_put(&h, &trivial_hash_ops_value_free, UINT32_TO_PTR(nhg->id), nhg);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_debug_errno(r, "Failed to store nexthop group, ignoring: %m");
continue;
}
if (r > 0)
TAKE_PTR(nhg);
}
hashmap_free_and_replace(nexthop->group, h);
nexthop_attach_to_group_members(nexthop);
return 0;
}
int manager_rtnl_process_nexthop(sd_netlink *rtnl, sd_netlink_message *message, Manager *m) {
int r;
assert(rtnl);
assert(message);
assert(m);
if (sd_netlink_message_is_error(message)) {
r = sd_netlink_message_get_errno(message);
if (r < 0)
log_message_warning_errno(message, r, "rtnl: failed to receive rule message, ignoring");
return 0;
}
uint16_t type;
r = sd_netlink_message_get_type(message, &type);
if (r < 0) {
log_warning_errno(r, "rtnl: could not get message type, ignoring: %m");
return 0;
} else if (!IN_SET(type, RTM_NEWNEXTHOP, RTM_DELNEXTHOP)) {
log_warning("rtnl: received unexpected message type %u when processing nexthop, ignoring.", type);
return 0;
}
uint32_t id;
r = sd_netlink_message_read_u32(message, NHA_ID, &id);
if (r == -ENODATA) {
log_warning_errno(r, "rtnl: received nexthop message without NHA_ID attribute, ignoring: %m");
return 0;
} else if (r < 0) {
log_warning_errno(r, "rtnl: could not get NHA_ID attribute, ignoring: %m");
return 0;
} else if (id == 0) {
log_warning("rtnl: received nexthop message with invalid nexthop ID, ignoring.");
return 0;
}
NextHop *nexthop = NULL;
(void) nexthop_get_by_id(m, id, &nexthop);
if (type == RTM_DELNEXTHOP) {
if (nexthop)
nexthop_forget(m, nexthop, "Forgetting removed");
else
log_nexthop_debug(&(const NextHop) { .id = id }, "Kernel removed unknown", m);
return 0;
}
Request *req = NULL;
(void) nexthop_get_request_by_id(m, id, &req);
/* If we did not know the nexthop, then save it. */
bool is_new = false;
if (!nexthop) {
if (!req && !m->manage_foreign_nexthops) {
log_nexthop_debug(&(const NextHop) { .id = id }, "Ignoring received", m);
return 0;
}
r = nexthop_add_new(m, id, &nexthop);
if (r < 0) {
log_warning_errno(r, "Failed to add received nexthop, ignoring: %m");
return 0;
}
is_new = true;
}
/* Also update information that cannot be obtained through netlink notification. */
if (req && req->waiting_reply) {
NextHop *n = ASSERT_PTR(req->userdata);
nexthop->source = n->source;
nexthop->provider = n->provider;
}
r = sd_rtnl_message_get_family(message, &nexthop->family);
if (r < 0)
log_debug_errno(r, "rtnl: could not get nexthop family, ignoring: %m");
r = sd_rtnl_message_nexthop_get_protocol(message, &nexthop->protocol);
if (r < 0)
log_debug_errno(r, "rtnl: could not get nexthop protocol, ignoring: %m");
r = sd_rtnl_message_nexthop_get_flags(message, &nexthop->flags);
if (r < 0)
log_debug_errno(r, "rtnl: could not get nexthop flags, ignoring: %m");
(void) nexthop_update_group(nexthop, message);
if (nexthop->family != AF_UNSPEC) {
r = netlink_message_read_in_addr_union(message, NHA_GATEWAY, nexthop->family, &nexthop->gw.address);
if (r == -ENODATA)
nexthop->gw.address = IN_ADDR_NULL;
else if (r < 0)
log_debug_errno(r, "rtnl: could not get NHA_GATEWAY attribute, ignoring: %m");
}
r = sd_netlink_message_has_flag(message, NHA_BLACKHOLE);
if (r < 0)
log_debug_errno(r, "rtnl: could not get NHA_BLACKHOLE attribute, ignoring: %m");
else
nexthop->blackhole = r;
uint32_t ifindex;
r = sd_netlink_message_read_u32(message, NHA_OIF, &ifindex);
if (r == -ENODATA)
nexthop->ifindex = 0;
else if (r < 0)
log_debug_errno(r, "rtnl: could not get NHA_OIF attribute, ignoring: %m");
else if (ifindex > INT32_MAX)
log_debug_errno(r, "rtnl: received invalid NHA_OIF attribute, ignoring: %m");
else
nexthop->ifindex = (int) ifindex;
/* The linux kernel does not set NHA_OID attribute when NHA_BLACKHOLE or NHA_GROUP is set.
* But let's check that for safety. */
if (!nexthop_bound_to_link(nexthop) && nexthop->ifindex != 0) {
log_debug("rtnl: received blackhole or group nexthop with NHA_OIF attribute, ignoring the attribute.");
nexthop->ifindex = 0;
}
nexthop_enter_configured(nexthop);
if (req)
nexthop_enter_configured(req->userdata);
log_nexthop_debug(nexthop, is_new ? "Remembering" : "Received remembered", m);
return 1;
}
#define log_nexthop_section(nexthop, fmt, ...) \
({ \
const NextHop *_nexthop = (nexthop); \
log_section_warning_errno( \
_nexthop ? _nexthop->section : NULL, \
SYNTHETIC_ERRNO(EINVAL), \
fmt " Ignoring [NextHop] section.", \
##__VA_ARGS__); \
})
static int nexthop_section_verify(NextHop *nh) {
if (section_is_invalid(nh->section))
return -EINVAL;
if (!nh->network->manager->manage_foreign_nexthops && nh->id == 0)
return log_nexthop_section(nh, "Nexthop without specifying Id= is not supported if ManageForeignNextHops=no is set in networkd.conf.");
if (nh->family == AF_UNSPEC)
nh->family = nh->gw.family;
else if (nh->gw.family != AF_UNSPEC && nh->gw.family != nh->family)
return log_nexthop_section(nh, "Family= and Gateway= settings for nexthop contradict each other.");
assert(nh->gw.family == nh->family || nh->gw.family == AF_UNSPEC);
if (!hashmap_isempty(nh->group)) {
if (in_addr_is_set(nh->family, &nh->gw.address))
return log_nexthop_section(nh, "Nexthop group cannot have gateway address.");
if (nh->family != AF_UNSPEC)
return log_nexthop_section(nh, "Nexthop group cannot have Family= setting.");
if (nh->blackhole)
return log_nexthop_section(nh, "Nexthop group cannot be a blackhole.");
if (nh->onlink > 0)
return log_nexthop_section(nh, "Nexthop group cannot have on-link flag.");
} else if (nh->family == AF_UNSPEC)
/* When neither Family=, Gateway=, nor Group= is specified, assume IPv4. */
nh->family = AF_INET;
if (nh->blackhole) {
if (in_addr_is_set(nh->family, &nh->gw.address))
return log_nexthop_section(nh, "Blackhole nexthop cannot have gateway address.");
if (nh->onlink > 0)
return log_nexthop_section(nh, "Blackhole nexthop cannot have on-link flag.");
}
if (nh->onlink < 0 && in_addr_is_set(nh->family, &nh->gw.address) &&
ordered_hashmap_isempty(nh->network->addresses_by_section)) {
/* If no address is configured, in most cases the gateway cannot be reachable.
* TODO: we may need to improve the condition above. */
log_section_warning(nh->section, "Nexthop with Gateway= specified, but no static address configured. Enabling OnLink= option.");
nh->onlink = true;
}
if (nh->onlink >= 0)
SET_FLAG(nh->flags, RTNH_F_ONLINK, nh->onlink);
return 0;
}
int network_drop_invalid_nexthops(Network *network) {
_cleanup_hashmap_free_ Hashmap *nexthops = NULL;
_cleanup_set_free_ Set *duplicated_nexthops = NULL;
NextHop *nh;
int r;
assert(network);
ORDERED_HASHMAP_FOREACH(nh, network->nexthops_by_section) {
if (nexthop_section_verify(nh) < 0) {
nexthop_detach(nh);
continue;
}
if (nh->id == 0)
continue;
/* Always use the setting specified later. So, remove the previously assigned setting. */
NextHop *dup = hashmap_remove(nexthops, UINT32_TO_PTR(nh->id));
if (dup) {
log_warning("%s: Duplicated nexthop settings for ID %"PRIu32" is specified at line %u and %u, "
"dropping the nexthop setting specified at line %u.",
dup->section->filename,
nh->id, nh->section->line,
dup->section->line, dup->section->line);
/* Do not call nexthop_detach() for 'dup' now, as we can remove only the current
* entry in the loop. We will drop the nexthop from nexthops_by_section later. */
r = set_ensure_put(&duplicated_nexthops, &nexthop_hash_ops, dup);
if (r < 0)
return log_oom();
assert(r > 0);
}
r = hashmap_ensure_put(&nexthops, NULL, UINT32_TO_PTR(nh->id), nh);
if (r < 0)
return log_oom();
assert(r > 0);
}
return 0;
}
int manager_build_nexthop_ids(Manager *manager) {
Network *network;
int r;
assert(manager);
if (!manager->manage_foreign_nexthops)
return 0;
manager->nexthop_ids = set_free(manager->nexthop_ids);
ORDERED_HASHMAP_FOREACH(network, manager->networks) {
NextHop *nh;
ORDERED_HASHMAP_FOREACH(nh, network->nexthops_by_section) {
if (nh->id == 0)
continue;
r = set_ensure_put(&manager->nexthop_ids, NULL, UINT32_TO_PTR(nh->id));
if (r < 0)
return r;
}
}
return 0;
}
static int config_parse_nexthop_family(
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) {
int *family = ASSERT_PTR(data);
if (isempty(rvalue))
*family = AF_UNSPEC;
else if (streq(rvalue, "ipv4"))
*family = AF_INET;
else if (streq(rvalue, "ipv6"))
*family = AF_INET6;
else
return log_syntax_parse_error(unit, filename, line, 0, lvalue, rvalue);
return 1;
}
static int config_parse_nexthop_group(
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) {
Hashmap **group = ASSERT_PTR(data);
int r;
if (isempty(rvalue)) {
*group = hashmap_free(*group);
return 1;
}
for (const char *p = rvalue;;) {
_cleanup_free_ struct nexthop_grp *nhg = NULL;
_cleanup_free_ char *word = NULL;
uint32_t w;
char *sep;
r = extract_first_word(&p, &word, NULL, 0);
if (r < 0)
return log_syntax_parse_error(unit, filename, line, r, lvalue, rvalue);
if (r == 0)
return 1;
nhg = new0(struct nexthop_grp, 1);
if (!nhg)
return log_oom();
sep = strchr(word, ':');
if (sep) {
*sep++ = '\0';
r = safe_atou32(sep, &w);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse weight for nexthop group, ignoring assignment: %s:%s",
word, sep);
continue;
}
if (w == 0 || w > 256) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Invalid weight for nexthop group, ignoring assignment: %s:%s",
word, sep);
continue;
}
/* See comments in config_parse_multipath_route(). */
nhg->weight = w - 1;
}
r = safe_atou32(word, &nhg->id);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse nexthop ID in %s=, ignoring assignment: %s%s%s",
lvalue, word, sep ? ":" : "", strempty(sep));
continue;
}
if (nhg->id == 0) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Nexthop ID in %s= must be positive, ignoring assignment: %s%s%s",
lvalue, word, sep ? ":" : "", strempty(sep));
continue;
}
r = hashmap_ensure_put(group, &trivial_hash_ops_value_free, UINT32_TO_PTR(nhg->id), nhg);
if (r == -ENOMEM)
return log_oom();
if (r == -EEXIST) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Nexthop ID %"PRIu32" is specified multiple times in %s=, ignoring assignment: %s%s%s",
nhg->id, lvalue, word, sep ? ":" : "", strempty(sep));
continue;
}
assert(r > 0);
TAKE_PTR(nhg);
}
}
int config_parse_nexthop_section(
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) {
static const ConfigSectionParser table[_NEXTHOP_CONF_PARSER_MAX] = {
[NEXTHOP_ID] = { .parser = config_parse_uint32, .ltype = 0, .offset = offsetof(NextHop, id), },
[NEXTHOP_GATEWAY] = { .parser = config_parse_in_addr_data, .ltype = 0, .offset = offsetof(NextHop, gw), },
[NEXTHOP_FAMILY] = { .parser = config_parse_nexthop_family, .ltype = 0, .offset = offsetof(NextHop, family), },
[NEXTHOP_ONLINK] = { .parser = config_parse_tristate, .ltype = 0, .offset = offsetof(NextHop, onlink), },
[NEXTHOP_BLACKHOLE] = { .parser = config_parse_bool, .ltype = 0, .offset = offsetof(NextHop, blackhole), },
[NEXTHOP_GROUP] = { .parser = config_parse_nexthop_group, .ltype = 0, .offset = offsetof(NextHop, group), },
};
_cleanup_(nexthop_unref_or_set_invalidp) NextHop *nexthop = NULL;
Network *network = ASSERT_PTR(userdata);
int r;
assert(filename);
r = nexthop_new_static(network, filename, section_line, &nexthop);
if (r < 0)
return log_oom();
r = config_section_parse(table, ELEMENTSOF(table),
unit, filename, line, section, section_line, lvalue, ltype, rvalue, nexthop);
if (r <= 0) /* 0 means non-critical error, but the section will be ignored. */
return r;
TAKE_PTR(nexthop);
return 0;
}