HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/network/networkd-nexthop.c

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

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