Page MenuHomeFreeBSD
Differential D36002 Diff 109873 sys/netlink/route/route.c

Changeset View

Standalone View

View Options

sys/netlink/route/route.c

  • This file was added.
/*-
* SPDX-License-Identifier: BSD-2-Clause-FreeBSD
*
* Copyright (c) 2021 Ng Peng Nam Sean
Lint: Possible Spelling Mistake
Inline Actions

Possible spelling error. You wrote 'nam', but did you mean 'name'?

Lint: Possible Spelling Mistake: Possible spelling error. You wrote 'nam', but did you mean 'name'?
* Copyright (c) 2022 Alexander V. Chernikov
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include "opt_inet.h"
#include "opt_inet6.h"
#include "opt_route.h"
#include <sys/types.h>
#include <sys/malloc.h>
#include <sys/rmlock.h>
#include <sys/socket.h>
#include <net/if.h>
#include <net/route.h>
#include <net/route/nhop.h>
#include <net/route/route_ctl.h>
#include <net/route/route_var.h>
#include <netlink/netlink.h>
#include <netlink/netlink_ctl.h>
#include <netlink/netlink_route.h>
#include <netlink/route/route_var.h>
#define DEBUG_MOD_NAME nl_route
#define DEBUG_MAX_LEVEL LOG_DEBUG3
#include <netlink/netlink_debug.h>
_DECLARE_DEBUG(LOG_DEBUG);
static unsigned char
get_rtm_type(const struct nhop_object *nh)
{
int nh_flags = nh->nh_flags;
/* Use the fact that nhg runtime flags are only NHF_MULTIPATH */
if (nh_flags & NHF_BLACKHOLE)
return (RTN_BLACKHOLE);
else if (nh_flags & NHF_REJECT)
return (RTN_PROHIBIT);
return (RTN_UNICAST);
}
static unsigned char
nl_get_rtm_protocol(const struct nhop_object *nh)
{
if (NH_IS_NHGRP(nh)) {
const struct nhgrp_object *nhg = (const struct nhgrp_object *)nh;
nh = nhg->nhops[0];
}
int rt_flags = nhop_get_rtflags(nh);
if (rt_flags & RTF_PROTO1)
return (RTPROT_ZEBRA);
if (rt_flags & RTF_STATIC)
return (RTPROT_STATIC);
return (RTPROT_KERNEL);
}
static int
get_rtmsg_type_from_rtsock(int cmd)
{
switch (cmd) {
case RTM_ADD:
case RTM_CHANGE:
case RTM_GET:
return NL_RTM_NEWROUTE;
case RTM_DELETE:
return NL_RTM_DELROUTE;
}
return (0);
}
/*
* fibnum heuristics
*
* if (dump && rtm_table == 0 && !rta_table) RT_ALL_FIBS
* msg rtm_table RTA_TABLE result
* RTM_GETROUTE/dump 0 - RT_ALL_FIBS
* RTM_GETROUTE/dump 1 - 1
* RTM_GETROUTE/get 0 - 0
*
*/
static struct nhop_object *
rc_get_nhop(const struct rib_cmd_info *rc)
{
return ((rc->rc_cmd == RTM_DELETE) ? rc->rc_nh_old : rc->rc_nh_new);
}
static bool
dump_rc_nhop_gw(struct nlmsg_state *ns, const struct nhop_object *nh)
{
int upper_family;
switch (nhop_get_neigh_family(nh)) {
case AF_LINK:
/* onlink prefix, skip */
break;
case AF_INET:
if (!nlattr_add(ns, NL_RTA_GATEWAY, 4, &nh->gw4_sa.sin_addr))
return (false);
break;
case AF_INET6:
upper_family = nhop_get_upper_family(nh);
if (upper_family == AF_INET6) {
if (!nlattr_add(ns, NL_RTA_GATEWAY, 16, &nh->gw6_sa.sin6_addr))
return (false);
} else if (upper_family == AF_INET) {
/* IPv4 over IPv6 */
char buf[20];
struct rtvia *via = (struct rtvia *)&buf[0];
via->rtvia_family = AF_INET6;
memcpy(via->rtvia_addr, &nh->gw6_sa.sin6_addr, 16);
if (!nlattr_add(ns, NL_RTA_VIA, 17, via))
return (false);
} else {
/* shouldn't happen */
return (false);
}
break;
}
return (true);
}
static bool
dump_rc_nhg(struct nlmsg_state *ns, const struct nhgrp_object *nhg)
{
uint32_t uidx = nhgrp_get_uidx(nhg);
if (uidx != 0) {
if (!nlattr_add_u32(ns, NL_RTA_NH_ID, uidx))
return (false);
}
uint32_t num_nhops;
const struct weightened_nhop *wn = nhgrp_get_nhops(nhg, &num_nhops);
int off = nlattr_save_offset(ns);
if (!nlattr_add_flag(ns, NL_RTA_MULTIPATH))
return (false);
for (int i = 0; i < num_nhops; i++) {
int nh_off = nlattr_save_offset(ns);
struct rtnexthop *rtnh = nlmsg_reserve_object(ns, struct rtnexthop);
if (rtnh == NULL)
return (false);
rtnh->rtnh_flags = 0;
rtnh->rtnh_ifindex = wn[i].nh->nh_ifp->if_index;
rtnh->rtnh_hops = wn[i].weight;
if (!dump_rc_nhop_gw(ns, wn[i].nh))
return (false);
rtnh = nlattr_restore_offset(ns, nh_off, struct rtnexthop);
/*
* nlattr_add() allocates 4-byte aligned storage, no need to aligh
* length here
* */
rtnh->rtnh_len = nlattr_save_offset(ns) - nh_off;
}
struct nlattr *nla = nlattr_restore_offset(ns, off, struct nlattr);
nla->nla_len = nlattr_save_offset(ns) - off;
return (true);
}
static bool
dump_rc_nhop(struct nlmsg_state *ns, const struct nhop_object *nh)
{
if (NH_IS_NHGRP(nh))
return (dump_rc_nhg(ns, (const struct nhgrp_object *)nh));
/*
* IPv4 over IPv6
* ('RTA_VIA', {'family': 10, 'addr': 'fe80::20c:29ff:fe67:2dd'}), ('RTA_OIF', 2),
* IPv4 w/ gw
* ('RTA_GATEWAY', '172.16.107.131'), ('RTA_OIF', 2)],
* Direct route:
* ('RTA_OIF', 2)
*/
if (nh->nh_flags & NHF_GATEWAY)
dump_rc_nhop_gw(ns, nh);
uint32_t uidx = nhop_get_uidx(nh);
if (uidx != 0) {
if (!nlattr_add_u32(ns, NL_RTA_NH_ID, uidx))
return (false);
}
if (nhop_get_rtflags(nh) & RTF_FIXEDMTU) {
int nla_len = sizeof(struct nlattr) * 2 + sizeof(uint32_t);
struct nlattr *nla = nlmsg_reserve_data(ns, nla_len, struct nlattr);
if (nla == NULL)
return (false);
nla->nla_type = NL_RTA_METRICS;
nla->nla_len = nla_len;
nla++;
nla->nla_type = NL_RTAX_MTU;
nla->nla_len = sizeof(struct nlattr) + sizeof(uint32_t);
*((uint32_t *)(nla + 1)) = nh->nh_mtu;
}
/* In any case, fill outgoing interface */
if (!nlattr_add_u32(ns, NL_RTA_OIF, nh->nh_ifp->if_index))
return (false);
return (true);
}
/*
* Dumps output from a rib command into an rtmsg
*/
static int
dump_px(uint32_t fibnum, const struct nlmsghdr *hdr,
const struct rtentry *rt, struct route_nhop_data *rnd,
struct nlmsg_state *ns)
{
struct rtmsg *rtm;
int error = 0;
NET_EPOCH_ASSERT();
int payload_len = sizeof(struct rtmsg);
if (!nlmsg_reply(ns, hdr, payload_len))
goto enomem;
int family = rt_get_family(rt);
int rtm_off = nlattr_save_offset(ns);
rtm = nlmsg_reserve_object(ns, struct rtmsg);
if (rtm == NULL)
goto enomem;
rtm->rtm_family = family;
rtm->rtm_dst_len = 0;
rtm->rtm_src_len = 0;
rtm->rtm_tos = 0;
if (fibnum < 255)
rtm->rtm_table = (unsigned char)fibnum;
rtm->rtm_scope = RT_SCOPE_UNIVERSE;
if (!NH_IS_NHGRP(rnd->rnd_nhop)) {
rtm->rtm_protocol = nl_get_rtm_protocol(rnd->rnd_nhop);
rtm->rtm_type = get_rtm_type(rnd->rnd_nhop);
} else {
rtm->rtm_protocol = RTPROT_UNSPEC; /* TODO: protocol from nhg? */
rtm->rtm_type = RTN_UNICAST;
}
rtm->rtm_flags = 0;
if (!nlattr_add_u32(ns, NL_RTA_TABLE, fibnum))
goto enomem;
int plen = 0;
uint32_t scopeid = 0;
switch (family) {
case AF_INET:
{
struct in_addr addr;
rt_get_inet_prefix_plen(rt, &addr, &plen, &scopeid);
if (!nlattr_add(ns, NL_RTA_DST, 4, &addr))
goto enomem;
break;
}
case AF_INET6:
{
struct in6_addr addr;
rt_get_inet6_prefix_plen(rt, &addr, &plen, &scopeid);
if (!nlattr_add(ns, NL_RTA_DST, 16, &addr))
goto enomem;
break;
}
default:
FIB_LOG(LOG_NOTICE, fibnum, family, "unknown rt family");
error = EAFNOSUPPORT;
goto flush;
}
if (plen > 0) {
rtm = nlattr_restore_offset(ns, rtm_off, struct rtmsg);
rtm->rtm_dst_len = plen;
}
if (!dump_rc_nhop(ns, rnd->rnd_nhop))
goto enomem;
/*
struct nlattr *metrics_nla;
metrics_nla = nla_nest_start(m, NL_RTA_METRICS);
nlattr_add_u32(m, NL_RTAX_MTU, nh->nh_mtu);
nla_nest_end(m, metrics_nla);
*/
nlmsg_end(ns);
return (0);
enomem:
error = ENOMEM;
flush:
nlmsg_abort(ns);
return (error);
}
static int
family_to_group(int family)
{
switch (family) {
case AF_INET:
return (RTNLGRP_IPV4_ROUTE);
case AF_INET6:
return (RTNLGRP_IPV6_ROUTE);
}
return (0);
}
static void
report_operation(uint32_t fibnum, struct rib_cmd_info *rc,
struct nlpcb *nlp, struct nlmsghdr *hdr)
{
struct nlmsg_state ns;
uint32_t group_mask = family_to_group(rt_get_family(rc->rc_rt));
if (nlmsg_get_group_writer(NLMSG_SMALL, group_mask, &ns)) {
struct route_nhop_data rnd = {
.rnd_nhop = rc_get_nhop(rc),
.rnd_weight = rc->rc_nh_weight,
};
dump_px(fibnum, hdr, rc->rc_rt, &rnd, &ns);
nlmsg_flush(&ns);
}
}
struct nl_parsed_route {
struct sockaddr *rta_dst;
struct sockaddr *rta_gw;
struct ifnet *rta_oif;
struct nlattr *rta_metrics;
uint32_t rta_table;
uint32_t rta_nh_id;
uint32_t rtax_mtu;
uint8_t rtm_family;
};
#define _OFF_S(_field) offsetof(struct nl_parsed_route, _field)
static struct nlattr_parser ps[] = {
{ .type = NL_RTA_DST, .off = _OFF_S(rta_dst), .cb = nlattr_get_ip },
{ .type = NL_RTA_OIF, .off = _OFF_S(rta_oif), .cb = nlattr_get_ifindex },
{ .type = NL_RTA_GATEWAY, .off = _OFF_S(rta_gw), .cb = nlattr_get_ip },
{ .type = NL_RTA_METRICS, .off = _OFF_S(rta_metrics), .cb = nlattr_get_nla },
{ .type = NL_RTA_TABLE, .off = _OFF_S(rta_table), .cb = nlattr_get_uint32 },
{ .type = NL_RTA_VIA, .off = _OFF_S(rta_gw), .cb = nlattr_get_ipvia },
{ .type = NL_RTA_NH_ID, .off = _OFF_S(rta_nh_id), .cb = nlattr_get_uint32 },
};
static struct nlattr_parser psm[] = {
{ .type = NL_RTAX_MTU, .off = _OFF_S(rtax_mtu), .cb = nlattr_get_uint32 },
};
struct netlink_walkargs {
struct nlmsg_state *ns;
struct route_nhop_data rnd;
struct nlmsghdr hdr;
struct nlpcb *nlp;
uint32_t fibnum;
int family;
int error;
int count;
int dumped;
int dumped_tables;
};
static int
dump_rtentry(struct rtentry *rt, void *_arg)
{
struct netlink_walkargs *wa = (struct netlink_walkargs *)_arg;
int error;
wa->count++;
if (wa->error != 0)
return (0);
wa->dumped++;
rt_get_rnd(rt, &wa->rnd);
error = dump_px(wa->fibnum, &wa->hdr, rt, &wa->rnd, wa->ns);
IF_DEBUG_LEVEL(LOG_DEBUG3) {
char rtbuf[INET6_ADDRSTRLEN + 5];
FIB_LOG(LOG_DEBUG3, wa->fibnum, wa->family,
"Dump %s, offset %u, error %d",
rt_print_buf(rt, rtbuf, sizeof(rtbuf)),
wa->ns->offset, error);
}
wa->error = error;
return (0);
}
static void
dump_rtable_one(struct netlink_walkargs *wa, uint32_t fibnum, int family)
{
FIB_LOG(LOG_DEBUG2, fibnum, family, "Start dump");
wa->count = 0;
wa->dumped = 0;
rib_walk(fibnum, family, false, dump_rtentry, wa);
wa->dumped_tables++;
FIB_LOG(LOG_DEBUG2, fibnum, family, "End dump, iterated %d dumped %d",
wa->count, wa->dumped);
RT_LOG(LOG_DEBUG2, "Current offset: %d", wa->ns->offset);
}
static int
dump_rtable_fib(struct netlink_walkargs *wa, uint32_t fibnum, int family)
{
wa->fibnum = fibnum;
if (family == AF_UNSPEC) {
for (int i = 0; i < AF_MAX; i++) {
if (rt_tables_get_rnh(fibnum, i) != 0) {
wa->family = i;
dump_rtable_one(wa, fibnum, i);
if (wa->error != 0)
break;
}
}
} else {
if (rt_tables_get_rnh(fibnum, family) != 0) {
wa->family = family;
dump_rtable_one(wa, fibnum, family);
}
}
return (wa->error);
}
static int
handle_rtm_getroute(struct nlpcb *nlp, struct nl_parsed_route *attrs,
struct nlmsghdr *hdr, struct nlmsg_state *ns)
{
RIB_RLOCK_TRACKER;
struct rib_head *rnh;
struct rtentry *rt;
uint32_t fibnum = attrs->rta_table;
sa_family_t family = attrs->rtm_family;
if (attrs->rta_dst == NULL) {
RT_LOG(LOG_DEBUG, "No RTA_DST supplied");
return (EINVAL);
}
FIB_LOG(LOG_DEBUG, fibnum, family, "getroute called");
rnh = rt_tables_get_rnh(fibnum, family);
if (rnh == NULL)
return (EAFNOSUPPORT);
RIB_RLOCK(rnh);
rt = (struct rtentry *)rnh->rnh_matchaddr(attrs->rta_dst, &rnh->head);
if (rt == NULL) {
RIB_RUNLOCK(rnh);
return (ESRCH);
}
struct route_nhop_data rnd;
rt_get_rnd(rt, &rnd);
rnd.rnd_nhop = nhop_select_func(rnd.rnd_nhop, 0);
RIB_RUNLOCK(rnh);
#if DEBUG_MAX_LEVEL >= LOG_DEBUG2
{
char rtbuf[INET6_ADDRSTRLEN + 5], nhbuf[INET6_ADDRSTRLEN + 5];
FIB_LOG(LOG_DEBUG2, fibnum, family, "getroute completed: got %s for %s",
nhop_print_buf_any(rnd.rnd_nhop, nhbuf, sizeof(nhbuf)),
rt_print_buf(rt, rtbuf, sizeof(rtbuf)));
}
#endif
hdr->nlmsg_type = NL_RTM_NEWROUTE;
dump_px(fibnum, hdr, rt, &rnd, ns);
return (0);
}
static int
handle_rtm_dump(struct nlpcb *nlp, uint32_t fibnum, int family,
struct nlmsghdr *hdr, struct nlmsg_state *ns)
{
struct netlink_walkargs wa = {
.nlp = nlp,
.ns = ns,
.hdr.nlmsg_pid = hdr->nlmsg_pid,
.hdr.nlmsg_seq = hdr->nlmsg_seq,
.hdr.nlmsg_type = NL_RTM_NEWROUTE,
.hdr.nlmsg_flags = hdr->nlmsg_flags | NLM_F_MULTI,
};
if (fibnum == RT_TABLE_UNSPEC) {
for (int i = 0; i < V_rt_numfibs; i++) {
dump_rtable_fib(&wa, fibnum, family);
if (wa.error != 0)
break;
}
} else
dump_rtable_fib(&wa, fibnum, family);
if (wa.error == 0 && wa.dumped_tables == 0) {
FIB_LOG(LOG_DEBUG, fibnum, family, "incorrect fibnum/family");
wa.error = ESRCH;
// How do we propagate it?
}
if (!nlmsg_end_dump(wa.ns, wa.error, &wa.hdr)) {
RT_LOG(LOG_DEBUG, "Unable to finalize the dump");
return (ENOMEM);
}
return (wa.error);
}
static struct nhop_object *
finalize_nhop(struct nhop_object *nh, int *perror)
{
/*
* The following MUST be filled:
* nh_ifp, nh_ifa, nh_gw
*/
if (nh->gw_sa.sa_family == 0) {
/*
* Empty gateway. Can be direct route with RTA_OIF set.
*/
if (nh->nh_ifp != NULL)
nhop_set_direct_gw(nh, nh->nh_ifp);
else {
RT_LOG(LOG_DEBUG, "empty gateway and interface, skipping");
*perror = EINVAL;
return (NULL);
}
/* Both nh_ifp and gateway are set */
} else {
/* Gateway is set up, we can derive ifp if not set */
if (nh->nh_ifp == NULL) {
struct ifaddr *ifa = ifa_ifwithnet(&nh->gw_sa, 1, nhop_get_fibnum(nh));
if (ifa == NULL) {
RT_LOG(LOG_DEBUG, "Unable to determine ifp, skipping");
*perror = EINVAL;
return (NULL);
}
nhop_set_transmit_ifp(nh, ifa->ifa_ifp);
}
}
/* Both nh_ifp and gateway are set */
if (nh->nh_ifa == NULL) {
struct ifaddr *ifa = ifaof_ifpforaddr(&nh->gw_sa, nh->nh_ifp);
if (ifa == NULL) {
RT_LOG(LOG_DEBUG, "Unable to determine ifa, skipping");
*perror = EINVAL;
return (NULL);
}
nhop_set_src(nh, ifa);
}
return (nhop_get_nhop(nh, perror));
}
static int
get_pxflag(const struct rtmsg *rtm)
{
int pxflag = 0;
switch (rtm->rtm_family) {
case AF_INET:
if (rtm->rtm_dst_len == 32)
pxflag = NHF_HOST;
else if (rtm->rtm_dst_len == 0)
pxflag = NHF_DEFAULT;
break;
case AF_INET6:
if (rtm->rtm_dst_len == 32)
pxflag = NHF_HOST;
else if (rtm->rtm_dst_len == 0)
pxflag = NHF_DEFAULT;
break;
}
return (pxflag);
}
static int
get_rtm_flags(int nlm_flags)
{
int rtm_flags = 0;
rtm_flags |= (nlm_flags & NLM_F_REPLACE) ? RTM_F_REPLACE : 0;
rtm_flags |= (nlm_flags & NLM_F_EXCL) ? RTM_F_EXCL : 0;
rtm_flags |= (nlm_flags & NLM_F_CREATE) ? RTM_F_CREATE : 0;
rtm_flags |= (nlm_flags & NLM_F_APPEND) ? RTM_F_APPEND : 0;
return (rtm_flags);
}
static int
rtnl_handle_newroute(struct nlmsghdr *hdr, struct nlpcb *nlp,
struct netlink_parse_tracker *npt)
{
struct rib_cmd_info rc = {};
struct nhop_object *nh = NULL;
int error;
error = nlp_has_priv_route(nlp);
if (error != 0)
return (error);
struct rtmsg *rtm = (struct rtmsg *)nlmsg_data(hdr);
struct nl_parsed_route attrs = {};
error = nl_parse_attrs(hdr, sizeof(*rtm), ps, sizeof(ps)/sizeof(ps[0]), npt, &attrs);
if (error != 0)
return (error);
if (attrs.rta_metrics != NULL) {
int data_len = attrs.rta_metrics->nla_len - sizeof(struct nlattr);
error = nl_parse_attrs_raw(attrs.rta_metrics + 1, data_len,
psm, sizeof(psm)/sizeof(psm[0]), npt, &attrs);
if (error != 0)
return (error);
}
/* Check if we have enough data */
if (attrs.rta_dst == NULL) {
RT_LOG(LOG_DEBUG, "missing RTA_DST");
return (EINVAL);
}
if (attrs.rta_nh_id != 0) {
/* Referenced uindex */
int pxflag = get_pxflag(rtm);
nh = nl_find_nhop(attrs.rta_table, rtm->rtm_family, attrs.rta_nh_id,
pxflag, &error);
if (error != 0)
return (error);
} else {
nh = nhop_alloc(attrs.rta_table, rtm->rtm_family);
if (nh == NULL)
return (ENOMEM);
if (attrs.rta_gw != NULL)
nhop_set_gw(nh, attrs.rta_gw, true);
if (attrs.rta_oif != NULL)
nhop_set_transmit_ifp(nh, attrs.rta_oif);
if (attrs.rtax_mtu != 0)
nhop_set_mtu(nh, attrs.rtax_mtu, true);
nh = finalize_nhop(nh, &error);
if (error != 0) {
RT_LOG(LOG_DEBUG, "Error finalising nexthop");
return (error);
}
}
int weight = NH_IS_NHGRP(nh) ? 0 : RT_DEFAULT_WEIGHT;
struct route_nhop_data rnd = { .rnd_nhop = nh, .rnd_weight = weight };
int rtm_flags = get_rtm_flags(hdr->nlmsg_flags);
error = rib_add_route_px(attrs.rta_table, attrs.rta_dst, rtm->rtm_dst_len,
&rnd, rtm_flags, &rc);
if (error == 0)
report_operation(attrs.rta_table, &rc, nlp, hdr);
return (error);
}
static int
path_match_func(const struct rtentry *rt, const struct nhop_object *nh, void *_data)
{
struct nl_parsed_route *attrs = (struct nl_parsed_route *)_data;
if ((attrs->rta_gw != NULL) && !rib_match_gw(rt, nh, attrs->rta_gw))
return (0);
if ((attrs->rta_oif != NULL) && (attrs->rta_oif != nh->nh_ifp))
return (0);
return (1);
}
static int
rtnl_handle_delroute(struct nlmsghdr *hdr, struct nlpcb *nlp,
struct netlink_parse_tracker *npt)
{
struct rib_cmd_info rc;
int error;
error = nlp_has_priv_route(nlp);
if (error != 0)
return (error);
struct rtmsg *rtm = (struct rtmsg *)nlmsg_data(hdr);
struct nl_parsed_route attrs = { .rtm_family = rtm->rtm_family };
error = nl_parse_attrs(hdr, sizeof(*rtm), ps, sizeof(ps)/sizeof(ps[0]), npt, &attrs);
if (error != 0)
return (error);
if (attrs.rta_dst == NULL) {
RT_LOG(LOG_DEBUG, "RTA_DST is not set");
return (ESRCH);
}
error = rib_del_route_px(attrs.rta_table, attrs.rta_dst,
rtm->rtm_dst_len, path_match_func, &attrs, 0, &rc);
if (error == 0)
report_operation(attrs.rta_table, &rc, nlp, hdr);
return (error);
}
static int
rtnl_handle_getroute(struct nlmsghdr *hdr, struct nlpcb *nlp, struct netlink_parse_tracker *npt)
{
int error;
struct rtmsg *rtm = (struct rtmsg *)nlmsg_data(hdr);
struct nl_parsed_route attrs = { .rtm_family = rtm->rtm_family };
error = nl_parse_attrs(hdr, sizeof(*rtm), ps, sizeof(ps)/sizeof(ps[0]), npt, &attrs);
if (error != 0)
return (error);
if (hdr->nlmsg_flags & NLM_F_DUMP)
error = handle_rtm_dump(nlp, attrs.rta_table, rtm->rtm_family, hdr, npt->ns);
else
error = handle_rtm_getroute(nlp, &attrs, hdr, npt->ns);
return (error);
}
void
rtnl_handle_route_event(uint32_t fibnum, const struct rt_addrinfo *info,
const struct rib_cmd_info *rc)
{
int family, nlm_flags = 0;
struct nlmsg_state ns;
family = rt_get_family(rc->rc_rt);
/* XXX: check if there are active listeners first */
/* TODO: consider passing PID/type/seq */
switch (rc->rc_cmd) {
case RTM_ADD:
nlm_flags = NLM_F_EXCL | NLM_F_CREATE;
break;
case RTM_CHANGE:
nlm_flags = NLM_F_REPLACE;
break;
case RTM_DELETE:
nlm_flags = 0;
break;
}
#if DEBUG_MAX_LEVEL >= LOG_DEBUG2
{
char rtbuf[INET6_ADDRSTRLEN + 5];
FIB_LOG(LOG_DEBUG2, fibnum, family,
"received event %s for %s / nlm_flags=%X",
rib_print_cmd(rc->rc_cmd),
rt_print_buf(rc->rc_rt, rtbuf, sizeof(rtbuf)),
nlm_flags);
}
#endif
struct nlmsghdr hdr = {
.nlmsg_flags = nlm_flags,
.nlmsg_type = get_rtmsg_type_from_rtsock(rc->rc_cmd),
};
struct route_nhop_data rnd = {
.rnd_nhop = rc_get_nhop(rc),
.rnd_weight = rc->rc_nh_weight,
};
uint32_t group_mask = family_to_group(family);
if (!nlmsg_get_group_writer(NLMSG_SMALL, group_mask, &ns)) {
RT_LOG(LOG_DEBUG, "error allocating mbuf");
return;
}
dump_px(fibnum, &hdr, rc->rc_rt, &rnd, &ns);
nlmsg_flush(&ns);
}
static struct rtnl_cmd_handler cmd_handlers[] = {
{ NL_RTM_GETROUTE, "RTM_GETROUTE", &rtnl_handle_getroute, sizeof(struct rtmsg)},
{ NL_RTM_DELROUTE, "RTM_DELROUTE", &rtnl_handle_delroute, sizeof(struct rtmsg)},
{ NL_RTM_NEWROUTE, "RTM_NEWROUTE", &rtnl_handle_newroute, sizeof(struct rtmsg)},
};
void
rtnl_routes_init()
{
rtnl_register_messages(cmd_handlers, RTNL_ARRAY_LEN(cmd_handlers));
}