diff --git a/sys/modules/netlink/Makefile b/sys/modules/netlink/Makefile new file mode 100644 --- /dev/null +++ b/sys/modules/netlink/Makefile @@ -0,0 +1,16 @@ +.PATH: ${SRCTOP}/sys/netlink +KMOD= netlink + +SRCS = netlink_module.c netlink_domain.c netlink_io.c netlink_helpers.c \ + netlink_message.c netlink_route.c \ + route/iface.c route/neigh.c route/nexthop.c route/route.c + +EXPORT_SYMS= +EXPORT_SYMS+= nlmsg_get_chain_writer +EXPORT_SYMS+= nlmsg_refill_buffer +EXPORT_SYMS+= nlmsg_end +EXPORT_SYMS+= nlmsg_flush + +EXPORT_SYMS= YES + +.include diff --git a/sys/net/route.c b/sys/net/route.c --- a/sys/net/route.c +++ b/sys/net/route.c @@ -77,6 +77,8 @@ VNET_PCPUSTAT_SYSUNINIT(rtstat); #endif +void *linux_netlink_p = NULL; /* Callback pointer for Linux translator functions */ + EVENTHANDLER_LIST_DEFINE(rt_addrmsg); static int rt_ifdelroute(const struct rtentry *rt, const struct nhop_object *, diff --git a/sys/net/route/nhgrp.c b/sys/net/route/nhgrp.c --- a/sys/net/route/nhgrp.c +++ b/sys/net/route/nhgrp.c @@ -115,7 +115,7 @@ * different set of "data plane" nexthops. * For now, ignore the data plane and focus on the control plane list. */ - if (a->nhg_nh_count != b->nhg_nh_count) + if (a->nhg_nh_count != b->nhg_nh_count || a->nhg_uidx != b->nhg_uidx) return (0); return !memcmp(a->nhg_nh_weights, b->nhg_nh_weights, sizeof(struct weightened_nhop) * a->nhg_nh_count); diff --git a/sys/net/route/nhgrp_ctl.c b/sys/net/route/nhgrp_ctl.c --- a/sys/net/route/nhgrp_ctl.c +++ b/sys/net/route/nhgrp_ctl.c @@ -80,7 +80,7 @@ static void sort_weightened_nhops(struct weightened_nhop *wn, int num_nhops); static struct nhgrp_priv *get_nhgrp(struct nh_control *ctl, - struct weightened_nhop *wn, int num_nhops, int *perror); + struct weightened_nhop *wn, int num_nhops, uint32_t uidx, int *perror); static void destroy_nhgrp(struct nhgrp_priv *nhg_priv); static void destroy_nhgrp_epoch(epoch_context_t ctx); static void free_nhgrp_nhops(struct nhgrp_priv *nhg_priv); @@ -465,7 +465,7 @@ */ struct nhgrp_priv * get_nhgrp(struct nh_control *ctl, struct weightened_nhop *wn, int num_nhops, - int *perror) + uint32_t uidx, int *perror) { struct nhgrp_priv *key, *nhg_priv; @@ -497,6 +497,7 @@ *perror = ENOMEM; return (NULL); } + key->nhg_uidx = uidx; nhg_priv = find_nhgrp(ctl, key); if (nhg_priv != NULL) { @@ -577,7 +578,7 @@ memcpy(&pnhops[curr_nhops], wn, num_nhops * sizeof(struct weightened_nhop)); curr_nhops += num_nhops; - nhg_priv = get_nhgrp(ctl, pnhops, curr_nhops, perror); + nhg_priv = get_nhgrp(ctl, pnhops, curr_nhops, 0, perror); if (pnhops != (struct weightened_nhop *)&storage[0]) free(pnhops, M_TEMP); @@ -598,13 +599,13 @@ */ int nhgrp_get_group(struct rib_head *rh, struct weightened_nhop *wn, int num_nhops, - struct nhgrp_object **pnhg) + uint32_t uidx, struct nhgrp_object **pnhg) { struct nh_control *ctl = rh->nh_control; struct nhgrp_priv *nhg_priv; int error; - nhg_priv = get_nhgrp(ctl, wn, num_nhops, &error); + nhg_priv = get_nhgrp(ctl, wn, num_nhops, uidx, &error); if (nhg_priv != NULL) *pnhg = nhg_priv->nhg; @@ -658,7 +659,7 @@ if (nhop_try_ref_object(rnd->rnd_nhop) == 0) error = EAGAIN; } else { - mp_priv = get_nhgrp(ctl, pnhops, num_nhops, &error); + mp_priv = get_nhgrp(ctl, pnhops, num_nhops, 0, &error); if (mp_priv != NULL) rnd->rnd_nhgrp = mp_priv->nhg; rnd->rnd_weight = 0; @@ -699,7 +700,7 @@ /* Simple merge of 2 non-multipath nexthops */ wn[1].nh = rnd_orig->rnd_nhop; wn[1].weight = rnd_orig->rnd_weight; - nhg_priv = get_nhgrp(ctl, wn, 2, &error); + nhg_priv = get_nhgrp(ctl, wn, 2, 0, &error); } else { /* Get new nhop group with @rt->rt_nhop as an additional nhop */ nhg_priv = append_nhops(ctl, rnd_orig->rnd_nhgrp, &wn[0], 1, @@ -731,6 +732,17 @@ return (nhg_priv->nhg_nh_weights); } +uint32_t +nhgrp_get_uidx(const struct nhgrp_object *nhg) +{ + const struct nhgrp_priv *nhg_priv; + + KASSERT(((nhg->nhg_flags & MPF_MULTIPATH) != 0), ("nhop is not mpath")); + + nhg_priv = NHGRP_PRIV_CONST(nhg); + return (nhg_priv->nhg_uidx); +} + /* * Prints nexhop group @nhg data in the provided @buf. * Example: nhg#33/sz=3:[#1:100,#2:100,#3:100] diff --git a/sys/net/route/nhgrp_var.h b/sys/net/route/nhgrp_var.h --- a/sys/net/route/nhgrp_var.h +++ b/sys/net/route/nhgrp_var.h @@ -47,6 +47,7 @@ struct nhgrp_priv { uint32_t nhg_idx; + uint32_t nhg_uidx; uint8_t nhg_nh_count; /* number of items in nh_weights */ uint8_t nhg_spare[3]; u_int nhg_refcount; /* use refcount */ diff --git a/sys/net/route/nhop.h b/sys/net/route/nhop.h --- a/sys/net/route/nhop.h +++ b/sys/net/route/nhop.h @@ -182,6 +182,7 @@ struct nhop_object *nhop_alloc(uint32_t fibnum, int family); void nhop_copy(struct nhop_object *nh, const struct nhop_object *nh_orig); struct nhop_object *nhop_get_nhop(struct nhop_object *nh, int *perror); +int nhop_finalize(struct nhop_object *nh); void nhop_set_direct_gw(struct nhop_object *nh, struct ifnet *ifp); bool nhop_set_gw(struct nhop_object *nh, const struct sockaddr *sa, bool is_gw); @@ -199,17 +200,23 @@ void nhop_set_transmit_ifp(struct nhop_object *nh, struct ifnet *ifp); uint32_t nhop_get_idx(const struct nhop_object *nh); +uint32_t nhop_get_uidx(const struct nhop_object *nh); +void nhop_set_uidx(struct nhop_object *nh, uint32_t uidx); enum nhop_type nhop_get_type(const struct nhop_object *nh); int nhop_get_rtflags(const struct nhop_object *nh); struct vnet *nhop_get_vnet(const struct nhop_object *nh); struct nhop_object *nhop_select_func(struct nhop_object *nh, uint32_t flowid); int nhop_get_upper_family(const struct nhop_object *nh); +bool nhop_set_upper_family(struct nhop_object *nh, int family); int nhop_get_neigh_family(const struct nhop_object *nh); uint32_t nhop_get_fibnum(const struct nhop_object *nh); void nhop_set_fibnum(struct nhop_object *nh, uint32_t fibnum); uint32_t nhop_get_expire(const struct nhop_object *nh); void nhop_set_expire(struct nhop_object *nh, uint32_t expire); +struct rib_head *nhop_get_rh(const struct nhop_object *nh); +struct nhgrp_object; +uint32_t nhgrp_get_uidx(const struct nhgrp_object *nhg); #endif /* _KERNEL */ /* Kernel <> userland structures */ diff --git a/sys/net/route/nhop_ctl.c b/sys/net/route/nhop_ctl.c --- a/sys/net/route/nhop_ctl.c +++ b/sys/net/route/nhop_ctl.c @@ -85,13 +85,12 @@ static int dump_nhop_entry(struct rib_head *rh, struct nhop_object *nh, struct sysctl_req *w); -static int finalize_nhop(struct nh_control *ctl, struct nhop_object *nh); +static int finalize_nhop(struct nh_control *ctl, struct nhop_object *nh, bool link); static struct ifnet *get_aifp(const struct nhop_object *nh); static void fill_sdl_from_ifp(struct sockaddr_dl_short *sdl, const struct ifnet *ifp); static void destroy_nhop_epoch(epoch_context_t ctx); static void destroy_nhop(struct nhop_object *nh); -static struct rib_head *nhop_get_rh(const struct nhop_object *nh); _Static_assert(__offsetof(struct nhop_object, nh_ifp) == 32, "nhop_object: wrong nh_ifp offset"); @@ -315,6 +314,12 @@ { struct rib_head *rnh = nhop_get_rh(nh); + if (__predict_false(rnh == NULL)) { + *perror = EAFNOSUPPORT; + nhop_free(nh); + return (NULL); + } + return (nhop_get_nhop_internal(rnh, nh, perror)); } @@ -349,10 +354,29 @@ * relative number of such nexthops is significant, which * is extremely unlikely. */ - *perror = finalize_nhop(rnh->nh_control, nh); + *perror = finalize_nhop(rnh->nh_control, nh, true); return (*perror == 0 ? nh : NULL); } +/* + * Alocates/references the remaining bits of nexthop data. + */ +int +nhop_finalize(struct nhop_object *nh) +{ + struct rib_head *rnh = nhop_get_rh(nh); + + if (__predict_false(rnh == NULL)) { + nhop_free(nh); + return (EAFNOSUPPORT); + } + + nh->nh_aifp = get_aifp(nh); + + return (finalize_nhop(rnh->nh_control, nh, false)); +} + + /* * Update @nh with data supplied in @info. * This is a helper function to support route changes. @@ -458,7 +482,7 @@ * errno otherwise. @nh_priv is freed in case of error. */ static int -finalize_nhop(struct nh_control *ctl, struct nhop_object *nh) +finalize_nhop(struct nh_control *ctl, struct nhop_object *nh, bool link) { /* Allocate per-cpu packet counter */ @@ -484,9 +508,14 @@ /* Please see nhop_free() comments on the initial value */ refcount_init(&nh->nh_priv->nh_linked, 2); - nh->nh_priv->nh_fibnum = ctl->ctl_rh->rib_fibnum; + MPASS(nh->nh_priv->nh_fibnum == ctl->ctl_rh->rib_fibnum); - if (link_nhop(ctl, nh->nh_priv) == 0) { + if (!link) { + refcount_release(&nh->nh_priv->nh_linked); + NHOPS_WLOCK(ctl); + nh->nh_priv->nh_finalized = 1; + NHOPS_WUNLOCK(ctl); + } else if (link_nhop(ctl, nh->nh_priv) == 0) { /* * Adding nexthop to the datastructures * failed. Call destructor w/o waiting for @@ -693,6 +722,22 @@ memset(&nh->gw_buf[nh->gw_sa.sa_len], 0, sizeof(nh->gw_buf) - nh->gw_sa.sa_len); } +bool +nhop_check_gateway(int upper_family, int neigh_family) +{ + if (upper_family == neigh_family) + return (true); + else if (neigh_family == AF_UNSPEC || neigh_family == AF_LINK) + return (true); +#if defined(INET) && defined(INET6) + else if (upper_family == AF_INET && neigh_family == AF_INET6 && + rib_can_4o6_nhop()) + return (true); +#endif + else + return (false); +} + /* * Sets gateway for the nexthop. * It can be "normal" gateway with is_gw set or a special form of @@ -707,6 +752,14 @@ gw->sa_family, gw->sa_len); return (false); } + + if (!nhop_check_gateway(nh->nh_priv->nh_upper_family, gw->sa_family)) { + FIB_NH_LOG(LOG_DEBUG, nh, + "error: invalid dst/gateway family combination (%d, %d)", + nh->nh_priv->nh_upper_family, gw->sa_family); + return (false); + } + memcpy(&nh->gw_sa, gw, gw->sa_len); memset(&nh->gw_buf[gw->sa_len], 0, sizeof(nh->gw_buf) - gw->sa_len); @@ -723,6 +776,20 @@ return (true); } +bool +nhop_set_upper_family(struct nhop_object *nh, int family) +{ + if (!nhop_check_gateway(nh->nh_priv->nh_upper_family, family)) { + FIB_NH_LOG(LOG_DEBUG, nh, + "error: invalid upper/neigh family combination (%d, %d)", + nh->nh_priv->nh_upper_family, family); + return (false); + } + + nh->nh_priv->nh_upper_family = family; + return (true); +} + void nhop_set_broadcast(struct nhop_object *nh, bool is_broadcast) { @@ -780,6 +847,18 @@ return (nh->nh_priv->nh_idx); } +uint32_t +nhop_get_uidx(const struct nhop_object *nh) +{ + return (nh->nh_priv->nh_uidx); +} + +void +nhop_set_uidx(struct nhop_object *nh, uint32_t uidx) +{ + nh->nh_priv->nh_uidx = uidx; +} + enum nhop_type nhop_get_type(const struct nhop_object *nh) { @@ -918,7 +997,7 @@ nh->nh_priv->nh_expire = expire; } -static struct rib_head * +struct rib_head * nhop_get_rh(const struct nhop_object *nh) { uint32_t fibnum = nhop_get_fibnum(nh); diff --git a/sys/net/route/nhop_utils.h b/sys/net/route/nhop_utils.h --- a/sys/net/route/nhop_utils.h +++ b/sys/net/route/nhop_utils.h @@ -139,6 +139,11 @@ for (_x = CHT_FIRST(_head, _i); _x; _x = _PX##_next(_x)) #define CHT_SLIST_FOREACH_END } +#define CHT_SLIST_FOREACH_SAFE(_head, _PX, _x, _tmp) \ + for (uint32_t _i = 0; _i < (_head)->hash_size; _i++) { \ + for (_x = CHT_FIRST(_head, _i); (_tmp = _PX##_next(_x), _x); _x = _tmp) +#define CHT_SLIST_FOREACH_SAFE_END } + #define CHT_SLIST_RESIZE(_head, _PX, _new_void_ptr, _new_hsize) \ uint32_t _new_idx; \ typeof((_head)->ptr) _new_ptr = (void *)_new_void_ptr; \ diff --git a/sys/net/route/nhop_var.h b/sys/net/route/nhop_var.h --- a/sys/net/route/nhop_var.h +++ b/sys/net/route/nhop_var.h @@ -79,6 +79,7 @@ uint16_t nh_type; /* nexthop type */ uint32_t rt_flags; /* routing flags for the control plane */ uint32_t nh_expire; /* path expiration time */ + uint32_t nh_uidx; /* userland-provided index */ /* nhop lookup comparison end */ uint32_t nh_idx; /* nexthop index */ uint32_t nh_fibnum; /* nexthop fib */ diff --git a/sys/net/route/route_ctl.h b/sys/net/route/route_ctl.h --- a/sys/net/route/route_ctl.h +++ b/sys/net/route/route_ctl.h @@ -35,6 +35,8 @@ #ifndef _NET_ROUTE_ROUTE_CTL_H_ #define _NET_ROUTE_ROUTE_CTL_H_ +#include + struct rib_cmd_info { uint8_t rc_cmd; /* RTM_ADD|RTM_DEL|RTM_CHANGE */ uint8_t spare[3]; @@ -130,6 +132,7 @@ bool rt_is_host(const struct rtentry *rt); sa_family_t rt_get_family(const struct rtentry *); struct nhop_object *rt_get_raw_nhop(const struct rtentry *rt); +void rt_get_rnd(const struct rtentry *rt, struct route_nhop_data *rnd); #ifdef INET struct in_addr; void rt_get_inet_prefix_plen(const struct rtentry *rt, struct in_addr *paddr, @@ -160,6 +163,8 @@ const struct weightened_nhop *nhgrp_get_nhops(const struct nhgrp_object *nhg, uint32_t *pnum_nhops); uint32_t nhgrp_get_count(struct rib_head *rh); +int nhgrp_get_group(struct rib_head *rh, struct weightened_nhop *wn, int num_nhops, + uint32_t uidx, struct nhgrp_object **pnhg); /* Route subscriptions */ enum rib_subscription_type { @@ -184,4 +189,31 @@ void rib_notify(struct rib_head *rnh, enum rib_subscription_type type, struct rib_cmd_info *rc); +/* Event bridge */ + +/* Types of events */ +#define NLBR_EVENT_ROUTE 1 + +/* Event providers */ +#define NLBR_PROVIDER_KERNEL 1 +#define NLBR_PROVIDER_RTSOCK 2 +#define NLBR_PROVIDER_NETLINK 3 + +struct rib_event_bridge; +typedef void rib_event_bridge_cb_t(uint32_t event_type, uint32_t fibnum, + const struct rt_addrinfo *info, const struct rib_cmd_info *rc, void *arg); + +struct rib_event_bridge { + rib_event_bridge_cb_t *reb_cb; + void *reb_cb_arg; + int reb_provider_id; + CK_STAILQ_ENTRY(rib_event_bridge) reb_link; +}; +void rib_bridge_generic_event(int provider_id, uint32_t event_type, uint32_t val1, + void *ptr1, void *ptr2); +void rib_bridge_rt_event(int provider_id, uint32_t fibnum, struct rt_addrinfo *info, + struct rib_cmd_info *rc); +void rib_bridge_link(struct rib_event_bridge *reb); +void rib_bridge_unlink(struct rib_event_bridge *reb); + #endif diff --git a/sys/net/route/route_ctl.c b/sys/net/route/route_ctl.c --- a/sys/net/route/route_ctl.c +++ b/sys/net/route/route_ctl.c @@ -59,7 +59,7 @@ #define DEBUG_MOD_NAME route_ctl #define DEBUG_MAX_LEVEL LOG_DEBUG #include -_DECLARE_DEBUG(LOG_INFO); +_DECLARE_DEBUG(LOG_DEBUG); /* * This file contains control plane routing tables functions. @@ -134,7 +134,7 @@ #if defined(INET) && defined(INET6) FEATURE(ipv4_rfc5549_support, "Route IPv4 packets via IPv6 nexthops"); #define V_rib_route_ipv6_nexthop VNET(rib_route_ipv6_nexthop) -VNET_DEFINE(u_int, rib_route_ipv6_nexthop) = 1; +VNET_DEFINE_STATIC(u_int, rib_route_ipv6_nexthop) = 1; SYSCTL_UINT(_net_route, OID_AUTO, ipv6_nexthop, CTLFLAG_RW | CTLFLAG_VNET, &VNET_NAME(rib_route_ipv6_nexthop), 0, "Enable IPv4 route via IPv6 Next Hop address"); #endif @@ -157,16 +157,10 @@ } #if defined(INET) && defined(INET6) -static bool -rib_can_ipv6_nexthop_address(struct rib_head *rh) +bool +rib_can_4o6_nhop(void) { - int result; - - CURVNET_SET(rh->rib_vnet); - result = !!V_rib_route_ipv6_nexthop; - CURVNET_RESTORE(); - - return (result); + return (!!V_rib_route_ipv6_nexthop); } #endif @@ -716,30 +710,6 @@ return (error); } -/* - * Checks if @dst and @gateway is valid combination. - * - * Returns true if is valid, false otherwise. - */ -static bool -check_gateway(struct rib_head *rnh, struct sockaddr *dst, - struct sockaddr *gateway) -{ - if (dst->sa_family == gateway->sa_family) - return (true); - else if (gateway->sa_family == AF_UNSPEC) - return (true); - else if (gateway->sa_family == AF_LINK) - return (true); -#if defined(INET) && defined(INET6) - else if (dst->sa_family == AF_INET && gateway->sa_family == AF_INET6 && - rib_can_ipv6_nexthop_address(rnh)) - return (true); -#endif - else - return (false); -} - static int add_route_byinfo(struct rib_head *rnh, struct rt_addrinfo *info, struct rib_cmd_info *rc) @@ -758,7 +728,7 @@ FIB_RH_LOG(LOG_DEBUG, rnh, "error: RTF_GATEWAY set with empty gw"); return (EINVAL); } - if (dst && gateway && !check_gateway(rnh, dst, gateway)) { + if (dst && gateway && !nhop_check_gateway(dst->sa_family, gateway->sa_family)) { FIB_RH_LOG(LOG_DEBUG, rnh, "error: invalid dst/gateway family combination (%d, %d)", dst->sa_family, gateway->sa_family); @@ -1181,7 +1151,7 @@ wn_new[found_idx].nh = nh_new; wn_new[found_idx].weight = get_info_weight(info, wn[found_idx].weight); - error = nhgrp_get_group(rnh, wn_new, num_nhops, &rnd_new.rnd_nhgrp); + error = nhgrp_get_group(rnh, wn_new, num_nhops, 0, &rnd_new.rnd_nhgrp); nhop_free(nh_new); free(wn_new, M_TEMP); @@ -1592,3 +1562,63 @@ } return ("unknown"); } + +CK_STAILQ_HEAD(rib_event_bridge_head, rib_event_bridge); +static struct rib_event_bridge_head bridge_head; +struct mtx bridge_lock; + +static void +rib_bridge_init(void) +{ + CK_STAILQ_INIT(&bridge_head); + mtx_init(&bridge_lock, "rib_event_bridge_lock", NULL, MTX_DEF); +} +SYSINIT(rib_bridge_init, SI_SUB_PROTO_DOMAIN, SI_ORDER_SECOND, rib_bridge_init, NULL); + + +void +rib_bridge_generic_event(int provider_id, uint32_t event_type, uint32_t val1, + void *ptr1, void *ptr2) +{ + struct rib_event_bridge *reb; + + NET_EPOCH_ASSERT(); + + CK_STAILQ_FOREACH(reb, &bridge_head, reb_link) { + RT_LOG(LOG_DEBUG3, "HERE reb %p %d", reb, reb->reb_provider_id); + if (reb->reb_provider_id != provider_id) + reb->reb_cb(event_type, val1, ptr1, ptr2, reb->reb_cb_arg); + } +} + +void +rib_bridge_rt_event(int provider_id, uint32_t fibnum, struct rt_addrinfo *info, + struct rib_cmd_info *rc) +{ +#if DEBUG_MAX_LEVEL >= LOG_DEBUG2 + char rtbuf[INET6_ADDRSTRLEN + 5]; + FIB_LOG(LOG_DEBUG3, fibnum, rt_get_family(rc->rc_rt), "received cmd %s for %s", + rib_print_cmd(rc->rc_cmd), rt_print_buf(rc->rc_rt, rtbuf, sizeof(rtbuf))); +#endif + rib_bridge_generic_event(provider_id, NLBR_EVENT_ROUTE, fibnum, info, rc); +} + + +void +rib_bridge_link(struct rib_event_bridge *reb) +{ + mtx_lock(&bridge_lock); + CK_STAILQ_INSERT_HEAD(&bridge_head, reb, reb_link); + mtx_unlock(&bridge_lock); + RT_LOG(LOG_DEBUG, "link %p", reb); +} + +void +rib_bridge_unlink(struct rib_event_bridge *reb) +{ + mtx_lock(&bridge_lock); + CK_STAILQ_REMOVE(&bridge_head, reb, rib_event_bridge, reb_link); + mtx_unlock(&bridge_lock); + RT_LOG(LOG_DEBUG, "unlink %p", reb); +} + diff --git a/sys/net/route/route_debug.h b/sys/net/route/route_debug.h --- a/sys/net/route/route_debug.h +++ b/sys/net/route/route_debug.h @@ -83,6 +83,8 @@ #define _output printf #define _DEBUG_PASS_MSG(_l) (DEBUG_VAR_NAME >= (_l)) +#define IF_DEBUG_LEVEL(_l) if ((DEBUG_MAX_LEVEL >= (_l)) && (__predict_false(DEBUG_VAR_NAME >= (_l)))) + /* * Logging for events specific for particular family and fib * Example: [nhop_neigh] inet.0 find_lle: nhop nh#4/inet/vtnet0/10.0.0.1: mapped to lle NULL @@ -155,6 +157,7 @@ struct llentry; struct nhop_neigh; struct rtentry; +struct ifnet; #define NHOP_PRINT_BUFSIZE 48 char *nhop_print_buf(const struct nhop_object *nh, char *buf, size_t bufsize); diff --git a/sys/net/route/route_rtentry.c b/sys/net/route/route_rtentry.c --- a/sys/net/route/route_rtentry.c +++ b/sys/net/route/route_rtentry.c @@ -192,6 +192,13 @@ return (rt->rt_nhop); } +void +rt_get_rnd(const struct rtentry *rt, struct route_nhop_data *rnd) +{ + rnd->rnd_nhop = rt->rt_nhop; + rnd->rnd_weight = rt->rt_weight; +} + #ifdef INET /* * Stores IPv4 address and prefix length of @rt inside diff --git a/sys/net/route/route_var.h b/sys/net/route/route_var.h --- a/sys/net/route/route_var.h +++ b/sys/net/route/route_var.h @@ -228,6 +228,7 @@ bool match_nhop_gw(const struct nhop_object *nh, const struct sockaddr *gw); int check_info_match_nhop(const struct rt_addrinfo *info, const struct rtentry *rt, const struct nhop_object *nh); +bool rib_can_4o6_nhop(void); /* route_rtentry.c */ void vnet_rtzone_init(void); @@ -255,6 +256,7 @@ struct nhop_object *nhop_get_nhop_internal(struct rib_head *rnh, struct nhop_object *nh, int *perror); +bool nhop_check_gateway(int upper_family, int neigh_family); int nhop_create_from_info(struct rib_head *rnh, struct rt_addrinfo *info, struct nhop_object **nh_ret); @@ -304,8 +306,6 @@ /* nhgrp_ctl.c */ int nhgrp_dump_sysctl(struct rib_head *rh, struct sysctl_req *w); -int nhgrp_get_group(struct rib_head *rh, struct weightened_nhop *wn, - int num_nhops, struct nhgrp_object **pnhg); int nhgrp_get_filtered_group(struct rib_head *rh, const struct rtentry *rt, const struct nhgrp_object *src, rib_filter_f_t flt_func, void *flt_data, struct route_nhop_data *rnd); diff --git a/sys/net/rtsock.c b/sys/net/rtsock.c --- a/sys/net/rtsock.c +++ b/sys/net/rtsock.c @@ -1074,6 +1074,7 @@ } error = rib_action(fibnum, rtm->rtm_type, &info, &rc); if (error == 0) { + rib_bridge_rt_event(NLBR_PROVIDER_RTSOCK, fibnum, &info, &rc); #ifdef ROUTE_MPATH if (NH_IS_NHGRP(rc.rc_nh_new) || (rc.rc_nh_old && NH_IS_NHGRP(rc.rc_nh_old))) { @@ -1095,6 +1096,7 @@ case RTM_DELETE: error = rib_action(fibnum, RTM_DELETE, &info, &rc); if (error == 0) { + rib_bridge_rt_event(NLBR_PROVIDER_RTSOCK, fibnum, &info, &rc); #ifdef ROUTE_MPATH if (NH_IS_NHGRP(rc.rc_nh_old) || (rc.rc_nh_new && NH_IS_NHGRP(rc.rc_nh_new))) { diff --git a/sys/netlink/netlink.h b/sys/netlink/netlink.h new file mode 100644 --- /dev/null +++ b/sys/netlink/netlink.h @@ -0,0 +1,232 @@ +/*- + * SPDX-License-Identifier: BSD-2-Clause-FreeBSD + * + * Copyright (c) 2021 Ng Peng Nam Sean + * 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. + */ + +/* + * This file contains structures and constants for RFC 3549 (Netlink) + * protocol. Some values have been taken from Linux implementation. + */ + +#ifndef _NETLINK_LINUX_NETLINK_H_ +#define _NETLINK_LINUX_NETLINK_H_ + +#ifndef _KERNEL +#ifndef PF_NETLINK +#define PF_NETLINK 38 +#endif +#ifndef AF_NETLINK +#define AF_NETLINK 38 +#endif +#ifndef AF_MPLS +#define AF_MPLS 39 +#endif +#endif + +#include +#include + +struct sockaddr_nl { + uint8_t nl_len; /* total length */ + sa_family_t nl_family; /* AF_NETLINK */ + uint16_t nl_pad; /* zero */ + uint32_t nl_pid; /* port ID */ + uint32_t nl_groups; /* multicast groups mask */ +}; + +#define SOL_NETLINK 270 + +/* Currently supported socket options */ +#define NETLINK_ADD_MEMBERSHIP 1 +#define NETLINK_DROP_MEMBERSHIP 2 +#define NETLINK_PKTINFO 3 /* XXX: not supported */ +#define NETLINK_BROADCAST_ERROR 4 /* XXX: not supported */ +#define NETLINK_NO_ENOBUFS 5 /* XXX: not supported */ +#define NETLINK_RX_RING 6 /* XXX: not supported */ +#define NETLINK_TX_RING 7 /* XXX: not supported */ +#define NETLINK_LISTEN_ALL_NSID 8 /* XXX: not supported */ + +#define NETLINK_LIST_MEMBERSHIPS 9 +#define NETLINK_CAP_ACK 10 +#define NETLINK_EXT_ACK 11 +#define NETLINK_GET_STRICT_CHK 12 /* XXX: not supported */ + + +/* + * RFC 3549, 2.3.2 Netlink Message Header + */ +struct nlmsghdr { + uint32_t nlmsg_len; /* Length of message including header */ + uint16_t nlmsg_type; /* Message type identifier */ + uint16_t nlmsg_flags; /* Flags (NLM_F_) */ + uint32_t nlmsg_seq; /* Sequence number */ + uint32_t nlmsg_pid; /* Sending process port ID */ +}; + +/* + * RFC 3549, 2.3.2.2 The ACK Netlink Message + */ +struct nlmsgerr { + int error; + struct nlmsghdr msg; +}; + +/* + * RFC 3549, 2.3.2 standard flag bits (nlmsg_flags) + */ +#define NLM_F_REQUEST 0x01 /* It is request message. */ +#define NLM_F_MULTI 0x02 /* Multipart message, terminated by NLMSG_DONE */ +#define NLM_F_ACK 0x04 /* Reply with ack, with zero or error code */ +#define NLM_F_ECHO 0x08 /* Echo this request */ +#define NLM_F_DUMP_INTR 0x10 /* Dump was inconsistent due to sequence change */ +#define NLM_F_DUMP_FILTERED 0x20 /* Dump was filtered as requested */ + +/* + * RFC 3549, 2.3.2 Additional flag bits for GET requests + */ +#define NLM_F_ROOT 0x100 /* Return the complete table */ +#define NLM_F_MATCH 0x200 /* Return all entries matching criteria */ +#define NLM_F_ATOMIC 0x400 /* Return an atomic snapshot (ignored) */ +#define NLM_F_DUMP (NLM_F_ROOT | NLM_F_MATCH) + +/* + * RFC 3549, 2.3.2 Additional flag bits for NEW requests + */ +#define NLM_F_REPLACE 0x100 /* Replace existing matching config object */ +#define NLM_F_EXCL 0x200 /* Don't replace the object if exists */ +#define NLM_F_CREATE 0x400 /* Create if it does not exist */ +#define NLM_F_APPEND 0x800 /* Add to end of list */ + +/* Modifiers to DELETE requests */ +#define NLM_F_NONREC 0x100 /* Do not delete recursively */ + +/* Flags for ACK message */ +#define NLM_F_CAPPED 0x100 /* request was capped */ +#define NLM_F_ACK_TLVS 0x200 /* extended ACK TVLs were included */ + +/* + * RFC 3549, 2.3.2 standard message types (nlmsg_type). + */ +#define NLMSG_NOOP 0x1 /* Message is ignored. */ +#define NLMSG_ERROR 0x2 /* reply error code reporting */ +#define NLMSG_DONE 0x3 /* Message terminates a multipart message. */ +#define NLMSG_OVERRUN 0x4 /* overrun detected, data is lost */ + +#define NLMSG_MIN_TYPE 0x10 /* < 0x10: reserved control messages */ + +/* + * Defition of numbers assigned to the netlink subsystems. + */ +#define NETLINK_ROUTE 0 /* Routing/device hook */ +#define NETLINK_UNUSED 1 /* not supported */ +#define NETLINK_USERSOCK 2 /* Reserved for user mode socket protocols (not supported) */ +#define NETLINK_FIREWALL 3 /* (not supported) */ +#define NETLINK_SOCK_DIAG 4 /* socket monitoring (not supported) */ +#define NETLINK_NFLOG 5 /* netfilter/iptables ULOG (not supported) */ +#define NETLINK_XFRM 6 /* ipsec (not supported) */ +#define NETLINK_SELINUX 7 /* SELinux event notifications (not supported) */ +#define NETLINK_ISCSI 8 /* Open-iSCSI (not supported) */ +#define NETLINK_AUDIT 9 /* auditing (not supported) */ +#define NETLINK_FIB_LOOKUP 10 /* not supported */ +#define NETLINK_CONNECTOR 11 /* not supported */ +#define NETLINK_NETFILTER 12 /* netfilter subsystem (not supported) */ +#define NETLINK_IP6_FW 13 /* not supporterd */ +#define NETLINK_DNRTMSG 14 /* DECnet routing messages (not supported ) */ +#define NETLINK_KOBJECT_UEVENT 15 /* Kernel messages to userspace (not supported) */ +#define NETLINK_GENERIC 16 /* not supported */ + + +#ifndef roundup2 +#define roundup2(x, y) (((x)+((y)-1))&(~((y)-1))) /* if y is powers of two */ +#endif +#define NL_ITEM_ALIGN_SIZE sizeof(uint32_t) +#define NL_ITEM_ALIGN(_len) roundup2(_len, NL_ITEM_ALIGN_SIZE) +#define NL_ITEM_DATA(_ptr, _off) ((void *)((char *)(_ptr) + _off)) +#define NL_ITEM_DATA_CONST(_ptr, _off) ((const void *)((const char *)(_ptr) + _off)) + +#define NL_ITEM_OK(_ptr, _len, _hlen, _LEN_M) \ + ((_len) >= _hlen && _LEN_M(_ptr) >= _hlen && _LEN_M(_ptr) <= (_len)) +#define NL_ITEM_NEXT(_ptr, _LEN_M) ((typeof(_ptr))((char *)(_ptr) + _LEN_M(_ptr))) +#define NL_ITEM_ITER(_ptr, _len, _LEN_MACRO) \ + ((_len) -= _LEN_MACRO(_ptr), NL_ITEM_NEXT(_ptr, _LEN_MACRO)) + + +#ifndef _KERNEL +/* part of netlink(3) API */ +#define NLMSG_ALIGNTO NL_ITEM_ALIGN_SIZE +#define NLMSG_ALIGN(_len) NL_ITEM_ALIGN(_len) +#define NLMSG_HDRLEN ((int)sizeof(struct nlmsghdr)) +#define NLMSG_LENGTH(_len) ((_len) + NLMSG_HDRLEN) +#define NLMSG_SPACE(len) NLMSG_ALIGN(NLMSG_LENGTH(_len)) +#define NLMSG_DATA(_hdr) NL_ITEM_DATA(_hdr, NLMSG_HDRLEN) +#define _NLMSG_LEN(_hdr) ((int)(_hdr)->nlmsg_len) +#define _NLMSG_ALIGNED_LEN(_hdr) NLMSG_ALIGN(_NLMSG_LEN(_hdr)) +#define NLMSG_OK(_hdr, _len) NL_ITEM_OK(_hdr, _len, NLMSG_HDRLEN, _NLMSG_LEN) +#define NLMSG_PAYLOAD(_hdr,_len) (_NLMSG_LEN(_hdr) - NLMSG_SPACE((_len))) +#define NLMSG_NEXT(_hdr, _len) NL_ITEM_ITER(_hdr, _len, _NLMSG_ALIGNED_LEN) + +#else +#define NLMSG_ALIGNTO 4U +#define NLMSG_ALIGN(len) (((len) + NLMSG_ALIGNTO - 1) & ~(NLMSG_ALIGNTO - 1)) +#define NLMSG_HDRLEN ((int)NLMSG_ALIGN(sizeof(struct nlmsghdr))) +#endif + +/* + * Base netlink attribute TLV header. + */ +struct nlattr { + uint16_t nla_len; /* Total attribute length */ + uint16_t nla_type; /* Attribute type */ +}; + +/* + * + * nl_type field enconding: + * + * 0 1 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * |N|O| Attribute type | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * N - attribute contains other attributes + * O - encoded in network byte order + * Note: N & O are mutually exclusive + * + * Note: attribute type value scope normally is per-message + * or per message group. + */ + +#define NLA_F_NESTED (1 << 15) +#define NLA_F_NET_BYTEORDER (1 << 14) +#define NLA_TYPE_MASK ~(NLA_F_NESTED | NLA_F_NET_BYTEORDER) + +#ifndef _KERNEL +#define NLA_ALIGNTO NL_ITEM_ALIGN_SIZE +#define NLA_ALIGN(_len) NL_ITEM_ALIGN(_len) +#define NLA_HDRLEN ((int)sizeof(struct nlattr)) +#endif + +#endif diff --git a/sys/netlink/netlink_ctl.h b/sys/netlink/netlink_ctl.h new file mode 100644 --- /dev/null +++ b/sys/netlink/netlink_ctl.h @@ -0,0 +1,344 @@ +/*- + * SPDX-License-Identifier: BSD-2-Clause-FreeBSD + * + * Copyright (c) 2021 Ng Peng Nam Sean + * 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. + */ + +#ifndef _NETLINK_NETLINK_CTL_H_ +#define _NETLINK_NETLINK_CTL_H_ + +/* + * This file provides headers for the public KPI of the netlink + * subsystem + */ + +MALLOC_DECLARE(M_NETLINK); + +/* + * Macro for handling attribute TLVs + */ +#define _roundup2(x, y) (((x)+((y)-1))&(~((y)-1))) + +#define NETLINK_ALIGN_SIZE sizeof(uint32_t) +#define NETLINK_ALIGN(_len) _roundup2(_len, NETLINK_ALIGN_SIZE) + +#define NLA_ALIGN_SIZE sizeof(uint32_t) +#define NLA_ALIGN(_len) _roundup2(_len, NLA_ALIGN_SIZE) +#define NLA_HDRLEN ((int)sizeof(struct nlattr)) +#define NLA_DATA_LEN(_nla) ((int)((_nla)->nla_len - NLA_HDRLEN)) +#define NLA_DATA(_nla) NL_ITEM_DATA(_nla, NLA_HDRLEN) +#define NLA_DATA_CONST(_nla) NL_ITEM_DATA_CONST(_nla, NLA_HDRLEN) + +#define NLA_TYPE(_nla) ((_nla)->nla_type & 0x3FFF) + +#define NLA_NEXT(_attr) (struct nlattr *)((char *)_attr + NLA_ALIGN(_attr->nla_len)) + +#define _NLA_END(_start, _len) ((char *)(_start) + (_len)) +#define NLA_FOREACH(_attr, _start, _len) \ + for (_attr = (_start); \ + ((char *)_attr < _NLA_END(_start, _len)) && \ + ((char *)NLA_NEXT(_attr) <= _NLA_END(_start, _len)); \ + _attr = NLA_NEXT(_attr)) + +/* + (NLA_ALIGN(_attr->nla_len) >= NLA_HDRLEN) && \ +*/ + +struct mbuf; +struct nlmsg_state; +typedef bool nlmsg_state_cb(struct nlmsg_state *ns, void *buf, int buflen, int cnt); + +struct nlmsg_state { + int alloc_len; /* allocated buffer length */ + int offset; /* offset from the start of the buffer */ + struct nlmsghdr *hdr; /* Pointer to the currently-filled msg */ + char *data; /* pointer to the contiguous storage */ + void *_storage; /* Underlying storage pointer */ + nlmsg_state_cb *cb; /* Callback to flush data */ + void *arg; /* Callback argument */ + int num_messages; /* Number of messages in the buffer */ + int malloc_flag; /* M_WAITOK or M_NOWAIT */ + uint8_t writer_type; /* NS_WRITER_TYPE_* */ + uint8_t writer_target; /* NS_WRITER_TARGET_* */ + bool ignore_limit; /* If true, ignores RCVBUF limit */ +}; +#define NS_WRITER_TARGET_SOCKET 0 +#define NS_WRITER_TARGET_GROUP 1 +#define NS_WRITER_TARGET_CHAIN 2 + +#define NS_WRITER_TYPE_MBUF 0 +#define NS_WRITER_TYPE_BUF 1 +#define NS_WRITER_TYPE_LBUF 2 +#define NS_WRITER_TYPE_MBUFC 3 + + +#define NLMSG_SMALL 128 +#define NLMSG_LARGE 2048 + +/* Message and attribute writing */ + +struct nlpcb; +bool nlmsg_get_socket_writer(int size, struct nlpcb *nlp, struct nlmsg_state *ns); +bool nlmsg_get_group_writer(int size, uint32_t group_mask, struct nlmsg_state *ns); +bool nlmsg_get_chain_writer(int size, struct mbuf **pm, struct nlmsg_state *ns); +bool nlmsg_flush(struct nlmsg_state *ns); +void nlmsg_ignore_limit(struct nlmsg_state *ns); + +bool nlmsg_refill_buffer(struct nlmsg_state *ns, int required_size); +bool nlmsg_add(struct nlmsg_state *ns, uint32_t portid, uint32_t seq, uint16_t type, + uint16_t flags, uint32_t len); +void nlmsg_end(struct nlmsg_state *ns); +void nlmsg_abort(struct nlmsg_state *ns); + +bool nlmsg_end_dump(struct nlmsg_state *ns, int error, struct nlmsghdr *hdr); + +static inline bool +nlmsg_reply(struct nlmsg_state *ns, const struct nlmsghdr *hdr, int payload_len) +{ + return (nlmsg_add(ns, hdr->nlmsg_pid, hdr->nlmsg_seq, hdr->nlmsg_type, + hdr->nlmsg_flags, payload_len)); +} + +#define nlmsg_data(_hdr) ((void *)((_hdr) + 1)) + +/* + * KPI similar to mtodo(): + * current (uncompleted) header is guaranteed to be contiguous, + * but can be reallocated, thus pointers may need to be readjusted. + */ +static inline int +nlattr_save_offset(const struct nlmsg_state *ns) +{ + return (ns->offset - ((char *)ns->hdr - ns->data)); +} + +static inline void * +_nlattr_restore_offset(const struct nlmsg_state *ns, int off) +{ + return ((void *)((char *)ns->hdr + off)); +} +#define nlattr_restore_offset(_ns, _off, _t) ((_t *)_nlattr_restore_offset(_ns, _off)) + +static inline void * +nlmsg_reserve_data_raw(struct nlmsg_state *ns, size_t sz) +{ + if (__predict_false(ns->offset + NETLINK_ALIGN(sz) > ns->alloc_len)) { + if (!nlmsg_refill_buffer(ns, NETLINK_ALIGN(sz))) + return (NULL); + } + + void *data_ptr = &ns->data[ns->offset]; + ns->offset += NLMSG_ALIGN(sz); + + return (data_ptr); +} +#define nlmsg_reserve_object(_ns, _t) ((_t *)nlmsg_reserve_data_raw(_ns, NLA_ALIGN(sizeof(_t)))) +#define nlmsg_reserve_data(_ns, _sz, _t) ((_t *)nlmsg_reserve_data_raw(_ns, _sz)) + +static inline void * +_nlmsg_reserve_attr(struct nlmsg_state *ns, uint16_t nla_type, uint16_t sz) +{ + sz += sizeof(struct nlattr); + + struct nlattr *nla = nlmsg_reserve_data(ns, sz, struct nlattr); + if (__predict_false(nla == NULL)) + return (NULL); + nla->nla_type = nla_type; + nla->nla_len = sz; + + return ((void *)(nla + 1)); +} +#define nlmsg_reserve_attr(_ns, _at, _t) ((_t *)_nlmsg_reserve_attr(_ns, _at, NLA_ALIGN(sizeof(_t)))) + +static inline bool +nlattr_add(struct nlmsg_state *ns, int attr_type, int attr_len, const void *data) +{ + int required_len = NLA_ALIGN(attr_len + sizeof(struct nlattr)); + + if (__predict_false(ns->offset + required_len > ns->alloc_len)) { + if (!nlmsg_refill_buffer(ns, required_len)) + return (false); + } + + struct nlattr *nla = (struct nlattr *)(&ns->data[ns->offset]); + + nla->nla_len = attr_len + sizeof(struct nlattr); + nla->nla_type = attr_type; + if (attr_len > 0) + memcpy((nla + 1), data, attr_len); + ns->offset += required_len; + return (true); +} + +static inline bool +nlattr_add_u8(struct nlmsg_state *ns, int attrtype, uint8_t value) +{ + return (nlattr_add(ns, attrtype, sizeof(uint8_t), &value)); +} + +static inline bool +nlattr_add_u16(struct nlmsg_state *ns, int attrtype, uint16_t value) +{ + return (nlattr_add(ns, attrtype, sizeof(uint16_t), &value)); +} + +static inline bool +nlattr_add_u32(struct nlmsg_state *ns, int attrtype, uint32_t value) +{ + return (nlattr_add(ns, attrtype, sizeof(uint32_t), &value)); +} + +static inline bool +nlattr_add_u64(struct nlmsg_state *ns, int attrtype, uint64_t value) +{ + return (nlattr_add(ns, attrtype, sizeof(uint64_t), &value)); +} + +static inline bool +nlattr_add_s8(struct nlmsg_state *ns, int attrtype, int8_t value) +{ + return (nlattr_add(ns, attrtype, sizeof(int8_t), &value)); +} + +static inline bool +nlattr_add_s16(struct nlmsg_state *ns, int attrtype, int16_t value) +{ + return (nlattr_add(ns, attrtype, sizeof(int16_t), &value)); +} + +static inline bool +nlattr_add_s32(struct nlmsg_state *ns, int attrtype, int32_t value) +{ + return (nlattr_add(ns, attrtype, sizeof(int32_t), &value)); +} + +static inline bool +nlattr_add_s64(struct nlmsg_state *ns, int attrtype, int64_t value) +{ + return (nlattr_add(ns, attrtype, sizeof(int64_t), &value)); +} + +static inline bool +nlattr_add_flag(struct nlmsg_state *ns, int attrtype) +{ + return (nlattr_add(ns, attrtype, 0, NULL)); +} + +static inline bool +nlattr_add_string(struct nlmsg_state *ns, int attrtype, const char *str) +{ + return (nlattr_add(ns, attrtype, strlen(str) + 1, str)); +} + +/* Attribute reading */ + +/* netlink_attr_helpers.c */ +struct netlink_parse_tracker; + +typedef int parse_attr_f(struct nlattr *attr, struct netlink_parse_tracker *npt, + void *target); +struct nlattr_parser { + uint16_t type; /* Attribute type */ + uint16_t off; /* field offset in the target structure */ + parse_attr_f *cb; /* parser function to call */ +}; + +int nl_parse_attrs_raw(struct nlattr *nla_head, int len, struct nlattr_parser *ps, + int pslen, struct netlink_parse_tracker *npt, void *target); +int nl_parse_attrs(struct nlmsghdr *hdr, int hdrlen, struct nlattr_parser *ps, + int pslen, struct netlink_parse_tracker *npt, void *target); + +int nlattr_get_flag(struct nlattr *nla, struct netlink_parse_tracker *npt, + void *target); +int nlattr_get_ip(struct nlattr *nla, struct netlink_parse_tracker *npt, + void *target); +int nlattr_get_uint32(struct nlattr *nla, struct netlink_parse_tracker *npt, + void *target); +int nlattr_get_ifindex(struct nlattr *nla, struct netlink_parse_tracker *npt, + void *target); +int nlattr_get_ipvia(struct nlattr *nla, struct netlink_parse_tracker *npt, + void *target); +int nlattr_get_string(struct nlattr *nla, struct netlink_parse_tracker *npt, + void *target); +int nlattr_get_nla(struct nlattr *nla, struct netlink_parse_tracker *npt, + void *target); + +/* Parsing state */ +struct linear_buffer { + char *base; /* Base allocated memory pointer */ + uint32_t offset; /* Currently used offset */ + uint32_t size; /* Total buffer size */ +}; + +static inline void * +lb_alloc(struct linear_buffer *lb, int len) +{ + len = roundup2(len, sizeof(uint64_t)); + if (lb->offset + len > lb->size) + return (NULL); + void *data = (void *)(lb->base + lb->offset); + lb->offset += len; + return (data); +} + +static inline void +lb_clear(struct linear_buffer *lb) +{ + memset(lb->base, 0, lb->size); + lb->offset = 0; +} + +#define SCRATCH_BUFFER_SIZE 1024 +struct netlink_parse_tracker { + struct linear_buffer lb; /* Per-message scratch buffer */ + struct nlpcb *nlp; /* Originator */ + struct nlmsg_state *ns; /* Message writer to use */ + int error; /* last operation error */ +}; + +static inline void * +npt_alloc(struct netlink_parse_tracker *npt, int len) +{ + return (lb_alloc(&npt->lb, len)); +} +#define npt_alloc_sockaddr(_npt, _len) ((struct sockaddr *)(npt_alloc(_npt, _len))) + + + +/* Protocol handlers */ +typedef int (*nl_handler_f)(struct nlmsghdr *hdr, struct netlink_parse_tracker *npt); + +bool netlink_register_proto(int proto, const char *proto_name, nl_handler_f handler); +bool netlink_unregister_proto(int proto); + +/* Generic */ +bool nl_has_listeners(int netlink_family, uint32_t groups_mask); +bool nlp_has_priv(struct nlpcb *nlp, int priv); +bool nlp_has_priv_route(struct nlpcb *nlp); + +/* Debug */ +uint32_t nlp_get_pid(const struct nlpcb *nlp); + +#endif diff --git a/sys/netlink/netlink_debug.h b/sys/netlink/netlink_debug.h new file mode 100644 --- /dev/null +++ b/sys/netlink/netlink_debug.h @@ -0,0 +1,80 @@ +/*- + * 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. + * 3. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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. + * + * $FreeBSD$ + */ + +#ifndef _NETLINK_NETLINK_DEBUG_H_ +#define _NETLINK_NETLINK_DEBUG_H_ + +#include + +/* + * Generic debug + * [nl_domain] func_name: debug text + */ +#define NL_DEBUG RT_DEBUG + +/* + * Logging for events specific for particular process + * Example: [nl_domain] PID 4834 fdump_sa: unsupported family: 45 + */ +#define NL_RAW_PID_LOG(_l, _pid, _fmt, ...) NL_RAW_PID_LOG_##_l(_l, _pid, _fmt, ## __VA_ARGS__) +#define _NL_RAW_PID_LOG(_l, _pid, _fmt, ...) if (_DEBUG_PASS_MSG(_l)) { \ + _output("[" DEBUG_PREFIX_NAME "] PID %u %s: " _fmt "\n", _pid, __func__, ##__VA_ARGS__); \ +} + +#define NLP_LOG(_l, _nlp, _fmt, ...) NL_RAW_PID_LOG_##_l(_l, nlp_get_pid(_nlp), _fmt, ## __VA_ARGS__) + +#if DEBUG_MAX_LEVEL>=LOG_DEBUG3 +#define NL_RAW_PID_LOG_LOG_DEBUG3 _NL_RAW_PID_LOG +#else +#define NL_RAW_PID_LOG_LOG_DEBUG3(_l, _pid, _fmt, ...) +#endif +#if DEBUG_MAX_LEVEL>=LOG_DEBUG2 +#define NL_RAW_PID_LOG_LOG_DEBUG2 _NL_RAW_PID_LOG +#else +#define NL_RAW_PID_LOG_LOG_DEBUG2(_l, _pid, _fmt, ...) +#endif +#if DEBUG_MAX_LEVEL>=LOG_DEBUG +#define NL_RAW_PID_LOG_LOG_DEBUG _NL_RAW_PID_LOG +#else +#define NL_RAW_PID_LOG_LOG_DEBUG(_l, _pid, _fmt, ...) +#endif +#if DEBUG_MAX_LEVEL>=LOG_INFO +#define NL_RAW_PID_LOG_LOG_INFO _NL_RAW_PID_LOG +#else +#define NL_RAW_PID_LOG_LOG_INFO(_l, _pid, _fmt, ...) +#endif +#define NL_RAW_PID_LOG_LOG_NOTICE _NL_RAW_PID_LOG +#define NL_RAW_PID_LOG_LOG_ERR _NL_RAW_PID_LOG +#define NL_RAW_PID_LOG_LOG_WARNING _NL_RAW_PID_LOG + + + +#endif diff --git a/sys/netlink/netlink_domain.c b/sys/netlink/netlink_domain.c new file mode 100644 --- /dev/null +++ b/sys/netlink/netlink_domain.c @@ -0,0 +1,635 @@ +/*- + * SPDX-License-Identifier: BSD-2-Clause-FreeBSD + * + * Copyright (c) 2021 Ng Peng Nam Sean + * 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. + */ + +/* + * This file contains socket and protocol bindings for netlink. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include /* priv_check */ + +#include +#include + +#include +#include +#include + +#define DEBUG_MOD_NAME nl_domain +#define DEBUG_MAX_LEVEL LOG_DEBUG3 +#include +_DECLARE_DEBUG(LOG_DEBUG); + + +static u_long nl_sendspace = NLSNDQ; +SYSCTL_ULONG(_net_netlink, OID_AUTO, sendspace, CTLFLAG_RW, &nl_sendspace, 0, + "Default netlink socket send space"); + +static u_long nl_recvspace = NLSNDQ; +SYSCTL_ULONG(_net_netlink, OID_AUTO, recvspace, CTLFLAG_RW, &nl_recvspace, 0, + "Default netlink socket receive space"); + +uint32_t +nlp_get_pid(const struct nlpcb *nlp) +{ + return (nlp->nl_process_id); +} + +/* + * Looks up a nlpcb struct based on the @portid. Need to claim nlsock_mtx. + * Returns nlpcb pointer if present else NULL + */ +static struct nlpcb * +nl_port_lookup(uint32_t port_id) +{ + struct nlpcb *nlp; + + CK_LIST_FOREACH(nlp, &V_nl_ctl->ctl_port_head, nl_port_next) { + if (nlp->nl_port == port_id) + return (nlp); + } + return (NULL); +} + +static void +nl_update_groups_locked(struct nlpcb *nlp, uint32_t nl_groups) +{ + /* Update group mask */ + RT_LOG(LOG_DEBUG2, "socket %p, groups 0x%X -> 0x%X", + nlp->nl_socket, nlp->nl_groups, nl_groups); + nlp->nl_groups = nl_groups; +} + +/* + * Broadcasts message @m to the one or more groups specified by + * @groups_mask. + */ +void +nl_send_group(struct mbuf *m, int num_messages, uint32_t groups_mask) +{ + struct nlpcb *nlp_last = NULL; + struct nlpcb *nlp; + NLCTL_TRACKER; + +#if DEBUG_MAX_LEVEL >= LOG_DEBUG2 + struct nlmsghdr *hdr = mtod(m, struct nlmsghdr *); + RT_LOG(LOG_DEBUG2, "MCAST mbuf len %u msg type %d len %u to groups 0x%X", + m->m_len, hdr->nlmsg_type, hdr->nlmsg_len, groups_mask); +#endif + + struct nl_control *ctl = atomic_load_ptr(&V_nl_ctl); + if (__predict_false(ctl == NULL)) { + /* + * Can be the case when notification is sent within VNET + * which doesn't have any netlink sockets. + */ + m_freem(m); + return; + } + + NLCTL_RLOCK(ctl); + + int io_flags = NL_IOF_UNTRANSLATED; + + CK_LIST_FOREACH(nlp, &ctl->ctl_pcb_head, nl_next) { + if (nlp->nl_groups & groups_mask) { + if (nlp_last != NULL) { + struct mbuf *m_copy; + m_copy = m_copym(m, 0, M_COPYALL, M_NOWAIT); + if (m_copy != NULL) + nl_send_one(m_copy, nlp_last, num_messages, io_flags); + else { + NLP_LOCK(nlp_last); + if (nlp_last->nl_socket != NULL) + sorwakeup(nlp_last->nl_socket); + NLP_UNLOCK(nlp_last); + } + } + nlp_last = nlp; + } + } + if (nlp_last != NULL) + nl_send_one(m, nlp_last, num_messages, io_flags); + else + m_freem(m); + + NLCTL_RUNLOCK(ctl); +} + +bool +nl_has_listeners(int netlink_family, uint32_t groups_mask) +{ + return (V_nl_ctl != NULL); +} + +bool +nlp_has_priv(struct nlpcb *nlp, int priv) +{ + return (priv_check_cred(nlp->nl_cred, priv)); +} + +bool +nlp_has_priv_route(struct nlpcb *nlp) +{ + return (nlp_has_priv(nlp, PRIV_NET_ROUTE)); +} + +static uint32_t +nl_find_port() { + /* + * app can open multiple netlink sockets. + * Start with current pid, if already taken, + * try random numbers in 65k..256k+65k space, + * avoiding clash with pids. + */ + if (nl_port_lookup(curproc->p_pid) == NULL) + return (curproc->p_pid); + for (int i = 0; i < 16; i++) { + uint32_t nl_port = (arc4random() % 65536) + 65536 * 4; + if (nl_port_lookup(nl_port) == 0) + return (nl_port); + RT_LOG(LOG_DEBUG3, "tried %u\n", nl_port); + } + return (curproc->p_pid); +} + +static int +nl_bind_locked(struct nlpcb *nlp, struct sockaddr_nl *snl) +{ + if (nlp->nl_bound) { + if (nlp->nl_port != snl->nl_pid) { + RT_LOG(LOG_DEBUG, + "bind() failed: program pid %d " + "is different from provided pid %d", + nlp->nl_port, snl->nl_pid); + return (EINVAL); // XXX: better error + } + } else { + if (snl->nl_pid == 0) + snl->nl_pid = nl_find_port(); + if (nl_port_lookup(snl->nl_pid) != NULL) + return (EADDRINUSE); + nlp->nl_port = snl->nl_pid; + nlp->nl_bound = true; + CK_LIST_INSERT_HEAD(&V_nl_ctl->ctl_port_head, nlp, nl_port_next); + } + nl_update_groups_locked(nlp, snl->nl_groups); + + return (0); +} + +static int +nl_pru_attach(struct socket *so, int proto, struct thread *td) +{ + struct nlpcb *nlp; + int error; + + if (__predict_false(netlink_unloading != 0)) + return (EAFNOSUPPORT); + + error = nl_verify_proto(proto); + if (error != 0) + return (error); + + bool is_linux = SV_PROC_ABI(td->td_proc) == SV_ABI_LINUX; + RT_LOG(LOG_DEBUG, "socket %p, %sPID %d: attaching socket to %s", + so, is_linux ? "(linux) " : "", curproc->p_pid, + nl_get_proto_name(proto)); + + /* Create per-VNET state on first socket init */ + struct nl_control *ctl = atomic_load_ptr(&V_nl_ctl); + if (ctl == NULL) + ctl = vnet_nl_ctl_init(); + KASSERT(V_nl_ctl != NULL, ("nl_attach: vnet_sock_init() failed")); + + MPASS(sotonlpcb(so) == NULL); + + nlp = malloc(sizeof(struct nlpcb), M_PCB, M_WAITOK | M_ZERO); + error = soreserve(so, nl_sendspace, nl_recvspace); + if (error != 0) { + free(nlp, M_PCB); + return (error); + } + so->so_pcb = (void *)nlp; + nlp->nl_socket = so; + /* Copy so_cred to avoid having socket_var.h in every header */ + nlp->nl_cred = so->so_cred; + nlp->nl_proto = proto; + nlp->nl_process_id = curproc->p_pid; + nlp->nl_linux = is_linux; + nlp->nl_active = true; + NLP_LOCK_INIT(nlp); + refcount_init(&nlp->nl_refcount, 1); + + nlp->nl_taskqueue = taskqueue_create("netlink_socket", M_WAITOK, + taskqueue_thread_enqueue, &nlp->nl_taskqueue); + TASK_INIT(&nlp->nl_task, 0, nl_taskqueue_handler, nlp); + taskqueue_start_threads(&nlp->nl_taskqueue, 1, PWAIT, + "netlink_socket (PID %u)", nlp->nl_process_id); + + NLCTL_WLOCK(ctl); + /* XXX: check ctl is still alive */ + CK_LIST_INSERT_HEAD(&ctl->ctl_pcb_head, nlp, nl_next); + NLCTL_WUNLOCK(ctl); + + soisconnected(so); + + return (0); +} + +static void +nl_pru_abort(struct socket *so) +{ + RT_LOG(LOG_DEBUG3, "socket %p, PID %d", so, curproc->p_pid); + MPASS(sotonlpcb(so) != NULL); + soisdisconnected(so); +} + +static int +nl_pru_bind(struct socket *so, struct sockaddr *nam, struct thread *td) +{ + struct nl_control *ctl = atomic_load_ptr(&V_nl_ctl); + struct nlpcb *nlp = sotonlpcb(so); + struct sockaddr_nl *snl = (struct sockaddr_nl *)nam; + int error; + + RT_LOG(LOG_DEBUG3, "socket %p, PID %d", so, curproc->p_pid); + if (snl->nl_len != sizeof(*snl)) { + RT_LOG(LOG_DEBUG, "socket %p, wrong sizeof(), ignoring bind()", so); + return (EINVAL); + } + + + NLCTL_WLOCK(ctl); + NLP_LOCK(nlp); + error = nl_bind_locked(nlp, snl); + NLP_UNLOCK(nlp); + NLCTL_WUNLOCK(ctl); + RT_LOG(LOG_DEBUG2, "socket %p, bind() to %u, groups %u, error %d", so, + snl->nl_pid, snl->nl_groups, error); + + return (error); +} + + +static int +nl_assign_port(struct nlpcb *nlp, uint32_t port_id) +{ + struct nl_control *ctl = atomic_load_ptr(&V_nl_ctl); + struct sockaddr_nl snl = { + .nl_pid = port_id, + }; + int error; + + NLCTL_WLOCK(ctl); + NLP_LOCK(nlp); + snl.nl_groups = nlp->nl_groups; + error = nl_bind_locked(nlp, &snl); + NLP_UNLOCK(nlp); + NLCTL_WUNLOCK(ctl); + + RT_LOG(LOG_DEBUG3, "socket %p, port assign: %d, error: %d", nlp->nl_socket, port_id, error); + return (error); +} + +/* + * nl_autobind_port binds a unused portid to @nlp + * @nlp: pcb data for the netlink socket + * @candidate_id: first id to consider + */ +static int +nl_autobind_port(struct nlpcb *nlp, uint32_t candidate_id) +{ + struct nl_control *ctl = atomic_load_ptr(&V_nl_ctl); + uint32_t port_id = candidate_id; + NLCTL_TRACKER; + bool exist; + int error; + + for (int i = 0; i < 10; i++) { + RT_LOG(LOG_DEBUG3, "socket %p, trying to assign port %d", nlp->nl_socket, port_id); + NLCTL_RLOCK(ctl); + exist = nl_port_lookup(port_id) != 0; + NLCTL_RUNLOCK(ctl); + if (!exist) { + error = nl_assign_port(nlp, port_id); + if (error != EADDRINUSE) + break; + } + port_id++; + } + RT_LOG(LOG_DEBUG3, "socket %p, autobind to %d, error: %d", nlp->nl_socket, port_id, error); + return (error); +} + +static int +nl_pru_connect(struct socket *so, struct sockaddr *nam, struct thread *td) +{ + struct sockaddr_nl *snl = (struct sockaddr_nl *)nam; + struct nlpcb *nlp; + + RT_LOG(LOG_DEBUG3, "socket %p, PID %d", so, curproc->p_pid); + if (snl->nl_len != sizeof(*snl)) { + RT_LOG(LOG_DEBUG, "socket %p, wrong sizeof(), ignoring bind()", so); + return (EINVAL); + } + + nlp = sotonlpcb(so); + if (!nlp->nl_bound) { + int error = nl_autobind_port(nlp, td->td_proc->p_pid); + if (error != 0) { + RT_LOG(LOG_DEBUG, "socket %p, nl_autobind() failed: %d", so, error); + return (error); + } + } + /* XXX: Handle socket flags & multicast */ + soisconnected(so); + + RT_LOG(LOG_DEBUG2, "socket %p, connect to %u", so, snl->nl_pid); + + return (0); +} + +static void +destroy_nlpcb(struct nlpcb *nlp) +{ + NLP_LOCK(nlp); + nl_free_io(nlp); + NLP_LOCK_DESTROY(nlp); + free(nlp, M_PCB); +} + +static void +destroy_nlpcb_epoch(epoch_context_t ctx) +{ + struct nlpcb *nlp; + + nlp = __containerof(ctx, struct nlpcb, nl_epoch_ctx); + + destroy_nlpcb(nlp); +} + + +static void +nl_pru_detach(struct socket *so) +{ + struct nl_control *ctl = atomic_load_ptr(&V_nl_ctl); + MPASS(sotonlpcb(so) != NULL); + struct nlpcb *nlp; + + RT_LOG(LOG_DEBUG2, "socket %p, PID %d", so, curproc->p_pid); + nlp = sotonlpcb(so); + + /* Mark as inactive so no new work can be enqueued */ + NLP_LOCK(nlp); + bool was_bound = nlp->nl_bound; + nlp->nl_active = false; + NLP_UNLOCK(nlp); + + /* Wait till all scheduled work has been completed */ + taskqueue_drain_all(nlp->nl_taskqueue); + taskqueue_free(nlp->nl_taskqueue); + + NLCTL_WLOCK(ctl); + NLP_LOCK(nlp); + if (was_bound) { + CK_LIST_REMOVE(nlp, nl_port_next); + RT_LOG(LOG_DEBUG3, "socket %p, unlinking bound pid %u", so, nlp->nl_port); + } + CK_LIST_REMOVE(nlp, nl_next); + nlp->nl_socket = NULL; + NLP_UNLOCK(nlp); + NLCTL_WUNLOCK(ctl); + + so->so_pcb = NULL; + + RT_LOG(LOG_DEBUG3, "socket %p, detached", so); + + /* XXX: is delayed free needed? */ + epoch_call(net_epoch_preempt, destroy_nlpcb_epoch, &nlp->nl_epoch_ctx); +} + +static int +nl_pru_disconnect(struct socket *so) +{ + RT_LOG(LOG_DEBUG3, "socket %p, PID %d", so, curproc->p_pid); + MPASS(sotonlpcb(so) != NULL); + return (ENOTCONN); +} + +static int +nl_pru_peeraddr(struct socket *so, struct sockaddr **nam) +{ + RT_LOG(LOG_DEBUG3, "socket %p, PID %d", so, curproc->p_pid); + MPASS(sotonlpcb(so) != NULL); + return (ENOTCONN); +} + +static int +nl_pru_shutdown(struct socket *so) +{ + RT_LOG(LOG_DEBUG3, "socket %p, PID %d", so, curproc->p_pid); + MPASS(sotonlpcb(so) != NULL); + socantsendmore(so); + return (0); +} + +static int +nl_pru_sockaddr(struct socket *so, struct sockaddr **nam) +{ + struct sockaddr_nl *snl; + + snl = malloc(sizeof(struct sockaddr_nl), M_SONAME, M_WAITOK | M_ZERO); + /* TODO: set other fields */ + snl->nl_len = sizeof(struct sockaddr_nl); + snl->nl_family = AF_NETLINK; + snl->nl_pid = sotonlpcb(so)->nl_port; + *nam = (struct sockaddr *)snl; + return (0); +} + +static void +nl_pru_close(struct socket *so) +{ + RT_LOG(LOG_DEBUG3, "socket %p, PID %d", so, curproc->p_pid); + MPASS(sotonlpcb(so) != NULL); + soisdisconnected(so); +} + +static int +nl_pru_output(struct mbuf *m, struct socket *so, ...) +{ + + if (__predict_false(m == NULL || + ((m->m_len < sizeof(struct nlmsghdr)) && + (m = m_pullup(m, sizeof(struct nlmsghdr))) == NULL))) + return (ENOBUFS); + MPASS((m->m_flags & M_PKTHDR) != 0); + + RT_LOG(LOG_DEBUG3, "sending message to kernel async processing"); + nl_receive_async(m, so); + return (0); +} + + +static int +nl_pru_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *nam, + struct mbuf *control, struct thread *td) +{ + RT_LOG(LOG_DEBUG2, "sending message to kernel"); + + if (__predict_false(control != NULL)) { + if (control->m_len) { + m_freem(control); + return (EINVAL); + } + m_freem(control); + } + + return (nl_pru_output(m, so)); +} + +static int +nl_pru_rcvd(struct socket *so, int flags) +{ + RT_LOG(LOG_DEBUG3, "socket %p, PID %d", so, curproc->p_pid); + MPASS(sotonlpcb(so) != NULL); + + nl_on_transmit(sotonlpcb(so)); + + return (0); +} + +static int +nl_ctloutput(struct socket *so, struct sockopt *sopt) +{ + struct nl_control *ctl = atomic_load_ptr(&V_nl_ctl); + struct nlpcb *nlp = sotonlpcb(so); + uint32_t flag, groups; + int optval, error = 0; + NLCTL_TRACKER; + + RT_LOG(LOG_DEBUG2, "%ssockopt(%p, %d)", (sopt->sopt_dir) ? "set" : "get", + so, sopt->sopt_name); + + switch (sopt->sopt_dir) { + case SOPT_SET: + switch (sopt->sopt_name) { + case NETLINK_ADD_MEMBERSHIP: + case NETLINK_DROP_MEMBERSHIP: + sooptcopyin(sopt, &optval, sizeof(optval), sizeof(optval)); + + NLCTL_WLOCK(ctl); + if (sopt->sopt_name == NETLINK_ADD_MEMBERSHIP) + groups = nlp->nl_groups | optval; + else + groups = nlp->nl_groups & ~optval; + nl_update_groups_locked(nlp, groups); + NLCTL_WUNLOCK(ctl); + break; + case NETLINK_CAP_ACK: + case NETLINK_EXT_ACK: + sooptcopyin(sopt, &optval, sizeof(optval), sizeof(optval)); + + if (sopt->sopt_name == NETLINK_CAP_ACK) + flag = NLF_CAP_ACK; + else if (sopt->sopt_name == NETLINK_EXT_ACK) + flag = NLF_EXT_ACK; + else + flag = 0; + + NLCTL_WLOCK(ctl); + if (optval != 0) + nlp->nl_flags |= flag; + else + nlp->nl_flags &= ~flag; + NLCTL_WUNLOCK(ctl); + break; + default: + error = ENOPROTOOPT; + } + break; + case SOPT_GET: + switch (sopt->sopt_name) { + case NETLINK_LIST_MEMBERSHIPS: + NLCTL_RLOCK(ctl); + optval = nlp->nl_groups; + NLCTL_RUNLOCK(ctl); + error = sooptcopyout(sopt, &optval, sizeof(optval)); + break; + default: + error = ENOPROTOOPT; + } + break; + default: + error = ENOPROTOOPT; + } + + return (error); +} + +static struct domain netlinkdomain; + +static struct protosw netlinksw = { + .pr_type = SOCK_RAW, + .pr_flags = PR_ATOMIC | PR_ADDR | PR_WANTRCVD, + .pr_ctloutput = nl_ctloutput, + .pr_abort = nl_pru_abort, + .pr_attach = nl_pru_attach, + .pr_bind = nl_pru_bind, + .pr_connect = nl_pru_connect, + .pr_detach = nl_pru_detach, + .pr_disconnect = nl_pru_disconnect, + .pr_peeraddr = nl_pru_peeraddr, + .pr_send = nl_pru_send, + .pr_rcvd = nl_pru_rcvd, + .pr_shutdown = nl_pru_shutdown, + .pr_sockaddr = nl_pru_sockaddr, + .pr_close = nl_pru_close +}; + +static struct domain netlinkdomain = { + .dom_family = PF_NETLINK, + .dom_name = "netlink", + .dom_flags = DOMF_UNLOADABLE, + .dom_nprotosw = 1, + .dom_protosw = { &netlinksw }, +}; + +DOMAIN_SET(netlink); diff --git a/sys/netlink/netlink_helpers.c b/sys/netlink/netlink_helpers.c new file mode 100644 --- /dev/null +++ b/sys/netlink/netlink_helpers.c @@ -0,0 +1,369 @@ +/*- + * SPDX-License-Identifier: BSD-2-Clause-FreeBSD + * + * 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 +__FBSDID("$FreeBSD$"); +#include "opt_inet.h" +#include "opt_inet6.h" +#include +#include +#include +#include + +#include +#include +#include + +#include +#include +#include +#include +#include + +#define DEBUG_MOD_NAME nl_helpers +#define DEBUG_MAX_LEVEL LOG_DEBUG3 +#include +_DECLARE_DEBUG(LOG_DEBUG); + +/* + * Sends an ack message + */ +void +nlmsg_ack(struct nlpcb *nlp, int error, struct nlmsghdr *hdr) +{ + struct nlmsgerr *errmsg; + int payload_len; + uint32_t flags = nlp->nl_flags; + struct nlmsg_state ns; + bool cap_ack; + + payload_len = sizeof(struct nlmsgerr); + + /* + * The only case when we send the full message in the + * reply is when there is an error and NETLINK_CAP_ACK + * is not set. + */ + cap_ack = (error == 0) || (flags & NLF_CAP_ACK); + if (!cap_ack) + payload_len += hdr->nlmsg_len - sizeof(struct nlmsghdr); + + /* + * TODO: handle NETLINK_F_EXT_ACK sockopt + * TODO: handle cookies + */ + + int sz = payload_len + sizeof(struct nlmsghdr); + if (!nlmsg_get_socket_writer(sz, nlp, &ns)) + goto enomem; + nlmsg_ignore_limit(&ns); + + RT_LOG(LOG_DEBUG3, "acknowledging message type %d seq %d", + hdr->nlmsg_type, hdr->nlmsg_seq); + + if (!nlmsg_add(&ns, nlp->nl_port, hdr->nlmsg_seq, NLMSG_ERROR, 0, payload_len)) + goto enomem; + + errmsg = nlmsg_reserve_data(&ns, payload_len, struct nlmsgerr); + errmsg->error = error; + /* In case of error copy the whole message, else just the header */ + memcpy(&errmsg->msg, hdr, cap_ack ? sizeof(*hdr) : hdr->nlmsg_len); + + nlmsg_end(&ns); + nlmsg_flush(&ns); + return; +enomem: + NLP_LOG(LOG_INFO, nlp, "error allocating ack data for message %d seq %u", + hdr->nlmsg_type, hdr->nlmsg_seq); +} + +bool +nlmsg_end_dump(struct nlmsg_state *ns, int error, struct nlmsghdr *hdr) +{ + if (!nlmsg_add(ns, hdr->nlmsg_pid, hdr->nlmsg_seq, NLMSG_DONE, 0, sizeof(int))) { + RT_LOG(LOG_DEBUG, "Error finalizing table dump"); + return (false); + } + /* Save operation result */ + int *perror = nlmsg_reserve_object(ns, int); + RT_LOG(LOG_DEBUG2, "record error=%d at off %d (%p)", error, + ns->offset, perror); + *perror = error; + nlmsg_end(ns); + + return (true); +} + + +static const struct nlattr_parser * +search_states(const struct nlattr_parser *ps, int pslen, int key) +{ + int left_i = 0, right_i = pslen - 1; + + if (key < ps[0].type || key > ps[pslen - 1].type) + return (NULL); + + while (left_i + 1 < right_i) { + int mid_i = (left_i + right_i) / 2; + if (key < ps[mid_i].type) + right_i = mid_i; + else if (key > ps[mid_i].type) + left_i = mid_i + 1; + else + return (&ps[mid_i]); + } + if (ps[left_i].type == key) + return (&ps[left_i]); + else if (ps[right_i].type == key) + return (&ps[right_i]); + return (NULL); +} + +int +nl_parse_attrs_raw(struct nlattr *nla_head, int len, struct nlattr_parser *ps, int pslen, + struct netlink_parse_tracker *npt, void *target) +{ + struct nlattr *nla; + int error = 0; + + RT_LOG(LOG_DEBUG3, "parse %p remaining_len %d", nla_head, len); + NLA_FOREACH(nla, nla_head, len) { + if (nla->nla_len < sizeof(struct nlattr)) { + RT_LOG(LOG_DEBUG, "Invalid attr len: %d", nla->nla_len); + return (EINVAL); + } + + int nla_type = nla->nla_type & NLA_TYPE_MASK; + const struct nlattr_parser *s = search_states(ps, pslen, nla_type); + if (s != NULL) { + void *ptr = (void *)((char *)target + s->off); + error = s->cb(nla, npt, ptr); + if (error != 0) + return (error); + } else { + /* Default policy is to ignore unknown attrs */ + } + + if (s == NULL) { + /* Default policy is to ignore */ + continue; + } + } + + return (0); +} + +int +nl_parse_attrs(struct nlmsghdr *hdr, int hdrlen, struct nlattr_parser *ps, int pslen, + struct netlink_parse_tracker *npt, void *target) +{ + int off = NLMSG_HDRLEN + NETLINK_ALIGN(hdrlen); + int len = hdr->nlmsg_len - off; + struct nlattr *nla_head = (struct nlattr *)((char *)hdr + off); + + return (nl_parse_attrs_raw(nla_head, len, ps, pslen, npt, target)); +} + +int +nlattr_get_flag(struct nlattr *nla, struct netlink_parse_tracker *npt, void *target) +{ + if (__predict_false(NLA_DATA_LEN(nla) != 0)) { + RT_LOG(LOG_DEBUG, "nla type %d size(%u) is not a flag", + nla->nla_type, NLA_DATA_LEN(nla)); + return (EINVAL); + } + + *((uint8_t *)target) = 1; + return (0); +} + +static struct sockaddr * +parse_rta_ip4(void *rta_data, struct netlink_parse_tracker *npt, int *perror) +{ + struct sockaddr_in *sin; + + sin = (struct sockaddr_in *)npt_alloc_sockaddr(npt, sizeof(struct sockaddr_in)); + if (__predict_false(sin == NULL)) { + *perror = ENOBUFS; + return (NULL); + } + sin->sin_len = sizeof(struct sockaddr_in); + sin->sin_family = AF_INET; + memcpy(&sin->sin_addr, rta_data, sizeof(struct in_addr)); + return ((struct sockaddr *)sin); +} + +static struct sockaddr * +parse_rta_ip6(void *rta_data, struct netlink_parse_tracker *npt, int *perror) +{ + struct sockaddr_in6 *sin6; + + sin6 = (struct sockaddr_in6 *)npt_alloc_sockaddr(npt, sizeof(struct sockaddr_in6)); + if (__predict_false(sin6 == NULL)) { + *perror = ENOBUFS; + return (NULL); + } + sin6->sin6_len = sizeof(struct sockaddr_in6); + sin6->sin6_family = AF_INET6; + memcpy(&sin6->sin6_addr, rta_data, sizeof(struct in_addr)); + return ((struct sockaddr *)sin6); +} + +static struct sockaddr * +parse_rta_ip(struct rtattr *rta, struct netlink_parse_tracker *npt, int *perror) +{ + void *rta_data = NL_RTA_DATA(rta); + int rta_len = NL_RTA_DATA_LEN(rta); + + if (rta_len == sizeof(struct in_addr)) { + return (parse_rta_ip4(rta_data, npt, perror)); + } else if (rta_len == sizeof(struct in6_addr)) { + return (parse_rta_ip6(rta_data, npt, perror)); + } else { + RT_LOG(LOG_NOTICE, "unknown IP len: %d for rta type %d", + rta_len, rta->rta_type); + *perror = ENOTSUP; + return (NULL); + } + return (NULL); +} + +int +nlattr_get_ip(struct nlattr *nla, struct netlink_parse_tracker *npt, void *target) +{ + int error = 0; + + struct sockaddr *sa = parse_rta_ip((struct rtattr *)nla, npt, &error); + + *((struct sockaddr **)target) = sa; + return (error); +} + +static struct sockaddr * +parse_rta_via(struct rtattr *rta, struct netlink_parse_tracker *npt, int *perror) +{ + struct rtvia *via = NL_RTA_DATA(rta); + int data_len = NL_RTA_DATA_LEN(rta); + + if (__predict_false(data_len) < sizeof(struct rtvia)) { + *perror = EINVAL; + return (NULL); + } + data_len -= offsetof(struct rtvia, rtvia_addr); + + switch (via->rtvia_family) { + case AF_INET: + if (__predict_false(data_len < sizeof(struct in_addr))) { + *perror = EINVAL; + return (NULL); + } + return (parse_rta_ip4(via->rtvia_addr, npt, perror)); + case AF_INET6: + if (__predict_false(data_len < sizeof(struct in6_addr))) { + *perror = EINVAL; + return (NULL); + } + return (parse_rta_ip6(via->rtvia_addr, npt, perror)); + default: + *perror = ENOTSUP; + return (NULL); + } +} + +int +nlattr_get_ipvia(struct nlattr *nla, struct netlink_parse_tracker *npt, void *target) +{ + int error = 0; + + struct sockaddr *sa = parse_rta_via((struct rtattr *)nla, npt, &error); + + *((struct sockaddr **)target) = sa; + return (error); +} + + +int +nlattr_get_uint32(struct nlattr *nla, struct netlink_parse_tracker *npt, void *target) +{ + if (__predict_false(NLA_DATA_LEN(nla) != sizeof(uint32_t))) { + RT_LOG(LOG_DEBUG, "nla type %d size(%u) is not uint32", + nla->nla_type, NLA_DATA_LEN(nla)); + return (EINVAL); + } + *((uint32_t *)target) = *((const uint32_t *)NL_RTA_DATA_CONST(nla)); + return (0); +} + +int +nlattr_get_ifindex(struct nlattr *nla, struct netlink_parse_tracker *npt, void *target) +{ + if (__predict_false(NLA_DATA_LEN(nla) != sizeof(uint32_t))) { + RT_LOG(LOG_DEBUG, "nla type %d size(%u) is not uint32", + nla->nla_type, NLA_DATA_LEN(nla)); + return (EINVAL); + } + uint32_t ifindex = *((const uint32_t *)NLA_DATA_CONST(nla)); + + NET_EPOCH_ASSERT(); + + struct ifnet *ifp = ifnet_byindex(ifindex); + if (__predict_false(ifp == NULL)) { + RT_LOG(LOG_DEBUG, "nla type %d: ifindex %u invalid", + nla->nla_type, ifindex); + return (ENOENT); + } + *((struct ifnet **)target) = ifp; + RT_LOG(LOG_DEBUG3, "nla type %d: ifindex %u -> %s", nla->nla_type, + ifindex, if_name(ifp)); + + return (0); +} + +int +nlattr_get_string(struct nlattr *nla, struct netlink_parse_tracker *npt, void *target) +{ + int maxlen = NLA_DATA_LEN(nla); + + if (__predict_false(strnlen((char *)NLA_DATA(nla), maxlen) >= maxlen)) { + RT_LOG(LOG_DEBUG, "nla type %d size(%u) is not NULL-terminated", + nla->nla_type, maxlen); + return (EINVAL); + } + + *((char **)target) = (char *)NLA_DATA(nla); + return (0); +} + +int +nlattr_get_nla(struct nlattr *nla, struct netlink_parse_tracker *npt, void *target) +{ + *((struct nlattr **)target) = nla; + return (0); +} + + + diff --git a/sys/netlink/netlink_io.c b/sys/netlink/netlink_io.c new file mode 100644 --- /dev/null +++ b/sys/netlink/netlink_io.c @@ -0,0 +1,514 @@ +/*- + * SPDX-License-Identifier: BSD-2-Clause-FreeBSD + * + * Copyright (c) 2021 Ng Peng Nam Sean + * 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 +__FBSDID("$FreeBSD$"); +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#define DEBUG_MOD_NAME nl_io +#define DEBUG_MAX_LEVEL LOG_DEBUG3 +#include +_DECLARE_DEBUG(LOG_DEBUG); + +/* + * The logic below provide a p2p interface for receiving and + * sending netlink data between the kernel and userland. + */ + + +static struct sockaddr_nl _nl_empty_src = { + .nl_len = sizeof(struct sockaddr_nl), + .nl_family = PF_NETLINK, + .nl_pid = 0 /* comes from the kernel */ +}; +static struct sockaddr *nl_empty_src = (struct sockaddr *)&_nl_empty_src; + +static struct mbuf *nl_process_mbuf(struct mbuf *m, struct nlpcb *nlp); + + +/* +struct nl_io_queue { + struct mbuf *head; + struct mbuf *last; + int length; +}; +*/ + +static void +queue_push(struct nl_io_queue *q, struct mbuf *m) +{ + struct mbuf *m_last; + + for (m_last = m; m_last->m_nextpkt != NULL; m_last = m_last->m_nextpkt) + q->length += m_length(m_last, NULL); + q->length += m_length(m_last, NULL); + + if (q->last == NULL) { + q->head = m; + q->last = m_last; + } else { + q->last->m_nextpkt = m; + q->last = m_last; + } +} + +static void +queue_push_head(struct nl_io_queue *q, struct mbuf *m) +{ + MPASS(m->m_nextpkt == NULL); + + q->length += m_length(m, NULL); + + if (q->last == NULL) { + q->head = m; + q->last = m; + } else { + m->m_nextpkt = q->head; + q->head = m; + } +} + +static struct mbuf * +queue_pop(struct nl_io_queue *q) +{ + if (q->head != NULL) { + struct mbuf *m = q->head; + q->head = m->m_nextpkt; + m->m_nextpkt = NULL; + if (q->head == NULL) + q->last = NULL; + q->length -= m_length(m, NULL); + + return (m); + } + return (NULL); +} + +static struct mbuf * +queue_head(const struct nl_io_queue *q) +{ + return (q->head); +} + +static inline bool +queue_empty(const struct nl_io_queue *q) +{ + return (q->length == 0); +} + +static void +queue_free(struct nl_io_queue *q) +{ + struct mbuf *m = q->head; + + while (m != NULL) { + struct mbuf *m_next = m->m_nextpkt; + m->m_nextpkt = NULL; + m_freem(m); + m = m_next; + } + q->head = NULL; + q->last = NULL; + q->length = 0; +} + + +static void +nl_schedule_taskqueue(struct nlpcb *nlp) +{ + if (!nlp->nl_task_pending) { + nlp->nl_task_pending = true; + taskqueue_enqueue(nlp->nl_taskqueue, &nlp->nl_task); + RT_LOG(LOG_DEBUG3, "taskqueue scheduled"); + } else { + RT_LOG(LOG_DEBUG3, "taskqueue schedule skipped"); + } +} + +int +nl_receive_async(struct mbuf *m, struct socket *so) +{ + struct nlpcb *nlp = sotonlpcb(so); + int error = 0; + + m->m_nextpkt = NULL; + + NLP_LOCK(nlp); + + if ((__predict_true(nlp->nl_active))) { + sbappend(&so->so_snd, m, 0); + RT_LOG(LOG_DEBUG3, "enqueue %u bytes", m_length(m, NULL)); + nl_schedule_taskqueue(nlp); + } else { + RT_LOG(LOG_DEBUG, "ignoring %u bytes on non-active socket", + m_length(m, NULL)); + m_free(m); + error = EINVAL; + } + + NLP_UNLOCK(nlp); + + return (error); +} + +static bool +tx_check_locked(struct nlpcb *nlp) +{ + if (queue_empty(&nlp->tx_queue)) + return (true); + + /* + * Check if something can be moved from the internal TX queue + * to the socket queue. + */ + + bool appended = false; + struct sockbuf *sb = &nlp->nl_socket->so_rcv; + SOCKBUF_LOCK(sb); + + while (true) { + struct mbuf *m = queue_head(&nlp->tx_queue); + if (m && sbappendaddr_locked(sb, nl_empty_src, m, NULL) != 0) { + /* appended successfully */ + queue_pop(&nlp->tx_queue); + appended = true; + } else + break; + } + + SOCKBUF_UNLOCK(sb); + + if (appended) + sorwakeup(nlp->nl_socket); + + return (queue_empty(&nlp->tx_queue)); +} + +static bool +nl_process_received_one(struct nlpcb *nlp) +{ + bool reschedule = false; + + NLP_LOCK(nlp); + nlp->nl_task_pending = false; + + if (!tx_check_locked(nlp)) { + /* TX overflow queue still not empty, ignore RX */ + NLP_UNLOCK(nlp); + return (false); + } + + if (queue_empty(&nlp->rx_queue)) { + /* + * Grab all data we have from the socket TX queue + * and store it the internal queue, so it can be worked on + * w/o holding socket lock. + */ + struct sockbuf *sb = &nlp->nl_socket->so_snd; + + SOCKBUF_LOCK(sb); + unsigned int avail = sbavail(sb); + if (avail > 0) { + RT_LOG(LOG_DEBUG3, "grabbed %u bytes", avail); + queue_push(&nlp->rx_queue, sbcut_locked(sb, avail)); + } + SOCKBUF_UNLOCK(sb); + } else { + /* Schedule another pass to read from the socket queue */ + reschedule = true; + } + + int prev_hiwat = nlp->tx_queue.hiwat; + NLP_UNLOCK(nlp); + + while (!queue_empty(&nlp->rx_queue)) { + struct mbuf *m = queue_pop(&nlp->rx_queue); + + m = nl_process_mbuf(m, nlp); + if (m != NULL) { + queue_push_head(&nlp->rx_queue, m); + reschedule = false; + break; + } + } + if (nlp->tx_queue.hiwat > prev_hiwat) { + NLP_LOG(LOG_DEBUG, nlp, "TX override peaked to %d", nlp->tx_queue.hiwat); + + } + + return (reschedule); +} + +static void +nl_process_received(struct nlpcb *nlp) +{ + RT_LOG(LOG_DEBUG3, "taskqueue called"); + + while (nl_process_received_one(nlp)) + ; +} + +void +nl_free_io(struct nlpcb *nlp) +{ + queue_free(&nlp->rx_queue); + queue_free(&nlp->tx_queue); +} + +/* + * Called after some data have been read from the socket. + */ +void +nl_on_transmit(struct nlpcb *nlp) +{ + NLP_LOCK(nlp); + + struct socket *so = nlp->nl_socket; + if (__predict_false(nlp->nl_dropped_bytes > 0 && so != NULL)) { + uint64_t dropped_bytes = nlp->nl_dropped_bytes; + uint64_t dropped_messages = nlp->nl_dropped_messages; + nlp->nl_dropped_bytes = 0; + nlp->nl_dropped_messages = 0; + + struct sockbuf *sb = &so->so_rcv; + NLP_LOG(LOG_DEBUG, nlp, + "socket RX overflowed, %lu messages (%lu bytes) dropped. " + "bytes: [%u/%u] mbufs: [%u/%u]", dropped_messages, dropped_bytes, + sb->sb_ccc, sb->sb_hiwat, sb->sb_mbcnt, sb->sb_mbmax); + /* TODO: send netlink message */ + } + + nl_schedule_taskqueue(nlp); + NLP_UNLOCK(nlp); +} + +void +nl_taskqueue_handler(void *_arg, int pending) +{ + struct nlpcb *nlp = (struct nlpcb *)_arg; + + CURVNET_SET(nlp->nl_socket->so_vnet); + nl_process_received(nlp); + CURVNET_RESTORE(); +} + +static __noinline void +queue_push_tx(struct nlpcb *nlp, struct mbuf *m) +{ + queue_push(&nlp->tx_queue, m); + nlp->nl_tx_blocked = true; + + if (nlp->tx_queue.length > nlp->tx_queue.hiwat) + nlp->tx_queue.hiwat = nlp->tx_queue.length; +} + +/* + * Tries to send @m to the socket @nlp. + * + * @m: mbuf(s) to send to. Consumed in any case. + * @nlp: socket to send to + * @cnt: number of messages in @m + * @io_flags: combination of NL_IOF_* flags + * + * Returns true on success. + * If no queue overrunes happened, wakes up socket owner. + */ +bool +nl_send_one(struct mbuf *m, struct nlpcb *nlp, int num_messages, int io_flags) +{ +#if DEBUG_MAX_LEVEL >= LOG_DEBUG2 + struct nlmsghdr *hdr = mtod(m, struct nlmsghdr *); + NLP_LOG(LOG_DEBUG2, nlp, "TX mbuf len %u msgs %u msg type %d first hdrlen %u io_flags %X", + m_length(m, NULL), num_messages, hdr->nlmsg_type, hdr->nlmsg_len, io_flags); +#endif + bool untranslated = io_flags & NL_IOF_UNTRANSLATED; + bool ignore_limits = io_flags & NL_IOF_IGNORE_LIMIT; + bool result = true; + + if (__predict_false(nlp->nl_linux && linux_netlink_p != NULL && untranslated)) { + m = linux_netlink_p->mbufs_to_linux(nlp->nl_proto, m, nlp); + if (m == NULL) + return (false); + } + + NLP_LOCK(nlp); + + if (__predict_false(nlp->nl_socket == NULL)) { + NLP_UNLOCK(nlp); + m_freem(m); + return (false); + } + + if (!queue_empty(&nlp->tx_queue)) { + if (ignore_limits) { + queue_push_tx(nlp, m); + } else { + m_free(m); + result = false; + } + NLP_UNLOCK(nlp); + return (result); + } + + struct socket *so = nlp->nl_socket; + if (sbappendaddr(&so->so_rcv, nl_empty_src, m, NULL) != 0) { + sorwakeup(so); + NLP_LOG(LOG_DEBUG3, nlp, "appended data & woken up"); + } else { + if (ignore_limits) { + queue_push_tx(nlp, m); + } else { + /* + * Store dropped data so it can be reported + * on the next read + */ + nlp->nl_dropped_bytes += m_length(m, NULL); + nlp->nl_dropped_messages += num_messages; + NLP_LOG(LOG_DEBUG2, nlp, "RX oveflow: %lu m (+%d), %lu b (+%d)", + nlp->nl_dropped_messages, num_messages, + nlp->nl_dropped_bytes, m_length(m, NULL)); + soroverflow(so); + m_freem(m); + result = false; + } + } + NLP_UNLOCK(nlp); + + return (result); +} + +static int +nl_receive_message(struct nlmsghdr *hdr, int remaining_length, + struct nlpcb *nlp, struct netlink_parse_tracker *npt) +{ + nl_handler_f handler = nl_handlers[nlp->nl_proto].cb; + int error = 0; + + RT_LOG(LOG_DEBUG2, "msg len: %d type: %d", hdr->nlmsg_len, hdr->nlmsg_type); + + if (__predict_false(hdr->nlmsg_len > remaining_length)) { + RT_LOG(LOG_DEBUG, "invalid message"); + return (EINVAL); + } else if (__predict_false(hdr->nlmsg_len < sizeof(*hdr))) { + RT_LOG(LOG_DEBUG, "message too short: %d", hdr->nlmsg_len); + return (EINVAL); + } + /* Stamp each message with sender pid */ + hdr->nlmsg_pid = nlp->nl_port; + + if (hdr->nlmsg_flags & NLM_F_REQUEST && hdr->nlmsg_type >= NLMSG_MIN_TYPE) { + RT_LOG(LOG_DEBUG2, "handling message with msg type: %d", + hdr->nlmsg_type); + + struct nlmsghdr *thdr = hdr; + if (nlp->nl_linux && linux_netlink_p != NULL) { + thdr = linux_netlink_p->msg_from_linux(nlp->nl_proto, hdr, npt); + } + error = handler(thdr, npt); + RT_LOG(LOG_DEBUG2, "retcode: %d", error); + } + if ((hdr->nlmsg_flags & NLM_F_ACK) || (error != 0 && error != EINTR)) { + RT_LOG(LOG_DEBUG3, "ack"); + nlmsg_ack(nlp, error, hdr); + RT_LOG(LOG_DEBUG3, "done"); + } + + return (0); +} + +/* + * Processes an incoming packet, which can contain multiple netlink messages + */ +static struct mbuf * +nl_process_mbuf(struct mbuf *m, struct nlpcb *nlp) +{ + int offset, buffer_length; + struct nlmsghdr *hdr; + char *buffer; + int error; + + RT_LOG(LOG_DEBUG3, "RX netlink mbuf %p on %p", m, nlp->nl_socket); + + /* TODO: alloc this buf once for nlp */ + int data_length = m_length(m, NULL); + buffer_length = roundup2(data_length, 8) + SCRATCH_BUFFER_SIZE; + if (nlp->nl_linux) + buffer_length += roundup2(data_length, 8); + buffer = malloc(buffer_length, M_NETLINK, M_NOWAIT | M_ZERO); + if (buffer == NULL) { + m_freem(m); + RT_LOG(LOG_DEBUG, "Unable to allocate %d bytes of memory", + buffer_length); + return (NULL); + } + m_copydata(m, 0, data_length, buffer); + + struct netlink_parse_tracker npt = { + .nlp = nlp, + .lb.base = &buffer[roundup2(data_length, 8)], + .lb.size = buffer_length - roundup2(data_length, 8), + }; + + for (offset = 0; offset + sizeof(struct nlmsghdr) <= data_length;) { + hdr = (struct nlmsghdr *)&buffer[offset]; + /* Save length prior to calling handler */ + int msglen = NLMSG_ALIGN(hdr->nlmsg_len); + RT_LOG(LOG_DEBUG3, "parsing offset %d/%d", offset, data_length); + /* Update parse state */ + lb_clear(&npt.lb); + error = nl_receive_message(hdr, data_length - offset, nlp, &npt); + offset += msglen; + if (__predict_false(error != 0 || nlp->nl_tx_blocked)) + break; + } + RT_LOG(LOG_DEBUG3, "packet parsing done"); + free(buffer, M_NETLINK); + + if (nlp->nl_tx_blocked) { + NLP_LOCK(nlp); + nlp->nl_tx_blocked = false; + NLP_UNLOCK(nlp); + m_adj(m, offset); + return (m); + } else { + m_freem(m); + return (NULL); + } +} diff --git a/sys/netlink/netlink_linux.h b/sys/netlink/netlink_linux.h new file mode 100644 --- /dev/null +++ b/sys/netlink/netlink_linux.h @@ -0,0 +1,54 @@ +/*- + * SPDX-License-Identifier: BSD-2-Clause-FreeBSD + * + * 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. + */ + +#ifndef _NETLINK_LINUX_VAR_H_ +#define _NETLINK_LINUX_VAR_H_ + +/* + * The file contains headers for the bridge interface between + * linux[_common] module and the netlink module + */ +struct nlpcb; +struct netlink_parse_tracker; + +typedef struct mbuf *mbufs_to_linux_cb_t(int netlink_family, struct mbuf *m, + struct nlpcb *nlp); +typedef struct mbuf *msgs_to_linux_cb_t(int netlink_family, char *buf, int data_length, + struct nlpcb *nlp); +typedef struct nlmsghdr *msg_from_linux_cb_t(int netlink_family, struct nlmsghdr *hdr, + struct netlink_parse_tracker *npt); + +struct linux_netlink_provider { + mbufs_to_linux_cb_t *mbufs_to_linux; + msgs_to_linux_cb_t *msgs_to_linux; + msg_from_linux_cb_t *msg_from_linux; + +}; + +extern struct linux_netlink_provider *linux_netlink_p; + +#endif diff --git a/sys/netlink/netlink_message.c b/sys/netlink/netlink_message.c new file mode 100644 --- /dev/null +++ b/sys/netlink/netlink_message.c @@ -0,0 +1,589 @@ +/*- + * SPDX-License-Identifier: BSD-2-Clause-FreeBSD + * + * 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 +__FBSDID("$FreeBSD$"); +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#define DEBUG_MOD_NAME nl_message +#define DEBUG_MAX_LEVEL LOG_DEBUG3 +#include +_DECLARE_DEBUG(LOG_DEBUG); + +/* + * The goal of this file is to provide convenient message writing KPI on top of + * different storage methods (mbufs, uio, temporary memory chunjs). + * + * The main KPI guarantee is the the (last) message always resides in the contiguous + * memory buffer, so one is able to update the header after writing the entire message. + * + * This guarantee comes with a side effect of potentially reallocating underlying buffer, + * so one needs to update the desired pointers before using them if something was added + * to the header. + */ + + +typedef bool nlwriter_op_init(struct nlmsg_state *ns, int size, bool waitok); +typedef bool nlwriter_op_write(struct nlmsg_state *ns, void *buf, int buflen, int cnt); + +struct nlwriter_ops { + nlwriter_op_init *init; + nlwriter_op_write *write_socket; + nlwriter_op_write *write_group; + nlwriter_op_write *write_chain; +}; + +/* + * NS_WRITER_TYPE_BUF + * Writes message to a temporary memory buffer, + * flushing to the socket/group when buffer size limit is reached + */ +static bool +nlmsg_get_ns_buf(struct nlmsg_state *ns, int size, bool waitok) +{ + int mflag = waitok ? M_WAITOK : M_NOWAIT; + ns->_storage = malloc(size, M_NETLINK, mflag | M_ZERO); + if (__predict_false(ns->_storage == NULL)) + return (false); + ns->alloc_len = size; + ns->offset = 0; + ns->hdr = NULL; + ns->data = ns->_storage; + ns->writer_type = NS_WRITER_TYPE_BUF; + ns->malloc_flag = mflag; + ns->num_messages = 0; + return (true); +} + +static bool +nlmsg_write_socket_buf(struct nlmsg_state *ns, void *buf, int datalen, int cnt) +{ + RT_LOG(LOG_DEBUG2, "IN: ptr: %p len: %d arg: %p", buf, datalen, ns); + if (__predict_false(datalen == 0)) { + free(buf, M_NETLINK); + return (true); + } + + struct mbuf *m = m_getm2(NULL, datalen, ns->malloc_flag, MT_DATA, M_PKTHDR); + if (__predict_false(m == NULL)) { + /* XXX: should we set sorcverr? */ + free(buf, M_NETLINK); + return (false); + } + m_append(m, datalen, buf); + free(buf, M_NETLINK); + + int io_flags = (ns->ignore_limit) ? NL_IOF_IGNORE_LIMIT : 0; + return (nl_send_one(m, (struct nlpcb *)(ns->arg), cnt, io_flags)); +} + +static bool +nlmsg_write_group_buf(struct nlmsg_state *ns, void *buf, int datalen, int cnt) +{ + RT_LOG(LOG_DEBUG2, "IN: ptr: %p len: %d arg: %p", buf, datalen, ns->arg); + if (__predict_false(datalen == 0)) { + free(buf, M_NETLINK); + return (true); + } + + struct mbuf *m = m_getm2(NULL, datalen, ns->malloc_flag, MT_DATA, M_PKTHDR); + if (__predict_false(m == NULL)) { + free(buf, M_NETLINK); + return (false); + } + bool success = m_append(m, datalen, buf) != 0; + free(buf, M_NETLINK); + + if (!success) + return (false); + + nl_send_group(m, cnt, (uint32_t)(uintptr_t)(ns->arg)); + return (true); +} + +static bool +nlmsg_write_chain_buf(struct nlmsg_state *ns, void *buf, int datalen, int cnt) +{ + struct mbuf **m0 = (struct mbuf **)(ns->arg); + RT_LOG(LOG_DEBUG2, "IN: ptr: %p len: %d arg: %p", buf, datalen, ns->arg); + + if (__predict_false(datalen == 0)) { + free(buf, M_NETLINK); + return (true); + } + + if (*m0 == NULL) { + struct mbuf *m; + + m = m_getm2(NULL, datalen, ns->malloc_flag, MT_DATA, M_PKTHDR); + if (__predict_false(m == NULL)) { + free(buf, M_NETLINK); + return (false); + } + *m0 = m; + } + if (__predict_false(m_append(*m0, datalen, buf) == 0)) { + free(buf, M_NETLINK); + return (false); + } + return (true); +} + + +/* + * NS_WRITER_TYPE_MBUF + * Writes message to the allocated mbuf, + * flushing to socket/group when mbuf size limit is reached. + * This is the most efficient mechanism as it avoids double-copying. + * + * Allocates a single mbuf suitable to store up to @size bytes of data. + * If size < MHLEN (around 160 bytes), allocates mbuf with pkghdr + * If size <= MCLBYTES (2k), allocate a single mbuf cluster + * Otherwise, return NULL. + */ +static bool +nlmsg_get_ns_mbuf(struct nlmsg_state *ns, int size, bool waitok) +{ + struct mbuf *m; + + int mflag = waitok ? M_WAITOK : M_NOWAIT; + m = m_get2(size, mflag, MT_DATA, M_PKTHDR); + if (__predict_false(m == NULL)) + return (false); + ns->alloc_len = M_TRAILINGSPACE(m); + ns->offset = 0; + ns->hdr = NULL; + ns->_storage = (void *)m; + ns->data = mtod(m, void *); + ns->writer_type = NS_WRITER_TYPE_MBUF; + ns->malloc_flag = mflag; + ns->num_messages = 0; + RT_LOG(LOG_DEBUG2, "alloc mbuf %p req_len %d alloc_len %d data_ptr %p", + m, size, ns->alloc_len, ns->data); + return (true); +} + +static bool +nlmsg_write_socket_mbuf(struct nlmsg_state *ns, void *buf, int datalen, int cnt) +{ + struct mbuf *m = (struct mbuf *)buf; + RT_LOG(LOG_DEBUG2, "IN: ptr: %p len: %d arg: %p", buf, datalen, ns->arg); + + if (__predict_false(datalen == 0)) { + m_freem(m); + return (true); + } + + m->m_pkthdr.len = datalen; + m->m_len = datalen; + int io_flags = (ns->ignore_limit) ? NL_IOF_IGNORE_LIMIT : 0; + return (nl_send_one(m, (struct nlpcb *)(ns->arg), cnt, io_flags)); +} + +static bool +nlmsg_write_group_mbuf(struct nlmsg_state *ns, void *buf, int datalen, int cnt) +{ + struct mbuf *m = (struct mbuf *)buf; + RT_LOG(LOG_DEBUG2, "IN: ptr: %p len: %d arg: %p", buf, datalen, ns->arg); + + if (__predict_false(datalen == 0)) { + m_freem(m); + return (true); + } + + m->m_pkthdr.len = datalen; + m->m_len = datalen; + nl_send_group(m, cnt, (uint32_t)(uintptr_t)(ns->arg)); + return (true); +} + +static bool +nlmsg_write_chain_mbuf(struct nlmsg_state *ns, void *buf, int datalen, int cnt) +{ + struct mbuf *m_new = (struct mbuf *)buf; + struct mbuf **m0 = (struct mbuf **)(ns->arg); + + RT_LOG(LOG_DEBUG2, "IN: ptr: %p len: %d arg: %p", buf, datalen, ns->arg); + + if (__predict_false(datalen == 0)) { + m_freem(m_new); + return (true); + } + + m_new->m_pkthdr.len = datalen; + m_new->m_len = datalen; + + if (*m0 == NULL) { + *m0 = m_new; + } else { + struct mbuf *m_last; + for (m_last = *m0; m_last->m_next != NULL; m_last = m_last->m_next) + ; + m_last->m_next = m_new; + (*m0)->m_pkthdr.len += datalen; + } + + return (true); +} + +/* + * NS_WRITER_TYPE_LBUF + * Writes message to the allocated memory buffer, + * flushing to socket/group when mbuf size limit is reached. + * Calls linux handler to rewrite messages before sending to the socket. + */ +static bool +nlmsg_get_ns_lbuf(struct nlmsg_state *ns, int size, bool waitok) +{ + int mflag = waitok ? M_WAITOK : M_NOWAIT; + size = roundup2(size, sizeof(void *)); + int add_size = sizeof(struct linear_buffer) + SCRATCH_BUFFER_SIZE; + char *buf = malloc(add_size + size * 2, M_NETLINK, mflag | M_ZERO); + if (__predict_false(buf == NULL)) + return (false); + + /* Fill buffer header first */ + struct linear_buffer *lb = (struct linear_buffer *)buf; + lb->base = &buf[sizeof(struct linear_buffer) + size]; + lb->size = size + SCRATCH_BUFFER_SIZE; + + ns->alloc_len = size; + ns->offset = 0; + ns->hdr = NULL; + ns->_storage = buf; + ns->data = (char *)(lb + 1); + ns->malloc_flag = mflag; + ns->writer_type = NS_WRITER_TYPE_LBUF; + ns->num_messages = 0; + return (true); +} + + +static bool +nlmsg_write_socket_lbuf(struct nlmsg_state *ns, void *buf, int datalen, int cnt) +{ + struct linear_buffer *lb = (struct linear_buffer *)buf; + char *data = (char *)(lb + 1); + struct nlpcb *nlp = (struct nlpcb *)(ns->arg); + + if (__predict_false(datalen == 0)) { + free(buf, M_NETLINK); + return (true); + } + + struct mbuf *m = NULL; + if (linux_netlink_p != NULL) + m = linux_netlink_p->msgs_to_linux(nlp->nl_proto, data, datalen, nlp); + free(buf, M_NETLINK); + + if (__predict_false(m == NULL)) { + /* XXX: should we set sorcverr? */ + return (false); + } + + int io_flags = (ns->ignore_limit) ? NL_IOF_IGNORE_LIMIT : 0; + return (nl_send_one(m, nlp, cnt, io_flags)); +} + +/* Shouldn't be called (maybe except Linux code originating message) */ +static bool +nlmsg_write_group_lbuf(struct nlmsg_state *ns, void *buf, int datalen, int cnt) +{ + struct linear_buffer *lb = (struct linear_buffer *)buf; + char *data = (char *)(lb + 1); + + if (__predict_false(datalen == 0)) { + free(buf, M_NETLINK); + return (true); + } + + struct mbuf *m = m_getm2(NULL, datalen, ns->malloc_flag, MT_DATA, M_PKTHDR); + if (__predict_false(m == NULL)) { + free(buf, M_NETLINK); + return (false); + } + m_append(m, datalen, data); + free(buf, M_NETLINK); + + nl_send_group(m, cnt, (uint32_t)(uintptr_t)(ns->arg)); + return (true); +} + +struct nlwriter_ops nlmsg_writers[] = { + /* NS_WRITER_TYPE_MBUF */ + { + .init = nlmsg_get_ns_mbuf, + .write_socket = nlmsg_write_socket_mbuf, + .write_group = nlmsg_write_group_mbuf, + .write_chain = nlmsg_write_chain_mbuf, + }, + /* NS_WRITER_TYPE_BUF */ + { + .init = nlmsg_get_ns_buf, + .write_socket = nlmsg_write_socket_buf, + .write_group = nlmsg_write_group_buf, + .write_chain = nlmsg_write_chain_buf, + }, + /* NS_WRITER_TYPE_LBUF */ + { + .init = nlmsg_get_ns_lbuf, + .write_socket = nlmsg_write_socket_lbuf, + .write_group = nlmsg_write_group_lbuf, + }, +}; + +static void +nlmsg_set_callback(struct nlmsg_state *ns) +{ + struct nlwriter_ops *pops = &nlmsg_writers[ns->writer_type]; + + switch (ns->writer_target) { + case NS_WRITER_TARGET_SOCKET: + ns->cb = pops->write_socket; + break; + case NS_WRITER_TARGET_GROUP: + ns->cb = pops->write_group; + break; + case NS_WRITER_TARGET_CHAIN: + ns->cb = pops->write_chain; + break; + default: + panic("not implemented"); + } +} + +static bool +nlmsg_get_buf_type(struct nlmsg_state *ns, int size, int type, bool waitok) +{ + MPASS(type + 1 <= sizeof(nlmsg_writers) / sizeof(nlmsg_writers[0])); + RT_LOG(LOG_DEBUG3, "Setting up ns %p size %d type %d", ns, size, type); + return (nlmsg_writers[type].init(ns, size, waitok)); +} + +static bool +nlmsg_get_buf(struct nlmsg_state *ns, int size, bool waitok, bool is_linux) +{ + int type; + + if (!is_linux) { + if (__predict_true(size <= MCLBYTES)) + type = NS_WRITER_TYPE_MBUF; + else + type = NS_WRITER_TYPE_BUF; + } else + type = NS_WRITER_TYPE_LBUF; + return (nlmsg_get_buf_type(ns, size, type, waitok)); +} + +bool +nlmsg_get_socket_writer(int size, struct nlpcb *nlp, struct nlmsg_state *ns) +{ + if (!nlmsg_get_buf(ns, size, false, nlp->nl_linux)) + return (false); + ns->arg = (void *)nlp; + ns->writer_target = NS_WRITER_TARGET_SOCKET; + nlmsg_set_callback(ns); + return (true); +} + +bool +nlmsg_get_group_writer(int size, uint32_t group_mask, struct nlmsg_state *ns) +{ + if (!nlmsg_get_buf(ns, size, false, false)) + return (false); + ns->arg = (void *)(uintptr_t)group_mask; + ns->writer_target = NS_WRITER_TARGET_GROUP; + nlmsg_set_callback(ns); + return (true); +} + +bool +nlmsg_get_chain_writer(int size, struct mbuf **pm, struct nlmsg_state *ns) +{ + if (!nlmsg_get_buf(ns, size, false, false)) + return (false); + *pm = NULL; + ns->arg = (void *)pm; + ns->writer_target = NS_WRITER_TARGET_CHAIN; + nlmsg_set_callback(ns); + RT_LOG(LOG_DEBUG3, "setup cb %p (need %p)", ns->cb, &nlmsg_write_chain_mbuf); + return (true); +} + +void +nlmsg_ignore_limit(struct nlmsg_state *ns) +{ + ns->ignore_limit = true; +} + +bool +nlmsg_flush(struct nlmsg_state *ns) +{ + + if (__predict_false(ns->hdr != NULL)) { + /* Last message has not been completed, skip it. */ + int completed_len = (char *)ns->hdr - ns->data; + /* Send completed messages */ + ns->offset -= ns->offset - completed_len; + ns->hdr = NULL; + } + + bool result = ns->cb(ns, ns->_storage, ns->offset, ns->num_messages); + ns->_storage = NULL; + + if (!result) { + RT_LOG(LOG_DEBUG, "ns %p offset %d: flush with %p() failed", ns, ns->offset, ns->cb); + } + + return (result); +} + +/* + * Flushes previous data and allocates new underlying storage + * sufficient for holding at least @required_len bytes. + * Return true on success. + */ +bool +nlmsg_refill_buffer(struct nlmsg_state *ns, int required_len) +{ + struct nlmsg_state ns_new = {}; + int completed_len, new_len; + + RT_LOG(LOG_DEBUG3, "no space at offset %d/%d (want %d), trying to reclaim", + ns->offset, ns->alloc_len, required_len); + + /* Calculated new buffer size and allocate it s*/ + completed_len = (ns->hdr != NULL) ? (char *)ns->hdr - ns->data : ns->offset; + if (completed_len > 0 && required_len < MCLBYTES) { + /* We already ran out of space, use the largest effective size */ + new_len = max(ns->alloc_len, MCLBYTES); + } else { + if (ns->alloc_len < MCLBYTES) + new_len = MCLBYTES; + else + new_len = ns->alloc_len * 2; + while (new_len < required_len) + new_len *= 2; + } + bool waitok = (ns->malloc_flag == M_WAITOK); + bool is_linux = (ns->writer_type == NS_WRITER_TYPE_LBUF); + if (!nlmsg_get_buf(&ns_new, new_len, waitok, is_linux)) + return (false); + if (ns->ignore_limit) + nlmsg_ignore_limit(&ns_new); + + /* Update callback data */ + ns_new.writer_target = ns->writer_target; + nlmsg_set_callback(&ns_new); + ns_new.arg = ns->arg; + + /* Copy last (unfinished) header to the new storage */ + int last_len = ns->offset - completed_len; + if (last_len > 0) { + memcpy(ns_new.data, ns->hdr, last_len); + ns_new.hdr = (struct nlmsghdr *)ns_new.data; + ns_new.offset = last_len; + } + + RT_LOG(LOG_DEBUG2, "completed: %d bytes, copied: %d bytes", completed_len, last_len); + + /* Flush completed headers */ + if (completed_len > 0) { + RT_LOG(LOG_DEBUG2, "Flushing %u completed message(s) (%d bytes)", + ns->num_messages, completed_len); + ns->offset -= last_len; + ns->hdr = NULL; + nlmsg_flush(ns); + } + + /* Update state */ + memcpy(ns, &ns_new, sizeof(struct nlmsg_state)); + RT_LOG(LOG_DEBUG2, "switched mbuf: used %d/%d bytes", ns->offset, ns->alloc_len); + + return (true); +} + +bool +nlmsg_add(struct nlmsg_state *ns, uint32_t portid, uint32_t seq, uint16_t type, + uint16_t flags, uint32_t len) +{ + struct nlmsghdr *hdr; + + MPASS(ns->hdr == NULL); + + int required_len = NETLINK_ALIGN(len + sizeof(struct nlmsghdr)); + if (__predict_false(ns->offset + required_len > ns->alloc_len)) { + if (!nlmsg_refill_buffer(ns, required_len)) + return (false); + } + + hdr = (struct nlmsghdr *)(&ns->data[ns->offset]); + + hdr->nlmsg_len = len; + hdr->nlmsg_type = type; + hdr->nlmsg_flags = flags; + hdr->nlmsg_seq = seq; + hdr->nlmsg_pid = portid; + + ns->hdr = hdr; + ns->offset += sizeof(struct nlmsghdr); + + return (true); +} + +void +nlmsg_end(struct nlmsg_state *ns) +{ + MPASS(ns->hdr != NULL); + + ns->hdr->nlmsg_len = (uint32_t)(ns->data + ns->offset - (char *)ns->hdr); + ns->hdr = NULL; + ns->num_messages++; +} + +void +nlmsg_abort(struct nlmsg_state *ns) +{ + if (ns->hdr != NULL) { + ns->offset = (uint32_t)((char *)ns->hdr - ns->data); + ns->hdr = NULL; + } +} + diff --git a/sys/netlink/netlink_module.c b/sys/netlink/netlink_module.c new file mode 100644 --- /dev/null +++ b/sys/netlink/netlink_module.c @@ -0,0 +1,226 @@ +/*- + * SPDX-License-Identifier: BSD-2-Clause-FreeBSD + * + * Copyright (c) 2021 Ng Peng Nam Sean + * 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 +__FBSDID("$FreeBSD$"); +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include + +#include + +MALLOC_DEFINE(M_NETLINK, "netlink", "Memory used for netlink packets"); + +#define DEBUG_MOD_NAME nl_mod +#define DEBUG_MAX_LEVEL LOG_DEBUG3 +#include +_DECLARE_DEBUG(LOG_DEBUG); + +SYSCTL_NODE(_net, OID_AUTO, netlink, CTLFLAG_RD, 0, ""); + +#define NL_MAX_HANDLERS 20 +struct nl_proto_handler _nl_handlers[NL_MAX_HANDLERS]; +struct nl_proto_handler *nl_handlers = _nl_handlers; + +CK_LIST_HEAD(nl_control_head, nl_control); +static struct nl_control_head vnets_head = CK_LIST_HEAD_INITIALIZER(); + +VNET_DEFINE(struct nl_control *, nl_ctl) = NULL; + +struct mtx nl_global_mtx; +MTX_SYSINIT(nl_global_mtx, &nl_global_mtx, "global netlink lock", MTX_DEF); + +#define NL_GLOBAL_LOCK() mtx_lock(&nl_global_mtx) +#define NL_GLOBAL_UNLOCK() mtx_unlock(&nl_global_mtx) + +int netlink_unloading = 0; + +static void +free_nl_ctl(struct nl_control *ctl) +{ + rm_destroy(&ctl->ctl_lock); + free(ctl, M_NETLINK); +} + +struct nl_control * +vnet_nl_ctl_init(void) +{ + struct nl_control *ctl; + + ctl = malloc(sizeof(struct nl_control), M_NETLINK, M_WAITOK | M_ZERO); + rm_init(&ctl->ctl_lock, "netlink lock"); + CK_LIST_INIT(&ctl->ctl_port_head); + CK_LIST_INIT(&ctl->ctl_pcb_head); + + NL_GLOBAL_LOCK(); + + struct nl_control *tmp = atomic_load_ptr(&V_nl_ctl); + + if (tmp == NULL) { + atomic_store_ptr(&V_nl_ctl, ctl); + CK_LIST_INSERT_HEAD(&vnets_head, ctl, ctl_next); + RT_LOG(LOG_DEBUG2, "VNET %p init done, inserted %p into global list", + curvnet, ctl); + } else { + RT_LOG(LOG_DEBUG, "per-VNET init clash, dropping this instance"); + free_nl_ctl(ctl); + ctl = tmp; + } + + NL_GLOBAL_UNLOCK(); + + return (ctl); +} + +static void +vnet_nl_ctl_destroy(const void *unused __unused) +{ + struct nl_control *ctl; + + /* Assume at the time all of the processes / sockets are dead */ + + NL_GLOBAL_LOCK(); + ctl = atomic_load_ptr(&V_nl_ctl); + atomic_store_ptr(&V_nl_ctl, NULL); + if (ctl != NULL) { + RT_LOG(LOG_DEBUG2, "Removing %p from global list", ctl); + CK_LIST_REMOVE(ctl, ctl_next); + } + NL_GLOBAL_UNLOCK(); + + if (ctl != NULL) + free_nl_ctl(ctl); +} +VNET_SYSUNINIT(vnet_nl_ctl_destroy, SI_SUB_PROTO_IF, SI_ORDER_ANY, + vnet_nl_ctl_destroy, NULL); + +int +nl_verify_proto(int proto) +{ + if (proto < 0 || proto >= NL_MAX_HANDLERS) { + return (EINVAL); + } + int handler_defined = nl_handlers[proto].cb != NULL; + return (handler_defined ? 0 : EPROTONOSUPPORT); +} + +const char * +nl_get_proto_name(int proto) +{ + return (nl_handlers[proto].proto_name); +} + +bool +netlink_register_proto(int proto, const char *proto_name, nl_handler_f handler) +{ + if ((proto < 0) || (proto >= NL_MAX_HANDLERS)) + return (false); + NL_GLOBAL_LOCK(); + KASSERT((nl_handlers[proto].cb == NULL), ("netlink handler %d is already set", proto)); + nl_handlers[proto].cb = handler; + nl_handlers[proto].proto_name = proto_name; + NL_GLOBAL_UNLOCK(); + RT_LOG(LOG_DEBUG, "Registered netlink %s(%d) handler", proto_name, proto); + return (true); +} + +bool +netlink_unregister_proto(int proto) +{ + if ((proto < 0) || (proto >= NL_MAX_HANDLERS)) + return (false); + NL_GLOBAL_LOCK(); + KASSERT((nl_handlers[proto].cb != NULL), ("netlink handler %d is not set", proto)); + nl_handlers[proto].cb = NULL; + nl_handlers[proto].proto_name = NULL; + NL_GLOBAL_UNLOCK(); + RT_LOG(LOG_DEBUG, "Unregistered netlink proto %d handler", proto); + return (true); +} + +static bool +can_unload(void) +{ + struct nl_control *ctl; + bool result = true; + + NL_GLOBAL_LOCK(); + + CK_LIST_FOREACH(ctl, &vnets_head, ctl_next) { + RT_LOG(LOG_DEBUG2, "Iterating VNET head %p", ctl); + if (!CK_LIST_EMPTY(&ctl->ctl_pcb_head)) { + RT_LOG(LOG_NOTICE, "non-empty socket list in ctl %p", ctl); + result = false; + break; + } + } + + NL_GLOBAL_UNLOCK(); + + return (result); +} + +static int +netlink_modevent(module_t mod __unused, int what, void *priv __unused) +{ + int ret = 0; + + switch (what) { + case MOD_LOAD: + RT_LOG(LOG_NOTICE, "Loading"); + break; + + case MOD_UNLOAD: + RT_LOG(LOG_NOTICE, "Unload called"); + if (can_unload()) { + RT_LOG(LOG_WARNING, "unloading"); + netlink_unloading = 1; + } else + ret = EBUSY; + break; + + default: + ret = EOPNOTSUPP; + break; + } + + return (ret); +} +static moduledata_t netlink_mod = { "netlink", netlink_modevent, NULL }; + +DECLARE_MODULE(netlink, netlink_mod, SI_SUB_PSEUDO, SI_ORDER_ANY); +MODULE_VERSION(netlink, 1); diff --git a/sys/netlink/netlink_route.h b/sys/netlink/netlink_route.h new file mode 100644 --- /dev/null +++ b/sys/netlink/netlink_route.h @@ -0,0 +1,43 @@ +/*- + * SPDX-License-Identifier: BSD-2-Clause-FreeBSD + * + * Copyright (c) 2021 Ng Peng Nam Sean + * + * 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. + */ +#ifndef _NETLINK_NETLINK_ROUTE_H_ +#define _NETLINK_NETLINK_ROUTE_H_ + +#include + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#endif diff --git a/sys/netlink/netlink_route.c b/sys/netlink/netlink_route.c new file mode 100644 --- /dev/null +++ b/sys/netlink/netlink_route.c @@ -0,0 +1,154 @@ +/*- + * SPDX-License-Identifier: BSD-2-Clause-FreeBSD + * + * Copyright (c) 2021 Ng Peng Nam Sean + * + * 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 +__FBSDID("$FreeBSD$"); +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#define DEBUG_MOD_NAME nl_route_core +#define DEBUG_MAX_LEVEL LOG_DEBUG3 +#include +_DECLARE_DEBUG(LOG_DEBUG); + +#define HANDLER_MAX_NUM (NL_RTM_MAX + 10) +static struct rtnl_cmd_handler *rtnl_handler[HANDLER_MAX_NUM] = {}; + +bool +rtnl_register_messages(struct rtnl_cmd_handler *handlers, int count) +{ + for (int i = 0; i < count; i++) { + if (handlers[i].rtnl_cmd >= HANDLER_MAX_NUM) + return (false); + MPASS(rtnl_handler[handlers[i].rtnl_cmd] == NULL); + } + for (int i = 0; i < count; i++) + rtnl_handler[handlers[i].rtnl_cmd] = &handlers[i]; + return (true); +} + +/* + * Handler called by netlink subsystem when matching netlink message is received + */ +static int +rtnl_handle_message(struct nlmsghdr *hdr, struct netlink_parse_tracker *npt) +{ + struct rtnl_cmd_handler *cmd; + struct epoch_tracker et; + struct nlpcb *nlp = npt->nlp; + int error = 0; + + if (__predict_false(hdr->nlmsg_type >= HANDLER_MAX_NUM)) { + NLP_LOG(LOG_DEBUG, nlp, "invalid message type: %d", hdr->nlmsg_type); + return (ENOTSUP); + } + + cmd = rtnl_handler[hdr->nlmsg_type]; + if (__predict_false(cmd == NULL)) { + RT_LOG(LOG_DEBUG, "invalid message type: %d", hdr->nlmsg_type); + return (ENOTSUP); + } + + NLP_LOG(LOG_DEBUG2, nlp, "received msg %s(%d) len %d", cmd->rtnl_cmd_name, + hdr->nlmsg_type, hdr->nlmsg_len); + /* XXX: check min header length if strict is set */ + + /* + * Setup message writer. TODO: init when reading mbuf batch. + */ + struct nlmsg_state ns = {}; + if (!nlmsg_get_socket_writer(NLMSG_SMALL, nlp, &ns)) { + RT_LOG(LOG_DEBUG, "error allocating socket writer"); + return (ENOMEM); + } + nlmsg_ignore_limit(&ns); + npt->ns = &ns; + + bool need_epoch = !(cmd->rtnl_flags & RTNL_F_NOEPOCH); + + if (need_epoch) + NET_EPOCH_ENTER(et); + error = cmd->rtnl_cb(hdr, nlp, npt); + if (need_epoch) + NET_EPOCH_EXIT(et); + + nlmsg_flush(&ns); + + return (error); +} + +static void nlbridge_cb_func(uint32_t event_type, uint32_t fibnum, + const struct rt_addrinfo *info, const struct rib_cmd_info *rc, void *arg) +{ + RT_LOG(LOG_DEBUG2, "received bridge event %d", event_type); + switch (event_type) { + case NLBR_EVENT_ROUTE: + rtnl_handle_route_event(fibnum, info, rc); + break; + } +} + +static struct rib_event_bridge nlbridge = { + .reb_cb = nlbridge_cb_func, + .reb_cb_arg = NULL, + .reb_provider_id = NLBR_PROVIDER_NETLINK, +}; + +static void +rtnl_load(void *u __unused) +{ + RT_LOG(LOG_ERR, "netlink support is in BETA stage"); + RT_LOG(LOG_NOTICE, "rtnl loading"); + rib_bridge_link(&nlbridge); + rtnl_neighs_init(); + rtnl_ifaces_init(); + rtnl_nexthops_init(); + rtnl_routes_init(); + netlink_register_proto(NETLINK_ROUTE, "NETLINK_ROUTE", rtnl_handle_message); +} +SYSINIT(rtnl_load, SI_SUB_PROTO_DOMAIN, SI_ORDER_THIRD, rtnl_load, NULL); + +static void +rtnl_unload(void *u __unused) +{ + rib_bridge_unlink(&nlbridge); + rtnl_ifaces_destroy(); + + /* Wait till all consumers read nlbridge data */ + epoch_wait_preempt(net_epoch_preempt); +} +SYSUNINIT(rtnl_unload, SI_SUB_PROTO_DOMAIN, SI_ORDER_THIRD, rtnl_unload, NULL); diff --git a/sys/netlink/netlink_var.h b/sys/netlink/netlink_var.h new file mode 100644 --- /dev/null +++ b/sys/netlink/netlink_var.h @@ -0,0 +1,148 @@ +/*- + * SPDX-License-Identifier: BSD-2-Clause-FreeBSD + * + * Copyright (c) 2021 Ng Peng Nam Sean + * 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. + */ +#ifndef _NETLINK_NETLINK_VAR_H_ +#define _NETLINK_NETLINK_VAR_H_ + +#include +#include +#include +#include + +#define NLSNDQ 65536 /* Default socket sendspace */ +#define NLRCVQ 65536 /* Default socket recvspace */ + +struct ucred; + +struct nl_io_queue { + struct mbuf *head; + struct mbuf *last; + int length; + int hiwat; +}; + +struct nlpcb { + struct socket *nl_socket; + uint32_t nl_port; + uint32_t nl_groups; + uint32_t nl_flags; + uint32_t nl_process_id; + int nl_proto; + bool nl_active; + bool nl_bound; + bool nl_task_pending; + bool nl_tx_blocked; /* No new requests accepted */ + bool nl_linux; /* true if running under compat */ + struct nl_io_queue rx_queue; + struct nl_io_queue tx_queue; + struct taskqueue *nl_taskqueue; + struct task nl_task; + struct ucred *nl_cred; /* Copy of nl_socket->so_cred */ + uint64_t nl_dropped_bytes; + uint64_t nl_dropped_messages; + CK_LIST_ENTRY(nlpcb) nl_next; + CK_LIST_ENTRY(nlpcb) nl_port_next; + volatile u_int nl_refcount; + struct mtx nl_lock; + struct epoch_context nl_epoch_ctx; +}; +#define sotonlpcb(so) ((struct nlpcb *)(so)->so_pcb) + +#define NLP_LOCK_INIT(_nlp) mtx_init(&((_nlp)->nl_lock), "nlp mtx", NULL, MTX_DEF) +#define NLP_LOCK_DESTROY(_nlp) mtx_destroy(&((_nlp)->nl_lock)) +#define NLP_LOCK(_nlp) mtx_lock(&((_nlp)->nl_lock)) +#define NLP_UNLOCK(_nlp) mtx_unlock(&((_nlp)->nl_lock)) + +#define ALIGNED_NL_SZ(_data) roundup2((((struct nlmsghdr *)(_data))->nlmsg_len), 16) + +#define NLF_CAP_ACK 0x01 /* Do not send message body with errmsg */ +#define NLF_EXT_ACK 0x02 /* Allow including extended TLVs in ack */ + +SYSCTL_DECL(_net_netlink); + +struct nl_io { + struct callout callout; + struct mbuf *head; + struct mbuf *last; + int64_t length; +}; + + +struct nl_control { + CK_LIST_HEAD(nl_pid_head, nlpcb) ctl_port_head; + CK_LIST_HEAD(nlpcb_head, nlpcb) ctl_pcb_head; + CK_LIST_ENTRY(nl_control) ctl_next; + struct nl_io ctl_io; + struct rmlock ctl_lock; +}; +VNET_DECLARE(struct nl_control *, nl_ctl); +#define V_nl_ctl VNET(nl_ctl) + + +/* locking */ +#define NLCTL_TRACKER struct rm_priotracker nl_tracker +#define NLCTL_RLOCK(_ctl) rm_rlock(&((_ctl)->ctl_lock), &nl_tracker) +#define NLCTL_RUNLOCK(_ctl) rm_runlock(&((_ctl)->ctl_lock), &nl_tracker) + +#define NLCTL_WLOCK(_ctl) rm_wlock(&((_ctl)->ctl_lock)) +#define NLCTL_WUNLOCK(_ctl) rm_wunlock(&((_ctl)->ctl_lock)) + +struct sockaddr_nl; +struct sockaddr; +struct nlmsghdr; + + +/* netlink_module.c */ +struct nl_control *vnet_nl_ctl_init(void); + +int nl_verify_proto(int proto); +const char *nl_get_proto_name(int proto); + +extern int netlink_unloading; + +struct nl_proto_handler { + nl_handler_f cb; + const char *proto_name; +}; +extern struct nl_proto_handler *nl_handlers; + +/* netlink_domain.c */ +void nl_send_group(struct mbuf *m, int cnt, uint32_t group_mask); + +/* netlink_io.c */ +#define NL_IOF_UNTRANSLATED 0x01 +#define NL_IOF_IGNORE_LIMIT 0x02 +bool nl_send_one(struct mbuf *m, struct nlpcb *nlp, int cnt, int io_flags); +void nlmsg_ack(struct nlpcb *nlp, int error, struct nlmsghdr *nlmsg); +void nl_on_transmit(struct nlpcb *nlp); +void nl_free_io(struct nlpcb *nlp); + +void nl_taskqueue_handler(void *_arg, int pending); +int nl_receive_async(struct mbuf *m, struct socket *so); +void nl_process_receive_locked(struct nlpcb *nlp); + +#endif diff --git a/sys/netlink/route/common.h b/sys/netlink/route/common.h new file mode 100644 --- /dev/null +++ b/sys/netlink/route/common.h @@ -0,0 +1,243 @@ +/* + * Common defines for all parts of the netlink route family + */ + +#ifndef _NETLINK_ROUTE_COMMON_H_ +#define _NETLINK_ROUTE_COMMON_H_ + +/* + * All messages defined by the NETLINK_ROUTE subsystem + */ +enum { + NL_RTM_BASE = 16, +#define NL_RTM_BASE NL_RTM_BASE + NL_RTM_NEWLINK = 16, +#define NL_RTM_NEWLINK NL_RTM_NEWLINK + NL_RTM_DELLINK, +#define NL_RTM_DELLINK NL_RTM_DELLINK + NL_RTM_GETLINK, +#define NL_RTM_GETLINK NL_RTM_GETLINK + NL_RTM_SETLINK, +#define NL_RTM_SETLINK NL_RTM_SETLINK + NL_RTM_NEWADDR = 20, +#define NL_RTM_NEWADDR NL_RTM_NEWADDR + NL_RTM_DELADDR, +#define NL_RTM_DELADDR NL_RTM_DELADDR + NL_RTM_GETADDR, +#define NL_RTM_GETADDR NL_RTM_GETADDR + NL_RTM_NEWROUTE = 24, +#define NL_RTM_NEWROUTE NL_RTM_NEWROUTE + NL_RTM_DELROUTE, +#define NL_RTM_DELROUTE NL_RTM_DELROUTE + NL_RTM_GETROUTE, +#define NL_RTM_GETROUTE NL_RTM_GETROUTE + NL_RTM_NEWNEIGH = 28, +#define NL_RTM_NEWNEIGH NL_RTM_NEWNEIGH + NL_RTM_DELNEIGH, +#define NL_RTM_DELNEIGH NL_RTM_DELNEIGH + NL_RTM_GETNEIGH, +#define NL_RTM_GETNEIGH NL_RTM_GETNEIGH + NL_RTM_NEWRULE = 32, +#define NL_RTM_NEWRULE NL_RTM_NEWRULE + NL_RTM_DELRULE, +#define NL_RTM_DELRULE NL_RTM_DELRULE + NL_RTM_GETRULE, +#define NL_RTM_GETRULE NL_RTM_GETRULE + NL_RTM_NEWQDISC = 36, +#define NL_RTM_NEWQDISC NL_RTM_NEWQDISC + NL_RTM_DELQDISC, +#define NL_RTM_DELQDISC NL_RTM_DELQDISC + NL_RTM_GETQDISC, +#define NL_RTM_GETQDISC NL_RTM_GETQDISC + NL_RTM_NEWTCLASS = 40, +#define NL_RTM_NEWTCLASS NL_RTM_NEWTCLASS + NL_RTM_DELTCLASS, +#define NL_RTM_DELTCLASS NL_RTM_DELTCLASS + NL_RTM_GETTCLASS, +#define NL_RTM_GETTCLASS NL_RTM_GETTCLASS + NL_RTM_NEWTFILTER = 44, +#define NL_RTM_NEWTFILTER NL_RTM_NEWTFILTER + NL_RTM_DELTFILTER, +#define NL_RTM_DELTFILTER NL_RTM_DELTFILTER + NL_RTM_GETTFILTER, +#define NL_RTM_GETTFILTER NL_RTM_GETTFILTER + NL_RTM_NEWACTION = 48, +#define NL_RTM_NEWACTION NL_RTM_NEWACTION + NL_RTM_DELACTION, +#define NL_RTM_DELACTION NL_RTM_DELACTION + NL_RTM_GETACTION, +#define NL_RTM_GETACTION NL_RTM_GETACTION + NL_RTM_NEWPREFIX = 52, +#define NL_RTM_NEWPREFIX NL_RTM_NEWPREFIX + NL_RTM_GETMULTICAST = 58, +#define NL_RTM_GETMULTICAST NL_RTM_GETMULTICAST + NL_RTM_GETANYCAST = 62, +#define NL_RTM_GETANYCAST NL_RTM_GETANYCAST + NL_RTM_NEWNEIGHTBL = 64, +#define NL_RTM_NEWNEIGHTBL NL_RTM_NEWNEIGHTBL + NL_RTM_GETNEIGHTBL = 66, +#define NL_RTM_GETNEIGHTBL NL_RTM_GETNEIGHTBL + NL_RTM_SETNEIGHTBL, +#define NL_RTM_SETNEIGHTBL NL_RTM_SETNEIGHTBL + NL_RTM_NEWNDUSEROPT = 68, +#define NL_RTM_NEWNDUSEROPT NL_RTM_NEWNDUSEROPT + NL_RTM_NEWADDRLABEL = 72, +#define NL_RTM_NEWADDRLABEL NL_RTM_NEWADDRLABEL + NL_RTM_DELADDRLABEL, +#define NL_RTM_DELADDRLABEL NL_RTM_DELADDRLABEL + NL_RTM_GETADDRLABEL, +#define NL_RTM_GETADDRLABEL NL_RTM_GETADDRLABEL + NL_RTM_GETDCB = 78, +#define NL_RTM_GETDCB NL_RTM_GETDCB + NL_RTM_SETDCB, +#define NL_RTM_SETDCB NL_RTM_SETDCB + NL_RTM_NEWNETCONF = 80, +#define NL_RTM_NEWNETCONF NL_RTM_NEWNETCONF + NL_RTM_GETNETCONF = 82, +#define NL_RTM_GETNETCONF NL_RTM_GETNETCONF + NL_RTM_NEWMDB = 84, +#define NL_RTM_NEWMDB NL_RTM_NEWMDB + NL_RTM_DELMDB = 85, +#define NL_RTM_DELMDB NL_RTM_DELMDB + NL_RTM_GETMDB = 86, +#define NL_RTM_GETMDB NL_RTM_GETMDB + NL_RTM_NEWNSID = 88, +#define NL_RTM_NEWNSID NL_RTM_NEWNSID + NL_RTM_DELNSID = 89, +#define NL_RTM_DELNSID NL_RTM_DELNSID + NL_RTM_GETNSID = 90, +#define NL_RTM_GETNSID NL_RTM_GETNSID + NL_RTM_NEWSTATS = 92, +#define NL_RTM_NEWSTATS NL_RTM_NEWSTATS + NL_RTM_GETSTATS = 94, +#define NL_RTM_GETSTATS NL_RTM_GETSTATS + NL_RTM_NEWNEXTHOP = 104, +#define NL_RTM_NEWNEXTHOP NL_RTM_NEWNEXTHOP + NL_RTM_DELNEXTHOP, +#define NL_RTM_DELNEXTHOP NL_RTM_DELNEXTHOP + NL_RTM_GETNEXTHOP, +#define NL_RTM_GETNEXTHOP NL_RTM_GETNEXTHOP + __NL_RTM_MAX, +}; +#define NL_RTM_MAX (((__NL_RTM_MAX + 3) & ~3) - 1) + +#ifndef _KERNEL +/* + * RTM_* namespace clashes with BSD rtsock namespace. + * Use NL_RTM_ prefix in the kernel and map it to RTM_ + * for userland. + */ +#define RTM_BASE NL_RTM_BASE +#define RTM_NEWLINK NL_RTM_NEWLINK +#define RTM_DELLINK NL_RTM_DELLINK +#define RTM_GETLINK NL_RTM_GETLINK +#define RTM_SETLINK NL_RTM_SETLINK +#define RTM_NEWADDR NL_RTM_NEWADDR +#define RTM_DELADDR NL_RTM_DELADDR +#define RTM_GETADDR NL_RTM_GETADDR +#define RTM_NEWROUTE NL_RTM_NEWROUTE +#define RTM_DELROUTE NL_RTM_DELROUTE +#define RTM_GETROUTE NL_RTM_GETROUTE +#define RTM_NEWNEXTHOP NL_RTM_NEWNEXTHOP +#define RTM_DELNEXTHOP NL_RTM_DELNEXTHOP +#define RTM_GETNEXTHOP NL_RTM_GETNEXTHOP +#endif + +#ifndef _KERNEL +/* rtnetlink multicast groups - backwards compatibility for userspace */ +#define RTMGRP_LINK 0x01 +#define RTMGRP_NOTIFY 0x02 +#define RTMGRP_NEIGH 0x04 +#define RTMGRP_TC 0x08 + +#define RTMGRP_IPV4_IFADDR 0x10 +#define RTMGRP_IPV4_MROUTE 0x20 +#define RTMGRP_IPV4_ROUTE 0x40 +#define RTMGRP_IPV4_RULE 0x80 + +#define RTMGRP_IPV6_IFADDR 0x100 +#define RTMGRP_IPV6_MROUTE 0x200 +#define RTMGRP_IPV6_ROUTE 0x400 +#define RTMGRP_IPV6_IFINFO 0x800 + +#define RTMGRP_DECnet_IFADDR 0x1000 +#define RTMGRP_DECnet_ROUTE 0x4000 + +#define RTMGRP_IPV6_PREFIX 0x20000 +#endif + +/* rtnetlink multicast groups */ +enum rtnetlink_groups { + RTNLGRP_NONE, +#define RTNLGRP_NONE RTNLGRP_NONE + RTNLGRP_LINK, +#define RTNLGRP_LINK RTNLGRP_LINK + RTNLGRP_NOTIFY, +#define RTNLGRP_NOTIFY RTNLGRP_NOTIFY + RTNLGRP_NEIGH, +#define RTNLGRP_NEIGH RTNLGRP_NEIGH + RTNLGRP_TC, +#define RTNLGRP_TC RTNLGRP_TC + RTNLGRP_IPV4_IFADDR, +#define RTNLGRP_IPV4_IFADDR RTNLGRP_IPV4_IFADDR + RTNLGRP_IPV4_MROUTE, +#define RTNLGRP_IPV4_MROUTE RTNLGRP_IPV4_MROUTE + RTNLGRP_IPV4_ROUTE, +#define RTNLGRP_IPV4_ROUTE RTNLGRP_IPV4_ROUTE + RTNLGRP_IPV4_RULE, +#define RTNLGRP_IPV4_RULE RTNLGRP_IPV4_RULE + RTNLGRP_IPV6_IFADDR, +#define RTNLGRP_IPV6_IFADDR RTNLGRP_IPV6_IFADDR + RTNLGRP_IPV6_MROUTE, +#define RTNLGRP_IPV6_MROUTE RTNLGRP_IPV6_MROUTE + RTNLGRP_IPV6_ROUTE, +#define RTNLGRP_IPV6_ROUTE RTNLGRP_IPV6_ROUTE + RTNLGRP_IPV6_IFINFO, +#define RTNLGRP_IPV6_IFINFO RTNLGRP_IPV6_IFINFO + RTNLGRP_DECnet_IFADDR, +#define RTNLGRP_DECnet_IFADDR RTNLGRP_DECnet_IFADDR + RTNLGRP_NOP2, + RTNLGRP_DECnet_ROUTE, +#define RTNLGRP_DECnet_ROUTE RTNLGRP_DECnet_ROUTE + RTNLGRP_DECnet_RULE, +#define RTNLGRP_DECnet_RULE RTNLGRP_DECnet_RULE + RTNLGRP_NOP4, + RTNLGRP_IPV6_PREFIX, +#define RTNLGRP_IPV6_PREFIX RTNLGRP_IPV6_PREFIX + RTNLGRP_IPV6_RULE, +#define RTNLGRP_IPV6_RULE RTNLGRP_IPV6_RULE + RTNLGRP_ND_USEROPT, +#define RTNLGRP_ND_USEROPT RTNLGRP_ND_USEROPT + RTNLGRP_PHONET_IFADDR, +#define RTNLGRP_PHONET_IFADDR RTNLGRP_PHONET_IFADDR + RTNLGRP_PHONET_ROUTE, +#define RTNLGRP_PHONET_ROUTE RTNLGRP_PHONET_ROUTE + RTNLGRP_DCB, +#define RTNLGRP_DCB RTNLGRP_DCB + RTNLGRP_IPV4_NETCONF, +#define RTNLGRP_IPV4_NETCONF RTNLGRP_IPV4_NETCONF + RTNLGRP_IPV6_NETCONF, +#define RTNLGRP_IPV6_NETCONF RTNLGRP_IPV6_NETCONF + RTNLGRP_MDB, +#define RTNLGRP_MDB RTNLGRP_MDB + RTNLGRP_MPLS_ROUTE, +#define RTNLGRP_MPLS_ROUTE RTNLGRP_MPLS_ROUTE + RTNLGRP_NSID, +#define RTNLGRP_NSID RTNLGRP_NSID + RTNLGRP_MPLS_NETCONF, +#define RTNLGRP_MPLS_NETCONF RTNLGRP_MPLS_NETCONF + RTNLGRP_IPV4_MROUTE_R, +#define RTNLGRP_IPV4_MROUTE_R RTNLGRP_IPV4_MROUTE_R + RTNLGRP_IPV6_MROUTE_R, +#define RTNLGRP_IPV6_MROUTE_R RTNLGRP_IPV6_MROUTE_R + RTNLGRP_NEXTHOP, +#define RTNLGRP_NEXTHOP RTNLGRP_NEXTHOP + RTNLGRP_BRVLAN, +#define RTNLGRP_BRVLAN RTNLGRP_BRVLAN + __RTNLGRP_MAX +}; +#define RTNLGRP_MAX (__RTNLGRP_MAX - 1) + + +#endif + diff --git a/sys/netlink/route/iface.c b/sys/netlink/route/iface.c new file mode 100644 --- /dev/null +++ b/sys/netlink/route/iface.c @@ -0,0 +1,718 @@ +/*- + * SPDX-License-Identifier: BSD-2-Clause-FreeBSD + * + * 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 +__FBSDID("$FreeBSD$"); +#include "opt_inet.h" +#include "opt_inet6.h" +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include /* scope deembedding */ + +#define DEBUG_MOD_NAME nl_iface +#define DEBUG_MAX_LEVEL LOG_DEBUG3 +#include +_DECLARE_DEBUG(LOG_DEBUG); + + +struct netlink_walkargs { + struct nlmsg_state *ns; + struct nlmsghdr hdr; + struct nlpcb *so; + uint32_t fibnum; + int family; + int error; + int count; + int dumped; +}; + +#define FAIL_ATTR(a) {\ + RT_LOG(LOG_DEBUG, "failed writing attribute %s (%d)", #a, a); \ + goto enomem; \ +} + +static eventhandler_tag ifdetach_event, ifattach_event, ifaddr_event; + +/* */ + +/* + * RTM_GETLINK request + * sendto(3, {{len=32, type=RTM_GETLINK, flags=NLM_F_REQUEST|NLM_F_DUMP, seq=1641940952, pid=0}, + * {ifi_family=AF_INET, ifi_type=ARPHRD_NETROM, ifi_index=0, ifi_flags=0, ifi_change=0}}, 32, 0, NULL, 0) = 32 + * + * Reply: + * {ifi_family=AF_UNSPEC, ifi_type=ARPHRD_ETHER, ifi_index=if_nametoindex("enp0s31f6"), ifi_flags=IFF_UP|IFF_BROADCAST|IFF_RUNNING|IFF_MULTICAST|IFF_LOWER_UP, ifi_change=0}, +{{nla_len=10, nla_type=IFLA_ADDRESS}, "\xfe\x54\x00\x52\x3e\x90"} + +[ +{{nla_len=14, nla_type=IFLA_IFNAME}, "enp0s31f6"}, +{{nla_len=8, nla_type=IFLA_TXQLEN}, 1000}, +{{nla_len=5, nla_type=IFLA_OPERSTATE}, 6}, +{{nla_len=5, nla_type=IFLA_LINKMODE}, 0}, +{{nla_len=8, nla_type=IFLA_MTU}, 1500}, +{{nla_len=8, nla_type=IFLA_MIN_MTU}, 68}, + {{nla_len=8, nla_type=IFLA_MAX_MTU}, 9000}, +{{nla_len=8, nla_type=IFLA_GROUP}, 0}, +{{nla_len=8, nla_type=IFLA_PROMISCUITY}, 0}, +{{nla_len=8, nla_type=IFLA_NUM_TX_QUEUES}, 1}, +{{nla_len=8, nla_type=IFLA_GSO_MAX_SEGS}, 65535}, +{{nla_len=8, nla_type=IFLA_GSO_MAX_SIZE}, 65536}, +{{nla_len=8, nla_type=IFLA_NUM_RX_QUEUES}, 1}, +{{nla_len=5, nla_type=IFLA_CARRIER}, 1}, +{{nla_len=13, nla_type=IFLA_QDISC}, "fq_codel"}, +{{nla_len=8, nla_type=IFLA_CARRIER_CHANGES}, 2}, +{{nla_len=5, nla_type=IFLA_PROTO_DOWN}, 0}, +{{nla_len=8, nla_type=IFLA_CARRIER_UP_COUNT}, 1}, +{{nla_len=8, nla_type=IFLA_CARRIER_DOWN_COUNT}, 1}, + */ + +struct if_state { + uint8_t ifla_operstate; + uint8_t ifla_carrier; +}; + +static void +get_operstate_ether(struct ifnet *ifp, struct if_state *pstate) +{ + struct ifmediareq ifmr = {}; + int error; + error = (*ifp->if_ioctl)(ifp, SIOCGIFMEDIA, (void *)&ifmr); + + if (error != 0) { + RT_LOG(LOG_DEBUG, "error calling SIOCGIFMEDIA on %s: %d", + if_name(ifp), error); + return; + } + + switch (IFM_TYPE(ifmr.ifm_active)) { + case IFM_ETHER: + if (ifmr.ifm_status & IFM_ACTIVE) { + pstate->ifla_carrier = 1; + if (ifp->if_flags & IFF_MONITOR) + pstate->ifla_operstate = IF_OPER_DORMANT; + else + pstate->ifla_operstate = IF_OPER_UP; + } else + pstate->ifla_operstate = IF_OPER_DOWN; + } +} + +static bool +get_stats(struct nlmsg_state *ns, struct ifnet *ifp) +{ + struct rtnl_link_stats64 *stats; + + int nla_len = sizeof(struct nlattr) + sizeof(*stats); + struct nlattr *nla = nlmsg_reserve_data(ns, nla_len, struct nlattr); + if (nla == NULL) + return (false); + nla->nla_type = IFLA_STATS64; + nla->nla_len = nla_len; + stats = (struct rtnl_link_stats64 *)(nla + 1); + + stats->rx_packets = ifp->if_get_counter(ifp, IFCOUNTER_IPACKETS); + stats->tx_packets = ifp->if_get_counter(ifp, IFCOUNTER_OPACKETS); + + stats->rx_bytes = ifp->if_get_counter(ifp, IFCOUNTER_IBYTES); + stats->tx_bytes = ifp->if_get_counter(ifp, IFCOUNTER_OBYTES); + stats->rx_errors = ifp->if_get_counter(ifp, IFCOUNTER_IERRORS); + stats->tx_errors = ifp->if_get_counter(ifp, IFCOUNTER_OERRORS); + stats->rx_dropped = ifp->if_get_counter(ifp, IFCOUNTER_IQDROPS); + stats->tx_dropped = ifp->if_get_counter(ifp, IFCOUNTER_OQDROPS); + stats->multicast = ifp->if_get_counter(ifp, IFCOUNTER_IMCASTS); + stats->rx_nohandler = ifp->if_get_counter(ifp, IFCOUNTER_NOPROTO); + + return (true); +} + +static void +get_operstate(struct ifnet *ifp, struct if_state *pstate) +{ + pstate->ifla_operstate = IF_OPER_UNKNOWN; + pstate->ifla_carrier = 0; /* no carrier */ + + switch (ifp->if_type) { + case IFT_ETHER: + get_operstate_ether(ifp, pstate); + break; + case IFT_LOOP: + if (ifp->if_flags & IFF_UP) { + pstate->ifla_operstate = IF_OPER_UP; + pstate->ifla_carrier = 1; + } else + pstate->ifla_operstate = IF_OPER_DOWN; + break; + } +} + +static unsigned +ifp_flags_to_netlink(const struct ifnet *ifp) +{ + return (ifp->if_flags | ifp->if_drv_flags); +} + +#define LLADDR_CONST(s) ((const void *)((s)->sdl_data + (s)->sdl_nlen)) +static bool +dump_sa(struct nlmsg_state *ns, int attr, const struct sockaddr *sa) +{ + uint32_t addr_len = 0; + const void *addr_data = NULL; + struct in6_addr addr6; + + if (sa == NULL) + return (true); + + switch (sa->sa_family) { + case AF_INET: + addr_len = sizeof(struct in_addr); + addr_data = &((const struct sockaddr_in *)sa)->sin_addr; + break; + case AF_INET6: + in6_splitscope(&((const struct sockaddr_in6 *)sa)->sin6_addr, &addr6, &addr_len); + addr_len = sizeof(struct in6_addr); + addr_data = &addr6; + break; + case AF_LINK: + addr_len = ((const struct sockaddr_dl *)sa)->sdl_alen; + addr_data = LLADDR_CONST((const struct sockaddr_dl *)sa); + break; + default: + RT_LOG(LOG_DEBUG, "unsupported family: %d, skipping", sa->sa_family); + return (true); + } + + return (nlattr_add(ns, attr, addr_len, addr_data)); +} + +/* + * Dumps interface state, properties and metrics. + * @ns: message writer + * @ifp: target interface + * @hdr: template header + * + * This function is called without epoch and MAY sleep. + */ +static bool +dump_iface(struct nlmsg_state *ns, struct ifnet *ifp, const struct nlmsghdr *hdr) +{ + struct ifinfomsg *ifinfo; + + RT_LOG(LOG_DEBUG3, "dumping interface %s data", if_name(ifp)); + + if (!nlmsg_reply(ns, hdr, sizeof(struct ifinfomsg))) + goto enomem; + + ifinfo = nlmsg_reserve_object(ns, struct ifinfomsg); + if (ifinfo == NULL) + goto enomem; + ifinfo->ifi_family = AF_UNSPEC; + ifinfo->__ifi_pad = 0; + ifinfo->ifi_type = ifp->if_type; // ARPHDR + ifinfo->ifi_index = ifp->if_index; + ifinfo->ifi_flags = ifp_flags_to_netlink(ifp); + ifinfo->ifi_change = 0; + + if (!nlattr_add_string(ns, IFLA_IFNAME, if_name(ifp))) + goto enomem; + + struct if_state ifs = {}; + get_operstate(ifp, &ifs); + + if (!nlattr_add_u8(ns, IFLA_OPERSTATE, ifs.ifla_operstate)) + goto enomem; + + if (!nlattr_add_u8(ns, IFLA_CARRIER, ifs.ifla_carrier)) + goto enomem; + +/* + if (!nlattr_add_u8(ns, IFLA_PROTO_DOWN, val)) + goto enomem; + + if (!nlattr_add_u8(ns, IFLA_LINKMODE, val)) + goto enomem; +*/ + if ((ifp->if_addr != NULL)) { + if (!dump_sa(ns, IFLA_ADDRESS, ifp->if_addr->ifa_addr)) + goto enomem; + } + + if ((ifp->if_broadcastaddr != NULL)) { + if (!nlattr_add(ns, IFLA_BROADCAST, ifp->if_addrlen, + ifp->if_broadcastaddr)) + goto enomem; + } + + if (!nlattr_add_u32(ns, IFLA_MTU, ifp->if_mtu)) + goto enomem; +/* + if (!nlattr_add_u32(ns, IFLA_MIN_MTU, 60)) + goto enomem; + + if (!nlattr_add_u32(ns, IFLA_MAX_MTU, 9000)) + goto enomem; + + if (!nlattr_add_u32(ns, IFLA_GROUP, 0)) + goto enomem; +*/ + if (!get_stats(ns, ifp)) + goto enomem; + + uint32_t val = (ifp->if_flags & IFF_PROMISC) != 0; + if (!nlattr_add_u32(ns, IFLA_PROMISCUITY, val)) + goto enomem; + + nlmsg_end(ns); + + return (true); + +enomem: + RT_LOG(LOG_DEBUG, "unable to dump interface %s state (ENOMEM)", if_name(ifp)); + nlmsg_abort(ns); + return (false); +} + +struct nl_parsed_link { + char *ifla_group; + char *ifla_ifname; + unsigned short ifi_type; + int ifi_index; +}; +#define _OFF_S(_field) offsetof(struct nl_parsed_link, _field) + +static struct nlattr_parser ps[] = { + { .type = IFLA_IFNAME, .off = _OFF_S(ifla_ifname), .cb = nlattr_get_string }, + { .type = IFLA_GROUP, .off = _OFF_S(ifla_group), .cb = nlattr_get_string }, + { .type = IFLA_ALT_IFNAME, .off = _OFF_S(ifla_ifname), .cb = nlattr_get_string }, +}; + +static bool +match_iface(struct nl_parsed_link *attrs, struct ifnet *ifp) +{ + if (attrs->ifi_index != 0 && attrs->ifi_index != ifp->if_index) + return (false); + if (attrs->ifi_type != 0 && attrs->ifi_index != ifp->if_type) + return (false); + if (attrs->ifla_ifname != NULL && strcmp(attrs->ifla_ifname, if_name(ifp))) + return (false); + /* TODO: add group match */ + + return (true); +} + +static int +rtnl_handle_getlink(struct nlmsghdr *hdr, struct nlpcb *nlp, struct netlink_parse_tracker *npt) +{ + struct epoch_tracker et; + struct ifnet *ifp; + int error = 0; + + struct ifinfomsg *ifm = (struct ifinfomsg *)nlmsg_data(hdr); + + struct nl_parsed_link attrs = { + .ifi_type = ifm->ifi_type, + .ifi_index = ifm->ifi_index, + }; + error = nl_parse_attrs(hdr, sizeof(*ifm), ps, sizeof(ps)/sizeof(ps[0]), npt, &attrs); + if (error != 0) + return (error); + + struct netlink_walkargs wa = { + .so = nlp, + .ns = npt->ns, + .hdr.nlmsg_pid = hdr->nlmsg_pid, + .hdr.nlmsg_seq = hdr->nlmsg_seq, + .hdr.nlmsg_flags = hdr->nlmsg_flags | NLM_F_MULTI, + .hdr.nlmsg_type = NL_RTM_NEWLINK, + }; + + /* Fast track for an interface w/ explicit index match */ + if (attrs.ifi_index != 0) { + NET_EPOCH_ENTER(et); + ifp = ifnet_byindex_ref(attrs.ifi_index); + NET_EPOCH_EXIT(et); + if (ifp != NULL) { + if (match_iface(&attrs, ifp)) { + if (!dump_iface(wa.ns, ifp, &wa.hdr)) + error = ENOMEM; + } else + error = ESRCH; + if_rele(ifp); + } else + error = ESRCH; + return (error); + } + + /* + * Fetching some link properties require performing ioctl's that may be blocking. + * Address it by saving referenced pointers of the matching links, + * exiting from epoch and going throught the list one-by-one. + */ + + RT_LOG(LOG_DEBUG2, "Start dump"); + + struct ifnet **match_array; + int offset = 0, base_count = 16; /* start with 128 bytes */ + match_array = malloc(base_count * sizeof(void *), M_TEMP, M_NOWAIT); + + NET_EPOCH_ENTER(et); + CK_STAILQ_FOREACH(ifp, &V_ifnet, if_link) { + wa.count++; + if (match_iface(&attrs, ifp)) { + if (offset < base_count) { + if (!if_try_ref(ifp)) + continue; + match_array[offset++] = ifp; + continue; + } + /* Too many matches, need to reallocate */ + struct ifnet **new_array; + int sz = base_count * sizeof(void *); + base_count *= 2; + new_array = malloc(sz * 2, M_TEMP, M_NOWAIT); + if (new_array == NULL) { + error = ENOMEM; + break; + } + memcpy(new_array, match_array, sz); + free(match_array, M_TEMP); + match_array = new_array; + } + wa.dumped++; + } + NET_EPOCH_EXIT(et); + + RT_LOG(LOG_DEBUG2, "Matched %d interface(s), dumping", wa.dumped); + for (int i = 0; error == 0 && i < offset; i++) { + if (!dump_iface(wa.ns, match_array[i], &wa.hdr)) + error = ENOMEM; + } + for (int i = 0; i < offset; i++) + if_rele(match_array[i]); + free(match_array, M_TEMP); + + RT_LOG(LOG_DEBUG2, "End dump, iterated %d dumped %d", wa.count, wa.dumped); + + if (!nlmsg_end_dump(wa.ns, error, &wa.hdr)) { + RT_LOG(LOG_DEBUG, "Unable to finalize the dump"); + return (ENOMEM); + } + + return (error); +} + + +/* + +{ifa_family=AF_INET, ifa_prefixlen=8, ifa_flags=IFA_F_PERMANENT, ifa_scope=RT_SCOPE_HOST, ifa_index=if_nametoindex("lo")}, + [ + {{nla_len=8, nla_type=IFA_ADDRESS}, inet_addr("127.0.0.1")}, + {{nla_len=8, nla_type=IFA_LOCAL}, inet_addr("127.0.0.1")}, + {{nla_len=7, nla_type=IFA_LABEL}, "lo"}, + {{nla_len=8, nla_type=IFA_FLAGS}, IFA_F_PERMANENT}, + {{nla_len=20, nla_type=IFA_CACHEINFO}, {ifa_prefered=4294967295, ifa_valid=4294967295, cstamp=3619, tstamp=3619}}]}, +--- + +{{len=72, type=RTM_NEWADDR, flags=NLM_F_MULTI, seq=1642191126, pid=566735}, + {ifa_family=AF_INET6, ifa_prefixlen=96, ifa_flags=IFA_F_PERMANENT, ifa_scope=RT_SCOPE_UNIVERSE, ifa_index=if_nametoindex("virbr0")}, + [ + {{nla_len=20, nla_type=IFA_ADDRESS}, inet_pton(AF_INET6, "2a01:4f8:13a:70c:ffff::1")}, + {{nla_len=20, nla_type=IFA_CACHEINFO}, {ifa_prefered=4294967295, ifa_valid=4294967295, cstamp=4283, tstamp=4283}}, + {{nla_len=8, nla_type=IFA_FLAGS}, IFA_F_PERMANENT}]}, +*/ + +static uint8_t +ifa_get_scope(const struct ifaddr *ifa) +{ + const struct sockaddr *sa; + uint8_t addr_scope = RT_SCOPE_UNIVERSE; + + sa = ifa->ifa_addr; + switch (sa->sa_family) { + case AF_INET: + { + struct in_addr addr; + addr = ((const struct sockaddr_in *)sa)->sin_addr; + if (IN_LOOPBACK(addr.s_addr)) + addr_scope = RT_SCOPE_HOST; + else if (IN_LINKLOCAL(addr.s_addr)) + addr_scope = RT_SCOPE_LINK; + break; + } + case AF_INET6: + { + const struct in6_addr *addr; + addr = &((const struct sockaddr_in6 *)sa)->sin6_addr; + if (IN6_IS_ADDR_LOOPBACK(addr)) + addr_scope = RT_SCOPE_HOST; + else if (IN6_IS_ADDR_LINKLOCAL(addr)) + addr_scope = RT_SCOPE_LINK; + break; + } + } + + return (addr_scope); +} + +static uint8_t +inet6_get_plen(const struct in6_addr *addr) +{ + + return (bitcount32(addr->s6_addr32[0]) + bitcount32(addr->s6_addr32[1]) + + bitcount32(addr->s6_addr32[2]) + bitcount32(addr->s6_addr32[3])); +} + +static uint8_t +get_sa_plen(const struct sockaddr *sa) +{ + const struct in6_addr *paddr6; + const struct in_addr *paddr; + + switch (sa->sa_family) { + case AF_INET: + if (sa == NULL) + return (32); + paddr = &(((const struct sockaddr_in *)sa)->sin_addr); + return bitcount32(paddr->s_addr);; + case AF_INET6: + if (sa == NULL) + return (128); + paddr6 = &(((const struct sockaddr_in6 *)sa)->sin6_addr); + return inet6_get_plen(paddr6); + } + + return (0); +} + + +/* + * {'attrs': [('IFA_ADDRESS', '12.0.0.1'), + ('IFA_LOCAL', '12.0.0.1'), + ('IFA_LABEL', 'eth10'), + ('IFA_FLAGS', 128), + ('IFA_CACHEINFO', {'ifa_preferred': 4294967295, 'ifa_valid': 4294967295, 'cstamp': 63745746, 'tstamp': 63745746})], + */ +static bool +dump_iface_addr(struct nlmsg_state *ns, struct ifnet *ifp, struct ifaddr *ifa, + const struct nlmsghdr *hdr) +{ + struct ifaddrmsg *ifamsg; + struct sockaddr *sa = ifa->ifa_addr; + + RT_LOG(LOG_DEBUG3, "dumping ifa %p type %s(%d) for interface %s", + ifa, rib_print_family(sa->sa_family), sa->sa_family, if_name(ifp)); + + if (!nlmsg_reply(ns, hdr, sizeof(struct ifaddrmsg))) + goto enomem; + + ifamsg = nlmsg_reserve_object(ns, struct ifaddrmsg); + if (ifamsg == NULL) + goto enomem; + ifamsg->ifa_family = sa->sa_family; + ifamsg->ifa_prefixlen = get_sa_plen(ifa->ifa_netmask); + ifamsg->ifa_flags = 0; // ifa_flags is useless + ifamsg->ifa_scope = ifa_get_scope(ifa); + ifamsg->ifa_index = ifp->if_index; + + struct sockaddr *dst_sa = ifa->ifa_dstaddr; + if ((dst_sa == NULL) || (dst_sa->sa_family != sa->sa_family)) + dst_sa = sa; + if (!dump_sa(ns, IFA_ADDRESS, dst_sa)) + FAIL_ATTR(IFA_ADDRESS); + if (!dump_sa(ns, IFA_LOCAL, sa)) + FAIL_ATTR(IFA_LOCAL); + + if (!nlattr_add_string(ns, IFA_LABEL, if_name(ifp))) + FAIL_ATTR(IFA_LABEL); + uint32_t val = 0; // ifa->ifa_flags; + if (!nlattr_add_u32(ns, IFA_FLAGS, val)) + FAIL_ATTR(IFA_FLAGS); + + nlmsg_end(ns); + return (true); +enomem: + RT_LOG(LOG_DEBUG, "Failed to dump ifa type %s(%d) for interface %s", + rib_print_family(sa->sa_family), sa->sa_family, if_name(ifp)); + nlmsg_abort(ns); + return (false); +} + +static int +rtnl_handle_getaddr(struct nlmsghdr *hdr, struct nlpcb *nlp, struct netlink_parse_tracker *npt) +{ + struct ifaddr *ifa; + struct ifnet *ifp; + int error = 0; + + struct netlink_walkargs wa = { + .so = nlp, + .ns = npt->ns, + .hdr.nlmsg_pid = hdr->nlmsg_pid, + .hdr.nlmsg_seq = hdr->nlmsg_seq, + .hdr.nlmsg_flags = hdr->nlmsg_flags | NLM_F_MULTI, + .hdr.nlmsg_type = NL_RTM_NEWADDR, + }; + + RT_LOG(LOG_DEBUG2, "Start dump"); + + CK_STAILQ_FOREACH(ifp, &V_ifnet, if_link) { + CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) { + if (wa.family != 0 && wa.family != ifa->ifa_addr->sa_family) + continue; + if (ifa->ifa_addr->sa_family == AF_LINK) + continue; + wa.count++; + if (!dump_iface_addr(wa.ns, ifp, ifa, &wa.hdr)) { + error = ENOMEM; + break; + } + wa.dumped++; + } + if (error != 0) + break; + } + + RT_LOG(LOG_DEBUG2, "End dump, iterated %d dumped %d", wa.count, wa.dumped); + + if (!nlmsg_end_dump(wa.ns, error, &wa.hdr)) { + RT_LOG(LOG_DEBUG, "Unable to finalize the dump"); + return (ENOMEM); + } + + return (error); +} + +static void +rtnl_handle_ifaddr(void *arg __unused, struct ifaddr *ifa, int cmd) +{ + struct nlmsghdr hdr = {}; + struct nlmsg_state ns = {}; + uint32_t group = 0; + + switch (ifa->ifa_addr->sa_family) { + case AF_INET: + group = RTNLGRP_IPV4_IFADDR; + break; + case AF_INET6: + group = RTNLGRP_IPV6_IFADDR; + break; + default: + RT_LOG(LOG_DEBUG2, "ifa notification for unknown AF: %d", + ifa->ifa_addr->sa_family); + return; + } + + if (!nl_has_listeners(NETLINK_ROUTE, group)) + return; + + if (!nlmsg_get_group_writer(NLMSG_LARGE, group, &ns)) { + RT_LOG(LOG_DEBUG, "error allocating group writer"); + return; + } + + hdr.nlmsg_type = (cmd == RTM_DELETE) ? NL_RTM_DELADDR : NL_RTM_NEWADDR; + + dump_iface_addr(&ns, ifa->ifa_ifp, ifa, &hdr); + nlmsg_flush(&ns); +} + +static void +rtnl_handle_ifattach(void *arg, struct ifnet *ifp) +{ + struct nlmsghdr hdr = { .nlmsg_type = NL_RTM_NEWLINK }; + struct nlmsg_state ns = {}; + + if (!nl_has_listeners(NETLINK_ROUTE, RTNLGRP_LINK)) + return; + + if (!nlmsg_get_group_writer(NLMSG_LARGE, RTNLGRP_LINK, &ns)) { + RT_LOG(LOG_DEBUG, "error allocating mbuf"); + return; + } + dump_iface(&ns, ifp, &hdr); + nlmsg_flush(&ns); +} + +static void +rtnl_handle_ifdetach(void *arg, struct ifnet *ifp) +{ + struct nlmsghdr hdr = { .nlmsg_type = NL_RTM_DELLINK }; + struct nlmsg_state ns = {}; + + if (!nl_has_listeners(NETLINK_ROUTE, RTNLGRP_LINK)) + return; + + if (!nlmsg_get_group_writer(NLMSG_LARGE, RTNLGRP_LINK, &ns)) { + RT_LOG(LOG_DEBUG, "error allocating mbuf"); + return; + } + dump_iface(&ns, ifp, &hdr); + nlmsg_flush(&ns); +} + +static struct rtnl_cmd_handler cmd_handlers[] = { + { NL_RTM_GETLINK, "RTM_GETLINK", &rtnl_handle_getlink, sizeof(struct ifinfomsg), RTNL_F_NOEPOCH }, + { NL_RTM_GETADDR, "RTM_GETADDR", &rtnl_handle_getaddr, sizeof(struct ifaddrmsg)}, +}; + +void +rtnl_ifaces_init(void) +{ + ifattach_event = EVENTHANDLER_REGISTER( + ifnet_arrival_event, rtnl_handle_ifattach, NULL, + EVENTHANDLER_PRI_ANY); + ifdetach_event = EVENTHANDLER_REGISTER( + ifnet_departure_event, rtnl_handle_ifdetach, NULL, + EVENTHANDLER_PRI_ANY); + ifaddr_event = EVENTHANDLER_REGISTER( + rt_addrmsg, rtnl_handle_ifaddr, NULL, + EVENTHANDLER_PRI_ANY); + rtnl_register_messages(cmd_handlers, RTNL_ARRAY_LEN(cmd_handlers)); +} + +void +rtnl_ifaces_destroy(void) +{ + EVENTHANDLER_DEREGISTER(ifnet_arrival_event, ifattach_event); + EVENTHANDLER_DEREGISTER(ifnet_departure_event, ifdetach_event); + EVENTHANDLER_DEREGISTER(rt_addrmsg, ifaddr_event); +} diff --git a/sys/netlink/route/ifaddrs.h b/sys/netlink/route/ifaddrs.h new file mode 100644 --- /dev/null +++ b/sys/netlink/route/ifaddrs.h @@ -0,0 +1,74 @@ +/* + * Interface address-related (RTM_ADDR) message header and attributes. + */ +#ifndef _NETLINK_ROUTE_IFADDRS_H_ +#define _NETLINK_ROUTE_IFADDRS_H_ + +/* Base header for all of the relevant messages */ +struct ifaddrmsg { + uint8_t ifa_family; /* Address family */ + uint8_t ifa_prefixlen; /* Prefix length */ + uint8_t ifa_flags; /* Address-specific flags */ + uint8_t ifa_scope; /* Address scope */ + uint32_t ifa_index; /* Link ifindex */ +}; + +#ifndef _KERNEL +#define _NL_IFA_HDRLEN ((int)sizeof(struct ifaddrmsg)) +#define IFA_RTA(_ifa) ((struct rtattr *)(NL_ITEM_DATA(_ifa, _NL_IFA_HDRLEN))) +#define IFA_PAYLOAD(_hdr) NLMSG_PAYLOAD(_hdr, _NL_IFA_HDRLEN) +#endif + +/* + * Important comment: + * IFA_ADDRESS is prefix address, rather than local interface address. + * It makes no difference for normally configured broadcast interfaces, + * but for point-to-point IFA_ADDRESS is DESTINATION address, + * local address is supplied in IFA_LOCAL attribute. + * + * IFA_FLAGS is a u32 attribute that extends the u8 field ifa_flags. + * If present, the value from struct ifaddrmsg will be ignored. + */ +enum { + IFA_UNSPEC, + IFA_ADDRESS, + IFA_LOCAL, + IFA_LABEL, + IFA_BROADCAST, + IFA_ANYCAST, + IFA_CACHEINFO, + IFA_MULTICAST, + IFA_FLAGS, + IFA_RT_PRIORITY, /* u32, priority/metric for prefix route */ + IFA_TARGET_NETNSID, + __IFA_MAX, +}; +#define IFA_MAX (__IFA_MAX - 1) + +/* ifa_flags */ +#define IFA_F_SECONDARY 0x01 +#define IFA_F_TEMPORARY IFA_F_SECONDARY +#define IFA_F_NODAD 0x02 +#define IFA_F_OPTIMISTIC 0x04 +#define IFA_F_DADFAILED 0x08 +#define IFA_F_HOMEADDRESS 0x10 +#define IFA_F_DEPRECATED 0x20 +#define IFA_F_TENTATIVE 0x40 +#define IFA_F_PERMANENT 0x80 +#define IFA_F_MANAGETEMPADDR 0x100 +#define IFA_F_NOPREFIXROUTE 0x200 +#define IFA_F_MCAUTOJOIN 0x400 +#define IFA_F_STABLE_PRIVACY 0x800 + +/* */ + + +struct ifa_cacheinfo { + uint32_t ifa_prefered; + uint32_t ifa_valid; + uint32_t cstamp; /* created timestamp, hundredths of seconds */ + uint32_t tstamp; /* updated timestamp, hundredths of seconds */ +}; + + +#endif diff --git a/sys/netlink/route/interface.h b/sys/netlink/route/interface.h new file mode 100644 --- /dev/null +++ b/sys/netlink/route/interface.h @@ -0,0 +1,189 @@ +/* + * Interface-related (RTM_LINK) message header and attributes. + */ + +#ifndef _NETLINK_ROUTE_INTERFACE_H_ +#define _NETLINK_ROUTE_INTERFACE_H_ + +/* Base header for all of the relevant messages */ +struct ifinfomsg { + unsigned char ifi_family; /* not used */ + unsigned char __ifi_pad; + unsigned short ifi_type; /* ARPHRD_* */ + int ifi_index; /* Inteface index */ + unsigned ifi_flags; /* IFF_* flags */ + unsigned ifi_change; /* IFF_* change mask */ +}; + +#ifndef _KERNEL +/* Compatilbility helpers */ +#define _IFINFO_HDRLEN ((int)sizeof(struct ifinfomsg)) +#define IFLA_RTA(_ifi) ((struct rtattr *)NL_ITEM_DATA(_ifi, _IFINFO_HDRLEN)) +#define IFLA_PAYLOAD(_ifi) NLMSG_PAYLOAD(_ifi, _IFINFO_HDRLEN) +#endif + +enum { + IFLA_UNSPEC = 0, + IFLA_ADDRESS = 1, /* binary: Link-level address (MAC) */ +#define IFLA_ADDRESS IFLA_ADDRESS + IFLA_BROADCAST = 2, /* binary: link-level broadcast address */ +#define IFLA_BROADCAST IFLA_BROADCAST + IFLA_IFNAME = 3, /* string: Interface name */ +#define IFLA_IFNAME IFLA_IFNAME + IFLA_MTU = 4, /* u32: Current interface L3 mtu */ +#define IFLA_MTU IFLA_MTU + IFLA_LINK = 5, /* not supported */ +#define IFLA_LINK IFLA_LINK + IFLA_QDISC = 6, /* string: Queing policy (not supported) */ +#define IFLA_QDISC IFLA_QDISC + IFLA_STATS = 7, /* Interface counters */ +#define IFLA_STATS IFLA_STATS + IFLA_COST = 8, /* not supported */ +#define IFLA_COST IFLA_COST + IFLA_PRIORITY = 9, /* not supported */ +#define IFLA_PRIORITY IFLA_PRIORITY + IFLA_MASTER = 10, /* u32: parent interface ifindex */ +#define IFLA_MASTER IFLA_MASTER + IFLA_WIRELESS = 11, /* not supported */ +#define IFLA_WIRELESS IFLA_WIRELESS + IFLA_PROTINFO = 12, /* protocol-specific data */ +#define IFLA_PROTINFO IFLA_PROTINFO + IFLA_TXQLEN = 13, /* u32: transmit queue length */ +#define IFLA_TXQLEN IFLA_TXQLEN + IFLA_MAP = 14, /* not supported */ +#define IFLA_MAP IFLA_MAP + IFLA_WEIGHT = 15, /* not supported */ +#define IFLA_WEIGHT IFLA_WEIGHT + IFLA_OPERSTATE = 16, /* u8: ifOperStatus per RFC 2863 */ +#define IFLA_OPERSTATE IFLA_OPERSTATE + IFLA_LINKMODE = 17, /* u8: ifmedia (not supported) */ +#define IFLA_LINKMODE IFLA_LINKMODE + IFLA_LINKINFO = 18, /* not supported */ +#define IFLA_LINKINFO IFLA_LINKINFO + IFLA_NET_NS_PID = 19, /* u32: vnet id (not supported) */ +#define IFLA_NET_NS_PID IFLA_NET_NS_PID + IFLA_IFALIAS = 20, /* not supported */ +#define IFLA_IFALIAS IFLA_IFALIAS + IFLA_NUM_VF = 21, /* not supported */ +#define IFLA_NUM_VF IFLA_NUM_VF + IFLA_VFINFO_LIST= 22, /* not supported */ +#define IFLA_VFINFO_LIST IFLA_VFINFO_LIST + IFLA_STATS64 = 23, /* rtnl_link_stats64: iface stats */ +#define IFLA_STATS64 IFLA_STATS64 + IFLA_VF_PORTS, + IFLA_PORT_SELF, + IFLA_AF_SPEC, + IFLA_GROUP, /* Group the device belongs to */ + IFLA_NET_NS_FD, + IFLA_EXT_MASK, /* Extended info mask, VFs, etc */ + IFLA_PROMISCUITY, /* Promiscuity count: > 0 means acts PROMISC */ +#define IFLA_PROMISCUITY IFLA_PROMISCUITY + IFLA_NUM_TX_QUEUES, + IFLA_NUM_RX_QUEUES, + IFLA_CARRIER, + IFLA_PHYS_PORT_ID, + IFLA_CARRIER_CHANGES, + IFLA_PHYS_SWITCH_ID, + IFLA_LINK_NETNSID, + IFLA_PHYS_PORT_NAME, + IFLA_PROTO_DOWN, + IFLA_GSO_MAX_SEGS, + IFLA_GSO_MAX_SIZE, + IFLA_PAD, + IFLA_XDP, + IFLA_EVENT, + IFLA_NEW_NETNSID, + IFLA_IF_NETNSID, + IFLA_TARGET_NETNSID = IFLA_IF_NETNSID, /* new alias */ + IFLA_CARRIER_UP_COUNT, + IFLA_CARRIER_DOWN_COUNT, + IFLA_NEW_IFINDEX, + IFLA_MIN_MTU, + IFLA_MAX_MTU, + IFLA_PROP_LIST, + IFLA_ALT_IFNAME, /* Alternative ifname */ + IFLA_PERM_ADDRESS, + IFLA_PROTO_DOWN_REASON, + __IFLA_MAX +}; +#define IFLA_MAX (__IFLA_MAX - 1) + +/* + * Attributes that can be used as filters: + * IFLA_IFNAME, IFLA_GROUP, IFLA_ALT_IFNAME + * Headers that can be used as filters: + * ifi_index, ifi_type + */ + +/* + * IFLA_OPERSTATE. + * The values below represent the possible + * states of ifOperStatus defined by RFC 2863 + */ +enum { + IF_OPER_UNKNOWN = 0, /* status can not be determined */ + IF_OPER_NOTPRESENT = 1, /* some (hardware) component not present */ + IF_OPER_DOWN = 2, /* down */ + IF_OPER_LOWERLAYERDOWN = 3, /* some lower-level interface is down */ + IF_OPER_TESTING = 4, /* in some test mode */ + IF_OPER_DORMANT = 5, /* "up" but waiting for some condition (802.1X) */ + IF_OPER_UP = 6, /* ready to pass packets */ +}; + +/* IFLA_STATS */ +struct rtnl_link_stats { + uint32_t rx_packets; /* total RX packets (IFCOUNTER_IPACKETS) */ + uint32_t tx_packets; /* total TX packets (IFCOUNTER_OPACKETS) */ + uint32_t rx_bytes; /* total RX bytes (IFCOUNTER_IBYTES) */ + uint32_t tx_bytes; /* total TX bytes (IFCOUNTER_OBYTES) */ + uint32_t rx_errors; /* RX errors (IFCOUNTER_IERRORS) */ + uint32_t tx_errors; /* RX errors (IFCOUNTER_OERRORS) */ + uint32_t rx_dropped; /* RX drop (no space in ring/no bufs) (IFCOUNTER_IQDROPS) */ + uint32_t tx_dropped; /* TX drop (IFCOUNTER_OQDROPS) */ + uint32_t multicast; /* RX multicast packets (IFCOUNTER_IMCASTS) */ + uint32_t collisions; /* not supported */ + uint32_t rx_length_errors; /* not supported */ + uint32_t rx_over_errors; /* not supported */ + uint32_t rx_crc_errors; /* not supported */ + uint32_t rx_frame_errors; /* not supported */ + uint32_t rx_fifo_errors; /* not supported */ + uint32_t rx_missed_errors; /* not supported */ + uint32_t tx_aborted_errors; /* not supported */ + uint32_t tx_carrier_errors; /* not supported */ + uint32_t tx_fifo_errors; /* not supported */ + uint32_t tx_heartbeat_errors; /* not supported */ + uint32_t tx_window_errors; /* not supported */ + uint32_t rx_compressed; /* not supported */ + uint32_t tx_compressed; /* not supported */ + uint32_t rx_nohandler; /* dropped due to no proto handler (IFCOUNTER_NOPROTO) */ +}; + +/* IFLA_STATS64 */ +struct rtnl_link_stats64 { + uint64_t rx_packets; /* total RX packets (IFCOUNTER_IPACKETS) */ + uint64_t tx_packets; /* total TX packets (IFCOUNTER_OPACKETS) */ + uint64_t rx_bytes; /* total RX bytes (IFCOUNTER_IBYTES) */ + uint64_t tx_bytes; /* total TX bytes (IFCOUNTER_OBYTES) */ + uint64_t rx_errors; /* RX errors (IFCOUNTER_IERRORS) */ + uint64_t tx_errors; /* RX errors (IFCOUNTER_OERRORS) */ + uint64_t rx_dropped; /* RX drop (no space in ring/no bufs) (IFCOUNTER_IQDROPS) */ + uint64_t tx_dropped; /* TX drop (IFCOUNTER_OQDROPS) */ + uint64_t multicast; /* RX multicast packets (IFCOUNTER_IMCASTS) */ + uint64_t collisions; /* not supported */ + uint64_t rx_length_errors; /* not supported */ + uint64_t rx_over_errors; /* not supported */ + uint64_t rx_crc_errors; /* not supported */ + uint64_t rx_frame_errors; /* not supported */ + uint64_t rx_fifo_errors; /* not supported */ + uint64_t rx_missed_errors; /* not supported */ + uint64_t tx_aborted_errors; /* not supported */ + uint64_t tx_carrier_errors; /* not supported */ + uint64_t tx_fifo_errors; /* not supported */ + uint64_t tx_heartbeat_errors; /* not supported */ + uint64_t tx_window_errors; /* not supported */ + uint64_t rx_compressed; /* not supported */ + uint64_t tx_compressed; /* not supported */ + uint64_t rx_nohandler; /* dropped due to no proto handler (IFCOUNTER_NOPROTO) */ +}; + +#endif diff --git a/sys/netlink/route/neigh.h b/sys/netlink/route/neigh.h new file mode 100644 --- /dev/null +++ b/sys/netlink/route/neigh.h @@ -0,0 +1,79 @@ + +/* + * Neighbors-related (RTM_NEIGH) message header and attributes. + */ + +#ifndef _NETLINK_ROUTE_NEIGH_H_ +#define _NETLINK_ROUTE_NEIGH_H_ + +/* Base header for all of the relevant messages */ +struct ndmsg { + uint8_t ndm_family; + uint8_t ndm_pad1; + uint16_t ndm_pad2; + int32_t ndm_ifindex; + uint16_t ndm_state; + uint8_t ndm_flags; + uint8_t ndm_type; +}; + +/* Attributes */ +enum { + NDA_UNSPEC, + NDA_DST, /* neigh l3 address */ + NDA_LLADDR, /* neigh link-level address */ + NDA_CACHEINFO, /* lifetime */ + NDA_PROBES, /* XXX */ + NDA_VLAN, /* upper 802.1Q tag */ + NDA_PORT, /* not used */ + NDA_VNI, /* not used */ + NDA_IFINDEX, /* interface index */ + NDA_MASTER, /* not used */ + NDA_LINK_NETNSID, /* not used */ + NDA_SRC_VNI, /* not used */ + NDA_PROTOCOL, /* XXX */ + NDA_NH_ID, /* not used */ + NDA_FDB_EXT_ATTRS, /* not used */ + NDA_FLAGS_EXT, /* ndm_flags */ + NDA_NDM_STATE_MASK, /* XXX */ + NDA_NDM_FLAGS_MASK, /* XXX */ + __NDA_MAX +}; + +#define NDA_MAX (__NDA_MAX - 1) + + +/* ndm_flags / NDA_FLAGS_EXT */ +#define NTF_USE 0x0001 /* XXX */ +#define NTF_SELF 0x0002 /* local station */ +#define NTF_MASTER 0x0004 /* XXX */ +#define NTF_PROXY 0x0008 /* proxy entry */ +#define NTF_EXT_LEARNED 0x0010 /* not used */ +#define NTF_OFFLOADED 0x0020 /* not used */ +#define NTF_STICKY 0x0040 /* permament entry */ +#define NTF_ROUTER 0x0080 /* dst indicated itself as a router */ +/* start of NDA_FLAGS_EXT */ +#define NTF_EXT_MANAGED 0x0100 /* not used */ + +/* ndm_state */ +#define NUD_INCOMPLETE 0x01 /* No lladdr, address resolution in progress */ +#define NUD_REACHABLE 0x02 /* reachable & recently resolved */ +#define NUD_STALE 0x04 /* has lladdr but it's stale */ +#define NUD_DELAY 0x08 /* has lladdr, is stale, probes delayed */ +#define NUD_PROBE 0x10 /* has lladdr, is stale, probes sent */ +#define NUD_FAILED 0x20 /* unused */ + +/* Dummy states */ +#define NUD_NOARP 0x40 /* not used */ +#define NUD_PERMANENT 0x80 /* not flushed */ +#define NUD_NONE 0x00 + +/* NDA_CACHEINFO */ +struct nda_cacheinfo { + uint32_t ndm_confirmed; /* seconds since ARP/ND was received from neigh */ + uint32_t ndm_used; /* seconds since last used (not provided) */ + uint32_t ndm_updated; /* seconds since state was updated last */ + uint32_t ndm_refcnt; /* number of references held */ +}; + +#endif diff --git a/sys/netlink/route/neigh.c b/sys/netlink/route/neigh.c new file mode 100644 --- /dev/null +++ b/sys/netlink/route/neigh.c @@ -0,0 +1,347 @@ +/*- + * SPDX-License-Identifier: BSD-2-Clause-FreeBSD + * + * Copyright (c) 2021 Ng Peng Nam Sean + * + * 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 +__FBSDID("$FreeBSD$"); +#include "opt_inet.h" +#include "opt_inet6.h" +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include /* nd6.h requires this */ +#include /* nd6 state machine */ +#include /* scope deembedding */ + +#define DEBUG_MOD_NAME nl_neigh +#define DEBUG_MAX_LEVEL LOG_DEBUG3 +#include +_DECLARE_DEBUG(LOG_DEBUG3); + +static int lle_families[] = { AF_INET, AF_INET6 }; + +struct netlink_walkargs { + struct nlmsg_state *ns; + struct nlmsghdr hdr; + struct nlpcb *so; + struct ifnet *ifp; + int family; + int error; + int count; + int dumped; +}; + +#define ENOMEM_IF_NULL(_v) if ((_v) == NULL) goto enomem + +static int +lle_state_to_nl_state(int family, struct llentry *lle) +{ + int state = lle->ln_state; + + switch (family) { + case AF_INET: + if (lle->la_flags & (LLE_STATIC | LLE_IFADDR)) + state = 1; + switch (state) { + case 0: /* ARP_LLINFO_INCOMPLETE */ + return (NUD_INCOMPLETE); + case 1: /* ARP_LLINFO_REACHABLE */ + return (NUD_REACHABLE); + case 2: /* ARP_LLINFO_VERIFY */ + return (NUD_PROBE); + } + break; + case AF_INET6: + switch (state) { + case ND6_LLINFO_INCOMPLETE: + return (NUD_INCOMPLETE); + case ND6_LLINFO_REACHABLE: + return (NUD_REACHABLE); + case ND6_LLINFO_STALE: + return (NUD_STALE); + case ND6_LLINFO_DELAY: + return (NUD_DELAY); + case ND6_LLINFO_PROBE: + return (NUD_PROBE); + } + break; + } + + return (NUD_NONE); +} + +static uint32_t +lle_flags_to_nl_flags(const struct llentry *lle) +{ + uint32_t nl_flags = 0; + + if (lle->la_flags & LLE_IFADDR) + nl_flags |= NTF_SELF; + if (lle->la_flags & LLE_PUB) + nl_flags |= NTF_PROXY; + if (lle->la_flags & LLE_STATIC) + nl_flags |= NTF_STICKY; + if (lle->ln_router != 0) + nl_flags |= NTF_ROUTER; + + return (nl_flags); +} + +static int +dump_lle(struct lltable *llt, struct llentry *lle, void *arg) +{ + struct netlink_walkargs *wa = (struct netlink_walkargs *)arg; + struct nlmsghdr *hdr = &wa->hdr; + struct nlmsg_state *ns = wa->ns; + struct ndmsg *ndm; + union { + struct in_addr in; + struct in6_addr in6; + } addr; + + LLE_RLOCK(lle); + +#if DEBUG_MAX_LEVEL >= LOG_DEBUG2 + { + char llebuf[NHOP_PRINT_BUFSIZE]; + llentry_print_buf_lltable(lle, llebuf, sizeof(llebuf)); + RT_LOG(LOG_DEBUG2, "dumping %s", llebuf); + } +#endif + + if (!nlmsg_reply(ns, hdr, sizeof(struct ndmsg))) + goto enomem; + + ndm = nlmsg_reserve_object(ns, struct ndmsg); + ENOMEM_IF_NULL(ndm); + ndm->ndm_family = wa->family; + ndm->ndm_ifindex = wa->ifp->if_index; + ndm->ndm_state = lle_state_to_nl_state(wa->family, lle); + ndm->ndm_flags = lle_flags_to_nl_flags(lle); + + switch (wa->family) { +#ifdef INET + case AF_INET: + addr.in = lle->r_l3addr.addr4; + if (!nlattr_add(ns, NDA_DST, 4, &addr)) + goto enomem; + break; +#endif +#ifdef INET6 + case AF_INET6: + addr.in6 = lle->r_l3addr.addr6; + in6_clearscope(&addr.in6); + if (!nlattr_add(ns, NDA_DST, 16, &addr)) + goto enomem; + break; +#endif + } + + if (lle->r_flags & RLLE_VALID) { + /* Has L2 */ + int addrlen = wa->ifp->if_addrlen; + if (!nlattr_add(ns, NDA_LLADDR, addrlen, lle->ll_addr)) + goto enomem; + } + + if (!nlattr_add_u32(ns, NDA_PROBES, lle->la_asked)) + goto enomem; + + struct nda_cacheinfo *cache; + cache = nlmsg_reserve_attr(ns, NDA_CACHEINFO, struct nda_cacheinfo); + ENOMEM_IF_NULL(cache); + /* TODO: provide confirmed/updated */ + cache->ndm_refcnt = lle->lle_refcnt; + + LLE_RUNLOCK(lle); + nlmsg_end(ns); + + return (0); + +enomem: + LLE_RUNLOCK(lle); + RT_LOG(LOG_DEBUG, "unable to dump lle state (ENOMEM)"); + nlmsg_abort(ns); + return (ENOMEM); +} + +static bool +dump_llt(struct lltable *llt, struct netlink_walkargs *wa) +{ + lltable_foreach_lle(llt, dump_lle, wa); + + return (true); +} + +static int +dump_llts_iface(struct netlink_walkargs *wa, struct ifnet *ifp, int family) +{ + int error = 0; + + wa->ifp = ifp; + for (int i = 0; i < sizeof(lle_families) / sizeof(int); i++) { + int fam = lle_families[i]; + struct lltable *llt = lltable_get(ifp, fam); + if (llt != NULL && (family == 0 || family == fam)) { + wa->count++; + wa->family = fam; + if (!dump_llt(llt, wa)) { + error = ENOMEM; + break; + } + wa->dumped++; + } + } + return (error); +} + +static int +dump_llts(struct netlink_walkargs *wa, struct ifnet *ifp, int family) +{ + RT_LOG(LOG_DEBUG, "Start dump ifp=%s family=%d", ifp ? if_name(ifp) : "NULL", family); + + wa->hdr.nlmsg_flags |= NLM_F_MULTI; + + if (ifp != NULL) { + dump_llts_iface(wa, ifp, family); + } else { + CK_STAILQ_FOREACH(ifp, &V_ifnet, if_link) { + dump_llts_iface(wa, ifp, family); + } + } + + RT_LOG(LOG_DEBUG, "End dump, iterated %d dumped %d", wa->count, wa->dumped); + + if (!nlmsg_end_dump(wa->ns, wa->error, &wa->hdr)) { + RT_LOG(LOG_DEBUG, "Unable to add new message"); + return (ENOMEM); + } + + return (0); +} + +static int +get_lle(struct netlink_walkargs *wa, struct ifnet *ifp, int family, struct sockaddr *dst) +{ + struct lltable *llt = lltable_get(ifp, family); + if (llt == NULL) + return (ESRCH); + +#ifdef INET6 + if (dst->sa_family == AF_INET6) { + struct sockaddr_in6 *dst6 = (struct sockaddr_in6 *)dst; + + if (IN6_IS_SCOPE_LINKLOCAL(&dst6->sin6_addr)) + in6_set_unicast_scopeid(&dst6->sin6_addr, ifp->if_index); + } +#endif + struct llentry *lle = lla_lookup(llt, LLE_UNLOCKED, dst); + if (lle == NULL) + return (ESRCH); + + wa->ifp = ifp; + wa->family = family; + + return (dump_lle(llt, lle, wa)); +} + +struct nl_parsed_neigh { + struct sockaddr *nda_dst; + uint32_t nda_ifindex; + uint8_t ndm_family; +}; +#define _OFF_S(_field) offsetof(struct nl_parsed_neigh, _field) + +static struct nlattr_parser ps[] = { + { .type = NDA_DST, .off = _OFF_S(nda_dst), .cb = nlattr_get_ip }, + { .type = NDA_IFINDEX, .off = _OFF_S(nda_ifindex), .cb = nlattr_get_uint32 }, +}; + +static int +rtnl_handle_getneigh(struct nlmsghdr *hdr, struct nlpcb *nlp, struct netlink_parse_tracker *npt) +{ + struct ifnet *ifp = NULL; + int error; + + struct ndmsg *ndm = (struct ndmsg *)nlmsg_data(hdr); + + struct nl_parsed_neigh attrs = { + .ndm_family = ndm->ndm_family, + .nda_ifindex = ndm->ndm_ifindex, + }; + error = nl_parse_attrs(hdr, sizeof(*ndm), ps, sizeof(ps)/sizeof(ps[0]), npt, &attrs); + if (error != 0) + return (error); + + if (attrs.nda_ifindex != 0) { + if ((ifp = ifnet_byindex(attrs.nda_ifindex)) == NULL) { + RT_LOG(LOG_DEBUG, "unknown ifindex %d", attrs.nda_ifindex); + return (EINVAL); + } + } + + if (attrs.nda_dst != NULL && ifp == NULL) { + RT_LOG(LOG_DEBUG, "has NDA_DST but no ifindex provided"); + return (EINVAL); + } + + struct netlink_walkargs wa = { + .so = nlp, + .ns = npt->ns, + .hdr.nlmsg_pid = hdr->nlmsg_pid, + .hdr.nlmsg_seq = hdr->nlmsg_seq, + .hdr.nlmsg_flags = hdr->nlmsg_flags, + .hdr.nlmsg_type = NL_RTM_NEWNEIGH, + }; + + if (attrs.nda_dst == NULL) + error = dump_llts(&wa, ifp, ndm->ndm_family); + else + error = get_lle(&wa, ifp, ndm->ndm_family, attrs.nda_dst); + + return (error); +} + +static struct rtnl_cmd_handler cmd_handlers[] = { + { NL_RTM_GETNEIGH, "RTM_GETNEIGH", &rtnl_handle_getneigh, sizeof(struct ndmsg)}, +}; + +void +rtnl_neighs_init() +{ + rtnl_register_messages(cmd_handlers, RTNL_ARRAY_LEN(cmd_handlers)); +} + diff --git a/sys/netlink/route/nexthop.h b/sys/netlink/route/nexthop.h new file mode 100644 --- /dev/null +++ b/sys/netlink/route/nexthop.h @@ -0,0 +1,75 @@ +/* + * NEXTHOP-related (RTM_NEXTHOP) message header and attributes. + */ + +#ifndef _NETLINK_ROUTE_NEXTHOP_H_ +#define _NETLINK_ROUTE_NEXTHOP_H_ + +/* Base header for all of the relevant messages */ +struct nhmsg { + unsigned char nh_family; /* transport family */ + unsigned char nh_scope; /* ignored on RX, filled by kernel */ + unsigned char nh_protocol; /* Routing protocol that installed nh */ + unsigned char resvd; + unsigned int nh_flags; /* RTNH_F_* flags from route.h */ +}; + +enum { + NHA_UNSPEC, + NHA_ID, /* u32: nexthop userland index, auto-assigned if 0 */ + NHA_GROUP, /* binary: array of struct nexthop_grp */ + NHA_GROUP_TYPE, /* u16: set to NEXTHOP_GRP_TYPE */ + NHA_BLACKHOLE, /* flag: nexthop used to blackhole packets */ + NHA_OIF, /* u32: transmit ifindex */ + NHA_GATEWAY, /* network: IPv4/IPv6 gateway addr */ + NHA_ENCAP_TYPE, /* not supported */ + NHA_ENCAP, /* not supported */ + NHA_GROUPS, /* flag: match nexthop groups */ + NHA_MASTER, /* not supported */ + NHA_FDB, /* not supported */ + NHA_RES_GROUP, /* not supported */ + NHA_RES_BUCKET, /* not supported */ + __NHA_MAX, +}; +#define NHA_MAX (__NHA_MAX - 1) + +/* + * Attributes that can be used as filters: + * NHA_ID (nexhop or group), NHA_OIF, NHA_GROUPS, + */ + +/* + * NHA_GROUP: array of the following structures. + * If attribute is set, the only other valid attributes are + * NHA_ID and NHA_GROUP_TYPE. + * NHA_RES_GROUP and NHA_RES_BUCKET are not supported yet + */ +struct nexthop_grp { + uint32_t id; /* nexhop userland index */ + uint8_t weight; /* weight of this nexthop */ + uint8_t resvd1; + uint16_t resvd2; +}; + +/* NHA_GROUP_TYPE: u16 */ +enum { + NEXTHOP_GRP_TYPE_MPATH, /* default nexthop group */ + NEXTHOP_GRP_TYPE_RES, /* resilient nexthop group */ + __NEXTHOP_GRP_TYPE_MAX, +}; +#define NEXTHOP_GRP_TYPE_MAX (__NEXTHOP_GRP_TYPE_MAX - 1) + + +/* NHA_RES_GROUP */ +enum { + NHA_RES_GROUP_UNSPEC, + NHA_RES_GROUP_PAD = NHA_RES_GROUP_UNSPEC, + NHA_RES_GROUP_BUCKETS, + NHA_RES_GROUP_IDLE_TIMER, + NHA_RES_GROUP_UNBALANCED_TIMER, + NHA_RES_GROUP_UNBALANCED_TIME, + __NHA_RES_GROUP_MAX, +}; +#define NHA_RES_GROUP_MAX (__NHA_RES_GROUP_MAX - 1) + +#endif diff --git a/sys/netlink/route/nexthop.c b/sys/netlink/route/nexthop.c new file mode 100644 --- /dev/null +++ b/sys/netlink/route/nexthop.c @@ -0,0 +1,1007 @@ +/*- + * SPDX-License-Identifier: BSD-2-Clause-FreeBSD + * + * 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 +__FBSDID("$FreeBSD$"); +#include "opt_inet.h" +#include "opt_inet6.h" +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#define DEBUG_MOD_NAME nl_nhop +#define DEBUG_MAX_LEVEL LOG_DEBUG3 +#include +_DECLARE_DEBUG(LOG_DEBUG3); + +/* + * This file contains the logic to maintain kernel nexthops and + * nexhop groups based om the data provided by the user. + * + * Kernel stores (nearly) all of the routing data in the nexthops, + * including the prefix-specific flags (NHF_HOST and NHF_DEFAULT). + * + * Netlink API provides higher-level abstraction for the user. Each + * user-created nexthop may map to multiple kernel nexthops. + * + * The following variations require separate kernel nexthop to be + * created: + * * prefix flags (NHF_HOST, NHF_DEFAULT) + * * using IPv6 gateway for IPv4 routes + * * different fibnum + * + * These kernel nexthops have the lifetime bound to the lifetime of + * the user_nhop object. They are not collected until user requests + * to delete the created user_nhop. + * + */ +struct user_nhop { + uint32_t un_idx; /* Userland-provided index */ + uint32_t un_fibfam; /* fibnum+af(as highest byte) */ + uint8_t un_protocol; /* protocol that install the record */ + struct nhop_object *un_nhop; /* "production" nexthop */ + struct nhop_object *un_nhop_src; /* nexthop to copy from */ + struct weightened_nhop *un_nhgrp_src; /* nexthops for nhg */ + uint32_t un_nhgrp_count; /* number of nexthops */ + struct user_nhop *un_next; /* next item in hash chain */ + struct user_nhop *un_nextchild; /* master -> children */ + struct epoch_context un_epoch_ctx; /* epoch ctl helper */ +}; + +/* produce hash value for an object */ +#define unhop_hash_obj(_obj) (hash_unhop(_obj)) +/* compare two objects */ +#define unhop_cmp(_one, _two) (cmp_unhop(_one, _two)) +/* next object accessor */ +#define unhop_next(_obj) (_obj)->un_next + +CHT_SLIST_DEFINE(unhop, struct user_nhop); + +struct unhop_ctl { + struct unhop_head un_head; + struct rmlock un_lock; +}; +#define UN_LOCK_INIT(_ctl) rm_init(&(_ctl)->un_lock, "unhop_ctl") +#define UN_TRACKER struct rm_priotracker un_tracker +#define UN_RLOCK(_ctl) rm_rlock(&((_ctl)->un_lock), &un_tracker) +#define UN_RUNLOCK(_ctl) rm_runlock(&((_ctl)->un_lock), &un_tracker) + +#define UN_WLOCK(_ctl) rm_wlock(&(_ctl)->un_lock); +#define UN_WUNLOCK(_ctl) rm_wunlock(&(_ctl)->un_lock); + +VNET_DEFINE_STATIC(struct unhop_ctl *, un_ctl) = NULL; +#define V_un_ctl VNET(un_ctl) + +static void consider_resize(struct unhop_ctl *ctl, uint32_t new_size); +static int cmp_unhop(const struct user_nhop *a, const struct user_nhop *b); +static unsigned int hash_unhop(const struct user_nhop *obj); + +static void destroy_unhop(struct user_nhop *unhop); +static struct nhop_object *clone_unhop(const struct user_nhop *unhop, + uint32_t fibnum, int family, int nh_flags); + +static int +cmp_unhop(const struct user_nhop *a, const struct user_nhop *b) +{ + return (a->un_idx == b->un_idx && a->un_fibfam == b->un_fibfam); +} + +/* + * Hash callback: calculate hash of an object + */ +static unsigned int +hash_unhop(const struct user_nhop *obj) +{ + return (obj->un_idx ^ obj->un_fibfam); +} + +#define UNHOP_IS_MASTER(_unhop) ((_unhop)->un_fibfam == 0) + +/* + * Factory interface for creating matching kernel nexthops/nexthop groups + * + * @uidx: userland nexhop index used to create the nexthop + * @fibnum: fibnum nexthop will be used in + * @family: upper family nexthop will be used in + * @nh_flags: desired nexthop prefix flags + * @perror: pointer to store error to + * + * Returns referenced nexthop linked to @fibnum/@family rib on success. + */ +struct nhop_object * +nl_find_nhop(uint32_t fibnum, int family, uint32_t uidx, + int nh_flags, int *perror) +{ + struct unhop_ctl *ctl = atomic_load_ptr(&V_un_ctl); + UN_TRACKER; + + if (__predict_false(ctl == NULL)) + return (NULL); + + struct user_nhop key= { + .un_idx = uidx, + .un_fibfam = fibnum | ((uint32_t)family) << 24, + }; + struct user_nhop *unhop; + + nh_flags = nh_flags & (NHF_HOST | NHF_DEFAULT); + + if (__predict_false(family == 0)) + return (NULL); + + UN_RLOCK(ctl); + CHT_SLIST_FIND_BYOBJ(&ctl->un_head, unhop, &key, unhop); + if (unhop != NULL) { + struct nhop_object *nh = unhop->un_nhop; + UN_RLOCK(ctl); + *perror = 0; + nhop_ref_any(nh); + return (nh); + } + + /* + * Exact nexthop not found. Search for template nexthop to clone from. + */ + key.un_fibfam = 0; + CHT_SLIST_FIND_BYOBJ(&ctl->un_head, unhop, &key, unhop); + if (unhop == NULL) { + UN_RUNLOCK(ctl); + *perror = ESRCH; + return (NULL); + } + + UN_RUNLOCK(ctl); + + /* Create entry to insert first */ + struct user_nhop *un_new, *un_tmp; + un_new = malloc(sizeof(struct user_nhop), M_NETLINK, M_NOWAIT | M_ZERO); + if (un_new == NULL) { + *perror = ENOMEM; + return (NULL); + } + un_new->un_idx = uidx; + un_new->un_fibfam = fibnum | ((uint32_t)family) << 24; + + /* Relying on epoch to protect unhop here */ + un_new->un_nhop = clone_unhop(unhop, fibnum, family, nh_flags); + if (un_new->un_nhop == NULL) { + free(un_new, M_NETLINK); + *perror = ENOMEM; + return (NULL); + } + + /* Insert back and report */ + UN_WLOCK(ctl); + + /* First, find template record once again */ + CHT_SLIST_FIND_BYOBJ(&ctl->un_head, unhop, &key, unhop); + if (unhop == NULL) { + /* Someone deleted the nexthop during the call */ + UN_WUNLOCK(ctl); + *perror = ESRCH; + destroy_unhop(un_new); + return (NULL); + } + + /* Second, check the direct match */ + CHT_SLIST_FIND_BYOBJ(&ctl->un_head, unhop, un_new, un_tmp); + struct nhop_object *nh; + if (un_tmp != NULL) { + /* Another thread already created the desired nextop, use it */ + nh = un_tmp->un_nhop; + } else { + /* Finally, insert the new nexthop and link it to the primary */ + nh = un_new->un_nhop; + CHT_SLIST_INSERT_HEAD(&ctl->un_head, unhop, un_new); + un_new->un_nextchild = unhop->un_nextchild; + unhop->un_nextchild = un_new; + un_new = NULL; + RT_LOG(LOG_DEBUG2, "linked cloned nexthop %p", nh); + } + + UN_WUNLOCK(ctl); + + if (un_new != NULL) + destroy_unhop(un_new); + + *perror = 0; + nhop_ref_any(nh); + return (nh); +} + +static struct user_nhop * +nl_find_base_unhop(struct unhop_ctl *ctl, uint32_t uidx) +{ + struct user_nhop key= { .un_idx = uidx }; + struct user_nhop *unhop = NULL; + UN_TRACKER; + + UN_RLOCK(ctl); + CHT_SLIST_FIND_BYOBJ(&ctl->un_head, unhop, &key, unhop); + UN_RUNLOCK(ctl); + + return (unhop); +} + +#define MAX_STACK_NHOPS 4 +static struct nhop_object * +clone_unhop(const struct user_nhop *unhop, uint32_t fibnum, int family, int nh_flags) +{ + const struct weightened_nhop *wn; + struct weightened_nhop *wn_new, wn_base[MAX_STACK_NHOPS]; + struct nhop_object *nh = NULL; + uint32_t num_nhops; + int error; + + if (unhop->un_nhop_src != NULL) { +#if DEBUG_MAX_LEVEL >= LOG_DEBUG2 + { + char nhbuf[NHOP_PRINT_BUFSIZE]; + nhop_print_buf_any(unhop->un_nhop_src, nhbuf, sizeof(nhbuf)); + FIB_NH_LOG(LOG_DEBUG2, unhop->un_nhop_src, + "cloning nhop %s -> %u.%u flags 0x%X", nhbuf, fibnum, + family, nh_flags); + } +#endif + struct nhop_object *nh; + nh = nhop_alloc(fibnum, AF_UNSPEC); + if (nh == NULL) + return (NULL); + nhop_copy(nh, unhop->un_nhop_src); + /* Check that nexthop gateway is compatible with the new family */ + if (!nhop_set_upper_family(nh, family)) { + nhop_free(nh); + return (NULL); + } + nhop_set_uidx(nh, unhop->un_idx); + nhop_set_pxtype_flag(nh, nh_flags); + return (nhop_get_nhop(nh, &error)); + } + + wn = unhop->un_nhgrp_src; + num_nhops = unhop->un_nhgrp_count; + + if (num_nhops > MAX_STACK_NHOPS) { + wn_new = malloc(num_nhops * sizeof(struct weightened_nhop), M_TEMP, M_NOWAIT); + if (wn_new == NULL) + return (NULL); + } else + wn_new = wn_base; + + for (int i = 0; i < num_nhops; i++) { + uint32_t uidx = nhop_get_uidx(wn[i].nh); + MPASS(uidx != 0); + wn_new[i].nh = nl_find_nhop(fibnum, family, uidx, nh_flags, &error); + if (error != 0) + break; + wn_new[i].weight = wn[i].weight; + } + + if (error == 0) { + struct rib_head *rh = nhop_get_rh(wn_new[0].nh); + struct nhgrp_object *nhg; + + error = nhgrp_get_group(rh, wn_new, num_nhops, unhop->un_idx, &nhg); + nh = (struct nhop_object *)nhg; + } + + if (wn_new != wn_base) + free(wn_new, M_TEMP); + return (nh); +} + +static void +destroy_unhop(struct user_nhop *unhop) +{ + if (unhop->un_nhop != NULL) + nhop_free_any(unhop->un_nhop); + if (unhop->un_nhop_src != NULL) + nhop_free_any(unhop->un_nhop_src); + free(unhop, M_NETLINK); +} + +static void +destroy_unhop_epoch(epoch_context_t ctx) +{ + struct user_nhop *unhop; + + unhop = __containerof(ctx, struct user_nhop, un_epoch_ctx); + + destroy_unhop(unhop); +} + +static uint32_t +find_spare_uidx(struct unhop_ctl *ctl) +{ + struct user_nhop *unhop, key = {}; + uint32_t uidx = 0; + UN_TRACKER; + + UN_RLOCK(ctl); + /* This should return spare uid with 75% of 65k used in ~99/100 cases */ + for (int i = 0; i < 16; i++) { + key.un_idx = (arc4random() % 65536) + 65536 * 4; + CHT_SLIST_FIND_BYOBJ(&ctl->un_head, unhop, &key, unhop); + if (unhop == NULL) { + uidx = key.un_idx; + break; + } + } + UN_RUNLOCK(ctl); + + return (uidx); +} + + +/* + * Actual netlink code + */ +struct netlink_walkargs { + struct nlmsg_state *ns; + struct nlmsghdr hdr; + struct nlpcb *so; + int family; + int error; + int count; + int dumped; +}; +#define ENOMEM_IF_NULL(_v) if ((_v) == NULL) goto enomem + +static bool +dump_nhgrp(const struct user_nhop *unhop, struct nlmsghdr *hdr, + struct nlmsg_state *ns) +{ + + if (!nlmsg_reply(ns, hdr, sizeof(struct nhmsg))) + goto enomem; + + struct nhmsg *nhm = nlmsg_reserve_object(ns, struct nhmsg); + ENOMEM_IF_NULL(nhm); + nhm->nh_family = AF_UNSPEC; + nhm->nh_scope = 0; + nhm->nh_protocol = unhop->un_protocol; + nhm->nh_flags = 0; + + if (!nlattr_add_u32(ns, NHA_ID, unhop->un_idx)) + goto enomem; + + if (!nlattr_add_u16(ns, NHA_GROUP_TYPE, NEXTHOP_GRP_TYPE_MPATH)) + goto enomem; + + struct weightened_nhop *wn = unhop->un_nhgrp_src; + uint32_t num_nhops = unhop->un_nhgrp_count; + /* TODO: a better API? */ + int nla_len = sizeof(struct nlattr); + nla_len += NETLINK_ALIGN(num_nhops * sizeof(struct nexthop_grp)); + struct nlattr *nla = nlmsg_reserve_data(ns, nla_len, struct nlattr); + if (nla == NULL) + goto enomem; + nla->nla_type = NHA_GROUP; + nla->nla_len = nla_len; + for (int i = 0; i < num_nhops; i++) { + struct nexthop_grp *grp = &((struct nexthop_grp *)(nla + 1))[i]; + grp->id = nhop_get_uidx(wn[i].nh); + grp->weight = wn[i].weight; + grp->resvd1 = 0; + grp->resvd2 = 0; + } + + nlmsg_end(ns); + return (true); + +enomem: + RT_LOG(LOG_DEBUG, "error: unable to allocate attribute memory"); + nlmsg_abort(ns); + return (false); +} + +static bool +dump_nhop(const struct user_nhop *unhop, struct nlmsghdr *hdr, + struct nlmsg_state *ns) +{ + struct nhop_object *nh = unhop->un_nhop_src; + + if (!nlmsg_reply(ns, hdr, sizeof(struct nhmsg))) + goto enomem; + + struct nhmsg *nhm = nlmsg_reserve_object(ns, struct nhmsg); + ENOMEM_IF_NULL(nhm); + nhm->nh_family = nhop_get_neigh_family(nh); + nhm->nh_scope = 0; // XXX: what's that? + nhm->nh_protocol = unhop->un_protocol; + nhm->nh_flags = 0; + + if (!nlattr_add_u32(ns, NHA_ID, unhop->un_idx)) + goto enomem; + + if (nh->nh_flags & NHF_BLACKHOLE) { + if (!nlattr_add_flag(ns, NHA_BLACKHOLE)) + goto enomem; + goto done; + } + + if (!nlattr_add_u32(ns, NHA_OIF, nh->nh_ifp->if_index)) + goto enomem; + + switch (nh->gw_sa.sa_family) { +#ifdef INET + case AF_INET: + if (!nlattr_add(ns, NHA_GATEWAY, 4, &nh->gw4_sa.sin_addr)) + goto enomem; + break; +#endif +#ifdef INET6 + case AF_INET6: + { + struct in6_addr addr = nh->gw6_sa.sin6_addr; + in6_clearscope(&addr); + if (!nlattr_add(ns, NHA_GATEWAY, 16, &addr)) + goto enomem; + break; + } +#endif + } + +done: + nlmsg_end(ns); + return (true); +enomem: + nlmsg_abort(ns); + return (false); +} + +static void +dump_unhop(const struct user_nhop *unhop, struct nlmsghdr *hdr, + struct nlmsg_state *ns) +{ + if (unhop->un_nhop_src != NULL) + dump_nhop(unhop, hdr, ns); + else + dump_nhgrp(unhop, hdr, ns); +} + +static int +delete_unhop(struct unhop_ctl *ctl, struct nlmsghdr *hdr, uint32_t uidx) +{ + struct user_nhop *unhop_ret, *unhop_base, *unhop_chain; + + struct user_nhop key = { .un_idx = uidx }; + + UN_WLOCK(ctl); + + CHT_SLIST_FIND_BYOBJ(&ctl->un_head, unhop, &key, unhop_base); + + if (unhop_base != NULL) { + CHT_SLIST_REMOVE(&ctl->un_head, unhop, unhop_base, unhop_ret); +#if DEBUG_MAX_LEVEL >= LOG_DEBUG2 + { +/* + char nhbuf[NHOP_PRINT_BUFSIZE]; + nhop_print_buf_any(unhop_base->un_nhop, nhbuf, sizeof(nhbuf)); + FIB_NH_LOG(LOG_DEBUG2, unhop_base->un_nhop, + "removed base nhop %u: %s", uidx, nhbuf); +*/ + } +#endif + /* Unlink all child nexhops as well, keeping the chain intact */ + unhop_chain = unhop_base->un_nextchild; + while (unhop_chain != NULL) { + CHT_SLIST_REMOVE(&ctl->un_head, unhop, unhop_chain, + unhop_ret); + MPASS(unhop_chain == unhop_ret); +#if DEBUG_MAX_LEVEL >= LOG_DEBUG2 + { +/* + char nhbuf[NHOP_PRINT_BUFSIZE]; + nhop_print_buf_any(unhop_chain->un_nhop, + nhbuf, sizeof(nhbuf)); + FIB_NH_LOG(LOG_DEBUG2, unhop_chain->un_nhop, + "removed child nhop %u: %s", uidx, nhbuf); +*/ + } +#endif + unhop_chain = unhop_chain->un_nextchild; + } + } + + UN_WUNLOCK(ctl); + + if (unhop_base == NULL) { + RT_LOG(LOG_DEBUG, "unable to find unhop %u", uidx); + return (ENOENT); + } + + /* Report nexthop deletion */ + struct netlink_walkargs wa = { + .hdr.nlmsg_pid = hdr->nlmsg_pid, + .hdr.nlmsg_seq = hdr->nlmsg_seq, + .hdr.nlmsg_flags = hdr->nlmsg_flags, + .hdr.nlmsg_type = NL_RTM_DELNEXTHOP, + }; + + struct nlmsg_state ns = {}; + if (!nlmsg_get_group_writer(NLMSG_SMALL, RTNLGRP_NEXTHOP, &ns)) { + RT_LOG(LOG_DEBUG, "error allocating message writer"); + return (ENOMEM); + } + + dump_unhop(unhop_base, &wa.hdr, &ns); + nlmsg_flush(&ns); + + while (unhop_base != NULL) { + unhop_chain = unhop_base->un_nextchild; + epoch_call(net_epoch_preempt, destroy_unhop_epoch, + &unhop_base->un_epoch_ctx); + unhop_base = unhop_chain; + } + + return (0); +} + +static void +consider_resize(struct unhop_ctl *ctl, uint32_t new_size) +{ + void *new_ptr = NULL; + size_t alloc_size; + + if (new_size == 0) + return; + + if (new_size != 0) { + alloc_size = CHT_SLIST_GET_RESIZE_SIZE(new_size); + new_ptr = malloc(alloc_size, M_NETLINK, M_NOWAIT | M_ZERO); + if (new_ptr == NULL) + return; + } + + RT_LOG(LOG_DEBUG, "resizing hash: %u -> %u", ctl->un_head.hash_size, new_size); + UN_WLOCK(ctl); + if (new_ptr != NULL) { + CHT_SLIST_RESIZE(&ctl->un_head, unhop, new_ptr, new_size); + } + UN_WUNLOCK(ctl); + + + if (new_ptr != NULL) + free(new_ptr, M_NETLINK); +} + +static bool __noinline +vnet_init_unhops() +{ + uint32_t num_buckets = 16; + size_t alloc_size = CHT_SLIST_GET_RESIZE_SIZE(num_buckets); + + struct unhop_ctl *ctl = malloc(sizeof(struct unhop_ctl), M_NETLINK, + M_NOWAIT | M_ZERO); + if (ctl == NULL) + return (false); + + void *ptr = malloc(alloc_size, M_NETLINK, M_NOWAIT | M_ZERO); + if (ptr == NULL) { + free(ctl, M_NETLINK); + return (false); + } + CHT_SLIST_INIT(&ctl->un_head, ptr, num_buckets); + UN_LOCK_INIT(ctl); + + if (!atomic_cmpset_ptr((uintptr_t *)&V_un_ctl, (uintptr_t)NULL, (uintptr_t)ctl)) { + free(ptr, M_NETLINK); + free(ctl, M_NETLINK); + } + + if (atomic_load_ptr(&V_un_ctl) == NULL) + return (false); + + RT_LOG(LOG_NOTICE, "UNHOPS init done"); + + return (true); +} + +static void +vnet_destroy_unhops(const void *unused __unused) +{ + struct unhop_ctl *ctl = atomic_load_ptr(&V_un_ctl); + struct user_nhop *unhop, *tmp; + + if (ctl == NULL) + return; + V_un_ctl = NULL; + + /* Wait till all unhop users finish their reads */ + epoch_wait_preempt(net_epoch_preempt); + + UN_WLOCK(ctl); + CHT_SLIST_FOREACH_SAFE(&ctl->un_head, unhop, unhop, tmp) { + destroy_unhop(unhop); + } CHT_SLIST_FOREACH_SAFE_END; + UN_WUNLOCK(ctl); + + free(ctl->un_head.ptr, M_NETLINK); + free(ctl, M_NETLINK); +} +VNET_SYSUNINIT(vnet_destroy_unhops, SI_SUB_PROTO_IF, SI_ORDER_ANY, + vnet_destroy_unhops, NULL); + +static int +nlattr_get_nhg(struct nlattr *nla, struct netlink_parse_tracker *npt, void *target) +{ + int error = 0; + + /* Verify attribute correctness */ + struct nexthop_grp *grp = NLA_DATA(nla); + int data_len = NLA_DATA_LEN(nla); + + int count = data_len / sizeof(*grp); + if (count == 0 || (count * sizeof(*grp) != data_len)) { + RT_LOG(LOG_DEBUG, "Invalid length for RTA_GROUP: %d", data_len); + return (EINVAL); + } + + *((struct nlattr **)target) = nla; + return (error); +} + +struct nl_parsed_nhop { + uint32_t nha_id; + uint8_t nha_blackhole; + uint8_t nha_groups; + struct ifnet *nha_oif; + struct sockaddr *nha_gw; + struct nlattr *nha_group; + int nh_family; +}; +#define _OFF_S(_field) offsetof(struct nl_parsed_nhop, _field) + +static struct nlattr_parser ps[] = { + { .type = NHA_ID, .off = _OFF_S(nha_id), .cb = nlattr_get_uint32 }, + { .type = NHA_GROUP, .off = _OFF_S(nha_group), .cb = nlattr_get_nhg }, + { .type = NHA_BLACKHOLE, .off = _OFF_S(nha_blackhole), .cb = nlattr_get_flag }, + { .type = NHA_OIF, .off = _OFF_S(nha_oif), .cb = nlattr_get_ifindex }, + { .type = NHA_GATEWAY, .off = _OFF_S(nha_gw), .cb = nlattr_get_ip }, + { .type = NHA_GROUPS, .off = _OFF_S(nha_groups), .cb = nlattr_get_flag }, +}; + +static bool +eligible_nhg(const struct nhop_object *nh) +{ + return (nh->nh_flags & NHF_GATEWAY); +} + +static int +newnhg(struct unhop_ctl *ctl, struct nl_parsed_nhop *attrs, struct user_nhop *unhop) +{ + struct nexthop_grp *grp = NLA_DATA(attrs->nha_group); + int count = NLA_DATA_LEN(attrs->nha_group) / sizeof(*grp); + struct weightened_nhop *wn; + + wn = malloc(sizeof(*wn) * count, M_NETLINK, M_NOWAIT | M_ZERO); + if (wn == NULL) + return (ENOMEM); + + for (int i = 0; i < count; i++) { + struct user_nhop *unhop; + unhop = nl_find_base_unhop(ctl, grp[i].id); + if (unhop == NULL) { + RT_LOG(LOG_DEBUG, "unable to find uidx %u", grp[i].id); + free(wn, M_NETLINK); + return (ESRCH); + } else if (unhop->un_nhop_src == NULL) { + RT_LOG(LOG_DEBUG, "uidx %u is a group, nested group unsupported", + grp[i].id); + free(wn, M_NETLINK); + return (ENOTSUP); + } else if (!eligible_nhg(unhop->un_nhop_src)) { + RT_LOG(LOG_DEBUG, "uidx %u nhop is not mpath-eligible", + grp[i].id); + free(wn, M_NETLINK); + return (ENOTSUP); + } + /* + * TODO: consider more rigid eligibility checks: + * restrict nexthops with the same gateway + */ + wn[i].nh = unhop->un_nhop_src; + wn[i].weight = grp[i].weight; + } + unhop->un_nhgrp_src = wn; + unhop->un_nhgrp_count = count; + return (0); +} + +static int +newnhop(struct nl_parsed_nhop *attrs, struct user_nhop *unhop) +{ + struct ifaddr *ifa = NULL; + struct nhop_object *nh; + int error; + + if (!attrs->nha_blackhole) { + if (attrs->nha_gw == NULL) { + RT_LOG(LOG_DEBUG, "missing NHA_GATEWAY"); + return (EINVAL); + } + if (attrs->nha_oif == NULL) { + RT_LOG(LOG_DEBUG, "missing NHA_OIF"); + return (EINVAL); + } + if (ifa == NULL) + ifa = ifaof_ifpforaddr(attrs->nha_gw, attrs->nha_oif); + if (ifa == NULL) { + RT_LOG(LOG_DEBUG, "Unable to determine default source IP"); + return (EINVAL); + } + } + + int family = attrs->nha_gw != NULL ? attrs->nha_gw->sa_family : attrs->nh_family; + + nh = nhop_alloc(RT_DEFAULT_FIB, family); + if (nh == NULL) { + RT_LOG(LOG_DEBUG, "Unable to allocate nexthop"); + return (ENOMEM); + } + nhop_set_uidx(nh, attrs->nha_id); + + if (attrs->nha_blackhole) + nhop_set_blackhole(nh, NHF_BLACKHOLE); + else { + nhop_set_gw(nh, attrs->nha_gw, true); + nhop_set_transmit_ifp(nh, attrs->nha_oif); + nhop_set_src(nh, ifa); + } + + error = nhop_finalize(nh); + if (error != 0) { + RT_LOG(LOG_DEBUG, "unable to finalize nexthop"); + return (error); + } + +#if DEBUG_MAX_LEVEL >= LOG_DEBUG2 + { + char nhbuf[NHOP_PRINT_BUFSIZE]; + nhop_print_buf(nh, nhbuf, sizeof(nhbuf)); + RT_LOG(LOG_DEBUG2, "Adding unhop %u: %s", attrs->nha_id, nhbuf); + } +#endif + unhop->un_nhop_src = nh; + return (0); +} + +static int +rtnl_handle_newnhop(struct nlmsghdr *hdr, struct nlpcb *nlp, + struct netlink_parse_tracker *npt) +{ + struct user_nhop *unhop; + int error; + + error = nlp_has_priv_route(nlp); + if (error != 0) + return (error); + + if ((__predict_false(V_un_ctl == NULL)) && (!vnet_init_unhops())) + return (ENOMEM); + struct unhop_ctl *ctl = V_un_ctl; + + struct nhmsg *nhm = (struct nhmsg *)nlmsg_data(hdr); + struct nl_parsed_nhop attrs = { .nh_family = nhm->nh_family }; + error = nl_parse_attrs(hdr, sizeof(*nhm), ps, sizeof(ps)/sizeof(ps[0]), npt, &attrs); + if (error != 0) + return (error); + + /* + * Get valid nha_id. Treat nha_id == 0 (auto-assignment) as a second-class + * citizen. + */ + if (attrs.nha_id == 0) { + attrs.nha_id = find_spare_uidx(ctl); + if (attrs.nha_id == 0) { + RT_LOG(LOG_DEBUG, "Unable to get spare uidx"); + return (ENOSPC); + } + } + + RT_LOG(LOG_DEBUG, "IFINDEX %d", attrs.nha_oif ? attrs.nha_oif->if_index : 0); + + unhop = malloc(sizeof(struct user_nhop), M_NETLINK, M_NOWAIT | M_ZERO); + if (unhop == NULL) { + RT_LOG(LOG_DEBUG, "Unable to allocate user_nhop"); + return (ENOMEM); + } + unhop->un_idx = attrs.nha_id; + unhop->un_protocol = nhm->nh_protocol; + + if (attrs.nha_group) + error = newnhg(ctl, &attrs, unhop); + else + error = newnhop(&attrs, unhop); + + if (error != 0) { + free(unhop, M_NETLINK); + return (error); + } + + UN_WLOCK(ctl); + /* Check if uidx already exists */ + struct user_nhop *tmp = NULL; + CHT_SLIST_FIND_BYOBJ(&ctl->un_head, unhop, unhop, tmp); + if (tmp != NULL) { + UN_WUNLOCK(ctl); + RT_LOG(LOG_DEBUG, "nhop idx %u already exists", attrs.nha_id); + destroy_unhop(unhop); + return (EEXIST); + } + CHT_SLIST_INSERT_HEAD(&ctl->un_head, unhop, unhop); + uint32_t num_buckets_new = CHT_SLIST_GET_RESIZE_BUCKETS(&ctl->un_head); + UN_WUNLOCK(ctl); + + /* Report addition of the next nexhop */ + struct netlink_walkargs wa = { + .hdr.nlmsg_pid = hdr->nlmsg_pid, + .hdr.nlmsg_seq = hdr->nlmsg_seq, + .hdr.nlmsg_flags = hdr->nlmsg_flags, + .hdr.nlmsg_type = NL_RTM_NEWNEXTHOP, + }; + + struct nlmsg_state ns = {}; + if (!nlmsg_get_group_writer(NLMSG_SMALL, RTNLGRP_NEXTHOP, &ns)) { + RT_LOG(LOG_DEBUG, "error allocating message writer"); + return (ENOMEM); + } + + dump_unhop(unhop, &wa.hdr, &ns); + nlmsg_flush(&ns); + + consider_resize(ctl, num_buckets_new); + + return (0); +} + +static int +rtnl_handle_delnhop(struct nlmsghdr *hdr, struct nlpcb *nlp, + struct netlink_parse_tracker *npt) +{ + struct unhop_ctl *ctl = atomic_load_ptr(&V_un_ctl); + int error; + + error = nlp_has_priv_route(nlp); + if (error != 0) + return (error); + + if (__predict_false(ctl == NULL)) + return (ESRCH); + + struct nhmsg *nhm = (struct nhmsg *)nlmsg_data(hdr); + struct nl_parsed_nhop attrs = {}; + error = nl_parse_attrs(hdr, sizeof(*nhm), ps, sizeof(ps)/sizeof(ps[0]), npt, &attrs); + if (error != 0) + return (error); + + if (attrs.nha_id == 0) { + RT_LOG(LOG_DEBUG, "NHA_ID not set"); + return (EINVAL); + } + + error = delete_unhop(ctl, hdr, attrs.nha_id); + + return (error); +} + +static bool +match_unhop(const struct nl_parsed_nhop *attrs, struct user_nhop *unhop) +{ + if (attrs->nha_id != 0 && unhop->un_idx != attrs->nha_id) + return (false); + if (attrs->nha_groups != 0 && unhop->un_nhgrp_src == NULL) + return (false); + if (attrs->nha_oif != NULL && + (unhop->un_nhop_src == NULL || unhop->un_nhop_src->nh_ifp != attrs->nha_oif)) + return (false); + + return (true); +} + +static int +rtnl_handle_getnhop(struct nlmsghdr *hdr, struct nlpcb *nlp, + struct netlink_parse_tracker *npt) +{ + struct unhop_ctl *ctl = atomic_load_ptr(&V_un_ctl); + struct user_nhop *unhop; + UN_TRACKER; + int error; + + if (__predict_false(ctl == NULL)) + return (ESRCH); + + struct nhmsg *nhm = (struct nhmsg *)nlmsg_data(hdr); + struct nl_parsed_nhop attrs = {}; + error = nl_parse_attrs(hdr, sizeof(*nhm), ps, sizeof(ps)/sizeof(ps[0]), npt, &attrs); + if (error != 0) + return (error); + + struct netlink_walkargs wa = { + .ns = npt->ns, + .hdr.nlmsg_pid = hdr->nlmsg_pid, + .hdr.nlmsg_seq = hdr->nlmsg_seq, + .hdr.nlmsg_flags = hdr->nlmsg_flags, + .hdr.nlmsg_type = NL_RTM_NEWNEXTHOP, + }; + + if (attrs.nha_id != 0) { + RT_LOG(LOG_DEBUG2, "searching for uidx %u", attrs.nha_id); + struct user_nhop key= { .un_idx = attrs.nha_id }; + UN_RLOCK(ctl); + CHT_SLIST_FIND_BYOBJ(&ctl->un_head, unhop, &key, unhop); + UN_RUNLOCK(ctl); + + if (unhop == NULL) + return (ESRCH); + dump_unhop(unhop, &wa.hdr, wa.ns); + return (0); + } + + UN_RLOCK(ctl); + wa.hdr.nlmsg_flags |= NLM_F_MULTI; + CHT_SLIST_FOREACH(&ctl->un_head, unhop, unhop) { + if (UNHOP_IS_MASTER(unhop) && match_unhop(&attrs, unhop)) + dump_unhop(unhop, &wa.hdr, wa.ns); + } CHT_SLIST_FOREACH_END; + UN_RUNLOCK(ctl); + + if (wa.error == 0) { + if (!nlmsg_end_dump(wa.ns, wa.error, &wa.hdr)) + return (ENOMEM); + } + return (0); +} + +static struct rtnl_cmd_handler cmd_handlers[] = { + { NL_RTM_GETNEXTHOP, "RTM_GETNEXTHOP", &rtnl_handle_getnhop, sizeof(struct nhmsg)}, + { NL_RTM_DELNEXTHOP, "RTM_DELNEXTHOP", &rtnl_handle_delnhop, sizeof(struct nhmsg)}, + { NL_RTM_NEWNEXTHOP, "RTM_NEWNEXTHOP", &rtnl_handle_newnhop, sizeof(struct nhmsg)}, +}; + +void +rtnl_nexthops_init() +{ + rtnl_register_messages(cmd_handlers, RTNL_ARRAY_LEN(cmd_handlers)); +} diff --git a/sys/netlink/route/route.h b/sys/netlink/route/route.h new file mode 100644 --- /dev/null +++ b/sys/netlink/route/route.h @@ -0,0 +1,349 @@ +/* + * Route-related (RTM_ROUTE) message header and attributes. + */ + +#ifndef _NETLINK_ROUTE_ROUTE_H_ +#define _NETLINK_ROUTE_ROUTE_H_ + +/* Base header for all of the relevant messages */ +struct rtmsg { + unsigned char rtm_family; /* address family */ + unsigned char rtm_dst_len; /* Prefix length */ + unsigned char rtm_src_len; /* Source prefix length (not used) */ + unsigned char rtm_tos; /* Type of service (not used) */ + unsigned char rtm_table; /* rtable id */ + unsigned char rtm_protocol; /* Routing protocol id (RTPROT_) */ + unsigned char rtm_scope; /* Route distance (RT_SCOPE_) */ + unsigned char rtm_type; /* Route type (RTN_) */ + unsigned rtm_flags; /* Route flags (RTM_F_) */ +}; + +/* + * RFC 3549, 3.1.1, route type (rtm_type field). + */ +enum { + RTN_UNSPEC, + RTN_UNICAST, /* Unicast route */ + RTN_LOCAL, /* Accept locally (not supported) */ + RTN_BROADCAST, /* Accept locally as broadcast, send as broadcast */ + RTN_ANYCAST, /* Accept locally as broadcast, but send as unicast */ + RTN_MULTICAST, /* Multicast route */ + RTN_BLACKHOLE, /* Drop traffic towards destination */ + RTN_UNREACHABLE, /* Destination is unreachable */ + RTN_PROHIBIT, /* Administratively prohibited */ + RTN_THROW, /* Not in this table (not supported) */ + RTN_NAT, /* Translate this address (not supported) */ + RTN_XRESOLVE, /* Use external resolver (not supported) */ + __RTN_MAX, +}; +#define RTN_MAX (__RTN_MAX - 1) + +/* + * RFC 3549, 3.1.1, protocol (Identifies what/who added the route). + * Values larger than RTPROT_STATIC(4) are not interpreted by the + * kernel, they are just for user information. + */ +#define RTPROT_UNSPEC 0 +#define RTPROT_REDIRECT 1 /* Route installed by ICMP redirect */ +#define RTPROT_KERNEL 2 /* Route installed by kernel */ +#define RTPROT_BOOT 3 /* Route installed during boot */ +#define RTPROT_STATIC 4 /* Route installed by administrator */ + +#define RTPROT_GATED 8 /* Apparently, GateD */ +#define RTPROT_RA 9 /* RDISC/ND router advertisements */ +#define RTPROT_MRT 10 /* Merit MRT */ +#define RTPROT_ZEBRA 11 /* Zebra */ +#define RTPROT_BIRD 12 /* BIRD */ +#define RTPROT_DNROUTED 13 /* DECnet routing daemon */ +#define RTPROT_XORP 14 /* XORP */ +#define RTPROT_NTK 15 /* Netsukuku */ +#define RTPROT_DHCP 16 /* DHCP client */ +#define RTPROT_MROUTED 17 /* Multicast daemon */ +#define RTPROT_KEEPALIVED 18 /* Keepalived daemon */ +#define RTPROT_BABEL 42 /* Babel daemon */ +#define RTPROT_OPENR 99 /* Open Routing (Open/R) Routes */ +#define RTPROT_BGP 186 /* BGP Routes */ +#define RTPROT_ISIS 187 /* ISIS Routes */ +#define RTPROT_OSPF 188 /* OSPF Routes */ +#define RTPROT_RIP 189 /* RIP Routes */ +#define RTPROT_EIGRP 192 /* EIGRP Routes */ + +/* + * RFC 3549 3.1.1 Route scope (valid distance to destination). + * + * The values between RT_SCOPE_UNIVERSE(0) and RT_SCOPE_SITE(200) + * are available to the user. + */ +enum rt_scope_t { + RT_SCOPE_UNIVERSE = 0, + /* User defined values */ + RT_SCOPE_SITE = 200, + RT_SCOPE_LINK = 253, + RT_SCOPE_HOST = 254, + RT_SCOPE_NOWHERE = 255 +}; + +/* + * RFC 3549 3.1.1 Route flags. + */ +#define RTM_F_NOTIFY 0x100 /* Notify user of route change */ +#define RTM_F_CLONED 0x200 /* This route is cloned (not used) */ +#define RTM_F_EQUALIZE 0x400 /* Multipath equalizer: NI */ +#define RTM_F_PREFIX 0x800 /* Prefix addresses */ +#define RTM_F_LOOKUP_TABLE 0x1000 /* set tableid to FIB lookup result */ +#define RTM_F_FIB_MATCH 0x2000 /* return full fib lookup match */ +#define RTM_F_OFFLOAD 0x4000 /* route is offloaded */ +#define RTM_F_TRAP 0x8000 /* route is trapping packets */ +#define RTM_F_OFFLOAD_FAILED 0x20000000 /* route offload failed */ + +/* Compatibility handling helpers */ +#ifndef _KERNEL +#define NL_RTM_HDRLEN ((int)sizeof(struct rtmsg)) +#define RTM_RTA(_rtm) ((struct rtattr *)((char *)(_rtm) + NL_RTM_HDRLEN)) +#define RTM_PAYLOAD(_hdr) NLMSG_PAYLOAD((_hdr), NL_RTM_HDRLEN) +#endif + +/* + * Routing table identifiers. + * FreeBSD route table numbering starts from 0, where 0 is a valid default routing table. + * Indicating "all tables" via netlink can be done by not including RTA_TABLE attribute + * and keeping rtm_table=0 (compatibility) or setting RTA_TABLE value to RT_TABLE_UNSPEC. + */ +#define RT_TABLE_MAIN 0 /* RT_DEFAULT_FIB */ +#define RT_TABLE_UNSPEC 0xFFFFFFFF /* RT_ALL_FIBS */ + +enum rtattr_type_t { + NL_RTA_UNSPEC, + NL_RTA_DST, /* network: IPv4/IPv6 destination */ + NL_RTA_SRC, + NL_RTA_IIF, /* not supported */ + NL_RTA_OIF, /* u32: transmit ifindex */ + NL_RTA_GATEWAY, /* network: IPv4/IPv6 gateway */ + NL_RTA_PRIORITY, + NL_RTA_PREFSRC, + NL_RTA_METRICS, + NL_RTA_MULTIPATH, + NL_RTA_PROTOINFO, /* not supported / deprecated */ + NL_RTA_FLOW, /* not supported */ + NL_RTA_CACHEINFO, /* not supported */ + NL_RTA_SESSION, /* not supported / deprecated */ + NL_RTA_MP_ALGO, /* not supported / deprecated */ + NL_RTA_TABLE, /* u32: fibnum */ + NL_RTA_MARK, /* not used */ + NL_RTA_MFC_STATS, + NL_RTA_VIA, /* network: af+ gw address */ + NL_RTA_NEWDST, + NL_RTA_PREF, + NL_RTA_ENCAP_TYPE, + NL_RTA_ENCAP, + NL_RTA_EXPIRES, + NL_RTA_PAD, + NL_RTA_UID, + NL_RTA_TTL_PROPAGATE, + NL_RTA_IP_PROTO, + NL_RTA_SPORT, + NL_RTA_DPORT, + NL_RTA_NH_ID, /* u32: nexthop/nexthop group index */ + __RTA_MAX +}; +#define NL_RTA_MAX (__RTA_MAX - 1) + +/* + * Attributes that can be used as filters: + * + */ + +#ifndef _KERNEL +/* + * RTA_* space has clashes with rtsock namespace. + * Use NL_RTA_ prefix in the kernel and map to + * RTA_ for userland. + */ +#define RTA_UNSPEC NL_RTA_UNSPEC +#define RTA_DST NL_RTA_DST +#define RTA_SRC NL_RTA_SRC +#define RTA_IIF NL_RTA_IIF +#define RTA_OIF NL_RTA_OIF +#define RTA_GATEWAY NL_RTA_GATEWAY +#define RTA_PRIORITY NL_RTA_PRIORITY +#define RTA_PREFSRC NL_RTA_PREFSRC +#define RTA_METRICS NL_RTA_METRICS +#define RTA_MULTIPATH NL_RTA_MULTIPATH +#define RTA_PROTOINFO NL_RTA_PROTOINFO +#define RTA_FLOW NL_RTA_FLOW +#define RTA_CACHEINFO NL_RTA_CACHEINFO +#define RTA_SESSION NL_RTA_SESSION +#define RTA_MP_ALGO NL_RTA_MP_ALGO +#define RTA_TABLE NL_RTA_TABLE +#define RTA_MARK NL_RTA_MARK +#define RTA_MFC_STATS NL_RTA_MFC_STATS +#define RTA_VIA NL_RTA_VIA +#define RTA_NEWDST NL_RTA_NEWDST +#define RTA_PREF NL_RTA_PREF +#define RTA_ENCAP_TYPE NL_RTA_ENCAP_TYPE +#define RTA_ENCAP NL_RTA_ENCAP +#define RTA_EXPIRES NL_RTA_EXPIRES +#define RTA_PAD NL_RTA_PAD +#define RTA_UID NL_RTA_UID +#define RTA_TTL_PROPAGATE NL_RTA_TTL_PROPAGATE +#define RTA_IP_PROTO NL_RTA_IP_PROTO +#define RTA_SPORT NL_RTA_SPORT +#define RTA_DPORT NL_RTA_DPORT +#define RTA_NH_ID NL_RTA_NH_ID +#define RTA_MAX NL_RTA_MAX +#endif + +/* route attribute header */ +struct rtattr { + unsigned short rta_len; + unsigned short rta_type; +}; + +#define NL_RTA_ALIGN_SIZE NL_ITEM_ALIGN_SIZE +#define NL_RTA_ALIGN NL_ITEM_ALIGN +#define NL_RTA_HDRLEN ((int)sizeof(struct rtattr)) +#define NL_RTA_DATA_LEN(_rta) ((int)((_rta)->rta_len - NL_RTA_HDRLEN)) +#define NL_RTA_DATA(_rta) NL_ITEM_DATA(_rta, NL_RTA_HDRLEN) +#define NL_RTA_DATA_CONST(_rta) NL_ITEM_DATA_CONST(_rta, NL_RTA_HDRLEN) + +/* Compatibility attribute handling helpers */ +#ifndef _KERNEL +#define RTA_ALIGNTO NL_RTA_ALIGN_SIZE +#define RTA_ALIGN(_len) NL_RTA_ALIGN(_len) +#define _RTA_LEN(_rta) ((int)(_rta)->rta_len) +#define _RTA_ALIGNED_LEN(_rta) RTA_ALIGN(_RTA_LEN(_rta)) +#define RTA_OK(_rta, _len) NL_ITEM_OK(_rta, _len, NL_RTA_HDRLEN, _RTA_LEN) +#define RTA_NEXT(_rta, _len) NL_ITEM_ITER(_rta, _len, _RTA_ALIGNED_LEN) +#define RTA_LENGTH(_len) (NL_RTA_HDRLEN + (_len)) +#define RTA_SPACE(_len) RTA_ALIGN(RTA_LENGTH(_len)) +#define RTA_DATA(_rta) NL_RTA_DATA(_rta) +#define RTA_PAYLOAD(_rta) ((int)(_RTA_LEN(_rta) - NL_RTA_HDRLEN)) +#endif + +/* RTA attribute headers */ + +/* RTA_VIA */ +struct rtvia { + sa_family_t rtvia_family; + uint8_t rtvia_addr[0]; +}; + +/* + * RTA_METRICS is a nested attribute, consising of array of 'struct rtattr' + * with the types defined below. Most of the values are uint32_t. + */ + enum { + NL_RTAX_UNSPEC, +#define NL_RTAX_UNSPEC NL_RTAX_UNSPEC + NL_RTAX_LOCK, +#define NL_RTAX_LOCK NL_RTAX_LOCK + NL_RTAX_MTU, +#define NL_RTAX_MTU NL_RTAX_MTU + NL_RTAX_WINDOW, +#define NL_RTAX_WINDOW NL_RTAX_WINDOW + NL_RTAX_RTT, +#define NL_RTAX_RTT NL_RTAX_RTT + NL_RTAX_RTTVAR, +#define NL_RTAX_RTTVAR NL_RTAX_RTTVAR + NL_RTAX_SSTHRESH, +#define NL_RTAX_SSTHRESH NL_RTAX_SSTHRESH + NL_RTAX_CWND, +#define NL_RTAX_CWND NL_RTAX_CWND + NL_RTAX_ADVMSS, +#define NL_RTAX_ADVMSS NL_RTAX_ADVMSS + NL_RTAX_REORDERING, +#define NL_RTAX_REORDERING NL_RTAX_REORDERING + NL_RTAX_HOPLIMIT, +#define NL_RTAX_HOPLIMIT NL_RTAX_HOPLIMIT + NL_RTAX_INITCWND, +#define NL_RTAX_INITCWND NL_RTAX_INITCWND + NL_RTAX_FEATURES, +#define NL_RTAX_FEATURES NL_RTAX_FEATURES + NL_RTAX_RTO_MIN, +#define NL_RTAX_RTO_MIN NL_RTAX_RTO_MIN + NL_RTAX_INITRWND, +#define NL_RTAX_INITRWND NL_RTAX_INITRWND + NL_RTAX_QUICKACK, +#define NL_RTAX_QUICKACK NL_RTAX_QUICKACK + NL_RTAX_CC_ALGO, +#define NL_RTAX_CC_ALGO NL_RTAX_CC_ALGO + NL_RTAX_FASTOPEN_NO_COOKIE, +#define NL_RTAX_FASTOPEN_NO_COOKIE NL_RTAX_FASTOPEN_NO_COOKIE + __NL_RTAX_MAX +}; +#define NL_RTAX_MAX (__NL_RTAX_MAX - 1) + +#define RTAX_FEATURE_ECN (1 << 0) +#define RTAX_FEATURE_SACK (1 << 1) +#define RTAX_FEATURE_TIMESTAMP (1 << 2) +#define RTAX_FEATURE_ALLFRAG (1 << 3) + +#define RTAX_FEATURE_MASK \ + (RTAX_FEATURE_ECN | RTAX_FEATURE_SACK | RTAX_FEATURE_TIMESTAMP | \ + RTAX_FEATURE_ALLFRAG) + +#ifndef _KERNEL + +/* + * RTAX_* space clashes with rtsock namespace. + * Use NL_RTAX_ prefix in the kernel and map to + * RTAX_ for userland. + */ +#define RTAX_UNSPEC NL_RTAX_UNSPEC +#define RTAX_LOCK NL_RTAX_LOCK +#define RTAX_MTU NL_RTAX_MTU +#define RTAX_WINDOW NL_RTAX_WINDOW +#define RTAX_RTT NL_RTAX_RTT +#define RTAX_RTTVAR NL_RTAX_RTTVAR +#define RTAX_SSTHRESH NL_RTAX_SSTHRESH +#define RTAX_CWND NL_RTAX_CWND +#define RTAX_ADVMSS NL_RTAX_ADVMSS +#define RTAX_REORDERING NL_RTAX_REORDERING +#define RTAX_HOPLIMIT NL_RTAX_HOPLIMIT +#define RTAX_INITCWND NL_RTAX_INITCWND +#define RTAX_FEATURES NL_RTAX_FEATURES +#define RTAX_RTO_MIN NL_RTAX_RTO_MIN +#define RTAX_INITRWND NL_RTAX_INITRWND +#define RTAX_QUICKACK NL_RTAX_QUICKACK +#define RTAX_CC_ALGO NL_RTAX_CC_ALGO +#define RTAX_FASTOPEN_NO_COOKIE NL_RTAX_FASTOPEN_NO_COOKIE +#endif + +/* RTA_MULTIPATH consists of an array of rtnexthop structures. */ +struct rtnexthop { + unsigned short rtnh_len; + unsigned char rtnh_flags; + unsigned char rtnh_hops; + int rtnh_ifindex; +}; + +/* rtnh_flags */ +#define RTNH_F_DEAD 0x01 /* Nexthop is dead (used by multipath) */ +#define RTNH_F_PERVASIVE 0x02 /* Do recursive gateway lookup */ +#define RTNH_F_ONLINK 0x04 /* Gateway is forced on link */ +#define RTNH_F_OFFLOAD 0x08 /* Nexthop is offloaded */ +#define RTNH_F_LINKDOWN 0x10 /* carrier-down on nexthop */ +#define RTNH_F_UNRESOLVED 0x20 /* The entry is unresolved (ipmr) */ +#define RTNH_F_TRAP 0x40 /* Nexthop is trapping packets */ + +#define RTNH_COMPARE_MASK (RTNH_F_DEAD | RTNH_F_LINKDOWN | \ + RTNH_F_OFFLOAD | RTNH_F_TRAP) + +/* Macros to handle hexthops */ +#define RTNH_ALIGNTO NL_ITEM_ALIGN_SIZE +#define RTNH_ALIGN(_len) NL_ITEM_ALIGN(_len) +#define RTNH_HDRLEN ((int)sizeof(struct rtnexthop)) +#define _RTNH_LEN(_nh) ((int)(_nh)->rtnh_len) +#define _RTNH_ALIGNED_LEN(_nh) RTNH_ALIGN(_RTNH_LEN(_nh)) +#define RTNH_OK(_nh, _len) NL_ITEM_OK(_nh, _len, RTNH_HDRLEN, _RTNH_LEN) +#define RTNH_NEXT(_nh) ((struct rtnexthop *)((char *)(_nh) + _RTNH_ALIGNED_LEN(_nh))) +#define RTNH_LENGTH(_len) (RTNH_HDRLEN + (_len)) +#define RTNH_SPACE(_len) RTNH_ALIGN(RTNH_LENGTH(_len)) +#define RTNH_DATA(_nh) ((struct rtattr *)NL_ITEM_DATA(_nh, RTNH_HDRLEN)) + + +struct rtgenmsg { + unsigned char rtgen_family; +}; + +#endif diff --git a/sys/netlink/route/route.c b/sys/netlink/route/route.c new file mode 100644 --- /dev/null +++ b/sys/netlink/route/route.c @@ -0,0 +1,821 @@ +/*- + * SPDX-License-Identifier: BSD-2-Clause-FreeBSD + * + * Copyright (c) 2021 Ng Peng Nam Sean + * 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 +__FBSDID("$FreeBSD$"); +#include "opt_inet.h" +#include "opt_inet6.h" +#include "opt_route.h" +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define DEBUG_MOD_NAME nl_route +#define DEBUG_MAX_LEVEL LOG_DEBUG3 +#include +_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)); +} diff --git a/sys/netlink/route/route_var.h b/sys/netlink/route/route_var.h new file mode 100644 --- /dev/null +++ b/sys/netlink/route/route_var.h @@ -0,0 +1,77 @@ +/*- + * SPDX-License-Identifier: BSD-2-Clause-FreeBSD + * + * Copyright (c) 2021 Ng Peng Nam Sean + * 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. + */ + +/* + * This file contains definitions shared amount NETLINK_ROUTE family + */ + +#ifndef _NETLINK_ROUTE_ROUTE_VAR_H_ +#define _NETLINK_ROUTE_ROUTE_VAR_H_ + +struct nlmsghdr; +struct nlpcb; +struct netlink_parse_tracker; + +typedef int rtnl_msg_cb_f(struct nlmsghdr *hdr, struct nlpcb *nlp, + struct netlink_parse_tracker *npt); + +struct rtnl_cmd_handler { + int rtnl_cmd; + const char *rtnl_cmd_name; + rtnl_msg_cb_f *rtnl_cb; + int rtnl_min_size; + int rtnl_flags; +}; +#define RTNL_ARRAY_LEN(_a) (sizeof(_a) / sizeof((_a)[0])) + +#define RTNL_F_NOEPOCH 0x01 +#define RTNL_F_NOWRITER 0x02 + +bool rtnl_register_messages(struct rtnl_cmd_handler *handlers, int count); + +/* route.c */ +struct rt_addrinfo; +struct rib_cmd_info; +void rtnl_handle_route_event(uint32_t fibnum, const struct rt_addrinfo *info, + const struct rib_cmd_info *rc); +void rtnl_routes_init(void); + +/* neigh.c */ +void rtnl_neighs_init(void); + +/* iface.c */ +void rtnl_ifaces_init(void); +void rtnl_ifaces_destroy(void); + +/* nexthop.c */ +void rtnl_nexthops_init(void); +struct nhop_object *nl_find_nhop(uint32_t fibnum, int family, + uint32_t uidx, int nh_flags, int *perror); + + +#endif diff --git a/tests/sys/net/routing/netlink.py b/tests/sys/net/routing/netlink.py new file mode 100644 --- /dev/null +++ b/tests/sys/net/routing/netlink.py @@ -0,0 +1,1090 @@ +#!/usr/local/bin/python3 + +from ctypes import * +import socket +import os +import sys +import unittest +import struct + +from enum import Enum, auto + +from typing import List, Callable, Dict, NamedTuple, Optional + + +def roundup2(val: int, num: int) -> int: + if val % num: + return (val | (num - 1)) + 1 + else: + return val + + +def align4(val: int) -> int: + return roundup2(val, 4) + + +class SockaddrNl(Structure): + _fields_ = [ + ("nl_len", c_ubyte), + ("nl_family", c_ubyte), + ("nl_pad", c_ushort), + ("nl_pid", c_uint), + ("nl_groups", c_uint), + ] + + +class Nlmsghdr(Structure): + _fields_ = [ + ("nlmsg_len", c_uint), + ("nlmsg_type", c_ushort), + ("nlmsg_flags", c_ushort), + ("nlmsg_seq", c_uint), + ("nlmsg_pid", c_uint), + ] + + +class Nlmsgerr(Structure): + _fields_ = [ + ("error", c_int), + ("msg", Nlmsghdr), + ] + + +class RtattrType(Enum): + RTA_UNSPEC = 0 + RTA_DST = auto() + RTA_SRC = auto() + RTA_IIF = auto() + RTA_OIF = auto() + RTA_GATEWAY = auto() + RTA_PRIORITY = auto() + RTA_PREFSRC = auto() + RTA_METRICS = auto() + RTA_MULTIPATH = auto() + RTA_PROTOINFO = auto() + RTA_FLOW = auto() + RTA_CACHEINFO = auto() + RTA_SESSION = auto() + RTA_MP_ALGO = auto() + RTA_TABLE = auto() + RTA_MARK = auto() + RTA_MFC_STATS = auto() + RTA_VIA = auto() + RTA_NEWDST = auto() + RTA_PREF = auto() + RTA_ENCAP_TYPE = auto() + RTA_ENCAP = auto() + RTA_EXPIRES = auto() + RTA_PAD = auto() + RTA_UID = auto() + RTA_TTL_PROPAGATE = auto() + RTA_IP_PROTO = auto() + RTA_SPORT = auto() + RTA_DPORT = auto() + RTA_NH_ID = auto() + + +class NlMsgType(Enum): + NLMSG_NOOP = 1 + NLMSG_ERROR = 2 + NLMSG_DONE = 3 + NLMSG_OVERRUN = 4 + + +class NlRtMsgType(Enum): + RTM_NEWLINK = 16 + RTM_DELLINK = 17 + RTM_GETLINK = 18 + RTM_SETLINK = 19 + RTM_NEWADDR = 20 + RTM_DELADDR = 21 + RTM_GETADDR = 22 + RTM_NEWROUTE = 24 + RTM_DELROUTE = 25 + RTM_GETROUTE = 26 + RTM_NEWNEIGH = 28 + RTM_DELNEIGH = 27 + RTM_GETNEIGH = 28 + RTM_NEWRULE = 32 + RTM_DELRULE = 33 + RTM_GETRULE = 34 + RTM_NEWQDISC = 36 + RTM_DELQDISC = 37 + RTM_GETQDISC = 38 + RTM_NEWTCLASS = 40 + RTM_DELTCLASS = 41 + RTM_GETTCLASS = 42 + RTM_NEWTFILTER = 44 + RTM_DELTFILTER = 45 + RTM_GETTFILTER = 46 + RTM_NEWACTION = 48 + RTM_DELACTION = 49 + RTM_GETACTION = 50 + RTM_NEWPREFIX = 52 + RTM_GETMULTICAST = 58 + RTM_GETANYCAST = 62 + RTM_NEWNEIGHTBL = 64 + RTM_GETNEIGHTBL = 66 + RTM_SETNEIGHTBL = 67 + RTM_NEWNDUSEROPT = 68 + RTM_NEWADDRLABEL = 72 + RTM_DELADDRLABEL = 73 + RTM_GETADDRLABEL = 74 + RTM_GETDCB = 78 + RTM_SETDCB = 79 + RTM_NEWNETCONF = 80 + RTM_GETNETCONF = 82 + RTM_NEWMDB = 84 + RTM_DELMDB = 85 + RTM_GETMDB = 86 + RTM_NEWNSID = 88 + RTM_DELNSID = 89 + RTM_GETNSID = 90 + RTM_NEWSTATS = 92 + RTM_GETSTATS = 94 + + +class RtAttr(Structure): + _fields_ = [ + ("rta_len", c_ushort), + ("rta_type", c_ushort), + ] + + +class RtMsgHdr(Structure): + _fields_ = [ + ("rtm_family", c_ubyte), + ("rtm_dst_len", c_ubyte), + ("rtm_src_len", c_ubyte), + ("rtm_tos", c_ubyte), + ("rtm_table", c_ubyte), + ("rtm_protocol", c_ubyte), + ("rtm_scope", c_ubyte), + ("rtm_type", c_ubyte), + ("rtm_flags", c_uint), + ] + + +class RtMsgFlags(Enum): + RTM_F_NOTIFY = 0x100 + RTM_F_CLONED = 0x200 + RTM_F_EQUALIZE = 0x400 + RTM_F_PREFIX = 0x800 + RTM_F_LOOKUP_TABLE = 0x1000 + RTM_F_FIB_MATCH = 0x2000 + RTM_F_OFFLOAD = 0x4000 + RTM_F_TRAP = 0x8000 + RTM_F_OFFLOAD_FAILED = 0x20000000 + + +class AddressFamilyLinux(Enum): + AF_INET = socket.AF_INET + AF_INET6 = socket.AF_INET6 + AF_NETLINK = 16 + + +class AddressFamilyBsd(Enum): + AF_INET = socket.AF_INET + AF_INET6 = socket.AF_INET6 + AF_NETLINK = 38 + + +class NlmBaseFlags(Enum): + NLM_F_REQUEST = 0x01 + NLM_F_MULTI = 0x02 + NLM_F_ACK = 0x04 + NLM_F_ECHO = 0x08 + NLM_F_DUMP_INTR = 0x10 + NLM_F_DUMP_FILTERED = 0x20 + +# XXX: in python3.8 it is possible to +# class NlmGetFlags(Enum, NlmBaseFlags): + + +class NlmGetFlags(Enum): + NLM_F_ROOT = 0x100 + NLM_F_MATCH = 0x200 + NLM_F_ATOMIC = 0x400 + + +class NlmNewFlags(Enum): + NLM_F_REPLACE = 0x100 + NLM_F_EXCL = 0x200 + NLM_F_CREATE = 0x400 + NLM_F_APPEND = 0x800 + + +class NlmDeleteFlags(Enum): + NLM_F_NONREC = 0x100 + + +class NlmAckFlags(Enum): + NLM_F_CAPPED = 0x100 + NLM_F_ACK_TLVS = 0x200 + + +class RtScope(Enum): + RT_SCOPE_UNIVERSE = 0 + RT_SCOPE_SITE = 200 + RT_SCOPE_LINK = 253 + RT_SCOPE_HOST = 254 + RT_SCOPE_NOWHERE = 255 + + +class RtType(Enum): + RTN_UNSPEC = 0 + RTN_UNICAST = auto() + RTN_LOCAL = auto() + RTN_BROADCAST = auto() + RTN_ANYCAST = auto() + RTN_MULTICAST = auto() + RTN_BLACKHOLE = auto() + RTN_UNREACHABLE = auto() + RTN_PROHIBIT = auto() + RTN_THROW = auto() + RTN_NAT = auto() + RTN_XRESOLVE = auto() + + +class RtProto(Enum): + RTPROT_UNSPEC = 0 + RTPROT_REDIRECT = 1 + RTPROT_KERNEL = 2 + RTPROT_BOOT = 3 + RTPROT_STATIC = 4 + RTPROT_GATED = 8 + RTPROT_RA = 9 + RTPROT_MRT = 10 + RTPROT_ZEBRA = 11 + RTPROT_BIRD = 12 + RTPROT_DNROUTED = 13 + RTPROT_XORP = 14 + RTPROT_NTK = 15 + RTPROT_DHCP = 16 + RTPROT_MROUTED = 17 + RTPROT_KEEPALIVED = 18 + RTPROT_BABEL = 42 + RTPROT_OPENR = 99 + RTPROT_BGP = 186 + RTPROT_ISIS = 187 + RTPROT_OSPF = 188 + RTPROT_RIP = 189 + RTPROT_EIGRP = 192 + + +class NlRtaxType(Enum): + RTAX_UNSPEC = 0 + RTAX_LOCK = auto() + RTAX_MTU = auto() + RTAX_WINDOW = auto() + RTAX_RTT = auto() + RTAX_RTTVAR = auto() + RTAX_SSTHRESH = auto() + RTAX_CWND = auto() + RTAX_ADVMSS = auto() + RTAX_REORDERING = auto() + RTAX_HOPLIMIT = auto() + RTAX_INITCWND = auto() + RTAX_FEATURES = auto() + RTAX_RTO_MIN = auto() + RTAX_INITRWND = auto() + RTAX_QUICKACK = auto() + RTAX_CC_ALGO = auto() + RTAX_FASTOPEN_NO_COOKIE = auto() + + +class NlRtGroup(Enum): + RTNLGRP_NONE = 0 + RTNLGRP_LINK = auto() + RTNLGRP_NOTIFY = auto() + RTNLGRP_NEIGH = auto() + RTNLGRP_TC = auto() + RTNLGRP_IPV4_IFADDR = auto() + RTNLGRP_IPV4_MROUTE = auto() + RTNLGRP_IPV4_ROUTE = auto() + RTNLGRP_IPV4_RULE = auto() + RTNLGRP_IPV6_IFADDR = auto() + RTNLGRP_IPV6_MROUTE = auto() + RTNLGRP_IPV6_ROUTE = auto() + RTNLGRP_IPV6_IFINFO = auto() + RTNLGRP_DECnet_IFADDR = auto() + RTNLGRP_NOP2 = auto() + RTNLGRP_DECnet_ROUTE = auto() + RTNLGRP_DECnet_RULE = auto() + RTNLGRP_NOP4 = auto() + RTNLGRP_IPV6_PREFIX = auto() + RTNLGRP_IPV6_RULE = auto() + RTNLGRP_ND_USEROPT = auto() + RTNLGRP_PHONET_IFADDR = auto() + RTNLGRP_PHONET_ROUTE = auto() + RTNLGRP_DCB = auto() + RTNLGRP_IPV4_NETCONF = auto() + RTNLGRP_IPV6_NETCONF = auto() + RTNLGRP_MDB = auto() + RTNLGRP_MPLS_ROUTE = auto() + RTNLGRP_NSID = auto() + RTNLGRP_MPLS_NETCONF = auto() + RTNLGRP_IPV4_MROUTE_R = auto() + RTNLGRP_IPV6_MROUTE_R = auto() + RTNLGRP_NEXTHOP = auto() + RTNLGRP_BRVLAN = auto() + + +class IfinfoMsg(Structure): + _fields_ = [ + ("ifi_family", c_ubyte), + ("__ifi_pad", c_ubyte), + ("ifi_type", c_ushort), + ("ifi_index", c_int), + ("ifi_flags", c_uint), + ("ifi_change", c_uint), + ] + + +class IflattrType(Enum): + IFLA_UNSPEC = 0 + IFLA_ADDRESS = auto() + IFLA_BROADCAST = auto() + IFLA_IFNAME = auto() + IFLA_MTU = auto() + IFLA_LINK = auto() + IFLA_QDISC = auto() + IFLA_STATS = auto() + IFLA_COST = auto() + IFLA_PRIORITY = auto() + IFLA_MASTER = auto() + IFLA_WIRELESS = auto() + IFLA_PROTINFO = auto() + IFLA_TXQLEN = auto() + IFLA_MAP = auto() + IFLA_WEIGHT = auto() + IFLA_OPERSTATE = auto() + IFLA_LINKMODE = auto() + IFLA_LINKINFO = auto() + IFLA_NET_NS_PID = auto() + IFLA_IFALIAS = auto() + IFLA_NUM_VF = auto() + IFLA_VFINFO_LIST = auto() + IFLA_STATS64 = auto() + IFLA_VF_PORTS = auto() + IFLA_PORT_SELF = auto() + IFLA_AF_SPEC = auto() + IFLA_GROUP = auto() + IFLA_NET_NS_FD = auto() + IFLA_EXT_MASK = auto() + IFLA_PROMISCUITY = auto() + IFLA_NUM_TX_QUEUES = auto() + IFLA_NUM_RX_QUEUES = auto() + IFLA_CARRIER = auto() + IFLA_PHYS_PORT_ID = auto() + IFLA_CARRIER_CHANGES = auto() + IFLA_PHYS_SWITCH_ID = auto() + IFLA_LINK_NETNSID = auto() + IFLA_PHYS_PORT_NAME = auto() + IFLA_PROTO_DOWN = auto() + IFLA_GSO_MAX_SEGS = auto() + IFLA_GSO_MAX_SIZE = auto() + IFLA_PAD = auto() + IFLA_XDP = auto() + IFLA_EVENT = auto() + IFLA_NEW_NETNSID = auto() + IFLA_IF_NETNSID = auto() + IFLA_CARRIER_UP_COUNT = auto() + IFLA_CARRIER_DOWN_COUNT = auto() + IFLA_NEW_IFINDEX = auto() + IFLA_MIN_MTU = auto() + IFLA_MAX_MTU = auto() + IFLA_PROP_LIST = auto() + IFLA_ALT_IFNAME = auto() + IFLA_PERM_ADDRESS = auto() + IFLA_PROTO_DOWN_REASON = auto() + + +class IfaddrMsg(Structure): + _fields_ = [ + ("ifa_family", c_ubyte), + ("ifa_prefixlen", c_ubyte), + ("ifa_flags", c_ubyte), + ("ifa_scope", c_ubyte), + ("ifa_index", c_uint), + ] + + +class IfattrType(Enum): + IFA_UNSPEC = 0 + IFA_ADDRESS = auto() + IFA_LOCAL = auto() + IFA_LABEL = auto() + IFA_BROADCAST = auto() + IFA_ANYCAST = auto() + IFA_CACHEINFO = auto() + IFA_MULTICAST = auto() + IFA_FLAGS = auto() + IFA_RT_PRIORITY = auto() + IFA_TARGET_NETNSID = auto() + + +class NlConst(): + AF_NETLINK = 38 + NETLINK_ROUTE = 0 + + +class NlHelper(): + def __init__(self): + self._pmap = {} + self._af_cls = self.get_af_cls() + + def get_af_cls(self): + if sys.platform.startswith("freebsd"): + cls = AddressFamilyBsd + else: + cls = AddressFamilyLinux + return cls + + def get_propmap(self, cls): + if cls not in self._pmap: + ret = {} + for prop in dir(cls): + if not prop.startswith("_"): + ret[getattr(cls, prop).value] = prop + self._pmap[cls] = ret + return self._pmap[cls] + + def get_name_propmap(self, cls): + ret = {} + for prop in dir(cls): + if not prop.startswith("_"): + ret[prop] = getattr(cls, prop).value + return ret + + def get_attr_byval(self, cls, attr_val): + propmap = self.get_propmap(cls) + return propmap.get(attr_val) + + def get_nlmsg_name(self, val): + for cls in [NlRtMsgType, NlMsgType]: + v = self.get_attr_byval(cls, val) + if v is not None: + return v + return "msg#{}".format(val) + + def get_af_name(self, family): + v = self.get_attr_byval(self._af_cls, family) + if v is not None: + return v + return "af#{}".format(family) + + def get_af_value(self, family_str: str) -> int: + propmap = self.get_name_propmap(self._af_cls) + return propmap.get(family_str) + + def get_rta_name(self, val): + return self.get_attr_byval(RtattrType, val) + + def get_bitmask_map(self, cls, val): + propmap = self.get_propmap(cls) + v = 1 + ret = {} + while val: + if v & val: + if v in propmap: + ret[v] = propmap[v] + else: + ret[v] = hex(v) + val -= v + v *= 2 + return ret + + def get_bitmask_str(self, cls, val): + bmap = self.get_bitmask_map(cls, val) + return ",".join([v for k, v in bmap.items()]) + + def get_nlm_flags_str(self, msg_str: str, reply: bool, val): + if reply: + return self.get_bitmask_str(NlmAckFlags, val) + if msg_str.startswith("RTM_GET"): + return self.get_bitmask_str(NlmGetFlags, val) + elif msg_str.startswith("RTM_DEL"): + return self.get_bitmask_str(NlmDeleteFlags, val) + elif msg_str.startswith("RTM_NEW"): + return self.get_bitmask_str(NlmNewFlags, val) + else: + return self.get_bitmask_str(NlmBaseFlags, val) + + +class BaseRtAttr(object): + def __init__(self, parent, rta_type, rta_len, data=None): + self.parent = parent + self.helper = parent.helper + self.attr_enum = parent.attr_enum + self.rta_type = rta_type & 0x3f + self.is_nested = rta_type & (1 << 15) + self.network_byte_order = rta_type & (1 << 14) + self.rta_len = rta_len + self.rta_type_str = self.helper.get_attr_byval(self.attr_enum, self.rta_type) # noqa: E501 + if data is not None: + self._validate(data) + self._parse(data) + self._orig_data = data + + def print_attribute(self, prepend=""): + if self.rta_type_str: + type_str = self.rta_type_str + else: + type_str = "rta#{}".format(self.rta_type) + print("{}rta_len={} rta_type={}({}){}".format(prepend, + self.rta_len, + type_str, + self.rta_type, + self._print_attr_value()) + ) + + def _print_attr_value(self): + return " [" + " ".join(["{:02X}".format(b) for b in self._orig_data[4:]]) + "]" # noqa: E501 + + @classmethod + def from_bytes(cls, parent, data): + if len(data) < sizeof(RtAttr): + raise ValueError("length less than rtattr header") + rta_hdr = RtAttr.from_buffer_copy(data) + self = cls(parent, rta_hdr.rta_type, rta_hdr.rta_len, data[:rta_hdr.rta_len]) # noqa: E501 + # XXX: nested + return self + + def __bytes__(self): + ret = self._orig_data + if align4(len(ret)) != len(ret): + ret += bytes(align4(len(ret)) - len(ret)) + return ret + + def _validate(self, data): + pass + + def _parse(self, data): + pass + + +class RtAttrIp(BaseRtAttr): + def _validate(self, data): + data_len = len(data) - 4 + if data_len != 4 and data_len != 16: + raise ValueError("Error validating attr {}: rta_len is not valid".format( # noqa: E501 + self.rta_type_str)) + + def _parse(self, data): + data_len = len(data) - 4 + if data_len == 4: + self.family = socket.AF_INET + self.addr = socket.inet_ntop(self.family, data[4:8]) + else: + self.family = socket.AF_INET6 + self.addr = socket.inet_ntop(self.family, data[4:20]) + + def _print_attr_value(self): + return " addr={}".format(self.addr) + + +class RtAttrU32(BaseRtAttr): + def _validate(self, data): + if len(data) != 8: + raise ValueError("Error validating attr {}: rta_len is not valid".format( # noqa: E501 + self.rta_type_str)) + + def _parse(self, data): + self.value = struct.unpack("@I", data[4:8])[0] + + def _print_attr_value(self): + return " value={}".format(self.value) + + +class RtAttrIfindex(RtAttrU32): + def _print_attr_value(self): + try: + ifname = socket.if_indextoname(self.value) + return " iface={}(#{})".format(ifname, self.value) + except OSError as e: + pass + return " iface=if#{}".format(self.value) + + +class RtAttrTable(RtAttrU32): + def _print_attr_value(self): + return " rtable={}".format(self.value) + + +class RtAttrNhId(RtAttrU32): + def _print_attr_value(self): + return " nh_id={}".format(self.value) + + +class RtAttrVia(BaseRtAttr): + def _validate(self, data): + data_len = len(data) - 4 + if data_len == 0: + raise ValueError("Error validating attr {}: empty data".format(self.rta_type_str)) # noqa: E501 + family = int(data_len[0]) + if family not in (socket.AF_INET, socket.AF_INET6): + raise ValueError("Error validating attr {}: unsupported AF {}".format( # noqa: E501 + self.rta_type_str, family)) + if family == socket.AF_INET: + expected_len = 1 + 4 + else: + expected_len = 1 + 16 + if data_len != expected_len: + raise ValueError("Error validating attr {}: expected len {} got {}".format( # noqa: E501 + self.rta_type_str, expected_len, data_len)) + + def _parse(self, data): + data_len = len(data) - 4 + self.family = int(data_len[0]) + if self.family == socket.AF_INET: + self.addr = socket.inet_ntop(self.family, data[5:9]) + else: + self.addr = socket.inet_ntop(self.family, data[5:21]) + + def _print_attr_value(self): + return ", via={}".format(self.addr) + + +class RtAttrStr(BaseRtAttr): + def _validate(self, data): + try: + s = data[4:].decode("utf-8") + except Exception as e: + raise ValueError("wrong utf-8 string") + + def _parse(self, data): + self.str = data[4:].decode("utf-8") + + def _print_attr_value(self): + return " str=\"{}\"".format(self.str) + + +rta_class_map = { + "RTA_DST": RtAttrIp, + "RTA_SRC": RtAttrIp, + "RTA_IIF": RtAttrIfindex, + "RTA_OIF": RtAttrIfindex, + "RTA_GATEWAY": RtAttrIp, + "RTA_TABLE": RtAttrTable, + "RTA_VIA": RtAttrVia, + "RTA_NH_ID": RtAttrNhId, +} + + +ifla_class_map = { + "IFLA_MTU": RtAttrU32, +} + +ifa_class_map = { + "IFA_ADDRESS": RtAttrIp, + "IFA_LOCAL": RtAttrIp, + "IFA_LABEL": RtAttrStr, + "IFA_BROADCAST": RtAttrIp, + "IFA_ANYCAST": RtAttrIp, + "IFA_FLAGS": RtAttrU32, +} + + +class BaseNetlinkMessage(object): + def __init__(self, helper, nlmsg_type): + self.nlmsg_type = nlmsg_type + self.ut = unittest.TestCase() + self.rta_list = [] + self._orig_data = None + self.helper = helper + self.nl_hdr = Nlmsghdr(nlmsg_type=nlmsg_type) + + def assertEqual(self, a, b, msg=None): + self.ut.assertEqual(a, b, msg) + + def assertNotEqual(self, a, b, msg=None): + self.ut.assertNotEqual(a, b, msg) + + @staticmethod + def parse_nl_header(data: bytes): + if len(data) < sizeof(Nlmsghdr): + raise ValueError("length less than netlink message header") + return Nlmsghdr.from_buffer_copy(data), sizeof(Nlmsghdr) + + def is_reply(self, hdr): + return hdr.nlmsg_type == NlMsgType.NLMSG_ERROR.value + + def print_nl_header(self, hdr, prepend=""): + # len=44, type=RTM_DELROUTE, flags=NLM_F_REQUEST|NLM_F_ACK, seq=1641163704, pid=0 # noqa: E501 + is_reply = self.is_reply(hdr) + msg_name = self.helper.get_nlmsg_name(hdr.nlmsg_type) + print("{}len={}, type={}, flags={}(0x{:X}), seq={}, pid={}".format( + prepend, + hdr.nlmsg_len, + msg_name, + self.helper.get_nlm_flags_str(msg_name, is_reply, hdr.nlmsg_flags), # noqa: E501 + hdr.nlmsg_flags, + hdr.nlmsg_seq, + hdr.nlmsg_pid + )) + + @classmethod + def from_bytes(cls, helper, data): + try: + hdr, hdrlen = BaseNetlinkMessage.parse_nl_header(data) + self = cls(helper, hdr.nlmsg_type) + self._orig_data = data + self.nl_hdr = hdr + except ValueError as e: + print("Failed to parse nl header: {}".format(e)) + cls.print_as_bytes(data) + raise + return self + + def print_message(self): + self.print_nl_header(self.nl_hdr) + + @staticmethod + def print_as_bytes(data: bytes, descr: str): + print("===vv {} (len:{:3d}) vv===".format(descr, len(data))) + off = 0 + step = 16 + while off < len(data): + for i in range(step): + if off + i < len(data): + print(" {:02X}".format(data[off + i]), end="") + print("") + off += step + print("--------------------") + + +class NetlinkErrorMessage(BaseNetlinkMessage): + messages = [NlMsgType.NLMSG_ERROR.value] + + def __init__(self, helper, nlmsg_type, error): + super().__init__(helper, nlmsg_type) + self.err_hdr = Nlmsgerr() + + def print_error_header(self, errhdr, prepend=""): + print("{}error={}, ".format(prepend), end="") + self.print_nl_header(errhdr.msg, prepend) + + def print_message(self, prepend=""): + self.print_nl_header(self.nl_nhr, prepend) + self.print_error_header(self.err_hdr, prepend + " ") + + +class BaseNetlinkRtMessage(BaseNetlinkMessage): + attr_class_map = {} + attr_enum = None + + def __init__(self, helper, nlm_type): + super().__init__(helper, nlm_type) + self.base_hdr = None + + def parse_rta_list(self, data: bytes) -> List[BaseRtAttr]: + ret = [] + offset = 0 + while offset < len(data): + # print("OFFSET={}".format(offset)) + if offset + 4 > len(data): + raise ValueError("only {} bytes remaining".format(len(data) - offset)) # noqa: E501 + rta_hdr = RtAttr.from_buffer_copy(data[offset:]) + rta_type_str = self.helper.get_attr_byval(self.attr_enum, rta_hdr.rta_type) # noqa: E501 + cls = self.attr_class_map.get(rta_type_str, BaseRtAttr) + rta = cls.from_bytes(self, data[offset:]) + offset += align4(rta.rta_len) + if rta.rta_len == 0: + raise ValueError("empty rta len, {} bytes remaining".format(len(data) - offset)) # noqa: E501 + ret.append(rta) + return ret, offset + + @classmethod + def from_bytes(cls, helper, data): + try: + hdr, hdrlen = BaseNetlinkMessage.parse_nl_header(data) + self = cls(helper, hdr.nlmsg_type) + self._orig_data = data + self.nl_hdr = hdr + except ValueError as e: + print("Failed to parse nl header: {}".format(e)) + cls.print_as_bytes(data) + raise + + offset = align4(hdrlen) + try: + base_hdr, hdrlen = self.parse_base_header(data[offset:]) + self.base_hdr = base_hdr + offset += align4(hdrlen) + except ValueError as e: + print("Failed to parse nl rt header: {}".format(e)) + cls.print_as_bytes(data) + raise + + orig_offset = offset + try: + rta_list, rta_len = self.parse_rta_list(data[offset:]) + offset += rta_len + if offset != len(data): + raise ValueError("{} bytes left at the end of the packet".format(len(data) - offset)) # noqa: E501 + self.rta_list = rta_list + except ValueError as e: + print("Failed to parse nl rta attributes at offset {}: {}".format(orig_offset, e)) # noqa: E501 + cls.print_as_bytes(data, "msg dump") + cls.print_as_bytes(data[orig_offset:], "failed block") + raise + return self + + def __bytes__(self): + ret = bytes() + for rta in self.rta_list: + ret += bytes(rta) + ret = bytes(self.base_hdr) + ret + self.nl_hdr.nlmsg_len = len(ret) + sizeof(Nlmsghdr) + return bytes(self.nl_hdr) + ret + + def print_message(self): + self.print_nl_header(self.nl_hdr) + self.print_base_header(self.base_hdr, " ") + for rta in self.rta_list: + rta.print_attribute(" ") + + +class NetlinkRtMessage(BaseNetlinkRtMessage): + messages = [ + NlRtMsgType.RTM_NEWROUTE.value, + NlRtMsgType.RTM_DELROUTE.value, + NlRtMsgType.RTM_GETROUTE.value, + ] + attr_class_map = rta_class_map + attr_enum = RtattrType + + def __init__(self, helper, nlm_type): + super().__init__(helper, nlm_type) + self.base_hdr = RtMsgHdr() + + def parse_base_header(self, data): + if len(data) < sizeof(RtMsgHdr): + raise ValueError("length less than rtmsg header") + rtm_hdr = RtMsgHdr.from_buffer_copy(data) + return (rtm_hdr, sizeof(RtMsgHdr)) + + def print_base_header(self, hdr, prepend=""): + family = self.helper.get_af_name(hdr.rtm_family) + print("{}family={}, dst_len={}, src_len={}, tos={}, table={}, protocol={}({}), scope={}({}), type={}({}), flags={}({})".format( # noqa: E501 + prepend, + family, + hdr.rtm_dst_len, + hdr.rtm_src_len, + hdr.rtm_tos, + hdr.rtm_table, + self.helper.get_attr_byval(RtProto, hdr.rtm_protocol), + hdr.rtm_protocol, + self.helper.get_attr_byval(RtScope, hdr.rtm_scope), + hdr.rtm_scope, + self.helper.get_attr_byval(RtType, hdr.rtm_type), + hdr.rtm_type, + self.helper.get_bitmask_str(RtMsgFlags, hdr.rtm_flags), + hdr.rtm_flags)) + + +class NetlinkIflaMessage(BaseNetlinkRtMessage): + messages = [ + NlRtMsgType.RTM_NEWLINK.value, + NlRtMsgType.RTM_DELLINK.value, + NlRtMsgType.RTM_GETLINK.value, + ] + attr_class_map = ifla_class_map + attr_enum = IflattrType + + def __init__(self, helper, nlm_type): + super().__init__(helper, nlm_type) + self.base_hdr = IfinfoMsg() + + def parse_base_header(self, data): + if len(data) < sizeof(IfinfoMsg): + raise ValueError("length less than IfinfoMsg header") + rtm_hdr = IfinfoMsg.from_buffer_copy(data) + return (rtm_hdr, sizeof(IfinfoMsg)) + + def print_base_header(self, hdr, prepend=""): + family = self.helper.get_af_name(hdr.ifi_family) + print("{}family={}, ifi_type={}, ifi_index={}, ifi_flags={}, ifi_change={}".format( # noqa: E501 + prepend, + family, + hdr.ifi_type, + hdr.ifi_index, + hdr.ifi_flags, + hdr.ifi_change)) + + +class NetlinkIfaMessage(BaseNetlinkRtMessage): + messages = [ + NlRtMsgType.RTM_NEWADDR.value, + NlRtMsgType.RTM_DELADDR.value, + NlRtMsgType.RTM_GETADDR.value, + ] + attr_class_map = ifa_class_map + attr_enum = IfattrType + + def __init__(self, helper, nlm_type): + super().__init__(helper, nlm_type) + self.base_hdr = IfaddrMsg() + + def parse_base_header(self, data): + if len(data) < sizeof(IfaddrMsg): + raise ValueError("length less than IfaddrMsg header") + rtm_hdr = IfaddrMsg.from_buffer_copy(data) + return (rtm_hdr, sizeof(IfaddrMsg)) + + def print_base_header(self, hdr, prepend=""): + family = self.helper.get_af_name(hdr.ifa_family) + print("{}family={}, ifa_prefixlen={}, ifa_flags={}, ifa_scope={}, ifa_index={}".format( # noqa: E501 + prepend, + family, + hdr.ifa_prefixlen, + hdr.ifa_flags, + hdr.ifa_scope, + hdr.ifa_index)) + + +class Nlsock(): + def __init__(self, helper): + self.helper = helper + self.sock_fd = self._setup_netlink() + self._data = bytes() + self.rtm_seq = 1 + self.pid = os.getpid() + self.msgmap = self.build_msgmap() + self.set_groups(NlRtGroup.RTNLGRP_IPV4_ROUTE.value | NlRtGroup.RTNLGRP_IPV6_ROUTE.value) # noqa: E501 + + def build_msgmap(self): + classes = [NetlinkRtMessage, NetlinkIfaMessage, NetlinkErrorMessage] + xmap = {} + for cls in classes: + for message in cls.messages: + xmap[message] = cls + return xmap + + def get_seq(self): + ret = self.rtm_seq + self.rtm_seq += 1 + return ret + + def _setup_netlink(self) -> int: + family = self.helper.get_af_value("AF_NETLINK") + s = socket.socket(family, socket.SOCK_RAW, NlConst.NETLINK_ROUTE) + return s + + def set_groups(self, mask: int): + self.sock_fd.setsockopt(socket.SOL_SOCKET, 1, mask) + # snl = SockaddrNl(nl_len = sizeof(SockaddrNl), nl_family=38, + # nl_pid=self.pid, nl_groups=mask) + # xbuffer = create_string_buffer(sizeof(SockaddrNl)) + # memmove(xbuffer, addressof(snl), sizeof(SockaddrNl)) + # k = struct.pack("@BBHII", 12, 38, 0, self.pid, mask) + # self.sock_fd.bind(k) + + def write_message(self, msg): + print("vvvvvvvv OUT vvvvvvvv") + msg.print_message() + msg_bytes = bytes(msg) + try: + ret = os.write(self.sock_fd.fileno(), bytes(msg)) + except Exception as e: + print("write({}) -> {}".format(len(msg_bytes), e)) + + def parse_message(self, data: bytes): + if len(data) < sizeof(Nlmsghdr): + raise Exception("Short read from nl: {} bytes".format(len(data))) + hdr = Nlmsghdr.from_buffer_copy(data) + nlmsg_type = hdr.nlmsg_type + cls = self.msgmap.get(nlmsg_type) + if not cls: + cls = BaseNetlinkMessage + return cls.from_bytes(self.helper, data) + + def write_data(self, data: bytes): + self.sock_fd.send(data) + + def read_data(self): + while True: + data = self.sock_fd.recv(65535) + self._data += data + if len(self._data) >= sizeof(Nlmsghdr): + break + if seq is None: + break + hdr = Nlmsghdr.from_buffer_copy(data) + if hdr.nlmsg_pid == self.pid and hdr.nlmsg_seq == seq: + break + return data + + def read_message(self) -> bytes: + if len(self._data) < sizeof(Nlmsghdr): + self.read_data() + hdr = Nlmsghdr.from_buffer_copy(self._data) + while (hdr.nlmsg_len > len(self._data)): + self.read_data() + raw_msg = self._data[:hdr.nlmsg_len] + self._data = self._data[hdr.nlmsg_len:] + return self.parse_message(raw_msg) + + def fill_msg_seq(self, msg): + msg.nl_hdr.nlmsg_seq = self.get_seq() + msg.nl_hdr.nlmsg_pid = self.pid + + def request_ifaces(self): + msg = NetlinkIfaMessage(self.helper, NlRtMsgType.RTM_GETLINK.value) + flags = NlmGetFlags.NLM_F_ROOT.value | NlmGetFlags.NLM_F_MATCH.value + self.fill_msg_seq(msg) + msg.nl_hdr.nlmsg_flags = flags | NlmBaseFlags.NLM_F_REQUEST.value + + msg_bytes = bytes(msg) + x = self.parse_message(msg_bytes) + x.print_message() + print(msg_bytes) + # Skip family for now + self.write_data(msg_bytes) + + def request_ifaddrs(self, family): + msg = NetlinkIfaMessage(self.helper, NlRtMsgType.RTM_GETADDR.value) + flags = NlmGetFlags.NLM_F_ROOT.value | NlmGetFlags.NLM_F_MATCH.value + self.fill_msg_seq(msg) + msg.base_hdr.ifa_family = family + msg.nl_hdr.nlmsg_flags = flags | NlmBaseFlags.NLM_F_REQUEST.value + + msg_bytes = bytes(msg) + x = self.parse_message(msg_bytes) + x.print_message() + print(msg_bytes) + # Skip family for now + self.write_data(msg_bytes) + + def request_routes(self, family): + msg = NetlinkRtMessage(self.helper, NlRtMsgType.RTM_GETROUTE.value) + flags = NlmGetFlags.NLM_F_ROOT.value | NlmGetFlags.NLM_F_MATCH.value + self.fill_msg_seq(msg) + msg.base_hdr.rtm_family = family + msg.nl_hdr.nlmsg_flags = flags | NlmBaseFlags.NLM_F_REQUEST.value + + msg_bytes = bytes(msg) + x = self.parse_message(msg_bytes) + x.print_message() + print(msg_bytes) + # Skip family for now + self.write_data(msg_bytes) + + +def main(): + helper = NlHelper() + nl = Nlsock(helper) + # nl.request_ifaddrs(socket.AF_INET) + #nl.request_routes(0) + nl.request_ifaces() + while True: + msg = nl.read_message() + print("") + msg.print_message() + + pass + + +if __name__ == "__main__": + main()