#include <sys/param.h>
#include <sys/systm.h>
#include <sys/malloc.h>
#include <sys/mbuf.h>
#include <sys/socket.h>
#include <sys/sockio.h>
#include <sys/time.h>
#include <sys/kernel.h>
#include <sys/errno.h>
#include <sys/syslog.h>
#include <sys/queue.h>
#include <sys/mcache.h>
#include <sys/protosw.h>
#include <dev/random/randomdev.h>
#include <kern/locks.h>
#include <kern/zalloc.h>
#include <machine/machine_routines.h>
#include <net/if.h>
#include <net/if_types.h>
#include <net/if_dl.h>
#include <net/route.h>
#include <net/radix.h>
#include <netinet/in.h>
#include <netinet6/in6_var.h>
#include <netinet6/in6_ifattach.h>
#include <netinet/ip6.h>
#include <netinet6/ip6_var.h>
#include <netinet6/nd6.h>
#include <netinet/icmp6.h>
#include <netinet6/scope6_var.h>
#include <net/net_osdep.h>
static void defrouter_addreq(struct nd_defrouter *, boolean_t);
static void defrouter_delreq(struct nd_defrouter *);
static struct nd_defrouter *defrtrlist_update_common(struct nd_defrouter *,
boolean_t);
static struct nd_defrouter *defrtrlist_update(struct nd_defrouter *);
static struct in6_ifaddr *in6_pfx_newpersistaddr(struct nd_prefix *, int,
int *);
static void defrtrlist_sync(struct ifnet *);
static struct nd_pfxrouter *pfxrtr_lookup(struct nd_prefix *,
struct nd_defrouter *);
static void pfxrtr_add(struct nd_prefix *, struct nd_defrouter *);
static void pfxrtr_del(struct nd_pfxrouter *, struct nd_prefix *);
static struct nd_pfxrouter *find_pfxlist_reachable_router(struct nd_prefix *);
static void nd6_rtmsg(int, struct rtentry *);
static int nd6_prefix_onlink_common(struct nd_prefix *, boolean_t,
unsigned int);
static struct nd_prefix *nd6_prefix_equal_lookup(struct nd_prefix *, boolean_t);
static void nd6_prefix_sync(struct ifnet *);
static void in6_init_address_ltimes(struct nd_prefix *,
struct in6_addrlifetime *);
static int rt6_deleteroute(struct radix_node *, void *);
static struct nd_defrouter *nddr_alloc(int);
static void nddr_free(struct nd_defrouter *);
static void nddr_trace(struct nd_defrouter *, int);
static struct nd_prefix *ndpr_alloc(int);
static void ndpr_free(struct nd_prefix *);
static void ndpr_trace(struct nd_prefix *, int);
extern int nd6_recalc_reachtm_interval;
static struct ifnet *nd6_defifp;
int nd6_defifindex;
static unsigned int nd6_defrouter_genid;
int ip6_use_tempaddr = 1;
int nd6_accept_6to4 = 1;
int ip6_desync_factor;
u_int32_t ip6_temp_preferred_lifetime = DEF_TEMP_PREFERRED_LIFETIME;
u_int32_t ip6_temp_valid_lifetime = DEF_TEMP_VALID_LIFETIME;
int ip6_temp_regen_advance = TEMPADDR_REGEN_ADVANCE;
extern lck_mtx_t *nd6_mutex;
static boolean_t nd_prefix_busy;
static void *nd_prefix_waitchan = &nd_prefix_busy;
static int nd_prefix_waiters = 0;
static boolean_t nd_defrouter_busy;
static void *nd_defrouter_waitchan = &nd_defrouter_busy;
static int nd_defrouter_waiters = 0;
#define RTPREF_HIGH 1
#define RTPREF_MEDIUM 0
#define RTPREF_LOW (-1)
#define RTPREF_RESERVED (-2)
#define RTPREF_INVALID (-3)
#define NDPR_TRACE_HIST_SIZE 32
__private_extern__ unsigned int ndpr_trace_hist_size = NDPR_TRACE_HIST_SIZE;
struct nd_prefix_dbg {
struct nd_prefix ndpr_pr;
u_int16_t ndpr_refhold_cnt;
u_int16_t ndpr_refrele_cnt;
ctrace_t ndpr_refhold[NDPR_TRACE_HIST_SIZE];
ctrace_t ndpr_refrele[NDPR_TRACE_HIST_SIZE];
};
static unsigned int ndpr_debug;
static unsigned int ndpr_size;
static struct zone *ndpr_zone;
#define NDPR_ZONE_MAX 64
#define NDPR_ZONE_NAME "nd6_prefix"
#define NDDR_TRACE_HIST_SIZE 32
__private_extern__ unsigned int nddr_trace_hist_size = NDDR_TRACE_HIST_SIZE;
struct nd_defrouter_dbg {
struct nd_defrouter nddr_dr;
uint16_t nddr_refhold_cnt;
uint16_t nddr_refrele_cnt;
ctrace_t nddr_refhold[NDDR_TRACE_HIST_SIZE];
ctrace_t nddr_refrele[NDDR_TRACE_HIST_SIZE];
};
static unsigned int nddr_debug;
static unsigned int nddr_size;
static struct zone *nddr_zone;
#define NDDR_ZONE_MAX 64
#define NDDR_ZONE_NAME "nd6_defrouter"
static unsigned int ndprtr_size;
static struct zone *ndprtr_zone;
#define NDPRTR_ZONE_MAX 64
#define NDPRTR_ZONE_NAME "nd6_pfxrouter"
void
nd6_rtr_init(void)
{
PE_parse_boot_argn("ifa_debug", &ndpr_debug, sizeof (ndpr_debug));
PE_parse_boot_argn("ifa_debug", &nddr_debug, sizeof (nddr_debug));
ndpr_size = (ndpr_debug == 0) ? sizeof (struct nd_prefix) :
sizeof (struct nd_prefix_dbg);
ndpr_zone = zinit(ndpr_size, NDPR_ZONE_MAX * ndpr_size, 0,
NDPR_ZONE_NAME);
if (ndpr_zone == NULL) {
panic("%s: failed allocating %s", __func__, NDPR_ZONE_NAME);
}
zone_change(ndpr_zone, Z_EXPAND, TRUE);
zone_change(ndpr_zone, Z_CALLERACCT, FALSE);
nddr_size = (nddr_debug == 0) ? sizeof (struct nd_defrouter) :
sizeof (struct nd_defrouter_dbg);
nddr_zone = zinit(nddr_size, NDDR_ZONE_MAX * nddr_size, 0,
NDDR_ZONE_NAME);
if (nddr_zone == NULL) {
panic("%s: failed allocating %s", __func__, NDDR_ZONE_NAME);
}
zone_change(nddr_zone, Z_EXPAND, TRUE);
zone_change(nddr_zone, Z_CALLERACCT, FALSE);
ndprtr_size = sizeof (struct nd_pfxrouter);
ndprtr_zone = zinit(ndprtr_size, NDPRTR_ZONE_MAX * ndprtr_size, 0,
NDPRTR_ZONE_NAME);
if (ndprtr_zone == NULL) {
panic("%s: failed allocating %s", __func__, NDPRTR_ZONE_NAME);
}
zone_change(ndprtr_zone, Z_EXPAND, TRUE);
zone_change(ndprtr_zone, Z_CALLERACCT, FALSE);
}
void
nd6_rs_input(
struct mbuf *m,
int off,
int icmp6len)
{
struct ifnet *ifp = m->m_pkthdr.rcvif;
struct ip6_hdr *ip6 = mtod(m, struct ip6_hdr *);
struct nd_router_solicit *nd_rs;
struct in6_addr saddr6 = ip6->ip6_src;
char *lladdr = NULL;
int lladdrlen = 0;
union nd_opts ndopts;
MBUF_STRICT_DATA_ALIGNMENT_CHECK_32(m);
if (!ip6_forwarding || !(ifp->if_eflags & IFEF_IPV6_ROUTER))
goto freeit;
if (ip6->ip6_hlim != 255) {
nd6log((LOG_ERR,
"nd6_rs_input: invalid hlim (%d) from %s to %s on %s\n",
ip6->ip6_hlim, ip6_sprintf(&ip6->ip6_src),
ip6_sprintf(&ip6->ip6_dst), if_name(ifp)));
goto bad;
}
if (IN6_IS_ADDR_UNSPECIFIED(&ip6->ip6_src)) {
goto freeit;
} else {
struct sockaddr_in6 src_sa6;
bzero(&src_sa6, sizeof (src_sa6));
src_sa6.sin6_family = AF_INET6;
src_sa6.sin6_len = sizeof (src_sa6);
src_sa6.sin6_addr = ip6->ip6_src;
if (!nd6_is_addr_neighbor(&src_sa6, ifp, 0)) {
nd6log((LOG_INFO, "nd6_rs_input: "
"RS packet from non-neighbor\n"));
goto freeit;
}
}
IP6_EXTHDR_CHECK(m, off, icmp6len, return);
nd_rs = (struct nd_router_solicit *)((caddr_t)ip6 + off);
icmp6len -= sizeof (*nd_rs);
nd6_option_init(nd_rs + 1, icmp6len, &ndopts);
if (nd6_options(&ndopts) < 0) {
nd6log((LOG_INFO,
"nd6_rs_input: invalid ND option, ignored\n"));
goto freeit;
}
if (ndopts.nd_opts_src_lladdr) {
lladdr = (char *)(ndopts.nd_opts_src_lladdr + 1);
lladdrlen = ndopts.nd_opts_src_lladdr->nd_opt_len << 3;
}
if (lladdr && ((ifp->if_addrlen + 2 + 7) & ~7) != lladdrlen) {
nd6log((LOG_INFO,
"nd6_rs_input: lladdrlen mismatch for %s "
"(if %d, RS packet %d)\n",
ip6_sprintf(&saddr6), ifp->if_addrlen, lladdrlen - 2));
goto bad;
}
nd6_cache_lladdr(ifp, &saddr6, lladdr, lladdrlen, ND_ROUTER_SOLICIT, 0);
freeit:
m_freem(m);
return;
bad:
icmp6stat.icp6s_badrs++;
m_freem(m);
}
void
nd6_ra_input(
struct mbuf *m,
int off,
int icmp6len)
{
struct ifnet *ifp = m->m_pkthdr.rcvif;
struct nd_ifinfo *ndi = NULL;
struct ip6_hdr *ip6 = mtod(m, struct ip6_hdr *);
struct nd_router_advert *nd_ra;
struct in6_addr saddr6 = ip6->ip6_src;
int mcast = 0;
union nd_opts ndopts;
struct nd_defrouter *dr = NULL;
u_int32_t mtu = 0;
char *lladdr = NULL;
u_int32_t lladdrlen = 0;
struct nd_prefix_list *nd_prefix_list_head = NULL;
u_int32_t nd_prefix_list_length = 0;
struct in6_ifaddr *ia6 = NULL;
struct nd_prefix_list *prfl;
struct nd_defrouter dr0;
u_int32_t advreachable;
MBUF_STRICT_DATA_ALIGNMENT_CHECK_32(m);
if (!(ifp->if_eflags & (IFEF_ACCEPT_RTADV | IFEF_IPV6_ROUTER)) ||
((ifp->if_eflags & IFEF_IPV6_ROUTER) &&
(ia6 = ifa_foraddr6(&saddr6)) == NULL))
goto freeit;
if (ia6 != NULL) {
IFA_REMREF(&ia6->ia_ifa);
ia6 = NULL;
}
if (ip6->ip6_hlim != 255) {
nd6log((LOG_ERR,
"nd6_ra_input: invalid hlim (%d) from %s to %s on %s\n",
ip6->ip6_hlim, ip6_sprintf(&ip6->ip6_src),
ip6_sprintf(&ip6->ip6_dst), if_name(ifp)));
goto bad;
}
if (!IN6_IS_ADDR_LINKLOCAL(&saddr6)) {
nd6log((LOG_ERR,
"nd6_ra_input: src %s is not link-local\n",
ip6_sprintf(&saddr6)));
goto bad;
}
IP6_EXTHDR_CHECK(m, off, icmp6len, return);
nd_ra = (struct nd_router_advert *)((caddr_t)ip6 + off);
icmp6len -= sizeof (*nd_ra);
nd6_option_init(nd_ra + 1, icmp6len, &ndopts);
if (nd6_options(&ndopts) < 0) {
nd6log((LOG_INFO,
"nd6_ra_input: invalid ND option, ignored\n"));
goto freeit;
}
advreachable = nd_ra->nd_ra_reachable;
if (IN6_IS_ADDR_MULTICAST(&ip6->ip6_dst))
mcast = 1;
lck_rw_lock_shared(nd_if_rwlock);
if (ifp->if_index >= nd_ifinfo_indexlim) {
lck_rw_done(nd_if_rwlock);
goto freeit;
}
ndi = &nd_ifinfo[ifp->if_index];
VERIFY(ndi->initialized);
lck_mtx_lock(&ndi->lock);
bzero(&dr0, sizeof (dr0));
dr0.rtaddr = saddr6;
dr0.flags = nd_ra->nd_ra_flags_reserved;
dr0.rtlifetime = ntohs(nd_ra->nd_ra_router_lifetime);
dr0.expire = net_uptime() + dr0.rtlifetime;
dr0.ifp = ifp;
if (advreachable) {
advreachable = ntohl(advreachable);
if (advreachable <= MAX_REACHABLE_TIME &&
ndi->basereachable != advreachable) {
ndi->basereachable = advreachable;
ndi->reachable = ND_COMPUTE_RTIME(ndi->basereachable);
ndi->recalctm = nd6_recalc_reachtm_interval;
}
}
if (nd_ra->nd_ra_retransmit)
ndi->retrans = ntohl(nd_ra->nd_ra_retransmit);
if (nd_ra->nd_ra_curhoplimit)
ndi->chlim = nd_ra->nd_ra_curhoplimit;
lck_mtx_unlock(&ndi->lock);
lck_rw_done(nd_if_rwlock);
ndi = NULL;
lck_mtx_lock(nd6_mutex);
dr = defrtrlist_update(&dr0);
lck_mtx_unlock(nd6_mutex);
if (ndopts.nd_opts_pi) {
struct nd_opt_hdr *pt;
struct nd_opt_prefix_info *pi = NULL;
struct nd_prefix pr;
for (pt = (struct nd_opt_hdr *)ndopts.nd_opts_pi;
pt <= (struct nd_opt_hdr *)ndopts.nd_opts_pi_end;
pt = (struct nd_opt_hdr *)((caddr_t)pt +
(pt->nd_opt_len << 3))) {
if (pt->nd_opt_type != ND_OPT_PREFIX_INFORMATION)
continue;
pi = (struct nd_opt_prefix_info *)pt;
if (pi->nd_opt_pi_len != 4) {
nd6log((LOG_INFO,
"nd6_ra_input: invalid option "
"len %d for prefix information option, "
"ignored\n", pi->nd_opt_pi_len));
continue;
}
if (128 < pi->nd_opt_pi_prefix_len) {
nd6log((LOG_INFO,
"nd6_ra_input: invalid prefix "
"len %d for prefix information option, "
"ignored\n", pi->nd_opt_pi_prefix_len));
continue;
}
if (IN6_IS_ADDR_MULTICAST(&pi->nd_opt_pi_prefix) ||
IN6_IS_ADDR_LINKLOCAL(&pi->nd_opt_pi_prefix)) {
nd6log((LOG_INFO,
"%s: invalid prefix %s, ignored\n",
__func__,
ip6_sprintf(&pi->nd_opt_pi_prefix)));
continue;
}
bzero(&pr, sizeof (pr));
lck_mtx_init(&pr.ndpr_lock, ifa_mtx_grp, ifa_mtx_attr);
NDPR_LOCK(&pr);
pr.ndpr_prefix.sin6_family = AF_INET6;
pr.ndpr_prefix.sin6_len = sizeof (pr.ndpr_prefix);
pr.ndpr_prefix.sin6_addr = pi->nd_opt_pi_prefix;
pr.ndpr_ifp = m->m_pkthdr.rcvif;
pr.ndpr_raf_onlink = (pi->nd_opt_pi_flags_reserved &
ND_OPT_PI_FLAG_ONLINK) ? 1 : 0;
pr.ndpr_raf_auto = (pi->nd_opt_pi_flags_reserved &
ND_OPT_PI_FLAG_AUTO) ? 1 : 0;
pr.ndpr_plen = pi->nd_opt_pi_prefix_len;
pr.ndpr_vltime = ntohl(pi->nd_opt_pi_valid_time);
pr.ndpr_pltime =
ntohl(pi->nd_opt_pi_preferred_time);
if (ip6_only_allow_rfc4193_prefix &&
!IN6_IS_ADDR_UNIQUE_LOCAL(&pi->nd_opt_pi_prefix)) {
nd6log((LOG_INFO,
"nd6_ra_input: no SLAAC on prefix %s "
"[not RFC 4193]\n",
ip6_sprintf(&pi->nd_opt_pi_prefix)));
pr.ndpr_raf_auto = 0;
} else if (!nd6_accept_6to4 &&
IN6_IS_ADDR_6TO4(&pi->nd_opt_pi_prefix)) {
nd6log((LOG_INFO,
"%s: no SLAAC on prefix %s "
"[6to4]\n", __func__,
ip6_sprintf(&pi->nd_opt_pi_prefix)));
pr.ndpr_raf_auto = 0;
}
if (in6_init_prefix_ltimes(&pr)) {
NDPR_UNLOCK(&pr);
lck_mtx_destroy(&pr.ndpr_lock, ifa_mtx_grp);
continue;
} else {
NDPR_UNLOCK(&pr);
}
(void) prelist_update(&pr, dr, m, mcast);
lck_mtx_destroy(&pr.ndpr_lock, ifa_mtx_grp);
prfl = NULL;
MALLOC(prfl, struct nd_prefix_list *, sizeof (*prfl),
M_TEMP, M_WAITOK | M_ZERO);
if (prfl == NULL) {
log(LOG_DEBUG, "%s: unable to MALLOC RA prefix "
"structure\n", __func__);
continue;
}
bcopy(&pr.ndpr_prefix, &prfl->pr.ndpr_prefix,
sizeof (prfl->pr.ndpr_prefix));
prfl->pr.ndpr_raf = pr.ndpr_raf;
prfl->pr.ndpr_plen = pr.ndpr_plen;
prfl->pr.ndpr_vltime = pr.ndpr_vltime;
prfl->pr.ndpr_pltime = pr.ndpr_pltime;
prfl->pr.ndpr_expire = pr.ndpr_expire;
prfl->pr.ndpr_base_calendartime =
pr.ndpr_base_calendartime;
prfl->pr.ndpr_base_uptime = pr.ndpr_base_uptime;
prfl->pr.ndpr_stateflags = pr.ndpr_stateflags;
prfl->pr.ndpr_addrcnt = pr.ndpr_addrcnt;
prfl->pr.ndpr_ifp = pr.ndpr_ifp;
prfl->next = nd_prefix_list_head;
nd_prefix_list_head = prfl;
nd_prefix_list_length++;
}
}
if (ndopts.nd_opts_mtu && ndopts.nd_opts_mtu->nd_opt_mtu_len == 1) {
mtu = ntohl(ndopts.nd_opts_mtu->nd_opt_mtu_mtu);
if (mtu < IPV6_MMTU) {
nd6log((LOG_INFO, "nd6_ra_input: bogus mtu option "
"mtu=%d sent from %s, ignoring\n",
mtu, ip6_sprintf(&ip6->ip6_src)));
goto skip;
}
lck_rw_lock_shared(nd_if_rwlock);
if (ifp->if_index >= nd_ifinfo_indexlim) {
lck_rw_done(nd_if_rwlock);
goto freeit;
}
ndi = &nd_ifinfo[ifp->if_index];
VERIFY(ndi->initialized);
lck_mtx_lock(&ndi->lock);
if (ndi->maxmtu) {
if (mtu <= ndi->maxmtu) {
int change = (ndi->linkmtu != mtu);
ndi->linkmtu = mtu;
lck_mtx_unlock(&ndi->lock);
lck_rw_done(nd_if_rwlock);
if (change)
in6_setmaxmtu();
} else {
nd6log((LOG_INFO, "nd6_ra_input: bogus mtu "
"mtu=%d sent from %s; "
"exceeds maxmtu %d, ignoring\n",
mtu, ip6_sprintf(&ip6->ip6_src),
ndi->maxmtu));
lck_mtx_unlock(&ndi->lock);
lck_rw_done(nd_if_rwlock);
}
} else {
lck_mtx_unlock(&ndi->lock);
lck_rw_done(nd_if_rwlock);
nd6log((LOG_INFO, "nd6_ra_input: mtu option "
"mtu=%d sent from %s; maxmtu unknown, "
"ignoring\n",
mtu, ip6_sprintf(&ip6->ip6_src)));
}
ndi = NULL;
}
skip:
if (ndopts.nd_opts_src_lladdr) {
lladdr = (char *)(ndopts.nd_opts_src_lladdr + 1);
lladdrlen = ndopts.nd_opts_src_lladdr->nd_opt_len << 3;
}
if (lladdr && ((ifp->if_addrlen + 2 + 7) & ~7) != lladdrlen) {
nd6log((LOG_INFO,
"nd6_ra_input: lladdrlen mismatch for %s "
"(if %d, RA packet %d)\n",
ip6_sprintf(&saddr6), ifp->if_addrlen, lladdrlen - 2));
goto bad;
}
nd6_cache_lladdr(ifp, &saddr6, lladdr, (int)lladdrlen,
ND_ROUTER_ADVERT, 0);
nd6_post_msg(KEV_ND6_RA, nd_prefix_list_head, nd_prefix_list_length,
mtu, lladdr, lladdrlen);
lck_mtx_lock(nd6_mutex);
pfxlist_onlink_check();
lck_mtx_unlock(nd6_mutex);
freeit:
m_freem(m);
if (dr)
NDDR_REMREF(dr);
prfl = NULL;
while ((prfl = nd_prefix_list_head) != NULL) {
nd_prefix_list_head = prfl->next;
FREE(prfl, M_TEMP);
}
return;
bad:
icmp6stat.icp6s_badra++;
goto freeit;
}
static void
nd6_rtmsg(cmd, rt)
int cmd;
struct rtentry *rt;
{
struct rt_addrinfo info;
struct ifnet *ifp = rt->rt_ifp;
RT_LOCK_ASSERT_HELD(rt);
bzero((caddr_t)&info, sizeof (info));
info.rti_info[RTAX_DST] = rt_key(rt);
info.rti_info[RTAX_GATEWAY] = rt->rt_gateway;
info.rti_info[RTAX_NETMASK] = rt_mask(rt);
info.rti_info[RTAX_IFP] = ifp->if_lladdr->ifa_addr;
info.rti_info[RTAX_IFA] = rt->rt_ifa->ifa_addr;
rt_missmsg(cmd, &info, rt->rt_flags, 0);
}
static void
defrouter_addreq(struct nd_defrouter *new, boolean_t scoped)
{
struct sockaddr_in6 def, mask, gate;
struct rtentry *newrt = NULL;
unsigned int ifscope;
int err;
lck_mtx_assert(nd6_mutex, LCK_MTX_ASSERT_NOTOWNED);
NDDR_LOCK_ASSERT_NOTHELD(new);
NDDR_LOCK(new);
if (new->stateflags & NDDRF_INSTALLED)
goto out;
if (new->ifp->if_eflags & IFEF_IPV6_ROUTER) {
nd6log2((LOG_INFO, "%s: ignoring router %s, scoped=%d, "
"static=%d on advertising interface\n", if_name(new->ifp),
ip6_sprintf(&new->rtaddr), scoped,
(new->stateflags & NDDRF_STATIC) ? 1 : 0));
goto out;
}
nd6log2((LOG_INFO, "%s: adding default router %s, scoped=%d, "
"static=%d\n", if_name(new->ifp), ip6_sprintf(&new->rtaddr),
scoped, (new->stateflags & NDDRF_STATIC) ? 1 : 0));
Bzero(&def, sizeof (def));
Bzero(&mask, sizeof (mask));
Bzero(&gate, sizeof (gate));
def.sin6_len = mask.sin6_len = gate.sin6_len
= sizeof (struct sockaddr_in6);
def.sin6_family = mask.sin6_family = gate.sin6_family = AF_INET6;
gate.sin6_addr = new->rtaddr;
ifscope = scoped ? new->ifp->if_index : IFSCOPE_NONE;
NDDR_UNLOCK(new);
err = rtrequest_scoped(RTM_ADD, (struct sockaddr *)&def,
(struct sockaddr *)&gate, (struct sockaddr *)&mask,
RTF_GATEWAY, &newrt, ifscope);
if (newrt) {
RT_LOCK(newrt);
nd6_rtmsg(RTM_ADD, newrt);
RT_REMREF_LOCKED(newrt);
RT_UNLOCK(newrt);
NDDR_LOCK(new);
new->stateflags |= NDDRF_INSTALLED;
if (ifscope != IFSCOPE_NONE)
new->stateflags |= NDDRF_IFSCOPE;
new->genid = nd6_defrouter_genid;
} else {
nd6log((LOG_ERR, "%s: failed to add default router "
"%s on %s scoped %d (errno = %d)\n", __func__,
ip6_sprintf(&gate.sin6_addr), if_name(new->ifp),
(ifscope != IFSCOPE_NONE), err));
NDDR_LOCK(new);
}
new->err = err;
out:
NDDR_UNLOCK(new);
}
struct nd_defrouter *
defrouter_lookup(
struct in6_addr *addr,
struct ifnet *ifp)
{
struct nd_defrouter *dr;
lck_mtx_assert(nd6_mutex, LCK_MTX_ASSERT_OWNED);
for (dr = TAILQ_FIRST(&nd_defrouter); dr;
dr = TAILQ_NEXT(dr, dr_entry)) {
NDDR_LOCK(dr);
if (dr->ifp == ifp && IN6_ARE_ADDR_EQUAL(addr, &dr->rtaddr)) {
NDDR_ADDREF_LOCKED(dr);
NDDR_UNLOCK(dr);
return (dr);
}
NDDR_UNLOCK(dr);
}
return (NULL);
}
static void
defrouter_delreq(struct nd_defrouter *dr)
{
struct sockaddr_in6 def, mask, gate;
struct rtentry *oldrt = NULL;
unsigned int ifscope;
int err;
lck_mtx_assert(nd6_mutex, LCK_MTX_ASSERT_NOTOWNED);
NDDR_LOCK_ASSERT_NOTHELD(dr);
NDDR_LOCK(dr);
if (dr->ifp != NULL && !(dr->stateflags & NDDRF_INSTALLED))
goto out;
nd6log2((LOG_INFO, "%s: removing default router %s, scoped=%d, "
"static=%d\n", dr->ifp != NULL ? if_name(dr->ifp) : "ANY",
ip6_sprintf(&dr->rtaddr), (dr->stateflags & NDDRF_IFSCOPE) ? 1 : 0,
(dr->stateflags & NDDRF_STATIC) ? 1 : 0));
Bzero(&def, sizeof (def));
Bzero(&mask, sizeof (mask));
Bzero(&gate, sizeof (gate));
def.sin6_len = mask.sin6_len = gate.sin6_len
= sizeof (struct sockaddr_in6);
def.sin6_family = mask.sin6_family = gate.sin6_family = AF_INET6;
gate.sin6_addr = dr->rtaddr;
if (dr->ifp != NULL) {
ifscope = (dr->stateflags & NDDRF_IFSCOPE) ?
dr->ifp->if_index : IFSCOPE_NONE;
} else {
ifscope = IFSCOPE_NONE;
}
NDDR_UNLOCK(dr);
err = rtrequest_scoped(RTM_DELETE,
(struct sockaddr *)&def, (struct sockaddr *)&gate,
(struct sockaddr *)&mask, RTF_GATEWAY, &oldrt, ifscope);
if (oldrt) {
RT_LOCK(oldrt);
nd6_rtmsg(RTM_DELETE, oldrt);
RT_UNLOCK(oldrt);
rtfree(oldrt);
} else if (err != ESRCH) {
nd6log((LOG_ERR, "%s: failed to delete default router "
"%s on %s scoped %d (errno = %d)\n", __func__,
ip6_sprintf(&gate.sin6_addr), dr->ifp != NULL ?
if_name(dr->ifp) : "ANY", (ifscope != IFSCOPE_NONE), err));
}
NDDR_LOCK(dr);
if (oldrt != NULL || err == ESRCH) {
dr->stateflags &= ~NDDRF_INSTALLED;
if (ifscope != IFSCOPE_NONE)
dr->stateflags &= ~NDDRF_IFSCOPE;
}
dr->err = 0;
out:
NDDR_UNLOCK(dr);
}
void
defrouter_reset(void)
{
struct nd_defrouter *dr, drany;
lck_mtx_assert(nd6_mutex, LCK_MTX_ASSERT_OWNED);
dr = TAILQ_FIRST(&nd_defrouter);
while (dr) {
NDDR_LOCK(dr);
if (dr->stateflags & NDDRF_INSTALLED) {
NDDR_ADDREF_LOCKED(dr);
NDDR_UNLOCK(dr);
lck_mtx_unlock(nd6_mutex);
defrouter_delreq(dr);
lck_mtx_lock(nd6_mutex);
NDDR_REMREF(dr);
dr = TAILQ_FIRST(&nd_defrouter);
} else {
NDDR_UNLOCK(dr);
dr = TAILQ_NEXT(dr, dr_entry);
}
}
if (ip6_doscopedroute) {
bzero(&drany, sizeof (drany));
lck_mtx_init(&drany.nddr_lock, ifa_mtx_grp, ifa_mtx_attr);
lck_mtx_unlock(nd6_mutex);
defrouter_delreq(&drany);
lck_mtx_destroy(&drany.nddr_lock, ifa_mtx_grp);
lck_mtx_lock(nd6_mutex);
}
}
int
defrtrlist_ioctl(u_long cmd, caddr_t data)
{
struct nd_defrouter dr0;
unsigned int ifindex;
struct ifnet *dr_ifp;
int error = 0, add = 0;
switch (cmd) {
case SIOCDRADD_IN6_32:
case SIOCDRADD_IN6_64:
++add;
case SIOCDRDEL_IN6_32:
case SIOCDRDEL_IN6_64:
bzero(&dr0, sizeof (dr0));
if (cmd == SIOCDRADD_IN6_64 || cmd == SIOCDRDEL_IN6_64) {
struct in6_defrouter_64 *r_64 =
(struct in6_defrouter_64 *)(void *)data;
u_int16_t i;
bcopy(&r_64->rtaddr.sin6_addr, &dr0.rtaddr,
sizeof (dr0.rtaddr));
dr0.flags = r_64->flags;
bcopy(&r_64->if_index, &i, sizeof (i));
ifindex = i;
} else {
struct in6_defrouter_32 *r_32 =
(struct in6_defrouter_32 *)(void *)data;
u_int16_t i;
bcopy(&r_32->rtaddr.sin6_addr, &dr0.rtaddr,
sizeof (dr0.rtaddr));
dr0.flags = r_32->flags;
bcopy(&r_32->if_index, &i, sizeof (i));
ifindex = i;
}
ifnet_head_lock_shared();
if (if_index < ifindex ||
(dr_ifp = ifindex2ifnet[ifindex]) == NULL) {
ifnet_head_done();
error = EINVAL;
break;
}
dr0.ifp = dr_ifp;
ifnet_head_done();
if (IN6_IS_SCOPE_EMBED(&dr0.rtaddr)) {
uint16_t *scope = &dr0.rtaddr.s6_addr16[1];
if (*scope == 0) {
*scope = htons(dr_ifp->if_index);
} else if (*scope != htons(dr_ifp->if_index)) {
error = EINVAL;
break;
}
}
if (add)
error = defrtrlist_add_static(&dr0);
if (!add || error != 0) {
int err = defrtrlist_del_static(&dr0);
if (!add)
error = err;
}
break;
default:
error = EOPNOTSUPP;
break;
}
return (error);
}
void
defrtrlist_del(struct nd_defrouter *dr)
{
struct nd_defrouter *deldr = NULL;
struct nd_prefix *pr;
struct ifnet *ifp = dr->ifp;
boolean_t resetmtu;
lck_mtx_assert(nd6_mutex, LCK_MTX_ASSERT_OWNED);
if (!ip6_doscopedroute && dr == TAILQ_FIRST(&nd_defrouter))
deldr = dr;
TAILQ_REMOVE(&nd_defrouter, dr, dr_entry);
++nd6_defrouter_genid;
if (ip6_doscopedroute || !ip6_forwarding) {
NDDR_ADDREF(dr);
lck_mtx_unlock(nd6_mutex);
rt6_flush(&dr->rtaddr, ifp);
lck_mtx_lock(nd6_mutex);
NDDR_REMREF(dr);
}
nd6log2((LOG_INFO, "%s: freeing defrouter %s\n", if_name(dr->ifp),
ip6_sprintf(&dr->rtaddr)));
NDDR_ADDREF(dr);
lck_mtx_unlock(nd6_mutex);
defrouter_delreq(dr);
lck_mtx_lock(nd6_mutex);
NDDR_REMREF(dr);
for (pr = nd_prefix.lh_first; pr; pr = pr->ndpr_next) {
struct nd_pfxrouter *pfxrtr;
NDPR_LOCK(pr);
if ((pfxrtr = pfxrtr_lookup(pr, dr)) != NULL)
pfxrtr_del(pfxrtr, pr);
NDPR_UNLOCK(pr);
}
pfxlist_onlink_check();
if (deldr || ip6_doscopedroute)
defrouter_select(ifp);
resetmtu = FALSE;
lck_rw_lock_shared(nd_if_rwlock);
if (ifp->if_index < nd_ifinfo_indexlim) {
struct nd_ifinfo *ndi = &nd_ifinfo[ifp->if_index];
VERIFY(ndi->initialized);
lck_mtx_lock(&ndi->lock);
VERIFY(ndi->ndefrouters >= 0);
if (ndi->ndefrouters > 0 && --ndi->ndefrouters == 0) {
nd6_ifreset(ifp);
resetmtu = TRUE;
}
lck_mtx_unlock(&ndi->lock);
}
lck_rw_done(nd_if_rwlock);
if (resetmtu)
nd6_setmtu(ifp);
NDDR_REMREF(dr);
}
int
defrtrlist_add_static(struct nd_defrouter *new)
{
struct nd_defrouter *dr;
int err = 0;
new->rtlifetime = -1;
new->stateflags |= NDDRF_STATIC;
new->flags &= ND_RA_FLAG_RTPREF_MASK;
lck_mtx_lock(nd6_mutex);
dr = defrouter_lookup(&new->rtaddr, new->ifp);
if (dr != NULL && !(dr->stateflags & NDDRF_STATIC)) {
err = EINVAL;
} else {
if (dr != NULL)
NDDR_REMREF(dr);
dr = defrtrlist_update(new);
if (dr != NULL)
err = dr->err;
else
err = ENOMEM;
}
if (dr != NULL)
NDDR_REMREF(dr);
lck_mtx_unlock(nd6_mutex);
return (err);
}
int
defrtrlist_del_static(struct nd_defrouter *new)
{
struct nd_defrouter *dr;
lck_mtx_lock(nd6_mutex);
dr = defrouter_lookup(&new->rtaddr, new->ifp);
if (dr == NULL || !(dr->stateflags & NDDRF_STATIC)) {
if (dr != NULL)
NDDR_REMREF(dr);
dr = NULL;
} else {
defrtrlist_del(dr);
NDDR_REMREF(dr);
}
lck_mtx_unlock(nd6_mutex);
return (dr != NULL ? 0 : EINVAL);
}
static int
rtpref(struct nd_defrouter *dr)
{
switch (dr->flags & ND_RA_FLAG_RTPREF_MASK) {
case ND_RA_FLAG_RTPREF_HIGH:
return (RTPREF_HIGH);
case ND_RA_FLAG_RTPREF_MEDIUM:
case ND_RA_FLAG_RTPREF_RSV:
return (RTPREF_MEDIUM);
case ND_RA_FLAG_RTPREF_LOW:
return (RTPREF_LOW);
default:
log(LOG_ERR, "rtpref: impossible RA flag %x\n", dr->flags);
return (RTPREF_INVALID);
}
}
void
defrouter_select(struct ifnet *ifp)
{
#pragma unused(ifp)
struct nd_defrouter *dr, *selected_dr = NULL, *installed_dr = NULL;
struct nd_defrouter *installed_dr0 = NULL;
struct rtentry *rt = NULL;
struct llinfo_nd6 *ln = NULL;
int update = 0;
boolean_t found_installedrt = FALSE;
lck_mtx_assert(nd6_mutex, LCK_MTX_ASSERT_OWNED);
if (ip6_forwarding && !ip6_doscopedroute) {
nd6log((LOG_WARNING,
"defrouter_select: called unexpectedly (forwarding=%d)\n",
ip6_forwarding));
return;
}
if (!TAILQ_FIRST(&nd_defrouter))
return;
while (nd_defrouter_busy) {
nd_defrouter_waiters++;
msleep(nd_defrouter_waitchan, nd6_mutex, (PZERO-1),
__func__, NULL);
lck_mtx_assert(nd6_mutex, LCK_MTX_ASSERT_OWNED);
}
nd_defrouter_busy = TRUE;
for (dr = TAILQ_FIRST(&nd_defrouter); dr;
dr = TAILQ_NEXT(dr, dr_entry)) {
boolean_t reachable, advrouter;
struct in6_addr rtaddr;
struct ifnet *drifp;
struct nd_defrouter *drrele;
drrele = NULL;
reachable = FALSE;
NDDR_LOCK(dr);
rtaddr = *(&dr->rtaddr);
drifp = dr->ifp;
advrouter = (drifp != NULL &&
(drifp->if_eflags & IFEF_IPV6_ROUTER));
NDDR_ADDREF_LOCKED(dr);
NDDR_UNLOCK(dr);
lck_mtx_unlock(nd6_mutex);
if ((rt = nd6_lookup(&rtaddr, 0, drifp, 0)) != NULL) {
RT_LOCK_ASSERT_HELD(rt);
if ((ln = rt->rt_llinfo) != NULL &&
ND6_IS_LLINFO_PROBREACH(ln)) {
reachable = TRUE;
if (selected_dr == NULL &&
(!ip6_doscopedroute ||
(drifp == nd6_defifp && !advrouter))) {
selected_dr = dr;
NDDR_ADDREF(selected_dr);
}
}
RT_REMREF_LOCKED(rt);
RT_UNLOCK(rt);
rt = NULL;
}
lck_mtx_lock(nd6_mutex);
NDDR_LOCK(dr);
if (ip6_doscopedroute && drifp == nd6_defifp && !advrouter &&
(selected_dr == NULL || rtpref(dr) > rtpref(selected_dr) ||
(rtpref(dr) == rtpref(selected_dr) &&
(dr->stateflags & NDDRF_STATIC) &&
!(selected_dr->stateflags & NDDRF_STATIC)))) {
if (selected_dr) {
VERIFY(drrele == NULL);
drrele = selected_dr;
}
selected_dr = dr;
NDDR_ADDREF_LOCKED(selected_dr);
}
if (!(dr->stateflags & NDDRF_INSTALLED)) {
if (!advrouter && (reachable ||
(dr->stateflags & NDDRF_STATIC))) {
dr->genid = -1;
++update;
nd6log2((LOG_INFO, "%s: possible router %s, "
"scoped=%d, static=%d\n", if_name(drifp),
ip6_sprintf(&rtaddr),
(dr->stateflags & NDDRF_IFSCOPE) ? 1 : 0,
(dr->stateflags & NDDRF_STATIC) ? 1 : 0));
}
NDDR_UNLOCK(dr);
NDDR_REMREF(dr);
if (drrele != NULL)
NDDR_REMREF(drrele);
continue;
}
if (!ip6_doscopedroute || !(dr->stateflags & NDDRF_IFSCOPE)) {
if (installed_dr == NULL) {
installed_dr = dr;
NDDR_ADDREF_LOCKED(installed_dr);
} else {
log(LOG_ERR, "defrouter_select: more than one "
"%s default router is installed\n",
ip6_doscopedroute ? "non-scoped" : "");
}
}
NDDR_UNLOCK(dr);
NDDR_REMREF(dr);
if (drrele != NULL)
NDDR_REMREF(drrele);
}
if (ip6_doscopedroute && selected_dr == NULL && installed_dr != NULL) {
selected_dr = installed_dr;
NDDR_ADDREF(selected_dr);
}
for (dr = TAILQ_FIRST(&nd_defrouter); dr;
dr = TAILQ_NEXT(dr, dr_entry)) {
struct nd_defrouter *_dr;
if (!ip6_doscopedroute)
break;
NDDR_LOCK(dr);
if ((dr->stateflags & NDDRF_INSTALLED) || dr->genid == -1) {
NDDR_UNLOCK(dr);
continue;
}
for (_dr = TAILQ_FIRST(&nd_defrouter); _dr;
_dr = TAILQ_NEXT(_dr, dr_entry)) {
if (_dr != dr)
NDDR_LOCK(_dr);
if (_dr == dr || _dr->ifp != dr->ifp) {
if (_dr != dr)
NDDR_UNLOCK(_dr);
continue;
}
if ((_dr->stateflags & NDDRF_INSTALLED) ||
_dr->genid == -1) {
if (_dr != dr)
NDDR_UNLOCK(_dr);
break;
}
if (_dr != dr)
NDDR_UNLOCK(_dr);
}
if (_dr == NULL && dr->ifp != NULL &&
!(dr->ifp->if_eflags & IFEF_IPV6_ROUTER)) {
dr->genid = -1;
++update;
nd6log2((LOG_INFO, "%s: possible router %s, "
"static=%d (unreachable)\n", if_name(dr->ifp),
ip6_sprintf(&dr->rtaddr),
(dr->stateflags & NDDRF_STATIC) ? 1 : 0));
}
NDDR_UNLOCK(dr);
}
dr = selected_dr;
if (dr != NULL) {
nd6log2((LOG_INFO, "%s: considering primary default router %s, "
"static=%d [round 1]\n", if_name(dr->ifp),
ip6_sprintf(&dr->rtaddr),
(dr->stateflags & NDDRF_STATIC) ? 1 : 0));
}
if (!ip6_doscopedroute && selected_dr == NULL) {
if (installed_dr == NULL ||
!TAILQ_NEXT(installed_dr, dr_entry)) {
selected_dr = TAILQ_FIRST(&nd_defrouter);
if (selected_dr)
NDDR_ADDREF(selected_dr);
} else {
selected_dr = TAILQ_NEXT(installed_dr, dr_entry);
if (selected_dr)
NDDR_ADDREF(selected_dr);
}
} else if (selected_dr != NULL && installed_dr != NULL) {
lck_mtx_unlock(nd6_mutex);
rt = nd6_lookup(&installed_dr->rtaddr, 0, installed_dr->ifp, 0);
if (rt) {
RT_LOCK_ASSERT_HELD(rt);
if ((ln = (struct llinfo_nd6 *)rt->rt_llinfo) &&
ND6_IS_LLINFO_PROBREACH(ln) &&
(!ip6_doscopedroute ||
installed_dr->ifp == nd6_defifp) &&
rtpref(selected_dr) <= rtpref(installed_dr)) {
NDDR_REMREF(selected_dr);
selected_dr = installed_dr;
NDDR_ADDREF(selected_dr);
}
RT_REMREF_LOCKED(rt);
RT_UNLOCK(rt);
rt = NULL;
found_installedrt = TRUE;
}
lck_mtx_lock(nd6_mutex);
}
if (ip6_doscopedroute) {
if (installed_dr != NULL && installed_dr->ifp != nd6_defifp &&
!(installed_dr->stateflags & NDDRF_IFSCOPE)) {
if (selected_dr != NULL &&
selected_dr->ifp != nd6_defifp) {
NDDR_REMREF(selected_dr);
selected_dr = NULL;
}
++update;
}
if (selected_dr != NULL &&
(selected_dr->stateflags & NDDRF_IFSCOPE))
++update;
if (installed_dr != NULL
&& selected_dr != NULL
&& installed_dr != selected_dr
&& found_installedrt == FALSE
&& installed_dr->ifp == selected_dr->ifp) {
installed_dr0 = installed_dr;
installed_dr = NULL;
selected_dr->genid = -1;
++update;
}
}
dr = selected_dr;
VERIFY(dr != NULL || ip6_doscopedroute);
if (!ip6_doscopedroute || !update) {
if (dr == NULL)
goto out;
if (dr != installed_dr) {
nd6log2((LOG_INFO, "%s: no update, selected router %s, "
"installed router %s\n", if_name(dr->ifp),
ip6_sprintf(&dr->rtaddr), installed_dr != NULL ?
ip6_sprintf(&installed_dr->rtaddr) : "NONE"));
} else {
nd6log2((LOG_INFO, "%s: no update, router is %s\n",
if_name(dr->ifp), ip6_sprintf(&dr->rtaddr)));
}
if (!ip6_doscopedroute && installed_dr != dr) {
lck_mtx_unlock(nd6_mutex);
if (installed_dr) {
defrouter_delreq(installed_dr);
}
defrouter_addreq(dr, FALSE);
lck_mtx_lock(nd6_mutex);
}
goto out;
}
if (dr != NULL) {
nd6log2((LOG_INFO, "%s: considering primary default router %s, "
"static=%d [round 2]\n", if_name(dr->ifp),
ip6_sprintf(&dr->rtaddr),
(dr->stateflags & NDDRF_STATIC) ? 1 : 0));
}
TAILQ_FOREACH(dr, &nd_defrouter, dr_entry) {
NDDR_LOCK(dr);
VERIFY((dr->stateflags & NDDRF_PROCESSED) == 0);
NDDR_UNLOCK(dr);
}
dr = TAILQ_FIRST(&nd_defrouter);
while (dr) {
NDDR_LOCK(dr);
if (!(dr->stateflags & NDDRF_INSTALLED) ||
dr->stateflags & NDDRF_PROCESSED) {
NDDR_UNLOCK(dr);
dr = TAILQ_NEXT(dr, dr_entry);
continue;
}
dr->stateflags |= NDDRF_PROCESSED;
if ((dr == selected_dr && (dr->stateflags & NDDRF_IFSCOPE)) ||
(dr != selected_dr && !(dr->stateflags & NDDRF_IFSCOPE))) {
NDDR_ADDREF_LOCKED(dr);
NDDR_UNLOCK(dr);
lck_mtx_unlock(nd6_mutex);
defrouter_delreq(dr);
lck_mtx_lock(nd6_mutex);
NDDR_LOCK(dr);
if (dr && dr != installed_dr0)
dr->genid = -1;
NDDR_UNLOCK(dr);
NDDR_REMREF(dr);
dr = TAILQ_FIRST(&nd_defrouter);
continue;
}
NDDR_UNLOCK(dr);
dr = TAILQ_NEXT(dr, dr_entry);
}
if (++nd6_defrouter_genid == -1)
nd6_defrouter_genid = 1;
TAILQ_FOREACH(dr, &nd_defrouter, dr_entry) {
NDDR_LOCK(dr);
dr->stateflags &= ~NDDRF_PROCESSED;
NDDR_UNLOCK(dr);
}
dr = TAILQ_FIRST(&nd_defrouter);
while (dr) {
struct nd_defrouter *_dr;
NDDR_LOCK(dr);
if (dr->stateflags & NDDRF_PROCESSED ||
dr->genid != -1) {
NDDR_UNLOCK(dr);
dr = TAILQ_NEXT(dr, dr_entry);
continue;
}
dr->stateflags |= NDDRF_PROCESSED;
for (_dr = TAILQ_FIRST(&nd_defrouter); _dr;
_dr = TAILQ_NEXT(_dr, dr_entry)) {
if (_dr == dr)
continue;
NDDR_LOCK(_dr);
if (_dr->ifp == dr->ifp && rtpref(_dr) >= rtpref(dr) &&
(_dr->stateflags & NDDRF_INSTALLED)) {
NDDR_ADDREF_LOCKED(_dr);
NDDR_UNLOCK(_dr);
break;
}
NDDR_UNLOCK(_dr);
}
if (_dr != NULL && rtpref(_dr) == rtpref(dr) &&
!(_dr->stateflags & NDDRF_STATIC) &&
(dr->stateflags & NDDRF_STATIC)) {
lck_mtx_unlock(nd6_mutex);
defrouter_delreq(_dr);
lck_mtx_lock(nd6_mutex);
NDDR_REMREF(_dr);
_dr = NULL;
}
if (_dr == NULL && !(dr->stateflags & NDDRF_INSTALLED)) {
NDDR_ADDREF_LOCKED(dr);
NDDR_UNLOCK(dr);
lck_mtx_unlock(nd6_mutex);
defrouter_addreq(dr, (selected_dr == NULL ||
dr->ifp != selected_dr->ifp));
dr->genid = nd6_defrouter_genid;
lck_mtx_lock(nd6_mutex);
NDDR_REMREF(dr);
dr = TAILQ_FIRST(&nd_defrouter);
continue;
}
NDDR_UNLOCK(dr);
dr = TAILQ_NEXT(dr, dr_entry);
}
out:
TAILQ_FOREACH(dr, &nd_defrouter, dr_entry) {
NDDR_LOCK(dr);
dr->stateflags &= ~NDDRF_PROCESSED;
NDDR_UNLOCK(dr);
}
if (selected_dr)
NDDR_REMREF(selected_dr);
if (installed_dr)
NDDR_REMREF(installed_dr);
if (installed_dr0)
NDDR_REMREF(installed_dr0);
lck_mtx_assert(nd6_mutex, LCK_MTX_ASSERT_OWNED);
VERIFY(nd_defrouter_busy);
nd_defrouter_busy = FALSE;
if (nd_defrouter_waiters > 0) {
nd_defrouter_waiters = 0;
wakeup(nd_defrouter_waitchan);
}
}
static struct nd_defrouter *
defrtrlist_update_common(struct nd_defrouter *new, boolean_t scoped)
{
struct nd_defrouter *dr, *n;
struct ifnet *ifp = new->ifp;
struct nd_ifinfo *ndi = NULL;
struct timeval caltime;
lck_mtx_assert(nd6_mutex, LCK_MTX_ASSERT_OWNED);
if ((dr = defrouter_lookup(&new->rtaddr, ifp)) != NULL) {
if (new->rtlifetime == 0) {
defrtrlist_del(dr);
NDDR_REMREF(dr);
dr = NULL;
} else {
int oldpref = rtpref(dr);
dr->flags = new->flags;
dr->rtlifetime = new->rtlifetime;
dr->expire = new->expire;
if (ip6_doscopedroute) {
struct nd_defrouter *p = NULL;
if (rtpref(new) == oldpref && scoped)
return (dr);
n = TAILQ_FIRST(&nd_defrouter);
while (n != NULL) {
if (rtpref(new) != oldpref)
break;
if (n != dr && rtpref(n) == oldpref &&
(!p || rtpref(p) > rtpref(n)))
break;
p = n;
n = TAILQ_NEXT(n, dr_entry);
}
if (n == NULL && (scoped ||
!(dr->stateflags & NDDRF_IFSCOPE)))
return (dr);
} else if (rtpref(new) == oldpref) {
return (dr);
}
TAILQ_REMOVE(&nd_defrouter, dr, dr_entry);
new->stateflags = dr->stateflags;
new->stateflags &= ~NDDRF_PROCESSED;
n = dr;
goto insert;
}
return (dr);
}
VERIFY(dr == NULL);
if (new->rtlifetime == 0) {
return (NULL);
}
n = nddr_alloc(M_WAITOK);
if (n == NULL) {
return (NULL);
}
lck_rw_lock_shared(nd_if_rwlock);
if (ifp->if_index >= nd_ifinfo_indexlim)
goto freeit;
ndi = &nd_ifinfo[ifp->if_index];
VERIFY(ndi->initialized);
lck_mtx_lock(&ndi->lock);
if (ip6_maxifdefrouters >= 0 &&
ndi->ndefrouters >= ip6_maxifdefrouters) {
lck_mtx_unlock(&ndi->lock);
freeit:
lck_rw_done(nd_if_rwlock);
nddr_free(n);
return (NULL);
}
NDDR_ADDREF(n);
NDDR_ADDREF(n);
++nd6_defrouter_genid;
ndi->ndefrouters++;
VERIFY(ndi->ndefrouters != 0);
lck_mtx_unlock(&ndi->lock);
lck_rw_done(nd_if_rwlock);
nd6log2((LOG_INFO, "%s: allocating defrouter %s\n", if_name(ifp),
ip6_sprintf(&new->rtaddr)));
getmicrotime(&caltime);
NDDR_LOCK(n);
memcpy(&n->rtaddr, &new->rtaddr, sizeof (n->rtaddr));
n->flags = new->flags;
n->stateflags = new->stateflags;
n->stateflags &= ~NDDRF_PROCESSED;
n->rtlifetime = new->rtlifetime;
n->expire = new->expire;
n->base_calendartime = caltime.tv_sec;
n->base_uptime = net_uptime();
n->ifp = new->ifp;
n->genid = new->genid;
n->err = new->err;
NDDR_UNLOCK(n);
insert:
++nd6_sched_timeout_want;
for (dr = TAILQ_FIRST(&nd_defrouter); dr;
dr = TAILQ_NEXT(dr, dr_entry)) {
if (rtpref(n) > rtpref(dr) ||
(ip6_doscopedroute && !scoped && rtpref(n) == rtpref(dr)))
break;
}
if (dr)
TAILQ_INSERT_BEFORE(dr, n, dr_entry);
else
TAILQ_INSERT_TAIL(&nd_defrouter, n, dr_entry);
defrouter_select(ifp);
return (n);
}
static struct nd_defrouter *
defrtrlist_update(struct nd_defrouter *new)
{
struct nd_defrouter *dr;
lck_mtx_assert(nd6_mutex, LCK_MTX_ASSERT_OWNED);
dr = defrtrlist_update_common(new,
(nd6_defifp != NULL && new->ifp != nd6_defifp));
return (dr);
}
static void
defrtrlist_sync(struct ifnet *ifp)
{
struct nd_defrouter *dr, new;
lck_mtx_assert(nd6_mutex, LCK_MTX_ASSERT_OWNED);
if (!ip6_doscopedroute) {
defrouter_select(ifp);
return;
}
for (dr = TAILQ_FIRST(&nd_defrouter); dr;
dr = TAILQ_NEXT(dr, dr_entry)) {
NDDR_LOCK(dr);
if (dr->ifp == ifp && (dr->stateflags & NDDRF_INSTALLED))
break;
NDDR_UNLOCK(dr);
}
if (dr == NULL) {
defrouter_select(ifp);
} else {
memcpy(&new.rtaddr, &dr->rtaddr, sizeof (new.rtaddr));
new.flags = dr->flags;
new.stateflags = dr->stateflags;
new.stateflags &= ~NDDRF_PROCESSED;
new.rtlifetime = dr->rtlifetime;
new.expire = dr->expire;
new.ifp = dr->ifp;
new.genid = dr->genid;
new.err = dr->err;
NDDR_UNLOCK(dr);
dr = defrtrlist_update_common(&new, FALSE);
if (dr)
NDDR_REMREF(dr);
}
}
static struct nd_pfxrouter *
pfxrtr_lookup(struct nd_prefix *pr, struct nd_defrouter *dr)
{
struct nd_pfxrouter *search;
lck_mtx_assert(nd6_mutex, LCK_MTX_ASSERT_OWNED);
NDPR_LOCK_ASSERT_HELD(pr);
for (search = pr->ndpr_advrtrs.lh_first; search;
search = search->pfr_next) {
if (search->router == dr)
break;
}
return (search);
}
static void
pfxrtr_add(struct nd_prefix *pr, struct nd_defrouter *dr)
{
struct nd_pfxrouter *new;
lck_mtx_assert(nd6_mutex, LCK_MTX_ASSERT_OWNED);
NDPR_LOCK_ASSERT_NOTHELD(pr);
new = zalloc(ndprtr_zone);
if (new == NULL)
return;
bzero(new, sizeof (*new));
new->router = dr;
NDPR_LOCK(pr);
LIST_INSERT_HEAD(&pr->ndpr_advrtrs, new, pfr_entry);
pr->ndpr_genid++;
NDPR_UNLOCK(pr);
pfxlist_onlink_check();
}
static void
pfxrtr_del(struct nd_pfxrouter *pfr, struct nd_prefix *pr)
{
lck_mtx_assert(nd6_mutex, LCK_MTX_ASSERT_OWNED);
NDPR_LOCK_ASSERT_HELD(pr);
pr->ndpr_genid++;
LIST_REMOVE(pfr, pfr_entry);
zfree(ndprtr_zone, pfr);
}
struct nd_prefix *
nd6_prefix_lookup(struct nd_prefix *pr)
{
struct nd_prefix *search;
lck_mtx_lock(nd6_mutex);
for (search = nd_prefix.lh_first; search; search = search->ndpr_next) {
NDPR_LOCK(search);
if (pr->ndpr_ifp == search->ndpr_ifp &&
pr->ndpr_plen == search->ndpr_plen &&
in6_are_prefix_equal(&pr->ndpr_prefix.sin6_addr,
&search->ndpr_prefix.sin6_addr, pr->ndpr_plen)) {
NDPR_ADDREF_LOCKED(search);
NDPR_UNLOCK(search);
break;
}
NDPR_UNLOCK(search);
}
lck_mtx_unlock(nd6_mutex);
return (search);
}
static void
purge_detached(struct ifnet *ifp)
{
struct nd_prefix *pr, *pr_next;
struct in6_ifaddr *ia;
struct ifaddr *ifa, *ifa_next;
boolean_t removed = FALSE;
lck_mtx_lock(nd6_mutex);
pr = nd_prefix.lh_first;
repeat:
while (pr) {
NDPR_LOCK(pr);
pr_next = pr->ndpr_next;
if (pr->ndpr_ifp != ifp ||
IN6_IS_ADDR_LINKLOCAL(&pr->ndpr_prefix.sin6_addr) ||
((pr->ndpr_stateflags & NDPRF_DETACHED) == 0 &&
!LIST_EMPTY(&pr->ndpr_advrtrs))) {
NDPR_UNLOCK(pr);
pr = pr_next;
continue;
}
NDPR_ADDREF_LOCKED(pr);
NDPR_UNLOCK(pr);
ifnet_lock_shared(ifp);
for (ifa = ifp->if_addrlist.tqh_first; ifa; ifa = ifa_next) {
IFA_LOCK(ifa);
ifa_next = ifa->ifa_list.tqe_next;
if (ifa->ifa_addr->sa_family != AF_INET6) {
IFA_UNLOCK(ifa);
continue;
}
ia = (struct in6_ifaddr *)ifa;
if ((ia->ia6_flags & IN6_IFF_AUTOCONF) ==
IN6_IFF_AUTOCONF && ia->ia6_ndpr == pr) {
IFA_ADDREF_LOCKED(ifa);
IFA_UNLOCK(ifa);
ifnet_lock_done(ifp);
lck_mtx_unlock(nd6_mutex);
in6_purgeaddr(ifa);
IFA_REMREF(ifa);
lck_mtx_lock(nd6_mutex);
NDPR_REMREF(pr);
pr = nd_prefix.lh_first;
goto repeat;
}
IFA_UNLOCK(ifa);
}
ifnet_lock_done(ifp);
NDPR_LOCK(pr);
if (pr->ndpr_addrcnt == 0 &&
!(pr->ndpr_stateflags & NDPRF_DEFUNCT)) {
prelist_remove(pr);
NDPR_UNLOCK(pr);
removed = TRUE;
pr_next = nd_prefix.lh_first;
} else {
NDPR_UNLOCK(pr);
}
NDPR_REMREF(pr);
pr = pr_next;
}
if (removed)
pfxlist_onlink_check();
lck_mtx_unlock(nd6_mutex);
}
int
nd6_prelist_add(struct nd_prefix *pr, struct nd_defrouter *dr,
struct nd_prefix **newp, boolean_t force_scoped)
{
struct nd_prefix *new = NULL;
struct ifnet *ifp = pr->ndpr_ifp;
struct nd_ifinfo *ndi = NULL;
int i, error;
if (ip6_maxifprefixes >= 0) {
lck_rw_lock_shared(nd_if_rwlock);
if (ifp->if_index >= nd_ifinfo_indexlim) {
lck_rw_done(nd_if_rwlock);
return (EINVAL);
}
ndi = &nd_ifinfo[ifp->if_index];
VERIFY(ndi->initialized);
lck_mtx_lock(&ndi->lock);
if (ndi->nprefixes >= ip6_maxifprefixes / 2) {
lck_mtx_unlock(&ndi->lock);
lck_rw_done(nd_if_rwlock);
purge_detached(ifp);
lck_rw_lock_shared(nd_if_rwlock);
ndi = &nd_ifinfo[ifp->if_index];
lck_mtx_lock(&ndi->lock);
}
if (ndi->nprefixes >= ip6_maxifprefixes) {
lck_mtx_unlock(&ndi->lock);
lck_rw_done(nd_if_rwlock);
return (ENOMEM);
}
lck_mtx_unlock(&ndi->lock);
lck_rw_done(nd_if_rwlock);
}
new = ndpr_alloc(M_WAITOK);
if (new == NULL)
return (ENOMEM);
NDPR_LOCK(new);
NDPR_LOCK(pr);
new->ndpr_ifp = pr->ndpr_ifp;
new->ndpr_prefix = pr->ndpr_prefix;
new->ndpr_plen = pr->ndpr_plen;
new->ndpr_vltime = pr->ndpr_vltime;
new->ndpr_pltime = pr->ndpr_pltime;
new->ndpr_flags = pr->ndpr_flags;
if (pr->ndpr_stateflags & NDPRF_STATIC)
new->ndpr_stateflags |= NDPRF_STATIC;
NDPR_UNLOCK(pr);
if ((error = in6_init_prefix_ltimes(new)) != 0) {
NDPR_UNLOCK(new);
ndpr_free(new);
return (error);
}
new->ndpr_lastupdate = net_uptime();
if (newp != NULL) {
*newp = new;
NDPR_ADDREF_LOCKED(new);
}
LIST_INIT(&new->ndpr_advrtrs);
in6_prefixlen2mask(&new->ndpr_mask, new->ndpr_plen);
for (i = 0; i < 4; i++)
new->ndpr_prefix.sin6_addr.s6_addr32[i] &=
new->ndpr_mask.s6_addr32[i];
NDPR_UNLOCK(new);
++nd6_sched_timeout_want;
lck_mtx_lock(nd6_mutex);
LIST_INSERT_HEAD(&nd_prefix, new, ndpr_entry);
new->ndpr_debug |= IFD_ATTACHED;
NDPR_ADDREF(new);
if (new->ndpr_raf_onlink) {
int e;
if ((e = nd6_prefix_onlink_common(new, force_scoped,
new->ndpr_ifp->if_index)) != 0) {
nd6log((LOG_ERR, "nd6_prelist_add: failed to make "
"the prefix %s/%d on-link %s on %s (errno=%d)\n",
ip6_sprintf(&new->ndpr_prefix.sin6_addr),
new->ndpr_plen, force_scoped ? "scoped" :
"non-scoped", if_name(ifp), e));
}
}
if (dr) {
pfxrtr_add(new, dr);
}
lck_rw_lock_shared(nd_if_rwlock);
ndi = &nd_ifinfo[ifp->if_index];
VERIFY(ndi->initialized);
lck_mtx_lock(&ndi->lock);
ndi->nprefixes++;
VERIFY(ndi->nprefixes != 0);
lck_mtx_unlock(&ndi->lock);
lck_rw_done(nd_if_rwlock);
lck_mtx_unlock(nd6_mutex);
return (0);
}
void
prelist_remove(struct nd_prefix *pr)
{
struct nd_pfxrouter *pfr, *next;
struct ifnet *ifp = pr->ndpr_ifp;
int e;
lck_mtx_assert(nd6_mutex, LCK_MTX_ASSERT_OWNED);
NDPR_LOCK_ASSERT_HELD(pr);
if (pr->ndpr_stateflags & NDPRF_DEFUNCT)
return;
if (pr->ndpr_addrcnt == 0)
pr->ndpr_stateflags |= NDPRF_DEFUNCT;
pr->ndpr_vltime = 0;
pr->ndpr_pltime = 0;
if (pr->ndpr_stateflags & NDPRF_ONLINK) {
NDPR_ADDREF_LOCKED(pr);
NDPR_UNLOCK(pr);
lck_mtx_unlock(nd6_mutex);
if ((e = nd6_prefix_offlink(pr)) != 0) {
nd6log((LOG_ERR, "prelist_remove: failed to make "
"%s/%d offlink on %s, errno=%d\n",
ip6_sprintf(&pr->ndpr_prefix.sin6_addr),
pr->ndpr_plen, if_name(ifp), e));
}
lck_mtx_lock(nd6_mutex);
NDPR_LOCK(pr);
if (NDPR_REMREF_LOCKED(pr) == NULL)
return;
}
if (pr->ndpr_addrcnt > 0) {
pr->ndpr_stateflags &= ~NDPRF_DEFUNCT;
return;
}
LIST_REMOVE(pr, ndpr_entry);
pr->ndpr_debug &= ~IFD_ATTACHED;
for (pfr = pr->ndpr_advrtrs.lh_first; pfr; pfr = next) {
next = pfr->pfr_next;
pfxrtr_del(pfr, pr);
}
lck_rw_lock_shared(nd_if_rwlock);
if (ifp->if_index < nd_ifinfo_indexlim) {
struct nd_ifinfo *ndi = &nd_ifinfo[ifp->if_index];
VERIFY(ndi->initialized);
lck_mtx_lock(&ndi->lock);
VERIFY(ndi->nprefixes > 0);
ndi->nprefixes--;
lck_mtx_unlock(&ndi->lock);
}
lck_rw_done(nd_if_rwlock);
if (NDPR_REMREF_LOCKED(pr) == NULL) {
panic("%s: unexpected (missing) refcnt ndpr=%p", __func__, pr);
}
}
int
prelist_update(
struct nd_prefix *new,
struct nd_defrouter *dr,
struct mbuf *m,
int mcast)
{
struct in6_ifaddr *ia6 = NULL, *ia6_match = NULL;
struct ifaddr *ifa;
struct ifnet *ifp = new->ndpr_ifp;
struct nd_prefix *pr;
int error = 0;
int newprefix = 0;
int auth;
struct in6_addrlifetime lt6_tmp;
uint64_t timenow = net_uptime();
NDPR_LOCK_ASSERT_NOTHELD(new);
auth = 0;
if (m) {
#if defined(M_AUTHIPHDR) && defined(M_AUTHIPDGM)
auth = (m->m_flags & M_AUTHIPHDR) && (m->m_flags & M_AUTHIPDGM);
#endif
}
if ((pr = nd6_prefix_lookup(new)) != NULL) {
lck_mtx_lock(nd6_mutex);
NDPR_LOCK(pr);
if (new->ndpr_raf_onlink == 1)
pr->ndpr_raf_onlink = 1;
if (new->ndpr_raf_auto == 1)
pr->ndpr_raf_auto = 1;
if (new->ndpr_raf_onlink) {
pr->ndpr_vltime = new->ndpr_vltime;
pr->ndpr_pltime = new->ndpr_pltime;
(void) in6_init_prefix_ltimes(pr);
pr->ndpr_lastupdate = net_uptime();
}
NDPR_ADDREF_LOCKED(pr);
if (new->ndpr_raf_onlink &&
(pr->ndpr_stateflags & NDPRF_ONLINK) == 0) {
int e;
NDPR_UNLOCK(pr);
if ((e = nd6_prefix_onlink(pr)) != 0) {
nd6log((LOG_ERR,
"prelist_update: failed to make "
"the prefix %s/%d on-link on %s "
"(errno=%d)\n",
ip6_sprintf(&pr->ndpr_prefix.sin6_addr),
pr->ndpr_plen, if_name(pr->ndpr_ifp), e));
}
NDPR_LOCK(pr);
}
if (dr && pfxrtr_lookup(pr, dr) == NULL) {
NDPR_UNLOCK(pr);
pfxrtr_add(pr, dr);
} else {
NDPR_UNLOCK(pr);
}
NDPR_REMREF(pr);
lck_mtx_unlock(nd6_mutex);
} else {
struct nd_prefix *newpr = NULL;
newprefix = 1;
if (new->ndpr_vltime == 0)
goto end;
if (new->ndpr_raf_onlink == 0 && new->ndpr_raf_auto == 0)
goto end;
bzero(&new->ndpr_addr, sizeof (struct in6_addr));
error = nd6_prelist_add(new, dr, &newpr, FALSE);
if (error != 0 || newpr == NULL) {
nd6log((LOG_NOTICE, "prelist_update: "
"nd6_prelist_add failed for %s/%d on %s "
"errno=%d, returnpr=0x%llx\n",
ip6_sprintf(&new->ndpr_prefix.sin6_addr),
new->ndpr_plen, if_name(new->ndpr_ifp),
error, (uint64_t)VM_KERNEL_ADDRPERM(newpr)));
goto end;
}
NDPR_LOCK(newpr);
if (newpr->ndpr_raf_onlink == 0) {
newpr->ndpr_vltime = 0;
newpr->ndpr_pltime = 0;
in6_init_prefix_ltimes(newpr);
}
pr = newpr;
NDPR_UNLOCK(newpr);
}
if (!new->ndpr_raf_auto)
goto afteraddrconf;
if (new->ndpr_pltime > new->ndpr_vltime) {
error = EINVAL;
goto end;
}
ifnet_lock_shared(ifp);
TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list) {
struct in6_ifaddr *ifa6;
u_int32_t remaininglifetime;
IFA_LOCK(ifa);
if (ifa->ifa_addr->sa_family != AF_INET6) {
IFA_UNLOCK(ifa);
continue;
}
ifa6 = (struct in6_ifaddr *)ifa;
if (!(ifa6->ia6_flags & IN6_IFF_AUTOCONF)) {
IFA_UNLOCK(ifa);
continue;
}
if ((ifa6->ia6_flags & IN6_IFF_ANYCAST) != 0) {
IFA_UNLOCK(ifa);
continue;
}
if (ifa6->ia6_ndpr != pr) {
IFA_UNLOCK(ifa);
continue;
}
if (ia6_match == NULL) {
ia6_match = ifa6;
IFA_ADDREF_LOCKED(ifa);
}
#define TWOHOUR (120*60)
in6ifa_getlifetime(ifa6, <6_tmp, 0);
if (lt6_tmp.ia6t_vltime == ND6_INFINITE_LIFETIME)
remaininglifetime = ND6_INFINITE_LIFETIME;
else if (timenow - ifa6->ia6_updatetime > lt6_tmp.ia6t_vltime) {
remaininglifetime = 0;
} else {
remaininglifetime = lt6_tmp.ia6t_vltime -
(timenow - ifa6->ia6_updatetime);
}
lt6_tmp.ia6t_vltime = remaininglifetime;
if (TWOHOUR < new->ndpr_vltime ||
remaininglifetime < new->ndpr_vltime) {
lt6_tmp.ia6t_vltime = new->ndpr_vltime;
} else if (remaininglifetime <= TWOHOUR) {
if (auth) {
lt6_tmp.ia6t_vltime = new->ndpr_vltime;
}
} else {
lt6_tmp.ia6t_vltime = TWOHOUR;
}
lt6_tmp.ia6t_pltime = new->ndpr_pltime;
if ((ifa6->ia6_flags & IN6_IFF_TEMPORARY) != 0) {
u_int32_t maxvltime, maxpltime;
if (lt6_tmp.ia6t_vltime > ip6_temp_valid_lifetime)
lt6_tmp.ia6t_vltime = ip6_temp_valid_lifetime;
if (lt6_tmp.ia6t_pltime > ip6_temp_preferred_lifetime)
lt6_tmp.ia6t_pltime =
ip6_temp_preferred_lifetime -
ip6_desync_factor;
if (ip6_temp_valid_lifetime >
(u_int32_t)((timenow - ifa6->ia6_createtime) +
ip6_desync_factor)) {
maxvltime = ip6_temp_valid_lifetime -
(timenow - ifa6->ia6_createtime) -
ip6_desync_factor;
} else
maxvltime = 0;
if (ip6_temp_preferred_lifetime >
(u_int32_t)((timenow - ifa6->ia6_createtime) +
ip6_desync_factor)) {
maxpltime = ip6_temp_preferred_lifetime -
(timenow - ifa6->ia6_createtime) -
ip6_desync_factor;
} else
maxpltime = 0;
if (lt6_tmp.ia6t_vltime == ND6_INFINITE_LIFETIME ||
lt6_tmp.ia6t_vltime > maxvltime)
lt6_tmp.ia6t_vltime = maxvltime;
if (lt6_tmp.ia6t_pltime == ND6_INFINITE_LIFETIME ||
lt6_tmp.ia6t_pltime > maxpltime)
lt6_tmp.ia6t_pltime = maxpltime;
}
in6_init_address_ltimes(pr, <6_tmp);
in6ifa_setlifetime(ifa6, <6_tmp);
ifa6->ia6_updatetime = timenow;
IFA_UNLOCK(ifa);
}
ifnet_lock_done(ifp);
if (ia6_match == NULL && new->ndpr_vltime) {
if ((ia6 = in6_pfx_newpersistaddr(new, mcast, &error))
!= NULL) {
IFA_LOCK(&ia6->ia_ifa);
NDPR_LOCK(pr);
ia6->ia6_ndpr = pr;
NDPR_ADDREF_LOCKED(pr);
pr->ndpr_addrcnt++;
VERIFY(pr->ndpr_addrcnt != 0);
NDPR_UNLOCK(pr);
IFA_UNLOCK(&ia6->ia_ifa);
if (ip6_use_tempaddr) {
int e;
if ((e = in6_tmpifadd(ia6, 1)) != 0) {
nd6log((LOG_NOTICE, "prelist_update: "
"failed to create a temporary "
"address, errno=%d\n",
e));
}
}
IFA_REMREF(&ia6->ia_ifa);
ia6 = NULL;
lck_mtx_lock(nd6_mutex);
pfxlist_onlink_check();
lck_mtx_unlock(nd6_mutex);
}
}
afteraddrconf:
end:
if (pr != NULL)
NDPR_REMREF(pr);
if (ia6_match != NULL)
IFA_REMREF(&ia6_match->ia_ifa);
return (error);
}
static struct nd_defrouter *
nddr_alloc(int how)
{
struct nd_defrouter *dr;
dr = (how == M_WAITOK) ? zalloc(nddr_zone) : zalloc_noblock(nddr_zone);
if (dr != NULL) {
bzero(dr, nddr_size);
lck_mtx_init(&dr->nddr_lock, ifa_mtx_grp, ifa_mtx_attr);
dr->nddr_debug |= IFD_ALLOC;
if (nddr_debug != 0) {
dr->nddr_debug |= IFD_DEBUG;
dr->nddr_trace = nddr_trace;
}
}
return (dr);
}
static void
nddr_free(struct nd_defrouter *dr)
{
NDDR_LOCK(dr);
if (dr->nddr_debug & IFD_ATTACHED) {
panic("%s: attached nddr %p is being freed", __func__, dr);
} else if (!(dr->nddr_debug & IFD_ALLOC)) {
panic("%s: nddr %p cannot be freed", __func__, dr);
}
dr->nddr_debug &= ~IFD_ALLOC;
NDDR_UNLOCK(dr);
lck_mtx_destroy(&dr->nddr_lock, ifa_mtx_grp);
zfree(nddr_zone, dr);
}
static void
nddr_trace(struct nd_defrouter *dr, int refhold)
{
struct nd_defrouter_dbg *dr_dbg = (struct nd_defrouter_dbg *)dr;
ctrace_t *tr;
uint32_t idx;
uint16_t *cnt;
if (!(dr->nddr_debug & IFD_DEBUG)) {
panic("%s: nddr %p has no debug structure", __func__, dr);
}
if (refhold) {
cnt = &dr_dbg->nddr_refhold_cnt;
tr = dr_dbg->nddr_refhold;
} else {
cnt = &dr_dbg->nddr_refrele_cnt;
tr = dr_dbg->nddr_refrele;
}
idx = atomic_add_16_ov(cnt, 1) % NDDR_TRACE_HIST_SIZE;
ctrace_record(&tr[idx]);
}
void
nddr_addref(struct nd_defrouter *nddr, int locked)
{
if (!locked)
NDDR_LOCK_SPIN(nddr);
else
NDDR_LOCK_ASSERT_HELD(nddr);
if (++nddr->nddr_refcount == 0) {
panic("%s: nddr %p wraparound refcnt\n", __func__, nddr);
} else if (nddr->nddr_trace != NULL) {
(*nddr->nddr_trace)(nddr, TRUE);
}
if (!locked)
NDDR_UNLOCK(nddr);
}
struct nd_defrouter *
nddr_remref(struct nd_defrouter *nddr, int locked)
{
if (!locked)
NDDR_LOCK_SPIN(nddr);
else
NDDR_LOCK_ASSERT_HELD(nddr);
if (nddr->nddr_refcount == 0) {
panic("%s: nddr %p negative refcnt\n", __func__, nddr);
} else if (nddr->nddr_trace != NULL) {
(*nddr->nddr_trace)(nddr, FALSE);
}
if (--nddr->nddr_refcount == 0) {
NDDR_UNLOCK(nddr);
nddr_free(nddr);
nddr = NULL;
}
if (!locked && nddr != NULL)
NDDR_UNLOCK(nddr);
return (nddr);
}
uint64_t
nddr_getexpire(struct nd_defrouter *dr)
{
struct timeval caltime;
uint64_t expiry;
if (dr->expire != 0) {
getmicrotime(&caltime);
dr->base_calendartime +=
NET_CALCULATE_CLOCKSKEW(caltime,
dr->base_calendartime, net_uptime(), dr->base_uptime);
expiry = dr->base_calendartime +
dr->expire - dr->base_uptime;
} else {
expiry = 0;
}
return (expiry);
}
static struct nd_prefix *
ndpr_alloc(int how)
{
struct nd_prefix *pr;
pr = (how == M_WAITOK) ? zalloc(ndpr_zone) : zalloc_noblock(ndpr_zone);
if (pr != NULL) {
bzero(pr, ndpr_size);
lck_mtx_init(&pr->ndpr_lock, ifa_mtx_grp, ifa_mtx_attr);
RB_INIT(&pr->ndpr_prproxy_sols);
pr->ndpr_debug |= IFD_ALLOC;
if (ndpr_debug != 0) {
pr->ndpr_debug |= IFD_DEBUG;
pr->ndpr_trace = ndpr_trace;
}
}
return (pr);
}
static void
ndpr_free(struct nd_prefix *pr)
{
NDPR_LOCK(pr);
if (pr->ndpr_debug & IFD_ATTACHED) {
panic("%s: attached ndpr %p is being freed", __func__, pr);
} else if (!(pr->ndpr_debug & IFD_ALLOC)) {
panic("%s: ndpr %p cannot be freed", __func__, pr);
} else if (pr->ndpr_rt != NULL) {
panic("%s: ndpr %p route %p not freed", __func__, pr,
pr->ndpr_rt);
} else if (pr->ndpr_prproxy_sols_cnt != 0) {
panic("%s: ndpr %p non-zero solicitors count (%d)",
__func__, pr, pr->ndpr_prproxy_sols_cnt);
} else if (!RB_EMPTY(&pr->ndpr_prproxy_sols)) {
panic("%s: ndpr %p non-empty solicitors tree", __func__, pr);
}
pr->ndpr_debug &= ~IFD_ALLOC;
NDPR_UNLOCK(pr);
lck_mtx_destroy(&pr->ndpr_lock, ifa_mtx_grp);
zfree(ndpr_zone, pr);
}
static void
ndpr_trace(struct nd_prefix *pr, int refhold)
{
struct nd_prefix_dbg *pr_dbg = (struct nd_prefix_dbg *)pr;
ctrace_t *tr;
u_int32_t idx;
u_int16_t *cnt;
if (!(pr->ndpr_debug & IFD_DEBUG)) {
panic("%s: ndpr %p has no debug structure", __func__, pr);
}
if (refhold) {
cnt = &pr_dbg->ndpr_refhold_cnt;
tr = pr_dbg->ndpr_refhold;
} else {
cnt = &pr_dbg->ndpr_refrele_cnt;
tr = pr_dbg->ndpr_refrele;
}
idx = atomic_add_16_ov(cnt, 1) % NDPR_TRACE_HIST_SIZE;
ctrace_record(&tr[idx]);
}
void
ndpr_addref(struct nd_prefix *ndpr, int locked)
{
if (!locked)
NDPR_LOCK_SPIN(ndpr);
else
NDPR_LOCK_ASSERT_HELD(ndpr);
if (++ndpr->ndpr_refcount == 0) {
panic("%s: ndpr %p wraparound refcnt\n", __func__, ndpr);
} else if (ndpr->ndpr_trace != NULL) {
(*ndpr->ndpr_trace)(ndpr, TRUE);
}
if (!locked)
NDPR_UNLOCK(ndpr);
}
struct nd_prefix *
ndpr_remref(struct nd_prefix *ndpr, int locked)
{
if (!locked)
NDPR_LOCK_SPIN(ndpr);
else
NDPR_LOCK_ASSERT_HELD(ndpr);
if (ndpr->ndpr_refcount == 0) {
panic("%s: ndpr %p negative refcnt\n", __func__, ndpr);
} else if (ndpr->ndpr_trace != NULL) {
(*ndpr->ndpr_trace)(ndpr, FALSE);
}
if (--ndpr->ndpr_refcount == 0) {
if (ndpr->ndpr_addrcnt != 0) {
panic("%s: freeing ndpr %p with outstanding address "
"reference (%d)", __func__, ndpr,
ndpr->ndpr_addrcnt);
}
NDPR_UNLOCK(ndpr);
ndpr_free(ndpr);
ndpr = NULL;
}
if (!locked && ndpr != NULL)
NDPR_UNLOCK(ndpr);
return (ndpr);
}
uint64_t
ndpr_getexpire(struct nd_prefix *pr)
{
struct timeval caltime;
uint64_t expiry;
if (pr->ndpr_expire != 0 && pr->ndpr_vltime != ND6_INFINITE_LIFETIME) {
getmicrotime(&caltime);
pr->ndpr_base_calendartime +=
NET_CALCULATE_CLOCKSKEW(caltime,
pr->ndpr_base_calendartime, net_uptime(),
pr->ndpr_base_uptime);
expiry = pr->ndpr_base_calendartime +
pr->ndpr_expire - pr->ndpr_base_uptime;
} else {
expiry = 0;
}
return (expiry);
}
static struct nd_pfxrouter *
find_pfxlist_reachable_router(struct nd_prefix *pr)
{
struct nd_pfxrouter *pfxrtr;
struct rtentry *rt;
struct llinfo_nd6 *ln;
struct ifnet *ifp;
struct in6_addr rtaddr;
unsigned int genid;
lck_mtx_assert(nd6_mutex, LCK_MTX_ASSERT_OWNED);
NDPR_LOCK_ASSERT_HELD(pr);
genid = pr->ndpr_genid;
pfxrtr = LIST_FIRST(&pr->ndpr_advrtrs);
while (pfxrtr) {
ifp = pfxrtr->router->ifp;
rtaddr = pfxrtr->router->rtaddr;
NDPR_UNLOCK(pr);
lck_mtx_unlock(nd6_mutex);
if ((rt = nd6_lookup(&rtaddr, 0, ifp, 0)) != NULL) {
RT_LOCK_ASSERT_HELD(rt);
if ((ln = rt->rt_llinfo) != NULL &&
ND6_IS_LLINFO_PROBREACH(ln)) {
RT_REMREF_LOCKED(rt);
RT_UNLOCK(rt);
lck_mtx_lock(nd6_mutex);
NDPR_LOCK(pr);
break;
}
RT_REMREF_LOCKED(rt);
RT_UNLOCK(rt);
}
lck_mtx_lock(nd6_mutex);
NDPR_LOCK(pr);
if (pr->ndpr_genid != genid) {
pfxrtr = LIST_FIRST(&pr->ndpr_advrtrs);
genid = pr->ndpr_genid;
} else
pfxrtr = LIST_NEXT(pfxrtr, pfr_entry);
}
NDPR_LOCK_ASSERT_HELD(pr);
return (pfxrtr);
}
void
pfxlist_onlink_check(void)
{
struct nd_prefix *pr, *prclear;
struct in6_ifaddr *ifa;
struct nd_defrouter *dr;
struct nd_pfxrouter *pfxrtr = NULL;
int err, i, found = 0;
struct ifaddr **ifap = NULL;
struct nd_prefix *ndpr;
lck_mtx_assert(nd6_mutex, LCK_MTX_ASSERT_OWNED);
while (nd_prefix_busy) {
nd_prefix_waiters++;
msleep(nd_prefix_waitchan, nd6_mutex, (PZERO-1),
__func__, NULL);
lck_mtx_assert(nd6_mutex, LCK_MTX_ASSERT_OWNED);
}
nd_prefix_busy = TRUE;
pr = nd_prefix.lh_first;
while (pr) {
NDPR_LOCK(pr);
if (pr->ndpr_stateflags & NDPRF_PROCESSED_ONLINK) {
NDPR_UNLOCK(pr);
pr = pr->ndpr_next;
continue;
}
NDPR_ADDREF_LOCKED(pr);
if (pr->ndpr_raf_onlink && find_pfxlist_reachable_router(pr) &&
(pr->ndpr_debug & IFD_ATTACHED)) {
if (NDPR_REMREF_LOCKED(pr) == NULL)
pr = NULL;
else
NDPR_UNLOCK(pr);
break;
}
pr->ndpr_stateflags |= NDPRF_PROCESSED_ONLINK;
NDPR_UNLOCK(pr);
NDPR_REMREF(pr);
pr = nd_prefix.lh_first;
}
LIST_FOREACH(prclear, &nd_prefix, ndpr_entry) {
NDPR_LOCK(prclear);
prclear->ndpr_stateflags &= ~NDPRF_PROCESSED_ONLINK;
NDPR_UNLOCK(prclear);
}
if (pr == NULL) {
for (dr = TAILQ_FIRST(&nd_defrouter); dr;
dr = TAILQ_NEXT(dr, dr_entry)) {
struct nd_prefix *pr0;
for (pr0 = nd_prefix.lh_first; pr0;
pr0 = pr0->ndpr_next) {
NDPR_LOCK(pr0);
if ((pfxrtr = pfxrtr_lookup(pr0, dr)) != NULL) {
NDPR_UNLOCK(pr0);
break;
}
NDPR_UNLOCK(pr0);
}
if (pfxrtr != NULL)
break;
}
}
if (pr != NULL || (TAILQ_FIRST(&nd_defrouter) && pfxrtr == NULL)) {
pr = nd_prefix.lh_first;
while (pr) {
NDPR_LOCK(pr);
if (pr->ndpr_raf_onlink == 0 ||
pr->ndpr_stateflags & NDPRF_PROCESSED_ONLINK ||
pr->ndpr_stateflags & NDPRF_STATIC) {
NDPR_UNLOCK(pr);
pr = pr->ndpr_next;
continue;
}
NDPR_ADDREF_LOCKED(pr);
if ((pr->ndpr_stateflags & NDPRF_DETACHED) == 0 &&
find_pfxlist_reachable_router(pr) == NULL &&
(pr->ndpr_debug & IFD_ATTACHED))
pr->ndpr_stateflags |= NDPRF_DETACHED;
if ((pr->ndpr_stateflags & NDPRF_DETACHED) != 0 &&
find_pfxlist_reachable_router(pr) != NULL &&
(pr->ndpr_debug & IFD_ATTACHED))
pr->ndpr_stateflags &= ~NDPRF_DETACHED;
pr->ndpr_stateflags |= NDPRF_PROCESSED_ONLINK;
NDPR_UNLOCK(pr);
NDPR_REMREF(pr);
pr = nd_prefix.lh_first;
}
} else {
for (pr = nd_prefix.lh_first; pr; pr = pr->ndpr_next) {
NDPR_LOCK(pr);
if (pr->ndpr_raf_onlink == 0 ||
pr->ndpr_stateflags & NDPRF_STATIC) {
NDPR_UNLOCK(pr);
continue;
}
if ((pr->ndpr_stateflags & NDPRF_DETACHED) != 0)
pr->ndpr_stateflags &= ~NDPRF_DETACHED;
NDPR_UNLOCK(pr);
}
}
LIST_FOREACH(prclear, &nd_prefix, ndpr_entry) {
NDPR_LOCK(prclear);
prclear->ndpr_stateflags &= ~NDPRF_PROCESSED_ONLINK;
NDPR_UNLOCK(prclear);
}
pr = nd_prefix.lh_first;
while (pr) {
int e;
NDPR_LOCK(pr);
if (pr->ndpr_raf_onlink == 0 ||
pr->ndpr_stateflags & NDPRF_STATIC ||
pr->ndpr_stateflags & NDPRF_PROCESSED_ONLINK ||
pr->ndpr_stateflags & NDPRF_DEFUNCT) {
NDPR_UNLOCK(pr);
pr = pr->ndpr_next;
continue;
}
pr->ndpr_stateflags |= NDPRF_PROCESSED_ONLINK;
NDPR_ADDREF_LOCKED(pr);
if ((pr->ndpr_stateflags & NDPRF_DETACHED) != 0 &&
(pr->ndpr_stateflags & NDPRF_ONLINK) != 0) {
NDPR_UNLOCK(pr);
lck_mtx_unlock(nd6_mutex);
if ((e = nd6_prefix_offlink(pr)) != 0) {
nd6log((LOG_ERR,
"pfxlist_onlink_check: failed to "
"make %s/%d offlink, errno=%d\n",
ip6_sprintf(&pr->ndpr_prefix.sin6_addr),
pr->ndpr_plen, e));
}
lck_mtx_lock(nd6_mutex);
NDPR_REMREF(pr);
pr = nd_prefix.lh_first;
continue;
}
if ((pr->ndpr_stateflags & NDPRF_DETACHED) == 0 &&
(pr->ndpr_stateflags & NDPRF_ONLINK) == 0 &&
pr->ndpr_raf_onlink) {
NDPR_UNLOCK(pr);
if ((e = nd6_prefix_onlink(pr)) != 0) {
nd6log((LOG_ERR,
"pfxlist_onlink_check: failed to "
"make %s/%d offlink, errno=%d\n",
ip6_sprintf(&pr->ndpr_prefix.sin6_addr),
pr->ndpr_plen, e));
}
NDPR_REMREF(pr);
pr = nd_prefix.lh_first;
continue;
} else {
NDPR_UNLOCK(pr);
}
NDPR_REMREF(pr);
pr = pr->ndpr_next;
}
LIST_FOREACH(prclear, &nd_prefix, ndpr_entry) {
NDPR_LOCK(prclear);
prclear->ndpr_stateflags &= ~NDPRF_PROCESSED_ONLINK;
NDPR_UNLOCK(prclear);
}
VERIFY(nd_prefix_busy);
nd_prefix_busy = FALSE;
if (nd_prefix_waiters > 0) {
nd_prefix_waiters = 0;
wakeup(nd_prefix_waitchan);
}
err = ifnet_get_address_list_family_internal(NULL, &ifap, AF_INET6, 0,
M_NOWAIT, 0);
if (err != 0 || ifap == NULL) {
nd6log((LOG_ERR, "%s: ifnet_get_address_list_family_internal "
"failed", __func__));
return;
}
for (i = 0; ifap[i]; i++) {
ifa = ifatoia6(ifap[i]);
IFA_LOCK(&ifa->ia_ifa);
if ((ifa->ia6_flags & IN6_IFF_AUTOCONF) == 0 ||
(ifap[i]->ifa_debug & IFD_ATTACHED) == 0) {
IFA_UNLOCK(&ifa->ia_ifa);
continue;
}
if ((ndpr = ifa->ia6_ndpr) == NULL) {
IFA_UNLOCK(&ifa->ia_ifa);
continue;
}
IFA_UNLOCK(&ifa->ia_ifa);
NDPR_LOCK(ndpr);
NDPR_ADDREF_LOCKED(ndpr);
if (find_pfxlist_reachable_router(ndpr)) {
if (NDPR_REMREF_LOCKED(ndpr) == NULL) {
found = 0;
} else {
NDPR_UNLOCK(ndpr);
found = 1;
}
break;
}
NDPR_UNLOCK(ndpr);
NDPR_REMREF(ndpr);
}
if (found) {
for (i = 0; ifap[i]; i++) {
ifa = ifatoia6(ifap[i]);
IFA_LOCK(&ifa->ia_ifa);
if ((ifa->ia6_flags & IN6_IFF_AUTOCONF) == 0 ||
(ifap[i]->ifa_debug & IFD_ATTACHED) == 0) {
IFA_UNLOCK(&ifa->ia_ifa);
continue;
}
if ((ndpr = ifa->ia6_ndpr) == NULL) {
IFA_UNLOCK(&ifa->ia_ifa);
continue;
}
IFA_UNLOCK(&ifa->ia_ifa);
NDPR_LOCK(ndpr);
NDPR_ADDREF_LOCKED(ndpr);
if (find_pfxlist_reachable_router(ndpr)) {
NDPR_UNLOCK(ndpr);
IFA_LOCK(&ifa->ia_ifa);
if (ifa->ia6_flags & IN6_IFF_DETACHED) {
ifa->ia6_flags &= ~IN6_IFF_DETACHED;
ifa->ia6_flags |= IN6_IFF_TENTATIVE;
IFA_UNLOCK(&ifa->ia_ifa);
nd6_dad_start((struct ifaddr *)ifa, 0);
} else {
IFA_UNLOCK(&ifa->ia_ifa);
}
} else {
NDPR_UNLOCK(ndpr);
IFA_LOCK(&ifa->ia_ifa);
ifa->ia6_flags |= IN6_IFF_DETACHED;
IFA_UNLOCK(&ifa->ia_ifa);
}
NDPR_REMREF(ndpr);
}
} else {
for (i = 0; ifap[i]; i++) {
ifa = ifatoia6(ifap[i]);
IFA_LOCK(&ifa->ia_ifa);
if ((ifa->ia6_flags & IN6_IFF_AUTOCONF) == 0) {
IFA_UNLOCK(&ifa->ia_ifa);
continue;
}
if (ifa->ia6_flags & IN6_IFF_DETACHED) {
ifa->ia6_flags &= ~IN6_IFF_DETACHED;
ifa->ia6_flags |= IN6_IFF_TENTATIVE;
IFA_UNLOCK(&ifa->ia_ifa);
nd6_dad_start((struct ifaddr *)ifa, 0);
} else {
IFA_UNLOCK(&ifa->ia_ifa);
}
}
}
ifnet_free_address_list(ifap);
}
static struct nd_prefix *
nd6_prefix_equal_lookup(struct nd_prefix *pr, boolean_t primary_only)
{
struct nd_prefix *opr;
lck_mtx_assert(nd6_mutex, LCK_MTX_ASSERT_OWNED);
for (opr = nd_prefix.lh_first; opr; opr = opr->ndpr_next) {
if (opr == pr)
continue;
NDPR_LOCK(opr);
if ((opr->ndpr_stateflags & NDPRF_ONLINK) == 0) {
NDPR_UNLOCK(opr);
continue;
}
if (opr->ndpr_plen == pr->ndpr_plen &&
in6_are_prefix_equal(&pr->ndpr_prefix.sin6_addr,
&opr->ndpr_prefix.sin6_addr, pr->ndpr_plen) &&
(!primary_only ||
!(opr->ndpr_stateflags & NDPRF_IFSCOPE))) {
NDPR_ADDREF_LOCKED(opr);
NDPR_UNLOCK(opr);
return (opr);
}
NDPR_UNLOCK(opr);
}
return (NULL);
}
static void
nd6_prefix_sync(struct ifnet *ifp)
{
struct nd_prefix *pr, *opr;
int err = 0;
lck_mtx_assert(nd6_mutex, LCK_MTX_ASSERT_OWNED);
if (!ip6_doscopedroute || ifp == NULL)
return;
for (pr = nd_prefix.lh_first; pr; pr = pr->ndpr_next) {
NDPR_LOCK(pr);
if (!(pr->ndpr_stateflags & NDPRF_ONLINK)) {
NDPR_UNLOCK(pr);
continue;
}
if (pr->ndpr_ifp == ifp &&
(pr->ndpr_stateflags & NDPRF_IFSCOPE) &&
!IN6_IS_ADDR_LINKLOCAL(&pr->ndpr_prefix.sin6_addr)) {
NDPR_UNLOCK(pr);
break;
}
NDPR_UNLOCK(pr);
}
if (pr == NULL)
return;
opr = nd6_prefix_equal_lookup(pr, TRUE);
if (opr != NULL) {
lck_mtx_unlock(nd6_mutex);
err = nd6_prefix_offlink(opr);
lck_mtx_lock(nd6_mutex);
if (err != 0) {
nd6log((LOG_ERR,
"%s: failed to make %s/%d offlink on %s, "
"errno=%d\n", __func__,
ip6_sprintf(&opr->ndpr_prefix.sin6_addr),
opr->ndpr_plen, if_name(opr->ndpr_ifp), err));
}
} else {
nd6log((LOG_ERR,
"%s: scoped %s/%d on %s has no matching unscoped prefix\n",
__func__, ip6_sprintf(&pr->ndpr_prefix.sin6_addr),
pr->ndpr_plen, if_name(pr->ndpr_ifp)));
}
lck_mtx_unlock(nd6_mutex);
err = nd6_prefix_offlink(pr);
lck_mtx_lock(nd6_mutex);
if (err != 0) {
nd6log((LOG_ERR,
"%s: failed to make %s/%d offlink on %s, errno=%d\n",
__func__, ip6_sprintf(&pr->ndpr_prefix.sin6_addr),
pr->ndpr_plen, if_name(pr->ndpr_ifp), err));
}
if (opr != NULL) {
err = nd6_prefix_onlink_scoped(opr, opr->ndpr_ifp->if_index);
if (err != 0) {
nd6log((LOG_ERR,
"%s: failed to make %s/%d scoped onlink on %s, "
"errno=%d\n", __func__,
ip6_sprintf(&opr->ndpr_prefix.sin6_addr),
opr->ndpr_plen, if_name(opr->ndpr_ifp), err));
}
}
err = nd6_prefix_onlink_scoped(pr, IFSCOPE_NONE);
if (err != 0) {
nd6log((LOG_ERR,
"%s: failed to make %s/%d onlink on %s, errno=%d\n",
__func__, ip6_sprintf(&pr->ndpr_prefix.sin6_addr),
pr->ndpr_plen, if_name(pr->ndpr_ifp), err));
}
if (err != 0) {
nd6log((LOG_ERR,
"%s: error promoting %s/%d to %s from %s\n",
__func__, ip6_sprintf(&pr->ndpr_prefix.sin6_addr),
pr->ndpr_plen, if_name(pr->ndpr_ifp),
(opr != NULL) ? if_name(opr->ndpr_ifp) : "NONE"));
} else {
nd6log2((LOG_INFO,
"%s: %s/%d promoted, previously on %s\n",
if_name(pr->ndpr_ifp),
ip6_sprintf(&pr->ndpr_prefix.sin6_addr), pr->ndpr_plen,
(opr != NULL) ? if_name(opr->ndpr_ifp) : "NONE"));
}
if (opr != NULL)
NDPR_REMREF(opr);
}
static int
nd6_prefix_onlink_common(struct nd_prefix *pr, boolean_t force_scoped,
unsigned int ifscope)
{
struct ifaddr *ifa;
struct ifnet *ifp = pr->ndpr_ifp;
struct sockaddr_in6 mask6, prefix;
struct nd_prefix *opr;
u_int32_t rtflags;
int error = 0, prproxy = 0;
struct rtentry *rt = NULL;
lck_mtx_assert(nd6_mutex, LCK_MTX_ASSERT_OWNED);
NDPR_LOCK(pr);
if ((pr->ndpr_stateflags & NDPRF_ONLINK) != 0) {
nd6log((LOG_ERR,
"%s: %s/%d on %s scoped=%d is already on-link\n",
__func__, ip6_sprintf(&pr->ndpr_prefix.sin6_addr),
pr->ndpr_plen, if_name(pr->ndpr_ifp),
(pr->ndpr_stateflags & NDPRF_IFSCOPE) ? 1 : 0);
NDPR_UNLOCK(pr);
return (EEXIST));
}
NDPR_UNLOCK(pr);
opr = nd6_prefix_equal_lookup(pr, FALSE);
if (opr != NULL)
NDPR_REMREF(opr);
if (!ip6_doscopedroute) {
if (opr != NULL)
return (0);
ifscope = IFSCOPE_NONE;
} else if (!force_scoped) {
ifscope = (opr != NULL) ? ifp->if_index : IFSCOPE_NONE;
opr = nd6_prefix_equal_lookup(pr, TRUE);
if (opr != NULL)
NDPR_REMREF(opr);
else if (ifscope != IFSCOPE_NONE)
ifscope = IFSCOPE_NONE;
}
ifa = (struct ifaddr *)in6ifa_ifpforlinklocal(ifp,
IN6_IFF_NOTREADY | IN6_IFF_ANYCAST);
if (ifa == NULL) {
struct in6_ifaddr *ia6;
ifnet_lock_shared(ifp);
IFP_TO_IA6(ifp, ia6);
ifnet_lock_done(ifp);
if (ia6 != NULL)
ifa = &ia6->ia_ifa;
}
NDPR_LOCK(pr);
if (ifa == NULL) {
nd6log((LOG_NOTICE,
"nd6_prefix_onlink: failed to find any ifaddr"
" to add route for a prefix(%s/%d) on %s\n",
ip6_sprintf(&pr->ndpr_prefix.sin6_addr),
pr->ndpr_plen, if_name(ifp)));
NDPR_UNLOCK(pr);
return (0);
}
bzero(&mask6, sizeof (mask6));
mask6.sin6_len = sizeof (mask6);
mask6.sin6_addr = pr->ndpr_mask;
prefix = pr->ndpr_prefix;
if ((rt = pr->ndpr_rt) != NULL)
pr->ndpr_rt = NULL;
NDPR_ADDREF_LOCKED(pr);
NDPR_UNLOCK(pr);
IFA_LOCK_SPIN(ifa);
rtflags = ifa->ifa_flags | RTF_CLONING | RTF_UP;
IFA_UNLOCK(ifa);
if (nd6_need_cache(ifp)) {
rtflags |= RTF_CLONING;
} else {
rtflags &= ~RTF_CLONING;
}
lck_mtx_unlock(nd6_mutex);
if (rt != NULL) {
rtfree(rt);
rt = NULL;
}
error = rtrequest_scoped(RTM_ADD, (struct sockaddr *)&prefix,
ifa->ifa_addr, (struct sockaddr *)&mask6, rtflags, &rt,
ifscope);
lck_mtx_lock(&proxy6_lock);
if (rt != NULL) {
RT_LOCK(rt);
nd6_rtmsg(RTM_ADD, rt);
RT_UNLOCK(rt);
NDPR_LOCK(pr);
} else {
NDPR_LOCK(pr);
nd6log((LOG_ERR, "nd6_prefix_onlink: failed to add route for a"
" prefix (%s/%d) on %s, gw=%s, mask=%s, flags=%lx,"
" scoped=%d, errno = %d\n",
ip6_sprintf(&pr->ndpr_prefix.sin6_addr),
pr->ndpr_plen, if_name(ifp),
ip6_sprintf(&((struct sockaddr_in6 *)
(void *)ifa->ifa_addr)->sin6_addr),
ip6_sprintf(&mask6.sin6_addr), rtflags,
(ifscope != IFSCOPE_NONE), error));
}
NDPR_LOCK_ASSERT_HELD(pr);
pr->ndpr_stateflags &= ~(NDPRF_IFSCOPE | NDPRF_PRPROXY);
if (!(pr->ndpr_stateflags & NDPRF_DEFUNCT) &&
(rt != NULL || error == EEXIST)) {
struct nd_ifinfo *ndi;
VERIFY(pr->ndpr_prproxy_sols_cnt == 0);
VERIFY(RB_EMPTY(&pr->ndpr_prproxy_sols));
lck_rw_lock_shared(nd_if_rwlock);
ndi = ND_IFINFO(ifp);
VERIFY(ndi != NULL && ndi->initialized);
lck_mtx_lock(&ndi->lock);
pr->ndpr_rt = rt;
pr->ndpr_stateflags |= NDPRF_ONLINK;
if (ifscope != IFSCOPE_NONE) {
pr->ndpr_stateflags |= NDPRF_IFSCOPE;
} else if ((rtflags & RTF_CLONING) &&
(ndi->flags & ND6_IFF_PROXY_PREFIXES) &&
!IN6_IS_ADDR_LINKLOCAL(&pr->ndpr_prefix.sin6_addr)) {
pr->ndpr_stateflags |= NDPRF_PRPROXY;
}
lck_mtx_unlock(&ndi->lock);
lck_rw_done(nd_if_rwlock);
} else if (rt != NULL && pr->ndpr_stateflags & NDPRF_DEFUNCT)
rtfree(rt);
prproxy = (pr->ndpr_stateflags & NDPRF_PRPROXY);
VERIFY(!prproxy || !(pr->ndpr_stateflags & NDPRF_IFSCOPE));
NDPR_UNLOCK(pr);
IFA_REMREF(ifa);
nd6_prproxy_prelist_update(pr, prproxy ? pr : NULL);
NDPR_REMREF(pr);
lck_mtx_unlock(&proxy6_lock);
lck_mtx_lock(nd6_mutex);
return (error);
}
int
nd6_prefix_onlink(struct nd_prefix *pr)
{
return (nd6_prefix_onlink_common(pr, FALSE, IFSCOPE_NONE));
}
int
nd6_prefix_onlink_scoped(struct nd_prefix *pr, unsigned int ifscope)
{
return (nd6_prefix_onlink_common(pr, TRUE, ifscope));
}
int
nd6_prefix_offlink(struct nd_prefix *pr)
{
int plen, error = 0, prproxy;
struct ifnet *ifp = pr->ndpr_ifp;
struct nd_prefix *opr;
struct sockaddr_in6 sa6, mask6, prefix;
struct rtentry *rt = NULL, *ndpr_rt = NULL;
unsigned int ifscope;
lck_mtx_assert(nd6_mutex, LCK_MTX_ASSERT_NOTOWNED);
NDPR_LOCK(pr);
if ((pr->ndpr_stateflags & NDPRF_ONLINK) == 0) {
nd6log((LOG_ERR,
"nd6_prefix_offlink: %s/%d on %s scoped=%d is already "
"off-link\n", ip6_sprintf(&pr->ndpr_prefix.sin6_addr),
pr->ndpr_plen, if_name(pr->ndpr_ifp),
(pr->ndpr_stateflags & NDPRF_IFSCOPE) ? 1 : 0));
NDPR_UNLOCK(pr);
return (EEXIST);
}
bzero(&sa6, sizeof (sa6));
sa6.sin6_family = AF_INET6;
sa6.sin6_len = sizeof (sa6);
bcopy(&pr->ndpr_prefix.sin6_addr, &sa6.sin6_addr,
sizeof (struct in6_addr));
bzero(&mask6, sizeof (mask6));
mask6.sin6_family = AF_INET6;
mask6.sin6_len = sizeof (sa6);
bcopy(&pr->ndpr_mask, &mask6.sin6_addr, sizeof (struct in6_addr));
prefix = pr->ndpr_prefix;
plen = pr->ndpr_plen;
if ((ndpr_rt = pr->ndpr_rt) != NULL)
pr->ndpr_rt = NULL;
NDPR_ADDREF_LOCKED(pr);
NDPR_UNLOCK(pr);
ifscope = (pr->ndpr_stateflags & NDPRF_IFSCOPE) ?
ifp->if_index : IFSCOPE_NONE;
error = rtrequest_scoped(RTM_DELETE, (struct sockaddr *)&sa6,
NULL, (struct sockaddr *)&mask6, 0, &rt, ifscope);
if (rt != NULL) {
RT_LOCK(rt);
nd6_rtmsg(RTM_DELETE, rt);
RT_UNLOCK(rt);
rtfree(rt);
lck_mtx_lock(nd6_mutex);
opr = nd_prefix.lh_first;
while (opr) {
if (ip6_doscopedroute)
break;
if (opr == pr) {
opr = opr->ndpr_next;
continue;
}
NDPR_LOCK(opr);
if ((opr->ndpr_stateflags & NDPRF_ONLINK) != 0) {
NDPR_UNLOCK(opr);
opr = opr->ndpr_next;
continue;
}
if ((opr->ndpr_stateflags & NDPRF_DETACHED) != 0) {
NDPR_UNLOCK(opr);
opr = opr->ndpr_next;
continue;
}
if (opr->ndpr_plen == plen &&
in6_are_prefix_equal(&prefix.sin6_addr,
&opr->ndpr_prefix.sin6_addr, plen)) {
int e;
NDPR_ADDREF_LOCKED(opr);
NDPR_UNLOCK(opr);
if ((e = nd6_prefix_onlink(opr)) != 0) {
nd6log((LOG_ERR,
"nd6_prefix_offlink: failed to "
"recover a prefix %s/%d from %s "
"to %s (errno = %d)\n",
ip6_sprintf(
&opr->ndpr_prefix.sin6_addr),
opr->ndpr_plen, if_name(ifp),
if_name(opr->ndpr_ifp), e));
}
NDPR_REMREF(opr);
opr = nd_prefix.lh_first;
} else {
NDPR_UNLOCK(opr);
opr = opr->ndpr_next;
}
}
lck_mtx_unlock(nd6_mutex);
} else {
nd6log((LOG_ERR,
"nd6_prefix_offlink: failed to delete route: "
"%s/%d on %s, scoped %d, (errno = %d)\n",
ip6_sprintf(&sa6.sin6_addr), plen, if_name(ifp),
(ifscope != IFSCOPE_NONE), error));
}
if (ndpr_rt != NULL)
rtfree(ndpr_rt);
lck_mtx_lock(&proxy6_lock);
NDPR_LOCK(pr);
prproxy = (pr->ndpr_stateflags & NDPRF_PRPROXY);
VERIFY(!prproxy || !(pr->ndpr_stateflags & NDPRF_IFSCOPE));
pr->ndpr_stateflags &= ~(NDPRF_ONLINK | NDPRF_IFSCOPE | NDPRF_PRPROXY);
if (pr->ndpr_prproxy_sols_cnt > 0) {
VERIFY(prproxy);
nd6_prproxy_sols_reap(pr);
VERIFY(pr->ndpr_prproxy_sols_cnt == 0);
VERIFY(RB_EMPTY(&pr->ndpr_prproxy_sols));
}
NDPR_UNLOCK(pr);
nd6_prproxy_prelist_update(pr, prproxy ? pr : NULL);
NDPR_REMREF(pr);
lck_mtx_unlock(&proxy6_lock);
return (error);
}
static struct in6_ifaddr *
in6_pfx_newpersistaddr(struct nd_prefix *pr, int mcast, int *errorp)
{
struct in6_ifaddr *ia6;
struct ifnet *ifp;
struct nd_ifinfo *ndi;
struct in6_addr mask;
struct in6_aliasreq ifra;
int error, ifaupdate, iidlen, notcga;
VERIFY(pr != NULL);
VERIFY(errorp != NULL);
NDPR_LOCK(pr);
ifp = pr->ndpr_ifp;
ia6 = NULL;
error = 0;
iidlen = in6_if2idlen(ifp);
if (iidlen < 0) {
error = EADDRNOTAVAIL;
log(LOG_ERR, "%s: IID length undefined (%s)\n",
__func__, if_name(ifp));
goto unlock1;
} else if (iidlen != 64) {
error = EADDRNOTAVAIL;
nd6log((LOG_INFO, "%s: IID length not 64 octets (%s)\n",
__func__, if_name(ifp)));
goto unlock1;
}
if (iidlen + pr->ndpr_plen != 128) {
error = EADDRNOTAVAIL;
nd6log((LOG_INFO,
"%s: invalid prefix length %d for %s, ignored\n",
__func__, pr->ndpr_plen, if_name(ifp)));
goto unlock1;
}
lck_rw_lock_shared(nd_if_rwlock);
if (ifp->if_index >= nd_ifinfo_indexlim) {
error = EADDRNOTAVAIL;
nd6log((LOG_INFO,
"%s: invalid prefix length %d for %s, ignored\n",
__func__, pr->ndpr_plen, if_name(ifp)));
goto unlock2;
}
bzero(&ifra, sizeof (ifra));
strlcpy(ifra.ifra_name, if_name(ifp), sizeof (ifra.ifra_name));
ifra.ifra_addr.sin6_family = AF_INET6;
ifra.ifra_addr.sin6_len = sizeof (struct sockaddr_in6);
bcopy(&pr->ndpr_prefix.sin6_addr, &ifra.ifra_addr.sin6_addr,
sizeof (ifra.ifra_addr.sin6_addr));
in6_len2mask(&mask, pr->ndpr_plen);
ifra.ifra_addr.sin6_addr.s6_addr32[0] &= mask.s6_addr32[0];
ifra.ifra_addr.sin6_addr.s6_addr32[1] &= mask.s6_addr32[1];
ifra.ifra_addr.sin6_addr.s6_addr32[2] &= mask.s6_addr32[2];
ifra.ifra_addr.sin6_addr.s6_addr32[3] &= mask.s6_addr32[3];
ndi = &nd_ifinfo[ifp->if_index];
VERIFY(ndi->initialized);
lck_mtx_lock(&ndi->lock);
notcga = nd6_send_opstate == ND6_SEND_OPMODE_DISABLED ||
(ndi->flags & ND6_IFF_INSECURE) != 0;
lck_mtx_unlock(&ndi->lock);
lck_rw_done(nd_if_rwlock);
NDPR_UNLOCK(pr);
if (notcga) {
ia6 = in6ifa_ifpforlinklocal(ifp, 0);
if (ia6 == NULL) {
error = EADDRNOTAVAIL;
nd6log((LOG_INFO, "%s: no link-local address (%s)\n",
__func__, if_name(ifp)));
goto done;
}
IFA_LOCK(&ia6->ia_ifa);
ifra.ifra_addr.sin6_addr.s6_addr32[0] |=
(ia6->ia_addr.sin6_addr.s6_addr32[0] & ~mask.s6_addr32[0]);
ifra.ifra_addr.sin6_addr.s6_addr32[1] |=
(ia6->ia_addr.sin6_addr.s6_addr32[1] & ~mask.s6_addr32[1]);
ifra.ifra_addr.sin6_addr.s6_addr32[2] |=
(ia6->ia_addr.sin6_addr.s6_addr32[2] & ~mask.s6_addr32[2]);
ifra.ifra_addr.sin6_addr.s6_addr32[3] |=
(ia6->ia_addr.sin6_addr.s6_addr32[3] & ~mask.s6_addr32[3]);
IFA_UNLOCK(&ia6->ia_ifa);
IFA_REMREF(&ia6->ia_ifa);
ia6 = NULL;
} else {
in6_cga_node_lock();
error = in6_cga_generate(NULL, 0, &ifra.ifra_addr.sin6_addr);
in6_cga_node_unlock();
if (error == 0)
ifra.ifra_flags |= IN6_IFF_SECURED;
else {
nd6log((LOG_ERR, "%s: no CGA available (%s)\n",
__func__, if_name(ifp)));
goto done;
}
}
VERIFY(ia6 == NULL);
ifra.ifra_prefixmask.sin6_len = sizeof (struct sockaddr_in6);
ifra.ifra_prefixmask.sin6_family = AF_INET6;
bcopy(&mask, &ifra.ifra_prefixmask.sin6_addr,
sizeof (ifra.ifra_prefixmask.sin6_addr));
ifra.ifra_lifetime.ia6t_vltime = pr->ndpr_vltime;
ifra.ifra_lifetime.ia6t_pltime = pr->ndpr_pltime;
ifra.ifra_flags |= IN6_IFF_AUTOCONF;
if ((ia6 = in6ifa_ifpwithaddr(ifp, &ifra.ifra_addr.sin6_addr))
!= NULL) {
error = EADDRNOTAVAIL;
IFA_REMREF(&ia6->ia_ifa);
ia6 = NULL;
log(LOG_INFO, "%s: %s is already configured!\n",
__func__, ip6_sprintf(&ifra.ifra_addr.sin6_addr));
goto done;
}
ifaupdate = IN6_IFAUPDATE_NOWAIT;
if (mcast)
ifaupdate |= IN6_IFAUPDATE_DADDELAY;
error = in6_update_ifa(ifp, &ifra, ifaupdate, &ia6);
if (error != 0) {
nd6log((LOG_ERR,
"%s: failed to make ifaddr %s on %s (errno=%d)\n",
__func__, ip6_sprintf(&ifra.ifra_addr.sin6_addr),
if_name(ifp), error));
error = EADDRNOTAVAIL;
goto done;
}
VERIFY(ia6 != NULL);
in6_post_msg(ifp, KEV_INET6_NEW_RTADV_ADDR, ia6, NULL);
goto done;
unlock2:
lck_rw_done(nd_if_rwlock);
unlock1:
NDPR_UNLOCK(pr);
done:
*errorp = error;
return (ia6);
}
#define IA6_NONCONST(i) ((struct in6_ifaddr *)(uintptr_t)(i))
int
in6_tmpifadd(const struct in6_ifaddr *ia0, int forcegen)
{
struct ifnet *ifp = ia0->ia_ifa.ifa_ifp;
struct in6_ifaddr *ia, *newia;
struct in6_aliasreq ifra;
int i, error, ifaupdate;
int trylimit = 3;
u_int32_t randid[2];
time_t vltime0, pltime0;
uint64_t timenow = net_uptime();
struct in6_addr addr;
struct nd_prefix *ndpr;
bzero(&ifra, sizeof (ifra));
strlcpy(ifra.ifra_name, if_name(ifp), sizeof (ifra.ifra_name));
IFA_LOCK(&IA6_NONCONST(ia0)->ia_ifa);
ifra.ifra_addr = ia0->ia_addr;
ifra.ifra_prefixmask = ia0->ia_prefixmask;
for (i = 0; i < 4; i++) {
ifra.ifra_addr.sin6_addr.s6_addr32[i]
&= ifra.ifra_prefixmask.sin6_addr.s6_addr32[i];
}
addr = ia0->ia_addr.sin6_addr;
IFA_UNLOCK(&IA6_NONCONST(ia0)->ia_ifa);
again:
in6_iid_mktmp(ifp, (u_int8_t *)randid,
(const u_int8_t *)&addr.s6_addr[8], forcegen);
ifra.ifra_addr.sin6_addr.s6_addr32[2] |=
(randid[0] & ~(ifra.ifra_prefixmask.sin6_addr.s6_addr32[2]));
ifra.ifra_addr.sin6_addr.s6_addr32[3] |=
(randid[1] & ~(ifra.ifra_prefixmask.sin6_addr.s6_addr32[3]));
if ((ia = in6ifa_ifpwithaddr(ifp, &ifra.ifra_addr.sin6_addr)) != NULL) {
IFA_REMREF(&ia->ia_ifa);
if (trylimit-- == 0) {
nd6log((LOG_NOTICE, "in6_tmpifadd: failed to find "
"a unique random IFID\n"));
return (EEXIST);
}
forcegen = 1;
goto again;
}
IFA_LOCK(&IA6_NONCONST(ia0)->ia_ifa);
if (ia0->ia6_lifetime.ia6ti_vltime != ND6_INFINITE_LIFETIME) {
vltime0 = IFA6_IS_INVALID(ia0, timenow) ? 0 :
(ia0->ia6_lifetime.ia6ti_vltime -
(timenow - ia0->ia6_updatetime));
if (vltime0 > ip6_temp_valid_lifetime)
vltime0 = ip6_temp_valid_lifetime;
} else {
vltime0 = ip6_temp_valid_lifetime;
}
if (ia0->ia6_lifetime.ia6ti_pltime != ND6_INFINITE_LIFETIME) {
pltime0 = IFA6_IS_DEPRECATED(ia0, timenow) ? 0 :
(ia0->ia6_lifetime.ia6ti_pltime -
(timenow - ia0->ia6_updatetime));
if (pltime0 > ip6_temp_preferred_lifetime - ip6_desync_factor)
pltime0 = ip6_temp_preferred_lifetime -
ip6_desync_factor;
} else {
pltime0 = ip6_temp_preferred_lifetime - ip6_desync_factor;
}
ifra.ifra_lifetime.ia6t_vltime = vltime0;
ifra.ifra_lifetime.ia6t_pltime = pltime0;
IFA_UNLOCK(&IA6_NONCONST(ia0)->ia_ifa);
if (ifra.ifra_lifetime.ia6t_pltime <= ip6_temp_regen_advance)
return (0);
ifra.ifra_flags |= (IN6_IFF_AUTOCONF|IN6_IFF_TEMPORARY);
ifaupdate = IN6_IFAUPDATE_NOWAIT | IN6_IFAUPDATE_DADDELAY;
error = in6_update_ifa(ifp, &ifra, ifaupdate, &newia);
if (error != 0) {
nd6log((LOG_ERR, "in6_tmpifadd: failed to add address.\n"));
return (error);
}
VERIFY(newia != NULL);
IFA_LOCK(&IA6_NONCONST(ia0)->ia_ifa);
ndpr = ia0->ia6_ndpr;
if (ndpr == NULL) {
nd6log((LOG_ERR, "in6_tmpifadd: no public address\n"));
VERIFY(!(ia0->ia6_flags & IN6_IFF_AUTOCONF));
IFA_UNLOCK(&IA6_NONCONST(ia0)->ia_ifa);
in6_purgeaddr(&newia->ia_ifa);
IFA_REMREF(&newia->ia_ifa);
return (EADDRNOTAVAIL);
}
NDPR_ADDREF(ndpr);
IFA_UNLOCK(&IA6_NONCONST(ia0)->ia_ifa);
IFA_LOCK(&newia->ia_ifa);
if (newia->ia6_ndpr != NULL) {
NDPR_LOCK(newia->ia6_ndpr);
VERIFY(newia->ia6_ndpr->ndpr_addrcnt != 0);
newia->ia6_ndpr->ndpr_addrcnt--;
NDPR_UNLOCK(newia->ia6_ndpr);
NDPR_REMREF(newia->ia6_ndpr);
}
newia->ia6_ndpr = ndpr;
NDPR_LOCK(newia->ia6_ndpr);
newia->ia6_ndpr->ndpr_addrcnt++;
VERIFY(newia->ia6_ndpr->ndpr_addrcnt != 0);
NDPR_ADDREF_LOCKED(newia->ia6_ndpr);
NDPR_UNLOCK(newia->ia6_ndpr);
IFA_UNLOCK(&newia->ia_ifa);
lck_mtx_lock(nd6_mutex);
pfxlist_onlink_check();
lck_mtx_unlock(nd6_mutex);
IFA_REMREF(&newia->ia_ifa);
NDPR_REMREF(ndpr);
return (0);
}
#undef IA6_NONCONST
int
in6_init_prefix_ltimes(struct nd_prefix *ndpr)
{
struct timeval caltime;
u_int64_t timenow = net_uptime();
NDPR_LOCK_ASSERT_HELD(ndpr);
getmicrotime(&caltime);
ndpr->ndpr_base_calendartime = caltime.tv_sec;
ndpr->ndpr_base_uptime = timenow;
if (ndpr->ndpr_pltime > ndpr->ndpr_vltime) {
nd6log((LOG_INFO, "in6_init_prefix_ltimes: preferred lifetime"
"(%d) is greater than valid lifetime(%d)\n",
(u_int)ndpr->ndpr_pltime, (u_int)ndpr->ndpr_vltime));
return (EINVAL);
}
if (ndpr->ndpr_pltime == ND6_INFINITE_LIFETIME)
ndpr->ndpr_preferred = 0;
else
ndpr->ndpr_preferred = timenow + ndpr->ndpr_pltime;
if (ndpr->ndpr_vltime == ND6_INFINITE_LIFETIME)
ndpr->ndpr_expire = 0;
else
ndpr->ndpr_expire = timenow + ndpr->ndpr_vltime;
return (0);
}
static void
in6_init_address_ltimes(struct nd_prefix *new, struct in6_addrlifetime *lt6)
{
#pragma unused(new)
uint64_t timenow = net_uptime();
if (lt6->ia6t_vltime == ND6_INFINITE_LIFETIME) {
lt6->ia6t_expire = 0;
} else {
lt6->ia6t_expire = timenow;
lt6->ia6t_expire += lt6->ia6t_vltime;
}
if (lt6->ia6t_pltime == ND6_INFINITE_LIFETIME) {
lt6->ia6t_preferred = 0;
} else {
lt6->ia6t_preferred = timenow;
lt6->ia6t_preferred += lt6->ia6t_pltime;
}
}
void
rt6_flush(
struct in6_addr *gateway,
struct ifnet *ifp)
{
struct radix_node_head *rnh = rt_tables[AF_INET6];
if (!IN6_IS_ADDR_LINKLOCAL(gateway)) {
return;
}
lck_mtx_lock(rnh_lock);
gateway->s6_addr16[1] = htons(ifp->if_index);
rnh->rnh_walktree(rnh, rt6_deleteroute, (void *)gateway);
lck_mtx_unlock(rnh_lock);
}
static int
rt6_deleteroute(
struct radix_node *rn,
void *arg)
{
struct rtentry *rt = (struct rtentry *)rn;
struct in6_addr *gate = (struct in6_addr *)arg;
lck_mtx_assert(rnh_lock, LCK_MTX_ASSERT_OWNED);
RT_LOCK(rt);
if (rt->rt_gateway == NULL || rt->rt_gateway->sa_family != AF_INET6) {
RT_UNLOCK(rt);
return (0);
}
if (!IN6_ARE_ADDR_EQUAL(gate, &SIN6(rt->rt_gateway)->sin6_addr)) {
RT_UNLOCK(rt);
return (0);
}
if ((rt->rt_flags & RTF_STATIC) != 0) {
RT_UNLOCK(rt);
return (0);
}
if ((rt->rt_flags & RTF_HOST) == 0) {
RT_UNLOCK(rt);
return (0);
}
RT_UNLOCK(rt);
return (rtrequest_locked(RTM_DELETE, rt_key(rt), rt->rt_gateway,
rt_mask(rt), rt->rt_flags, 0));
}
int
nd6_setdefaultiface(
int ifindex)
{
int error = 0;
ifnet_t def_ifp = NULL;
lck_mtx_assert(nd6_mutex, LCK_MTX_ASSERT_NOTOWNED);
ifnet_head_lock_shared();
if (ifindex < 0 || if_index < ifindex) {
ifnet_head_done();
return (EINVAL);
}
def_ifp = ifindex2ifnet[ifindex];
ifnet_head_done();
lck_mtx_lock(nd6_mutex);
if (nd6_defifindex != ifindex) {
struct ifnet *odef_ifp = nd6_defifp;
nd6_defifindex = ifindex;
if (nd6_defifindex > 0)
nd6_defifp = def_ifp;
else
nd6_defifp = NULL;
if (nd6_defifp != NULL)
nd6log((LOG_INFO, "%s: is now the default "
"interface (was %s)\n", if_name(nd6_defifp),
odef_ifp != NULL ? if_name(odef_ifp) : "NONE"));
else
nd6log((LOG_INFO, "No default interface set\n"));
if (ip6_doscopedroute || TAILQ_FIRST(&nd_defrouter) == NULL) {
defrtrlist_sync(nd6_defifp);
nd6_prefix_sync(nd6_defifp);
}
scope6_setdefault(nd6_defifp);
}
lck_mtx_unlock(nd6_mutex);
return (error);
}