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

Changeset View

Standalone View

View Options

sys/netlink/route/neigh.c

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

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

Lint: Possible Spelling Mistake: Possible spelling error. You wrote 'nam', but did you mean 'name'?
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include "opt_inet.h"
#include "opt_inet6.h"
#include <sys/types.h>
#include <sys/malloc.h>
#include <sys/socket.h>
#include <sys/syslog.h>
#include <sys/socketvar.h>
#include <net/if.h>
#include <net/if_llatbl.h>
#include <netlink/netlink.h>
#include <netlink/netlink_ctl.h>
#include <netlink/netlink_route.h>
#include <netlink/route/route_var.h>
#include <netinet6/in6_var.h> /* nd6.h requires this */
#include <netinet6/nd6.h> /* nd6 state machine */
#include <netinet6/scope6_var.h> /* scope deembedding */
#define DEBUG_MOD_NAME nl_neigh
#define DEBUG_MAX_LEVEL LOG_DEBUG3
#include <netlink/netlink_debug.h>
_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));
}