/*
* Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
* All rights reserved.
*
* 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 project 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 PROJECT 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 PROJECT 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.
*/
/* A loopback interface always has ND6_IFF_AUTO_LINKLOCAL.
* A bridge interface should not have ND6_IFF_AUTO_LINKLOCAL
* because one of its members should. */
if ((ip6_auto_linklocal && ifp->if_type != IFT_BRIDGE) ||
(ifp->if_flags & IFF_LOOPBACK))
nd->flags |= ND6_IFF_AUTO_LINKLOCAL;
if (ndopts->nd_opts_search == NULL)
return NULL;
if (ndopts->nd_opts_done)
return NULL;
nd_opt = ndopts->nd_opts_search;
/* make sure nd_opt_len is inside the buffer */
if ((void *)&nd_opt->nd_opt_len >= (void *)ndopts->nd_opts_last) {
memset(ndopts, 0, sizeof(*ndopts));
return NULL;
}
olen = nd_opt->nd_opt_len << 3;
if (olen == 0) {
/*
* Message validation requires that all included
* options have a length that is greater than zero.
*/
memset(ndopts, 0, sizeof(*ndopts));
return NULL;
}
ndopts->nd_opts_search = (struct nd_opt_hdr *)((char *)nd_opt + olen);
if (ndopts->nd_opts_search > ndopts->nd_opts_last) {
/* option overruns the end of buffer, invalid */
memset(ndopts, 0, sizeof(*ndopts));
return NULL;
} else if (ndopts->nd_opts_search == ndopts->nd_opts_last) {
/* reached the end of options chain */
ndopts->nd_opts_done = 1;
ndopts->nd_opts_search = NULL;
}
return nd_opt;
}
/*
* Parse multiple ND options.
* This function is much easier to use, for ND routines that do not need
* multiple options of the same type.
*/
int
nd6_options(union nd_opts *ndopts)
{
struct nd_opt_hdr *nd_opt;
int i = 0;
while (1) {
nd_opt = nd6_option(ndopts);
if (nd_opt == NULL && ndopts->nd_opts_last == NULL) {
/*
* Message validation requires that all included
* options have a length that is greater than zero.
*/
ICMP6_STATINC(ICMP6_STAT_ND_BADOPT);
memset(ndopts, 0, sizeof(*ndopts));
return -1;
}
if (nd_opt == NULL)
goto skip1;
switch (nd_opt->nd_opt_type) {
case ND_OPT_SOURCE_LINKADDR:
case ND_OPT_TARGET_LINKADDR:
case ND_OPT_MTU:
case ND_OPT_REDIRECTED_HEADER:
case ND_OPT_NONCE:
if (ndopts->nd_opt_array[nd_opt->nd_opt_type]) {
nd6log(LOG_INFO,
"duplicated ND6 option found (type=%d)\n",
nd_opt->nd_opt_type);
/* XXX bark? */
} else {
ndopts->nd_opt_array[nd_opt->nd_opt_type]
= nd_opt;
}
break;
case ND_OPT_PREFIX_INFORMATION:
if (ndopts->nd_opt_array[nd_opt->nd_opt_type] == 0) {
ndopts->nd_opt_array[nd_opt->nd_opt_type]
= nd_opt;
}
ndopts->nd_opts_pi_end =
(struct nd_opt_prefix_info *)nd_opt;
break;
default:
/*
* Unknown options must be silently ignored,
* to accommodate future extension to the protocol.
*/
nd6log(LOG_DEBUG,
"nd6_options: unsupported option %d - "
"option ignored\n", nd_opt->nd_opt_type);
}
skip1:
i++;
if (i > nd6_maxndopt) {
ICMP6_STATINC(ICMP6_STAT_ND_TOOMANYOPT);
nd6log(LOG_INFO, "too many loop in nd opt\n");
break;
}
if (ndopts->nd_opts_done)
break;
}
return 0;
}
/*
* Gets source address of the first packet in hold queue
* and stores it in @src.
* Returns pointer to @src (if hold queue is not empty) or NULL.
*/
static struct in6_addr *
nd6_llinfo_get_holdsrc(struct llentry *ln, struct in6_addr *src)
{
struct ip6_hdr *hip6;
if (ln == NULL || ln->ln_hold == NULL)
return NULL;
/*
* assuming every packet in ln_hold has the same IP header
*/
hip6 = mtod(ln->ln_hold, struct ip6_hdr *);
/* XXX pullup? */
if (sizeof(*hip6) < ln->ln_hold->m_len)
*src = hip6->ip6_src;
else
src = NULL;
return src;
}
static union l3addr *
nd6_llinfo_holdsrc(struct llentry *ln, union l3addr *src)
{
if (nd6_llinfo_get_holdsrc(ln, &src->addr6) == NULL)
return NULL;
return src;
}
static void
nd6_llinfo_output(struct ifnet *ifp, const union l3addr *daddr,
const union l3addr *taddr, __unused const uint8_t *tlladdr,
const union l3addr *hsrc)
{
ifp = ia6->ia_ifa.ifa_ifp;
IFNET_LOCK(ifp);
/*
* Need to take the lock first to prevent if_detach
* from running in6_purgeaddr concurrently.
*/
if (!if_is_deactivated(ifp)) {
ia6_release(ia6, &psref);
in6_purgeaddr(&ia6->ia_ifa);
} else {
/*
* ifp is being destroyed, ia6 will be destroyed
* by if_detach.
*/
ia6_release(ia6, &psref);
}
ia6 = NULL;
IFNET_UNLOCK(ifp);
} else if (IFA6_IS_DEPRECATED(ia6)) {
int oldflags = ia6->ia6_flags;
if ((oldflags & IN6_IFF_DEPRECATED) == 0) {
ia6->ia6_flags |= IN6_IFF_DEPRECATED;
rt_addrmsg(RTM_NEWADDR, (struct ifaddr *)ia6);
}
} else {
/*
* A new RA might have made a deprecated address
* preferred.
*/
if (ia6->ia6_flags & IN6_IFF_DEPRECATED) {
ia6->ia6_flags &= ~IN6_IFF_DEPRECATED;
rt_addrmsg(RTM_NEWADDR, (struct ifaddr *)ia6);
}
}
s = pserialize_read_enter();
ia6_release(ia6, &psref);
}
pserialize_read_exit(s);
curlwp_bindx(bound);
/*
* During detach, the ND info might be already removed, but
* then is explitly passed as argument.
* Otherwise get it from ifp->if_afdata.
*/
if (ext == NULL)
ext = ifp->if_afdata[AF_INET6];
if (ext == NULL)
return;
/*
* We may not need to nuke the neighbor cache entries here
* because the neighbor cache is kept in if_afdata[AF_INET6].
* nd6_purge() is invoked by in6_ifdetach() which is called
* from if_detach() where everything gets purged. However
* in6_ifdetach is directly called from vlan(4), so we still
* need to purge entries here.
*/
if (ext->lltable != NULL)
lltable_purge_entries(ext->lltable);
}
if (rt != NULL)
rt_unref(rt);
if (ln != NULL)
ln->ln_state = ND_LLINFO_NOSTATE;
return ln;
}
/*
* Test whether a given IPv6 address is a neighbor or not, ignoring
* the actual neighbor cache. The neighbor cache is ignored in order
* to not reenter the routing code from within itself.
*/
static int
nd6_is_new_addr_neighbor(const struct sockaddr_in6 *addr, struct ifnet *ifp)
{
struct ifaddr *dstaddr;
int s;
/*
* A link-local address is always a neighbor.
* XXX: a link does not necessarily specify a single interface.
*/
if (IN6_IS_ADDR_LINKLOCAL(&addr->sin6_addr)) {
struct sockaddr_in6 sin6_copy;
u_int32_t zone;
/*
* We need sin6_copy since sa6_recoverscope() may modify the
* content (XXX).
*/
sin6_copy = *addr;
if (sa6_recoverscope(&sin6_copy))
return 0; /* XXX: should be impossible */
if (in6_setscope(&sin6_copy.sin6_addr, ifp, &zone))
return 0;
if (sin6_copy.sin6_scope_id == zone)
return 1;
else
return 0;
}
/*
* If the address is assigned on the node of the other side of
* a p2p interface, the address should be a neighbor.
*/
s = pserialize_read_enter();
dstaddr = ifa_ifwithdstaddr(sin6tocsa(addr));
if (dstaddr != NULL) {
if (dstaddr->ifa_ifp == ifp) {
pserialize_read_exit(s);
return 1;
}
}
pserialize_read_exit(s);
return 0;
}
/*
* Detect if a given IPv6 address identifies a neighbor on a given link.
* XXX: should take care of the destination of a p2p link?
*/
int
nd6_is_addr_neighbor(const struct sockaddr_in6 *addr, struct ifnet *ifp)
{
struct llentry *ln;
struct rtentry *rt;
/*
* A link-local address is always a neighbor.
* XXX: a link does not necessarily specify a single interface.
*/
if (IN6_IS_ADDR_LINKLOCAL(&addr->sin6_addr)) {
struct sockaddr_in6 sin6_copy;
u_int32_t zone;
/*
* We need sin6_copy since sa6_recoverscope() may modify the
* content (XXX).
*/
sin6_copy = *addr;
if (sa6_recoverscope(&sin6_copy))
return 0; /* XXX: should be impossible */
if (in6_setscope(&sin6_copy.sin6_addr, ifp, &zone))
return 0;
if (sin6_copy.sin6_scope_id == zone)
return 1;
else
return 0;
}
if (nd6_is_new_addr_neighbor(addr, ifp))
return 1;
/*
* Even if the address matches none of our addresses, it might be
* in the neighbor cache or a connected route.
*/
ln = nd6_lookup(&addr->sin6_addr, ifp, false);
if (ln != NULL) {
LLE_RUNLOCK(ln);
return 1;
}
rt = rtalloc1(sin6tocsa(addr), 0);
if (rt == NULL)
return 0;
/*
* Free an nd6 llinfo entry.
* Since the function would cause significant changes in the kernel, DO NOT
* make it global, unless you have a strong reason for the change, and are sure
* that the change is safe.
*/
static void
nd6_free(struct llentry *ln, int gc)
{
struct ifnet *ifp;
KASSERT(ln != NULL);
LLE_WLOCK_ASSERT(ln);
/*
* If the reason for the deletion is just garbage collection,
* and the neighbor is an active router, do not delete it.
* Instead, reset the GC timer using the router's lifetime.
* XXX: the check for ln_state should be redundant,
* but we intentionally keep it just in case.
*/
if (!ip6_forwarding && ln->ln_router &&
ln->ln_state == ND_LLINFO_STALE && gc)
{
nd_set_timer(ln, ND_TIMER_EXPIRE);
LLE_WUNLOCK(ln);
return;
}
/*
* Save to unlock. We still hold an extra reference and will not
* free(9) in llentry_free() if someone else holds one as well.
*/
LLE_WUNLOCK(ln);
IF_AFDATA_LOCK(ifp);
LLE_WLOCK(ln);
if ((rt->rt_flags & RTF_GATEWAY) != 0) {
if (req != RTM_ADD)
return;
/*
* linklayers with particular MTU limitation.
*/
switch(ifp->if_type) {
#if NARCNET > 0
case IFT_ARCNET:
if (rt->rt_rmx.rmx_mtu > ARC_PHDS_MAXMTU) /* RFC2497 */
rt->rt_rmx.rmx_mtu = ARC_PHDS_MAXMTU;
break;
#endif
}
return;
}
if (nd6_need_cache(ifp) == 0 && (rt->rt_flags & RTF_HOST) == 0) {
RT_DPRINTF("rt_getkey(rt) = %p\n", rt_getkey(rt));
/*
* This is probably an interface direct route for a link
* which does not need neighbor caches (e.g. fe80::%lo0/64).
* We do not need special treatment below for such a route.
* Moreover, the RTF_LLINFO flag which would be set below
* would annoy the ndp(8) command.
*/
return;
}
switch (req) {
case RTM_ADD: {
struct psref psref;
RT_DPRINTF("rt_getkey(rt) = %p\n", rt_getkey(rt));
/*
* There is no backward compatibility :)
*
* if ((rt->rt_flags & RTF_HOST) == 0 &&
* SIN(rt_mask(rt))->sin_addr.s_addr != 0xffffffff)
* rt->rt_flags |= RTF_CLONING;
*/
/* XXX should move to route.c? */
if (rt->rt_flags & (RTF_CONNECTED | RTF_LOCAL)) {
union {
struct sockaddr sa;
struct sockaddr_dl sdl;
struct sockaddr_storage ss;
} u;
/*
* Case 1: This route should come from a route to
* interface (RTF_CLONING case) or the route should be
* treated as on-link but is currently not
* (RTF_LLINFO && ln == NULL case).
*/
if (sockaddr_dl_init(&u.sdl, sizeof(u.ss),
ifp->if_index, ifp->if_type,
NULL, namelen, NULL, addrlen) == NULL) {
printf("%s.%d: sockaddr_dl_init(, %zu, ) "
"failed on %s\n", __func__, __LINE__,
sizeof(u.ss), if_name(ifp));
}
rt_setgate(rt, &u.sa);
gate = rt->rt_gateway;
RT_DPRINTF("rt_getkey(rt) = %p\n", rt_getkey(rt));
if (gate == NULL) {
log(LOG_ERR,
"%s: rt_setgate failed on %s\n", __func__,
if_name(ifp));
break;
}
RT_DPRINTF("rt_getkey(rt) = %p\n", rt_getkey(rt));
if ((rt->rt_flags & RTF_CONNECTED) != 0)
break;
}
RT_DPRINTF("rt_getkey(rt) = %p\n", rt_getkey(rt));
/*
* In IPv4 code, we try to annonuce new RTF_ANNOUNCE entry here.
* We don't do that here since llinfo is not ready yet.
*
* There are also couple of other things to be discussed:
* - unsolicited NA code needs improvement beforehand
* - RFC2461 says we MAY send multicast unsolicited NA
* (7.2.6 paragraph 4), however, it also says that we
* SHOULD provide a mechanism to prevent multicast NA storm.
* we don't have anything like it right now.
* note that the mechanism needs a mutual agreement
* between proxies, which means that we need to implement
* a new protocol, or a new kludge.
* - from RFC2461 6.2.4, host MUST NOT send an unsolicited NA.
* we need to check ip6forwarding before sending it.
* (or should we allow proxy ND configuration only for
* routers? there's no mention about proxy ND from hosts)
*/
#if 0
/* XXX it does not work */
if (rt->rt_flags & RTF_ANNOUNCE)
nd6_na_output(ifp,
&satocsin6(rt_getkey(rt))->sin6_addr,
&satocsin6(rt_getkey(rt))->sin6_addr,
ip6_forwarding ? ND_NA_FLAG_ROUTER : 0,
1, NULL);
#endif
if ((ifp->if_flags & (IFF_POINTOPOINT | IFF_LOOPBACK)) == 0) {
RT_DPRINTF("rt_getkey(rt) = %p\n", rt_getkey(rt));
/*
* Address resolution isn't necessary for a point to
* point link, so we can skip this test for a p2p link.
*/
if (gate->sa_family != AF_LINK ||
gate->sa_len <
sockaddr_dl_measure(namelen, addrlen)) {
log(LOG_DEBUG,
"nd6_rtrequest: bad gateway value: %s\n",
if_name(ifp));
break;
}
satosdl(gate)->sdl_type = ifp->if_type;
satosdl(gate)->sdl_index = ifp->if_index;
RT_DPRINTF("rt_getkey(rt) = %p\n", rt_getkey(rt));
}
RT_DPRINTF("rt_getkey(rt) = %p\n", rt_getkey(rt));
/*
* When called from rt_ifa_addlocal, we cannot depend on that
* the address (rt_getkey(rt)) exits in the address list of the
* interface. So check RTF_LOCAL instead.
*/
if (rt->rt_flags & RTF_LOCAL) {
if (nd6_useloopback)
rt->rt_ifp = lo0ifp; /* XXX */
break;
}
/*
* check if rt_getkey(rt) is an address assigned
* to the interface.
*/
ifa = (struct ifaddr *)in6ifa_ifpwithaddr_psref(ifp,
&satocsin6(rt_getkey(rt))->sin6_addr, &psref);
if (ifa != NULL) {
if (nd6_useloopback) {
rt->rt_ifp = lo0ifp; /* XXX */
/*
* Make sure rt_ifa be equal to the ifaddr
* corresponding to the address.
* We need this because when we refer
* rt_ifa->ia6_flags in ip6_input, we assume
* that the rt_ifa points to the address instead
* of the loopback address.
*/
if (!ISSET(info->rti_flags, RTF_DONTCHANGEIFA)
&& ifa != rt->rt_ifa)
rt_replace_ifa(rt, ifa);
}
} else if (rt->rt_flags & RTF_ANNOUNCE) {
/* join solicited node multicast for proxy ND */
if (ifp->if_flags & IFF_MULTICAST) {
struct in6_addr llsol;
int error;
llsol = satocsin6(rt_getkey(rt))->sin6_addr;
llsol.s6_addr32[0] = htonl(0xff020000);
llsol.s6_addr32[1] = 0;
llsol.s6_addr32[2] = htonl(1);
llsol.s6_addr8[12] = 0xff;
if (in6_setscope(&llsol, ifp, NULL))
goto out;
if (!in6_addmulti(&llsol, ifp, &error, 0)) {
char ip6buf[INET6_ADDRSTRLEN];
nd6log(LOG_ERR, "%s: failed to join "
"%s (errno=%d)\n", if_name(ifp),
IN6_PRINT(ip6buf, &llsol), error);
}
}
}
out:
ifa_release(ifa, &psref);
/*
* If we have too many cache entries, initiate immediate
* purging for some entries.
*/
if (rt->rt_ifp != NULL)
nd6_gc_neighbors(LLTABLE6(rt->rt_ifp), NULL);
break;
}
case RTM_DELETE:
/* leave from solicited node multicast for proxy ND */
if ((rt->rt_flags & RTF_ANNOUNCE) != 0 &&
(ifp->if_flags & IFF_MULTICAST) != 0) {
struct in6_addr llsol;
if (ndi->flags & ND6_IFF_IFDISABLED && !(flags & ND6_IFF_IFDISABLED)) {
/*
* If the interface is marked as ND6_IFF_IFDISABLED and
* has a link-local address with IN6_IFF_DUPLICATED,
* do not clear ND6_IFF_IFDISABLED.
* See RFC 4862, section 5.4.5.
*/
bool duplicated_linklocal = false;
s = pserialize_read_enter();
IFADDR_READER_FOREACH(ifa, ifp) {
if (ifa->ifa_addr->sa_family != AF_INET6)
continue;
ia = (struct in6_ifaddr *)ifa;
if ((ia->ia6_flags & IN6_IFF_DUPLICATED) &&
IN6_IS_ADDR_LINKLOCAL(IA6_IN6(ia)))
{
duplicated_linklocal = true;
break;
}
}
pserialize_read_exit(s);
if (duplicated_linklocal) {
flags |= ND6_IFF_IFDISABLED;
log(LOG_ERR, "%s: Cannot enable an interface"
" with a link-local address marked"
" duplicate.\n", if_name(ifp));
} else {
ndi->flags &= ~ND6_IFF_IFDISABLED;
if (ifp->if_flags & IFF_UP)
in6_if_up(ifp);
}
} else if (!(ndi->flags & ND6_IFF_IFDISABLED) &&
(flags & ND6_IFF_IFDISABLED))
{
struct psref psref;
int bound = curlwp_bind();
/* Mark all IPv6 addresses as tentative. */
ndi->flags |= ND6_IFF_IFDISABLED;
s = pserialize_read_enter();
IFADDR_READER_FOREACH(ifa, ifp) {
if (ifa->ifa_addr->sa_family != AF_INET6)
continue;
ifa_acquire(ifa, &psref);
pserialize_read_exit(s);
nd6_dad_stop(ifa);
ia = (struct in6_ifaddr *)ifa;
ia->ia6_flags |= IN6_IFF_TENTATIVE;
s = pserialize_read_enter();
ifa_release(ifa, &psref);
}
pserialize_read_exit(s);
curlwp_bindx(bound);
}
if (flags & ND6_IFF_AUTO_LINKLOCAL) {
if (!(ndi->flags & ND6_IFF_AUTO_LINKLOCAL)) {
/* auto_linklocal 0->1 transition */
ndi->flags |= ND6_IFF_AUTO_LINKLOCAL;
in6_ifattach(ifp, NULL);
} else if (!(flags & ND6_IFF_IFDISABLED) &&
ifp->if_flags & IFF_UP)
{
/*
* When the IF already has
* ND6_IFF_AUTO_LINKLOCAL, no link-local
* address is assigned, and IFF_UP, try to
* assign one.
*/
bool haslinklocal = 0;
s = pserialize_read_enter();
ifa = in6ifa_first_lladdr(ifp);
if (ifa != NULL)
haslinklocal = true;
pserialize_read_exit(s);
if (!haslinklocal)
in6_ifattach(ifp, NULL);
}
}
/*
* we assume ifp is not a p2p here, so
* just set the 2nd argument as the
* 1st one.
*/
ip6_if_output(ifp, ifp, m_hold, &sin6, NULL);
}
LLE_WLOCK(ln);
LLE_REMREF(ln);
}
/*
* Create neighbor cache entry and cache link-layer address,
* on reception of inbound ND6 packets. (RS/RA/NS/redirect)
*/
void
nd6_cache_lladdr(
struct ifnet *ifp,
struct in6_addr *from,
char *lladdr,
int lladdrlen,
int type, /* ICMP6 type */
int code /* type dependent information */
)
{
struct llentry *ln = NULL;
int is_newentry;
int do_update;
int olladdr;
int llchange;
int newstate = 0;
KASSERT(ifp != NULL);
KASSERT(from != NULL);
/* nothing must be updated for unspecified address */
if (IN6_IS_ADDR_UNSPECIFIED(from))
return;
/*
* Validation about ifp->if_addrlen and lladdrlen must be done in
* the caller.
*
* XXX If the link does not have link-layer adderss, what should
* we do? (ifp->if_addrlen == 0)
* Spec says nothing in sections for RA, RS and NA. There's small
* description on it in NS section (RFC 2461 7.2.3).
*/
ln = nd6_lookup(from, ifp, true);
if (ln == NULL) {
#if 0
/* nothing must be done if there's no lladdr */
if (!lladdr || !lladdrlen)
return NULL;
#endif
ln = nd6_create(from, ifp);
is_newentry = 1;
} else {
/* do nothing if static ndp is set */
if (ln->la_flags & LLE_STATIC) {
LLE_WUNLOCK(ln);
return;
}
is_newentry = 0;
}
/*
* newentry olladdr lladdr llchange (*=record)
* 0 n n -- (1)
* 0 y n -- (2)
* 0 n y -- (3) * STALE
* 0 y y n (4) *
* 0 y y y (5) * STALE
* 1 -- n -- (6) NOSTATE(= PASSIVE)
* 1 -- y -- (7) * STALE
*/
if (lladdr) { /* (3-5) and (7) */
/*
* Record source link-layer address
* XXX is it dependent to ifp->if_type?
*/
memcpy(&ln->ll_addr, lladdr, ifp->if_addrlen);
ln->la_flags |= LLE_VALID;
}
if (do_update) {
/*
* Update the state of the neighbor cache.
*/
ln->ln_state = newstate;
if (ln->ln_state == ND_LLINFO_STALE) {
/*
* XXX: since nd6_output() below will cause
* state tansition to DELAY and reset the timer,
* we must set the timer now, although it is actually
* meaningless.
*/
nd_set_timer(ln, ND_TIMER_GC);
nd6_llinfo_release_pkts(ln, ifp);
} else if (ln->ln_state == ND_LLINFO_INCOMPLETE) {
/* probe right away */
nd_set_timer(ln, ND_TIMER_IMMEDIATE);
}
}
/*
* ICMP6 type dependent behavior.
*
* NS: clear IsRouter if new entry
* RS: clear IsRouter
* RA: set IsRouter if there's lladdr
* redir: clear IsRouter if new entry
*
* RA case, (1):
* The spec says that we must set IsRouter in the following cases:
* - If lladdr exist, set IsRouter. This means (1-5).
* - If it is old entry (!newentry), set IsRouter. This means (7).
* So, based on the spec, in (1-5) and (7) cases we must set IsRouter.
* A question arises for (1) case. (1) case has no lladdr in the
* neighbor cache, this is similar to (6).
* This case is rare but we figured that we MUST NOT set IsRouter.
*
* newentry olladdr lladdr llchange NS RS RA redir
* D R
* 0 n n -- (1) c ? s
* 0 y n -- (2) c s s
* 0 n y -- (3) c s s
* 0 y y n (4) c s s
* 0 y y y (5) c s s
* 1 -- n -- (6) c c c s
* 1 -- y -- (7) c c s c s
*
* (c=clear s=set)
*/
switch (type & 0xff) {
case ND_NEIGHBOR_SOLICIT:
/*
* New entry must have is_router flag cleared.
*/
if (is_newentry) /* (6-7) */
ln->ln_router = 0;
break;
case ND_REDIRECT:
/*
* If the icmp is a redirect to a better router, always set the
* is_router flag. Otherwise, if the entry is newly created,
* clear the flag. [RFC 2461, sec 8.3]
*/
if (code == ND_REDIRECT_ROUTER)
ln->ln_router = 1;
else if (is_newentry) /* (6-7) */
ln->ln_router = 0;
break;
case ND_ROUTER_SOLICIT:
/*
* is_router flag must always be cleared.
*/
ln->ln_router = 0;
break;
case ND_ROUTER_ADVERT:
/*
* Mark an entry with lladdr as a router.
*/
if ((!is_newentry && (olladdr || lladdr)) || /* (2-5) */
(is_newentry && lladdr)) { /* (7) */
ln->ln_router = 1;
}
break;
}
if (do_update && lladdr != NULL) {
struct sockaddr_in6 sin6;
/*
* If we have too many cache entries, initiate immediate
* purging for some entries.
*/
if (is_newentry)
nd6_gc_neighbors(LLTABLE6(ifp), &ln->r_l3addr.addr6);
}
s = pserialize_read_enter();
IFNET_READER_FOREACH(ifp) {
ndi = ND_IFINFO(ifp);
if (ndi->basereachable && /* already initialized */
(ndi->recalctm -= ND6_SLOWTIMER_INTERVAL) <= 0) {
if_acquire(ifp, &psref);
pserialize_read_exit(s);
/*
* Since reachable time rarely changes by router
* advertisements, we SHOULD insure that a new random
* value gets recomputed at least once every few hours.
* (RFC 2461, 6.3.4)
*/
ndi->recalctm = nd6_recalc_reachtm_interval;
ndi->reachable = ND_COMPUTE_RTIME(ndi->basereachable);
s = pserialize_read_enter();
if_release(ifp, &psref);
}
}
pserialize_read_exit(s);
SOFTNET_KERNEL_UNLOCK_UNLESS_NET_MPSAFE();
}
/*
* Return 0 if a neighbor cache is found. Return EWOULDBLOCK if a cache is not
* found and trying to resolve a neighbor; in this case the mbuf is queued in
* the list. Otherwise return errno after freeing the mbuf.
*/
int
nd6_resolve(struct ifnet *ifp, const struct rtentry *rt, struct mbuf *m,
const struct sockaddr *_dst, uint8_t *lldst, size_t dstsize)
{
struct llentry *ln = NULL;
bool created = false;
const struct sockaddr_in6 *dst = satocsin6(_dst);
int error;
struct nd_kifinfo *ndi = ND_IFINFO(ifp);
/* discard the packet if IPv6 operation is disabled on the interface */
if (ndi->flags & ND6_IFF_IFDISABLED) {
m_freem(m);
return ENETDOWN; /* better error? */
}
/*
* Address resolution or Neighbor Unreachability Detection
* for the next hop.
* At this point, the destination of the packet must be a unicast
* or an anycast address(i.e. not a multicast).
*/
/* Look up the neighbor cache for the nexthop */
ln = nd6_lookup(&dst->sin6_addr, ifp, false);
if (ln != NULL && (ln->la_flags & LLE_VALID) != 0 &&
/* Only STALE needs to go the slow path to change its state. */
(ln->ln_state == ND_LLINFO_REACHABLE ||
ln->ln_state == ND_LLINFO_DELAY ||
ln->ln_state == ND_LLINFO_PROBE)) {
/* Fast path */
memcpy(lldst, &ln->ll_addr, MIN(dstsize, ifp->if_addrlen));
LLE_RUNLOCK(ln);
return 0;
}
if (ln != NULL)
LLE_RUNLOCK(ln);
/* Slow path */
ln = nd6_lookup(&dst->sin6_addr, ifp, true);
if (ln == NULL && nd6_is_addr_neighbor(dst, ifp)) {
/*
* Since nd6_is_addr_neighbor() internally calls nd6_lookup(),
* the condition below is not very efficient. But we believe
* it is tolerable, because this should be a rare case.
*/
ln = nd6_create(&dst->sin6_addr, ifp);
if (ln == NULL) {
char ip6buf[INET6_ADDRSTRLEN];
log(LOG_DEBUG,
"%s: can't allocate llinfo for %s "
"(ln=%p, rt=%p)\n", __func__,
IN6_PRINT(ip6buf, &dst->sin6_addr), ln, rt);
m_freem(m);
return ENOBUFS;
}
created = true;
}
if (created)
nd6_gc_neighbors(LLTABLE6(ifp), &dst->sin6_addr);
return error;
}
int
nd6_need_cache(struct ifnet *ifp)
{
/*
* XXX: we currently do not make neighbor cache on any interface
* other than ARCnet, Ethernet, and GIF.
*
* RFC2893 says:
* - unidirectional tunnels needs no ND
*/
switch (ifp->if_type) {
case IFT_ARCNET:
case IFT_ETHER:
case IFT_IEEE1394:
case IFT_CARP:
case IFT_GIF: /* XXX need more cases? */
case IFT_IPSEC:
case IFT_PPP:
case IFT_TUNNEL:
return 1;
default:
return 0;
}
}
int
nd6_sysctl(
int name,
void *oldp, /* syscall arg, need copyout */
size_t *oldlenp,
void *newp, /* syscall arg, need copyin */
size_t newlen
)
{
int error;
if (newp)
return EPERM;
switch (name) {
/* call the nd6 compat_90 hook to validate the nd6-related names */
case OICMPV6CTL_ND6_DRLIST: /* FALLTHROUGH */
case OICMPV6CTL_ND6_PRLIST:
MODULE_HOOK_CALL(net_inet6_nd_90_hook, (name), ENOPROTOOPT,
error);
if (error == 0)
*oldlenp = 0;
return error;
case ICMPV6CTL_ND6_MAXQLEN:
return 0;
default:
return ENOPROTOOPT;
}
}
