Home | History | Annotate | Line # | Download | only in net
rtsock.c revision 1.120
      1 /*	$NetBSD: rtsock.c,v 1.120 2009/01/11 02:45:54 christos Exp $	*/
      2 
      3 /*
      4  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
      5  * All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  * 3. Neither the name of the project nor the names of its contributors
     16  *    may be used to endorse or promote products derived from this software
     17  *    without specific prior written permission.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
     20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
     23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     29  * SUCH DAMAGE.
     30  */
     31 
     32 /*
     33  * Copyright (c) 1988, 1991, 1993
     34  *	The Regents of the University of California.  All rights reserved.
     35  *
     36  * Redistribution and use in source and binary forms, with or without
     37  * modification, are permitted provided that the following conditions
     38  * are met:
     39  * 1. Redistributions of source code must retain the above copyright
     40  *    notice, this list of conditions and the following disclaimer.
     41  * 2. Redistributions in binary form must reproduce the above copyright
     42  *    notice, this list of conditions and the following disclaimer in the
     43  *    documentation and/or other materials provided with the distribution.
     44  * 3. Neither the name of the University nor the names of its contributors
     45  *    may be used to endorse or promote products derived from this software
     46  *    without specific prior written permission.
     47  *
     48  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     49  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     50  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     51  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     52  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     53  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     54  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     55  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     56  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     57  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     58  * SUCH DAMAGE.
     59  *
     60  *	@(#)rtsock.c	8.7 (Berkeley) 10/12/95
     61  */
     62 
     63 #include <sys/cdefs.h>
     64 __KERNEL_RCSID(0, "$NetBSD: rtsock.c,v 1.120 2009/01/11 02:45:54 christos Exp $");
     65 
     66 #include "opt_inet.h"
     67 #ifdef _KERNEL_OPT
     68 #include "opt_compat_netbsd.h"
     69 #endif
     70 
     71 #include <sys/param.h>
     72 #include <sys/systm.h>
     73 #include <sys/proc.h>
     74 #include <sys/mbuf.h>
     75 #include <sys/socket.h>
     76 #include <sys/socketvar.h>
     77 #include <sys/domain.h>
     78 #include <sys/protosw.h>
     79 #include <sys/sysctl.h>
     80 #include <sys/kauth.h>
     81 #include <sys/intr.h>
     82 #ifdef RTSOCK_DEBUG
     83 #include <netinet/in.h>
     84 #endif /* RTSOCK_DEBUG */
     85 
     86 #include <net/if.h>
     87 #include <net/route.h>
     88 #include <net/raw_cb.h>
     89 
     90 #if defined(COMPAT_14) || defined(COMPAT_50)
     91 #include <compat/net/if.h>
     92 #endif
     93 
     94 #include <machine/stdarg.h>
     95 
     96 DOMAIN_DEFINE(routedomain);	/* forward declare and add to link set */
     97 
     98 struct	sockaddr route_dst = { .sa_len = 2, .sa_family = PF_ROUTE, };
     99 struct	sockaddr route_src = { .sa_len = 2, .sa_family = PF_ROUTE, };
    100 
    101 int	route_maxqlen = IFQ_MAXLEN;
    102 static struct	ifqueue route_intrq;
    103 static void	*route_sih;
    104 
    105 static int rt_msg2(int, struct rt_addrinfo *, void *, struct rt_walkarg *, int *);
    106 static int rt_xaddrs(u_char, const char *, const char *, struct rt_addrinfo *);
    107 static struct mbuf *rt_makeifannouncemsg(struct ifnet *, int, int,
    108     struct rt_addrinfo *);
    109 static int sysctl_dumpentry(struct rtentry *, void *);
    110 static int sysctl_iflist(int, struct rt_walkarg *, int);
    111 static int sysctl_rtable(SYSCTLFN_PROTO);
    112 static inline void rt_adjustcount(int, int);
    113 static void route_enqueue(struct mbuf *, int);
    114 
    115 static inline void
    116 rt_adjustcount(int af, int cnt)
    117 {
    118 	route_cb.any_count += cnt;
    119 	switch (af) {
    120 	case AF_INET:
    121 		route_cb.ip_count += cnt;
    122 		return;
    123 #ifdef INET6
    124 	case AF_INET6:
    125 		route_cb.ip6_count += cnt;
    126 		return;
    127 #endif
    128 	case AF_IPX:
    129 		route_cb.ipx_count += cnt;
    130 		return;
    131 	case AF_NS:
    132 		route_cb.ns_count += cnt;
    133 		return;
    134 	case AF_ISO:
    135 		route_cb.iso_count += cnt;
    136 		return;
    137 	}
    138 }
    139 static inline void
    140 cvtmetrics(struct rt_metrics *ortm, const struct nrt_metrics *rtm)
    141 {
    142 	ortm->rmx_locks = rtm->rmx_locks;
    143 	ortm->rmx_mtu = rtm->rmx_mtu;
    144 	ortm->rmx_hopcount = rtm->rmx_hopcount;
    145 	ortm->rmx_expire = rtm->rmx_expire;
    146 	ortm->rmx_recvpipe = rtm->rmx_recvpipe;
    147 	ortm->rmx_sendpipe = rtm->rmx_sendpipe;
    148 	ortm->rmx_ssthresh = rtm->rmx_ssthresh;
    149 	ortm->rmx_rtt = rtm->rmx_rtt;
    150 	ortm->rmx_rttvar = rtm->rmx_rttvar;
    151 	ortm->rmx_pksent = rtm->rmx_pksent;
    152 }
    153 
    154 /*ARGSUSED*/
    155 int
    156 route_usrreq(struct socket *so, int req, struct mbuf *m, struct mbuf *nam,
    157 	struct mbuf *control, struct lwp *l)
    158 {
    159 	int error = 0;
    160 	struct rawcb *rp = sotorawcb(so);
    161 	int s;
    162 
    163 	if (req == PRU_ATTACH) {
    164 		sosetlock(so);
    165 		rp = malloc(sizeof(*rp), M_PCB, M_WAITOK|M_ZERO);
    166 		so->so_pcb = rp;
    167 	}
    168 	if (req == PRU_DETACH && rp)
    169 		rt_adjustcount(rp->rcb_proto.sp_protocol, -1);
    170 	s = splsoftnet();
    171 
    172 	/*
    173 	 * Don't call raw_usrreq() in the attach case, because
    174 	 * we want to allow non-privileged processes to listen on
    175 	 * and send "safe" commands to the routing socket.
    176 	 */
    177 	if (req == PRU_ATTACH) {
    178 		if (l == NULL)
    179 			error = EACCES;
    180 		else
    181 			error = raw_attach(so, (int)(long)nam);
    182 	} else
    183 		error = raw_usrreq(so, req, m, nam, control, l);
    184 
    185 	rp = sotorawcb(so);
    186 	if (req == PRU_ATTACH && rp) {
    187 		if (error) {
    188 			free(rp, M_PCB);
    189 			splx(s);
    190 			return error;
    191 		}
    192 		rt_adjustcount(rp->rcb_proto.sp_protocol, 1);
    193 		rp->rcb_laddr = &route_src;
    194 		rp->rcb_faddr = &route_dst;
    195 		soisconnected(so);
    196 		so->so_options |= SO_USELOOPBACK;
    197 	}
    198 	splx(s);
    199 	return error;
    200 }
    201 
    202 static const struct sockaddr *
    203 intern_netmask(const struct sockaddr *mask)
    204 {
    205 	struct radix_node *rn;
    206 	extern struct radix_node_head *mask_rnhead;
    207 
    208 	if (mask != NULL &&
    209 	    (rn = rn_search(mask, mask_rnhead->rnh_treetop)))
    210 		mask = (const struct sockaddr *)rn->rn_key;
    211 
    212 	return mask;
    213 }
    214 
    215 /*ARGSUSED*/
    216 int
    217 route_output(struct mbuf *m, ...)
    218 {
    219 	struct sockproto proto = { .sp_family = PF_ROUTE, };
    220 	struct rt_msghdr *rtm = NULL;
    221 	struct rt_msghdr *old_rtm = NULL;
    222 	struct rtentry *rt = NULL;
    223 	struct rtentry *saved_nrt = NULL;
    224 	struct rt_addrinfo info;
    225 	int len, error = 0, ifa_route = 0;
    226 	struct ifnet *ifp = NULL;
    227 	struct ifaddr *ifa = NULL, *oifa;
    228 	struct socket *so;
    229 	va_list ap;
    230 	sa_family_t family;
    231 
    232 	va_start(ap, m);
    233 	so = va_arg(ap, struct socket *);
    234 	va_end(ap);
    235 
    236 #define senderr(e) do { error = e; goto flush;} while (/*CONSTCOND*/ 0)
    237 	if (m == NULL || ((m->m_len < sizeof(int32_t)) &&
    238 	   (m = m_pullup(m, sizeof(int32_t))) == NULL))
    239 		return ENOBUFS;
    240 	if ((m->m_flags & M_PKTHDR) == 0)
    241 		panic("route_output");
    242 	len = m->m_pkthdr.len;
    243 	if (len < sizeof(*rtm) ||
    244 	    len != mtod(m, struct rt_msghdr *)->rtm_msglen) {
    245 		info.rti_info[RTAX_DST] = NULL;
    246 		senderr(EINVAL);
    247 	}
    248 	R_Malloc(rtm, struct rt_msghdr *, len);
    249 	if (rtm == NULL) {
    250 		info.rti_info[RTAX_DST] = NULL;
    251 		senderr(ENOBUFS);
    252 	}
    253 	m_copydata(m, 0, len, rtm);
    254 	if (rtm->rtm_version != RTM_VERSION) {
    255 		info.rti_info[RTAX_DST] = NULL;
    256 		senderr(EPROTONOSUPPORT);
    257 	}
    258 	rtm->rtm_pid = curproc->p_pid;
    259 	memset(&info, 0, sizeof(info));
    260 	info.rti_addrs = rtm->rtm_addrs;
    261 	if (rt_xaddrs(rtm->rtm_type, (const char *)(rtm + 1), len + (char *)rtm,
    262 	    &info))
    263 		senderr(EINVAL);
    264 	info.rti_flags = rtm->rtm_flags;
    265 #ifdef RTSOCK_DEBUG
    266 	if (info.rti_info[RTAX_DST]->sa_family == AF_INET) {
    267 		printf("%s: extracted info.rti_info[RTAX_DST] %s\n", __func__,
    268 		    inet_ntoa(((const struct sockaddr_in *)
    269 		    info.rti_info[RTAX_DST])->sin_addr));
    270 	}
    271 #endif /* RTSOCK_DEBUG */
    272 	if (info.rti_info[RTAX_DST] == NULL ||
    273 	    (info.rti_info[RTAX_DST]->sa_family >= AF_MAX))
    274 		senderr(EINVAL);
    275 	if (info.rti_info[RTAX_GATEWAY] != NULL &&
    276 	    (info.rti_info[RTAX_GATEWAY]->sa_family >= AF_MAX))
    277 		senderr(EINVAL);
    278 
    279 	/*
    280 	 * Verify that the caller has the appropriate privilege; RTM_GET
    281 	 * is the only operation the non-superuser is allowed.
    282 	 */
    283 	if (kauth_authorize_network(curlwp->l_cred, KAUTH_NETWORK_ROUTE,
    284 	    0, rtm, NULL, NULL) != 0)
    285 		senderr(EACCES);
    286 
    287 	switch (rtm->rtm_type) {
    288 
    289 	case RTM_ADD:
    290 		if (info.rti_info[RTAX_GATEWAY] == NULL)
    291 			senderr(EINVAL);
    292 		error = rtrequest1(rtm->rtm_type, &info, &saved_nrt);
    293 		if (error == 0 && saved_nrt) {
    294 			rt_setmetrics(rtm->rtm_inits,
    295 			    &rtm->rtm_rmx, &saved_nrt->rt_rmx);
    296 			saved_nrt->rt_refcnt--;
    297 		}
    298 		break;
    299 
    300 	case RTM_DELETE:
    301 		error = rtrequest1(rtm->rtm_type, &info, &saved_nrt);
    302 		if (error == 0) {
    303 			(rt = saved_nrt)->rt_refcnt++;
    304 			ifa = rt_get_ifa(rt);
    305 			/*
    306 			 * If deleting an automatic route, scrub the flag.
    307 			 */
    308 			if (ifa->ifa_flags & IFA_ROUTE)
    309 				ifa->ifa_flags &= ~IFA_ROUTE;
    310 			goto report;
    311 		}
    312 		break;
    313 
    314 	case RTM_GET:
    315 	case RTM_CHANGE:
    316 	case RTM_LOCK:
    317                 /* XXX This will mask info.rti_info[RTAX_DST] with
    318 		 * info.rti_info[RTAX_NETMASK] before
    319                  * searching.  It did not used to do that.  --dyoung
    320 		 */
    321 		error = rtrequest1(RTM_GET, &info, &rt);
    322 		if (error != 0)
    323 			senderr(error);
    324 		if (rtm->rtm_type != RTM_GET) {/* XXX: too grotty */
    325 			struct radix_node *rn;
    326 
    327 			if (memcmp(info.rti_info[RTAX_DST], rt_getkey(rt),
    328 			    info.rti_info[RTAX_DST]->sa_len) != 0)
    329 				senderr(ESRCH);
    330 			info.rti_info[RTAX_NETMASK] = intern_netmask(
    331 			    info.rti_info[RTAX_NETMASK]);
    332 			for (rn = rt->rt_nodes; rn; rn = rn->rn_dupedkey)
    333 				if (info.rti_info[RTAX_NETMASK] ==
    334 				    (const struct sockaddr *)rn->rn_mask)
    335 					break;
    336 			if (rn == NULL)
    337 				senderr(ETOOMANYREFS);
    338 			rt = (struct rtentry *)rn;
    339 		}
    340 
    341 		switch (rtm->rtm_type) {
    342 		case RTM_GET:
    343 		report:
    344 			info.rti_info[RTAX_DST] = rt_getkey(rt);
    345 			info.rti_info[RTAX_GATEWAY] = rt->rt_gateway;
    346 			info.rti_info[RTAX_NETMASK] = rt_mask(rt);
    347 			if ((rtm->rtm_addrs & (RTA_IFP | RTA_IFA)) == 0)
    348 				;
    349 			else if ((ifp = rt->rt_ifp) != NULL) {
    350 				const struct ifaddr *rtifa;
    351 				info.rti_info[RTAX_IFP] = ifp->if_dl->ifa_addr;
    352                                 /* rtifa used to be simply rt->rt_ifa.
    353                                  * If rt->rt_ifa != NULL, then
    354                                  * rt_get_ifa() != NULL.  So this
    355                                  * ought to still be safe. --dyoung
    356 				 */
    357 				rtifa = rt_get_ifa(rt);
    358 				info.rti_info[RTAX_IFA] = rtifa->ifa_addr;
    359 #ifdef RTSOCK_DEBUG
    360 				if (info.rti_info[RTAX_IFA]->sa_family ==
    361 				    AF_INET) {
    362 					printf("%s: copying out RTAX_IFA %s ",
    363 					    __func__, inet_ntoa(
    364 					    (const struct sockaddr_in *)
    365 					    info.rti_info[RTAX_IFA])->sin_addr);
    366 					printf("for info.rti_info[RTAX_DST] %s "
    367 					    "ifa_getifa %p ifa_seqno %p\n",
    368 					    inet_ntoa(
    369 					    (const struct sockaddr_in *)
    370 					    info.rti_info[RTAX_DST])->sin_addr),
    371 					    (void *)rtifa->ifa_getifa,
    372 					    rtifa->ifa_seqno);
    373 				}
    374 #endif /* RTSOCK_DEBUG */
    375 				if (ifp->if_flags & IFF_POINTOPOINT) {
    376 					info.rti_info[RTAX_BRD] =
    377 					    rtifa->ifa_dstaddr;
    378 				} else
    379 					info.rti_info[RTAX_BRD] = NULL;
    380 				rtm->rtm_index = ifp->if_index;
    381 			} else {
    382 				info.rti_info[RTAX_IFP] = NULL;
    383 				info.rti_info[RTAX_IFA] = NULL;
    384 			}
    385 			(void)rt_msg2(rtm->rtm_type, &info, NULL, NULL, &len);
    386 			if (len > rtm->rtm_msglen) {
    387 				old_rtm = rtm;
    388 				R_Malloc(rtm, struct rt_msghdr *, len);
    389 				if (rtm == NULL)
    390 					senderr(ENOBUFS);
    391 				(void)memcpy(rtm, old_rtm, old_rtm->rtm_msglen);
    392 			}
    393 			(void)rt_msg2(rtm->rtm_type, &info, rtm, NULL, 0);
    394 			rtm->rtm_flags = rt->rt_flags;
    395 			cvtmetrics(&rtm->rtm_rmx, &rt->rt_rmx);
    396 			rtm->rtm_addrs = info.rti_addrs;
    397 			break;
    398 
    399 		case RTM_CHANGE:
    400 			/*
    401 			 * new gateway could require new ifaddr, ifp;
    402 			 * flags may also be different; ifp may be specified
    403 			 * by ll sockaddr when protocol address is ambiguous
    404 			 */
    405 			if ((error = rt_getifa(&info)) != 0)
    406 				senderr(error);
    407 			if (info.rti_info[RTAX_GATEWAY] &&
    408 			    rt_setgate(rt, info.rti_info[RTAX_GATEWAY]))
    409 				senderr(EDQUOT);
    410 			/* new gateway could require new ifaddr, ifp;
    411 			   flags may also be different; ifp may be specified
    412 			   by ll sockaddr when protocol address is ambiguous */
    413 			if (info.rti_info[RTAX_IFP] &&
    414 			    (ifa = ifa_ifwithnet(info.rti_info[RTAX_IFP])) &&
    415 			    (ifp = ifa->ifa_ifp) && (info.rti_info[RTAX_IFA] ||
    416 			    info.rti_info[RTAX_GATEWAY])) {
    417 				ifa = ifaof_ifpforaddr(info.rti_info[RTAX_IFA] ?
    418 				    info.rti_info[RTAX_IFA] :
    419 				    info.rti_info[RTAX_GATEWAY], ifp);
    420 			} else if ((info.rti_info[RTAX_IFA] &&
    421 			    (ifa = ifa_ifwithaddr(info.rti_info[RTAX_IFA]))) ||
    422 			    (info.rti_info[RTAX_GATEWAY] &&
    423 			    (ifa = ifa_ifwithroute(rt->rt_flags,
    424 			    rt_getkey(rt), info.rti_info[RTAX_GATEWAY])))) {
    425 				ifp = ifa->ifa_ifp;
    426 			}
    427 			oifa = rt->rt_ifa;
    428 			if (oifa && oifa->ifa_flags & IFA_ROUTE) {
    429 				/*
    430 				 * If changing an automatically added route,
    431 				 * remove the flag and store the fact.
    432 				 */
    433 				oifa->ifa_flags &= ~IFA_ROUTE;
    434 				ifa_route = 1;
    435 			}
    436 			if (ifa) {
    437 				if (oifa != ifa) {
    438 					if (oifa && oifa->ifa_rtrequest) {
    439 						oifa->ifa_rtrequest(RTM_DELETE,
    440 						    rt, &info);
    441 					}
    442 					/*
    443 					 * If changing an automatically added
    444 					 * route, store this if not static.
    445 					 */
    446 					if (ifa_route &&
    447 					    !(rt->rt_flags & RTF_STATIC))
    448 						ifa->ifa_flags |= IFA_ROUTE;
    449 					rt_replace_ifa(rt, ifa);
    450 					rt->rt_ifp = ifp;
    451 				}
    452 			}
    453 			rt_setmetrics(rtm->rtm_inits, &rtm->rtm_rmx,
    454 			    &rt->rt_rmx);
    455 			if (rt->rt_ifa && rt->rt_ifa->ifa_rtrequest)
    456 				rt->rt_ifa->ifa_rtrequest(RTM_ADD, rt, &info);
    457 			/*FALLTHROUGH*/
    458 		case RTM_LOCK:
    459 			rt->rt_rmx.rmx_locks &= ~(rtm->rtm_inits);
    460 			rt->rt_rmx.rmx_locks |=
    461 			    (rtm->rtm_inits & rtm->rtm_rmx.rmx_locks);
    462 			break;
    463 		}
    464 		break;
    465 
    466 	default:
    467 		senderr(EOPNOTSUPP);
    468 	}
    469 
    470 flush:
    471 	if (rtm) {
    472 		if (error)
    473 			rtm->rtm_errno = error;
    474 		else
    475 			rtm->rtm_flags |= RTF_DONE;
    476 	}
    477 	family = info.rti_info[RTAX_DST] ? info.rti_info[RTAX_DST]->sa_family :
    478 	    0;
    479 	/* We cannot free old_rtm until we have stopped using the
    480 	 * pointers in info, some of which may point to sockaddrs
    481 	 * in old_rtm.
    482 	 */
    483 	if (old_rtm != NULL)
    484 		Free(old_rtm);
    485 	if (rt)
    486 		rtfree(rt);
    487     {
    488 	struct rawcb *rp = NULL;
    489 	/*
    490 	 * Check to see if we don't want our own messages.
    491 	 */
    492 	if ((so->so_options & SO_USELOOPBACK) == 0) {
    493 		if (route_cb.any_count <= 1) {
    494 			if (rtm)
    495 				Free(rtm);
    496 			m_freem(m);
    497 			return error;
    498 		}
    499 		/* There is another listener, so construct message */
    500 		rp = sotorawcb(so);
    501 	}
    502 	if (rtm) {
    503 		m_copyback(m, 0, rtm->rtm_msglen, rtm);
    504 		if (m->m_pkthdr.len < rtm->rtm_msglen) {
    505 			m_freem(m);
    506 			m = NULL;
    507 		} else if (m->m_pkthdr.len > rtm->rtm_msglen)
    508 			m_adj(m, rtm->rtm_msglen - m->m_pkthdr.len);
    509 		Free(rtm);
    510 	}
    511 	if (rp)
    512 		rp->rcb_proto.sp_family = 0; /* Avoid us */
    513 	if (family)
    514 		proto.sp_protocol = family;
    515 	if (m)
    516 		raw_input(m, &proto, &route_src, &route_dst);
    517 	if (rp)
    518 		rp->rcb_proto.sp_family = PF_ROUTE;
    519     }
    520 	return error;
    521 }
    522 
    523 void
    524 rt_setmetrics(u_long which, const struct rt_metrics *in, struct nrt_metrics *out)
    525 {
    526 #define metric(f, e) if (which & (f)) out->e = in->e;
    527 	metric(RTV_RPIPE, rmx_recvpipe);
    528 	metric(RTV_SPIPE, rmx_sendpipe);
    529 	metric(RTV_SSTHRESH, rmx_ssthresh);
    530 	metric(RTV_RTT, rmx_rtt);
    531 	metric(RTV_RTTVAR, rmx_rttvar);
    532 	metric(RTV_HOPCOUNT, rmx_hopcount);
    533 	metric(RTV_MTU, rmx_mtu);
    534 	/* XXX time_t: Will not work after 2038 */
    535 	metric(RTV_EXPIRE, rmx_expire);
    536 #undef metric
    537 }
    538 
    539 #define ROUNDUP(a) \
    540 	((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
    541 #define ADVANCE(x, n) (x += ROUNDUP((n)->sa_len))
    542 
    543 static int
    544 rt_xaddrs(u_char rtmtype, const char *cp, const char *cplim,
    545     struct rt_addrinfo *rtinfo)
    546 {
    547 	const struct sockaddr *sa = NULL;	/* Quell compiler warning */
    548 	int i;
    549 
    550 	for (i = 0; i < RTAX_MAX && cp < cplim; i++) {
    551 		if ((rtinfo->rti_addrs & (1 << i)) == 0)
    552 			continue;
    553 		rtinfo->rti_info[i] = sa = (const struct sockaddr *)cp;
    554 		ADVANCE(cp, sa);
    555 	}
    556 
    557 	/*
    558 	 * Check for extra addresses specified, except RTM_GET asking
    559 	 * for interface info.
    560 	 */
    561 	if (rtmtype == RTM_GET) {
    562 		if (((rtinfo->rti_addrs &
    563 		    (~((1 << RTAX_IFP) | (1 << RTAX_IFA)))) & (~0 << i)) != 0)
    564 			return 1;
    565 	} else if ((rtinfo->rti_addrs & (~0 << i)) != 0)
    566 		return 1;
    567 	/* Check for bad data length.  */
    568 	if (cp != cplim) {
    569 		if (i == RTAX_NETMASK + 1 && sa != NULL &&
    570 		    cp - ROUNDUP(sa->sa_len) + sa->sa_len == cplim)
    571 			/*
    572 			 * The last sockaddr was info.rti_info[RTAX_NETMASK].
    573 			 * We accept this for now for the sake of old
    574 			 * binaries or third party softwares.
    575 			 */
    576 			;
    577 		else
    578 			return 1;
    579 	}
    580 	return 0;
    581 }
    582 
    583 struct mbuf *
    584 rt_msg1(int type, struct rt_addrinfo *rtinfo, void *data, int datalen)
    585 {
    586 	struct rt_msghdr *rtm;
    587 	struct mbuf *m;
    588 	int i;
    589 	const struct sockaddr *sa;
    590 	int len, dlen;
    591 
    592 	m = m_gethdr(M_DONTWAIT, MT_DATA);
    593 	if (m == NULL)
    594 		return m;
    595 	MCLAIM(m, &routedomain.dom_mowner);
    596 	switch (type) {
    597 
    598 	case RTM_DELADDR:
    599 	case RTM_NEWADDR:
    600 		len = sizeof(struct ifa_msghdr);
    601 		break;
    602 
    603 #ifdef COMPAT_14
    604 	case RTM_OOIFINFO:
    605 		len = sizeof(struct if_msghdr14);
    606 		break;
    607 #endif
    608 #ifdef COMPAT_50
    609 	case RTM_OIFINFO:
    610 		len = sizeof(struct if_msghdr50);
    611 		break;
    612 #endif
    613 
    614 	case RTM_IFINFO:
    615 		len = sizeof(struct if_msghdr);
    616 		break;
    617 
    618 	case RTM_IFANNOUNCE:
    619 	case RTM_IEEE80211:
    620 		len = sizeof(struct if_announcemsghdr);
    621 		break;
    622 
    623 	default:
    624 		len = sizeof(struct rt_msghdr);
    625 	}
    626 	if (len > MHLEN + MLEN)
    627 		panic("rt_msg1: message too long");
    628 	else if (len > MHLEN) {
    629 		m->m_next = m_get(M_DONTWAIT, MT_DATA);
    630 		if (m->m_next == NULL) {
    631 			m_freem(m);
    632 			return NULL;
    633 		}
    634 		MCLAIM(m->m_next, m->m_owner);
    635 		m->m_pkthdr.len = len;
    636 		m->m_len = MHLEN;
    637 		m->m_next->m_len = len - MHLEN;
    638 	} else {
    639 		m->m_pkthdr.len = m->m_len = len;
    640 	}
    641 	m->m_pkthdr.rcvif = NULL;
    642 	m_copyback(m, 0, datalen, data);
    643 	if (len > datalen)
    644 		(void)memset(mtod(m, char *) + datalen, 0, len - datalen);
    645 	rtm = mtod(m, struct rt_msghdr *);
    646 	for (i = 0; i < RTAX_MAX; i++) {
    647 		if ((sa = rtinfo->rti_info[i]) == NULL)
    648 			continue;
    649 		rtinfo->rti_addrs |= (1 << i);
    650 		dlen = ROUNDUP(sa->sa_len);
    651 		m_copyback(m, len, dlen, sa);
    652 		len += dlen;
    653 	}
    654 	if (m->m_pkthdr.len != len) {
    655 		m_freem(m);
    656 		return NULL;
    657 	}
    658 	rtm->rtm_msglen = len;
    659 	rtm->rtm_version = RTM_VERSION;
    660 	rtm->rtm_type = type;
    661 	return m;
    662 }
    663 
    664 /*
    665  * rt_msg2
    666  *
    667  *	 fills 'cp' or 'w'.w_tmem with the routing socket message and
    668  *		returns the length of the message in 'lenp'.
    669  *
    670  * if walkarg is 0, cp is expected to be 0 or a buffer large enough to hold
    671  *	the message
    672  * otherwise walkarg's w_needed is updated and if the user buffer is
    673  *	specified and w_needed indicates space exists the information is copied
    674  *	into the temp space (w_tmem). w_tmem is [re]allocated if necessary,
    675  *	if the allocation fails ENOBUFS is returned.
    676  */
    677 static int
    678 rt_msg2(int type, struct rt_addrinfo *rtinfo, void *cpv, struct rt_walkarg *w,
    679 	int *lenp)
    680 {
    681 	int i;
    682 	int len, dlen, second_time = 0;
    683 	char *cp0, *cp = cpv;
    684 
    685 	rtinfo->rti_addrs = 0;
    686 again:
    687 	switch (type) {
    688 
    689 	case RTM_DELADDR:
    690 	case RTM_NEWADDR:
    691 		len = sizeof(struct ifa_msghdr);
    692 		break;
    693 #ifdef COMPAT_14
    694 	case RTM_OOIFINFO:
    695 		len = sizeof(struct if_msghdr14);
    696 		break;
    697 #endif
    698 #ifdef COMPAT_50
    699 	case RTM_OIFINFO:
    700 		len = sizeof(struct if_msghdr50);
    701 		break;
    702 #endif
    703 
    704 	case RTM_IFINFO:
    705 		len = sizeof(struct if_msghdr);
    706 		break;
    707 
    708 	default:
    709 		len = sizeof(struct rt_msghdr);
    710 	}
    711 	if ((cp0 = cp) != NULL)
    712 		cp += len;
    713 	for (i = 0; i < RTAX_MAX; i++) {
    714 		const struct sockaddr *sa;
    715 
    716 		if ((sa = rtinfo->rti_info[i]) == NULL)
    717 			continue;
    718 		rtinfo->rti_addrs |= (1 << i);
    719 		dlen = ROUNDUP(sa->sa_len);
    720 		if (cp) {
    721 			(void)memcpy(cp, sa, (size_t)dlen);
    722 			cp += dlen;
    723 		}
    724 		len += dlen;
    725 	}
    726 	if (cp == NULL && w != NULL && !second_time) {
    727 		struct rt_walkarg *rw = w;
    728 
    729 		rw->w_needed += len;
    730 		if (rw->w_needed <= 0 && rw->w_where) {
    731 			if (rw->w_tmemsize < len) {
    732 				if (rw->w_tmem)
    733 					free(rw->w_tmem, M_RTABLE);
    734 				rw->w_tmem = malloc(len, M_RTABLE, M_NOWAIT);
    735 				if (rw->w_tmem)
    736 					rw->w_tmemsize = len;
    737 				else
    738 					rw->w_tmemsize = 0;
    739 			}
    740 			if (rw->w_tmem) {
    741 				cp = rw->w_tmem;
    742 				second_time = 1;
    743 				goto again;
    744 			} else {
    745 				rw->w_tmemneeded = len;
    746 				return ENOBUFS;
    747 			}
    748 		}
    749 	}
    750 	if (cp) {
    751 		struct rt_msghdr *rtm = (struct rt_msghdr *)cp0;
    752 
    753 		rtm->rtm_version = RTM_VERSION;
    754 		rtm->rtm_type = type;
    755 		rtm->rtm_msglen = len;
    756 	}
    757 	if (lenp)
    758 		*lenp = len;
    759 	return 0;
    760 }
    761 
    762 /*
    763  * This routine is called to generate a message from the routing
    764  * socket indicating that a redirect has occurred, a routing lookup
    765  * has failed, or that a protocol has detected timeouts to a particular
    766  * destination.
    767  */
    768 void
    769 rt_missmsg(int type, struct rt_addrinfo *rtinfo, int flags, int error)
    770 {
    771 	struct rt_msghdr rtm;
    772 	struct mbuf *m;
    773 	const struct sockaddr *sa = rtinfo->rti_info[RTAX_DST];
    774 
    775 	if (route_cb.any_count == 0)
    776 		return;
    777 	memset(&rtm, 0, sizeof(rtm));
    778 	rtm.rtm_flags = RTF_DONE | flags;
    779 	rtm.rtm_errno = error;
    780 	m = rt_msg1(type, rtinfo, &rtm, sizeof(rtm));
    781 	if (m == NULL)
    782 		return;
    783 	mtod(m, struct rt_msghdr *)->rtm_addrs = rtinfo->rti_addrs;
    784 	route_enqueue(m, sa ? sa->sa_family : 0);
    785 }
    786 
    787 /*
    788  * This routine is called to generate a message from the routing
    789  * socket indicating that the status of a network interface has changed.
    790  */
    791 void
    792 rt_ifmsg(struct ifnet *ifp)
    793 {
    794 	struct if_msghdr ifm;
    795 	struct mbuf *m;
    796 	struct rt_addrinfo info;
    797 
    798 	if (route_cb.any_count == 0)
    799 		return;
    800 	(void)memset(&info, 0, sizeof(info));
    801 	(void)memset(&ifm, 0, sizeof(ifm));
    802 	ifm.ifm_index = ifp->if_index;
    803 	ifm.ifm_flags = ifp->if_flags;
    804 	ifm.ifm_data = ifp->if_data;
    805 	ifm.ifm_addrs = 0;
    806 	m = rt_msg1(RTM_IFINFO, &info, &ifm, sizeof(ifm));
    807 	if (m == NULL)
    808 		return;
    809 	route_enqueue(m, 0);
    810 #ifdef COMPAT_14
    811 	compat_14_rt_ifmsg(ifp, &ifm);
    812 #endif
    813 #ifdef COMPAT_50
    814 	compat_50_rt_ifmsg(ifp, &ifm);
    815 #endif
    816 }
    817 
    818 
    819 /*
    820  * This is called to generate messages from the routing socket
    821  * indicating a network interface has had addresses associated with it.
    822  * if we ever reverse the logic and replace messages TO the routing
    823  * socket indicate a request to configure interfaces, then it will
    824  * be unnecessary as the routing socket will automatically generate
    825  * copies of it.
    826  */
    827 void
    828 rt_newaddrmsg(int cmd, struct ifaddr *ifa, int error, struct rtentry *rt)
    829 {
    830 #define	cmdpass(__cmd, __pass)	(((__cmd) << 2) | (__pass))
    831 	struct rt_addrinfo info;
    832 	const struct sockaddr *sa;
    833 	int pass;
    834 	struct mbuf *m;
    835 	struct ifnet *ifp = ifa->ifa_ifp;
    836 	struct rt_msghdr rtm;
    837 	struct ifa_msghdr ifam;
    838 	int ncmd;
    839 
    840 	if (route_cb.any_count == 0)
    841 		return;
    842 	for (pass = 1; pass < 3; pass++) {
    843 		memset(&info, 0, sizeof(info));
    844 		switch (cmdpass(cmd, pass)) {
    845 		case cmdpass(RTM_ADD, 1):
    846 		case cmdpass(RTM_CHANGE, 1):
    847 		case cmdpass(RTM_DELETE, 2):
    848 			if (cmd == RTM_ADD)
    849 				ncmd = RTM_NEWADDR;
    850 			else
    851 				ncmd = RTM_DELADDR;
    852 
    853 			info.rti_info[RTAX_IFA] = sa = ifa->ifa_addr;
    854 			info.rti_info[RTAX_IFP] = ifp->if_dl->ifa_addr;
    855 			info.rti_info[RTAX_NETMASK] = ifa->ifa_netmask;
    856 			info.rti_info[RTAX_BRD] = ifa->ifa_dstaddr;
    857 			memset(&ifam, 0, sizeof(ifam));
    858 			ifam.ifam_index = ifp->if_index;
    859 			ifam.ifam_metric = ifa->ifa_metric;
    860 			ifam.ifam_flags = ifa->ifa_flags;
    861 			m = rt_msg1(ncmd, &info, &ifam, sizeof(ifam));
    862 			if (m == NULL)
    863 				continue;
    864 			mtod(m, struct ifa_msghdr *)->ifam_addrs =
    865 			    info.rti_addrs;
    866 			break;
    867 		case cmdpass(RTM_ADD, 2):
    868 		case cmdpass(RTM_CHANGE, 2):
    869 		case cmdpass(RTM_DELETE, 1):
    870 			if (rt == NULL)
    871 				continue;
    872 			info.rti_info[RTAX_NETMASK] = rt_mask(rt);
    873 			info.rti_info[RTAX_DST] = sa = rt_getkey(rt);
    874 			info.rti_info[RTAX_GATEWAY] = rt->rt_gateway;
    875 			memset(&rtm, 0, sizeof(rtm));
    876 			rtm.rtm_index = ifp->if_index;
    877 			rtm.rtm_flags |= rt->rt_flags;
    878 			rtm.rtm_errno = error;
    879 			m = rt_msg1(cmd, &info, &rtm, sizeof(rtm));
    880 			if (m == NULL)
    881 				continue;
    882 			mtod(m, struct rt_msghdr *)->rtm_addrs = info.rti_addrs;
    883 			break;
    884 		default:
    885 			continue;
    886 		}
    887 #ifdef DIAGNOSTIC
    888 		if (m == NULL)
    889 			panic("%s: called with wrong command", __func__);
    890 #endif
    891 		route_enqueue(m, sa ? sa->sa_family : 0);
    892 	}
    893 #undef cmdpass
    894 }
    895 
    896 static struct mbuf *
    897 rt_makeifannouncemsg(struct ifnet *ifp, int type, int what,
    898     struct rt_addrinfo *info)
    899 {
    900 	struct if_announcemsghdr ifan;
    901 
    902 	memset(info, 0, sizeof(*info));
    903 	memset(&ifan, 0, sizeof(ifan));
    904 	ifan.ifan_index = ifp->if_index;
    905 	strlcpy(ifan.ifan_name, ifp->if_xname, sizeof(ifan.ifan_name));
    906 	ifan.ifan_what = what;
    907 	return rt_msg1(type, info, &ifan, sizeof(ifan));
    908 }
    909 
    910 /*
    911  * This is called to generate routing socket messages indicating
    912  * network interface arrival and departure.
    913  */
    914 void
    915 rt_ifannouncemsg(struct ifnet *ifp, int what)
    916 {
    917 	struct mbuf *m;
    918 	struct rt_addrinfo info;
    919 
    920 	if (route_cb.any_count == 0)
    921 		return;
    922 	m = rt_makeifannouncemsg(ifp, RTM_IFANNOUNCE, what, &info);
    923 	if (m == NULL)
    924 		return;
    925 	route_enqueue(m, 0);
    926 }
    927 
    928 /*
    929  * This is called to generate routing socket messages indicating
    930  * IEEE80211 wireless events.
    931  * XXX we piggyback on the RTM_IFANNOUNCE msg format in a clumsy way.
    932  */
    933 void
    934 rt_ieee80211msg(struct ifnet *ifp, int what, void *data, size_t data_len)
    935 {
    936 	struct mbuf *m;
    937 	struct rt_addrinfo info;
    938 
    939 	if (route_cb.any_count == 0)
    940 		return;
    941 	m = rt_makeifannouncemsg(ifp, RTM_IEEE80211, what, &info);
    942 	if (m == NULL)
    943 		return;
    944 	/*
    945 	 * Append the ieee80211 data.  Try to stick it in the
    946 	 * mbuf containing the ifannounce msg; otherwise allocate
    947 	 * a new mbuf and append.
    948 	 *
    949 	 * NB: we assume m is a single mbuf.
    950 	 */
    951 	if (data_len > M_TRAILINGSPACE(m)) {
    952 		struct mbuf *n = m_get(M_NOWAIT, MT_DATA);
    953 		if (n == NULL) {
    954 			m_freem(m);
    955 			return;
    956 		}
    957 		(void)memcpy(mtod(n, void *), data, data_len);
    958 		n->m_len = data_len;
    959 		m->m_next = n;
    960 	} else if (data_len > 0) {
    961 		(void)memcpy(mtod(m, uint8_t *) + m->m_len, data, data_len);
    962 		m->m_len += data_len;
    963 	}
    964 	if (m->m_flags & M_PKTHDR)
    965 		m->m_pkthdr.len += data_len;
    966 	mtod(m, struct if_announcemsghdr *)->ifan_msglen += data_len;
    967 	route_enqueue(m, 0);
    968 }
    969 
    970 /*
    971  * This is used in dumping the kernel table via sysctl().
    972  */
    973 static int
    974 sysctl_dumpentry(struct rtentry *rt, void *v)
    975 {
    976 	struct rt_walkarg *w = v;
    977 	int error = 0, size;
    978 	struct rt_addrinfo info;
    979 
    980 	if (w->w_op == NET_RT_FLAGS && !(rt->rt_flags & w->w_arg))
    981 		return 0;
    982 	memset(&info, 0, sizeof(info));
    983 	info.rti_info[RTAX_DST] = rt_getkey(rt);
    984 	info.rti_info[RTAX_GATEWAY] = rt->rt_gateway;
    985 	info.rti_info[RTAX_NETMASK] = rt_mask(rt);
    986 	if (rt->rt_ifp) {
    987 		const struct ifaddr *rtifa;
    988 		info.rti_info[RTAX_IFP] = rt->rt_ifp->if_dl->ifa_addr;
    989 		/* rtifa used to be simply rt->rt_ifa.  If rt->rt_ifa != NULL,
    990 		 * then rt_get_ifa() != NULL.  So this ought to still be safe.
    991 		 * --dyoung
    992 		 */
    993 		rtifa = rt_get_ifa(rt);
    994 		info.rti_info[RTAX_IFA] = rtifa->ifa_addr;
    995 		if (rt->rt_ifp->if_flags & IFF_POINTOPOINT)
    996 			info.rti_info[RTAX_BRD] = rtifa->ifa_dstaddr;
    997 	}
    998 	if ((error = rt_msg2(RTM_GET, &info, 0, w, &size)))
    999 		return error;
   1000 	if (w->w_where && w->w_tmem && w->w_needed <= 0) {
   1001 		struct rt_msghdr *rtm = (struct rt_msghdr *)w->w_tmem;
   1002 
   1003 		rtm->rtm_flags = rt->rt_flags;
   1004 		rtm->rtm_use = rt->rt_use;
   1005 		cvtmetrics(&rtm->rtm_rmx, &rt->rt_rmx);
   1006 		KASSERT(rt->rt_ifp != NULL);
   1007 		rtm->rtm_index = rt->rt_ifp->if_index;
   1008 		rtm->rtm_errno = rtm->rtm_pid = rtm->rtm_seq = 0;
   1009 		rtm->rtm_addrs = info.rti_addrs;
   1010 		if ((error = copyout(rtm, w->w_where, size)) != 0)
   1011 			w->w_where = NULL;
   1012 		else
   1013 			w->w_where = (char *)w->w_where + size;
   1014 	}
   1015 	return error;
   1016 }
   1017 
   1018 static int
   1019 sysctl_iflist(int af, struct rt_walkarg *w, int type)
   1020 {
   1021 	struct ifnet *ifp;
   1022 	struct ifaddr *ifa;
   1023 	struct	rt_addrinfo info;
   1024 	int	len, error = 0;
   1025 
   1026 	memset(&info, 0, sizeof(info));
   1027 	IFNET_FOREACH(ifp) {
   1028 		if (w->w_arg && w->w_arg != ifp->if_index)
   1029 			continue;
   1030 		if (IFADDR_EMPTY(ifp))
   1031 			continue;
   1032 		info.rti_info[RTAX_IFP] = ifp->if_dl->ifa_addr;
   1033 		switch (type) {
   1034 		case NET_RT_IFLIST:
   1035 			error = rt_msg2(RTM_IFINFO, &info, NULL, w, &len);
   1036 			break;
   1037 #ifdef COMPAT_14
   1038 		case NET_RT_OOIFLIST:
   1039 			error = rt_msg2(RTM_OOIFINFO, &info, NULL, w, &len);
   1040 			break;
   1041 #endif
   1042 #ifdef COMPAT_50
   1043 		case NET_RT_OIFLIST:
   1044 			error = rt_msg2(RTM_OIFINFO, &info, NULL, w, &len);
   1045 			break;
   1046 #endif
   1047 		default:
   1048 			panic("sysctl_iflist(1)");
   1049 		}
   1050 		if (error)
   1051 			return error;
   1052 		info.rti_info[RTAX_IFP] = NULL;
   1053 		if (w->w_where && w->w_tmem && w->w_needed <= 0) {
   1054 			switch (type) {
   1055 			case NET_RT_IFLIST: {
   1056 				struct if_msghdr *ifm;
   1057 
   1058 				ifm = (struct if_msghdr *)w->w_tmem;
   1059 				ifm->ifm_index = ifp->if_index;
   1060 				ifm->ifm_flags = ifp->if_flags;
   1061 				ifm->ifm_data = ifp->if_data;
   1062 				ifm->ifm_addrs = info.rti_addrs;
   1063 				error = copyout(ifm, w->w_where, len);
   1064 				if (error)
   1065 					return error;
   1066 				w->w_where = (char *)w->w_where + len;
   1067 				break;
   1068 			}
   1069 
   1070 #ifdef COMPAT_14
   1071 			case NET_RT_OOIFLIST:
   1072 				error = compat_14_iflist(ifp, w, &info, len);
   1073 				if (error)
   1074 					return error;
   1075 				break;
   1076 #endif
   1077 #ifdef COMPAT_50
   1078 			case NET_RT_OIFLIST:
   1079 				error = compat_50_iflist(ifp, w, &info, len);
   1080 				if (error)
   1081 					return error;
   1082 				break;
   1083 #endif
   1084 			default:
   1085 				panic("sysctl_iflist(2)");
   1086 			}
   1087 		}
   1088 		IFADDR_FOREACH(ifa, ifp) {
   1089 			if (af && af != ifa->ifa_addr->sa_family)
   1090 				continue;
   1091 			info.rti_info[RTAX_IFA] = ifa->ifa_addr;
   1092 			info.rti_info[RTAX_NETMASK] = ifa->ifa_netmask;
   1093 			info.rti_info[RTAX_BRD] = ifa->ifa_dstaddr;
   1094 			if ((error = rt_msg2(RTM_NEWADDR, &info, 0, w, &len)))
   1095 				return error;
   1096 			if (w->w_where && w->w_tmem && w->w_needed <= 0) {
   1097 				struct ifa_msghdr *ifam;
   1098 
   1099 				ifam = (struct ifa_msghdr *)w->w_tmem;
   1100 				ifam->ifam_index = ifa->ifa_ifp->if_index;
   1101 				ifam->ifam_flags = ifa->ifa_flags;
   1102 				ifam->ifam_metric = ifa->ifa_metric;
   1103 				ifam->ifam_addrs = info.rti_addrs;
   1104 				error = copyout(w->w_tmem, w->w_where, len);
   1105 				if (error)
   1106 					return error;
   1107 				w->w_where = (char *)w->w_where + len;
   1108 			}
   1109 		}
   1110 		info.rti_info[RTAX_IFA] = info.rti_info[RTAX_NETMASK] =
   1111 		    info.rti_info[RTAX_BRD] = NULL;
   1112 	}
   1113 	return 0;
   1114 }
   1115 
   1116 static int
   1117 sysctl_rtable(SYSCTLFN_ARGS)
   1118 {
   1119 	void 	*where = oldp;
   1120 	size_t	*given = oldlenp;
   1121 	const void *new = newp;
   1122 	int	i, s, error = EINVAL;
   1123 	u_char  af;
   1124 	struct	rt_walkarg w;
   1125 
   1126 	if (namelen == 1 && name[0] == CTL_QUERY)
   1127 		return sysctl_query(SYSCTLFN_CALL(rnode));
   1128 
   1129 	if (new)
   1130 		return EPERM;
   1131 	if (namelen != 3)
   1132 		return EINVAL;
   1133 	af = name[0];
   1134 	w.w_tmemneeded = 0;
   1135 	w.w_tmemsize = 0;
   1136 	w.w_tmem = NULL;
   1137 again:
   1138 	/* we may return here if a later [re]alloc of the t_mem buffer fails */
   1139 	if (w.w_tmemneeded) {
   1140 		w.w_tmem = malloc(w.w_tmemneeded, M_RTABLE, M_WAITOK);
   1141 		w.w_tmemsize = w.w_tmemneeded;
   1142 		w.w_tmemneeded = 0;
   1143 	}
   1144 	w.w_op = name[1];
   1145 	w.w_arg = name[2];
   1146 	w.w_given = *given;
   1147 	w.w_needed = 0 - w.w_given;
   1148 	w.w_where = where;
   1149 
   1150 	s = splsoftnet();
   1151 	switch (w.w_op) {
   1152 
   1153 	case NET_RT_DUMP:
   1154 	case NET_RT_FLAGS:
   1155 		for (i = 1; i <= AF_MAX; i++)
   1156 			if ((af == 0 || af == i) &&
   1157 			    (error = rt_walktree(i, sysctl_dumpentry, &w)))
   1158 				break;
   1159 		break;
   1160 
   1161 #ifdef COMPAT_14
   1162 	case NET_RT_OOIFLIST:
   1163 		error = sysctl_iflist(af, &w, w.w_op);
   1164 		break;
   1165 #endif
   1166 #ifdef COMPAT_50
   1167 	case NET_RT_OIFLIST:
   1168 		error = sysctl_iflist(af, &w, w.w_op);
   1169 		break;
   1170 #endif
   1171 
   1172 	case NET_RT_IFLIST:
   1173 		error = sysctl_iflist(af, &w, w.w_op);
   1174 	}
   1175 	splx(s);
   1176 
   1177 	/* check to see if we couldn't allocate memory with NOWAIT */
   1178 	if (error == ENOBUFS && w.w_tmem == 0 && w.w_tmemneeded)
   1179 		goto again;
   1180 
   1181 	if (w.w_tmem)
   1182 		free(w.w_tmem, M_RTABLE);
   1183 	w.w_needed += w.w_given;
   1184 	if (where) {
   1185 		*given = (char *)w.w_where - (char *)where;
   1186 		if (*given < w.w_needed)
   1187 			return ENOMEM;
   1188 	} else {
   1189 		*given = (11 * w.w_needed) / 10;
   1190 	}
   1191 	return error;
   1192 }
   1193 
   1194 /*
   1195  * Routing message software interrupt routine
   1196  */
   1197 static void
   1198 route_intr(void *cookie)
   1199 {
   1200 	struct sockproto proto = { .sp_family = PF_ROUTE, };
   1201 	struct mbuf *m;
   1202 	int s;
   1203 
   1204 	mutex_enter(softnet_lock);
   1205 	KERNEL_LOCK(1, NULL);
   1206 	while (!IF_IS_EMPTY(&route_intrq)) {
   1207 		s = splnet();
   1208 		IF_DEQUEUE(&route_intrq, m);
   1209 		splx(s);
   1210 		if (m == NULL)
   1211 			break;
   1212 		proto.sp_protocol = M_GETCTX(m, uintptr_t);
   1213 		raw_input(m, &proto, &route_src, &route_dst);
   1214 	}
   1215 	KERNEL_UNLOCK_ONE(NULL);
   1216 	mutex_exit(softnet_lock);
   1217 }
   1218 
   1219 /*
   1220  * Enqueue a message to the software interrupt routine.
   1221  */
   1222 void
   1223 route_enqueue(struct mbuf *m, int family)
   1224 {
   1225 	int s, wasempty;
   1226 
   1227 	s = splnet();
   1228 	if (IF_QFULL(&route_intrq)) {
   1229 		IF_DROP(&route_intrq);
   1230 		m_freem(m);
   1231 	} else {
   1232 		wasempty = IF_IS_EMPTY(&route_intrq);
   1233 		M_SETCTX(m, (uintptr_t)family);
   1234 		IF_ENQUEUE(&route_intrq, m);
   1235 		if (wasempty)
   1236 			softint_schedule(route_sih);
   1237 	}
   1238 	splx(s);
   1239 }
   1240 
   1241 void
   1242 rt_init(void)
   1243 {
   1244 
   1245 	route_intrq.ifq_maxlen = route_maxqlen;
   1246 	route_sih = softint_establish(SOFTINT_NET | SOFTINT_MPSAFE,
   1247 	    route_intr, NULL);
   1248 }
   1249 
   1250 /*
   1251  * Definitions of protocols supported in the ROUTE domain.
   1252  */
   1253 PR_WRAP_USRREQ(route_usrreq)
   1254 #define	route_usrreq	route_usrreq_wrapper
   1255 
   1256 const struct protosw routesw[] = {
   1257 	{
   1258 		.pr_type = SOCK_RAW,
   1259 		.pr_domain = &routedomain,
   1260 		.pr_flags = PR_ATOMIC|PR_ADDR,
   1261 		.pr_input = raw_input,
   1262 		.pr_output = route_output,
   1263 		.pr_ctlinput = raw_ctlinput,
   1264 		.pr_usrreq = route_usrreq,
   1265 		.pr_init = raw_init,
   1266 	},
   1267 };
   1268 
   1269 struct domain routedomain = {
   1270 	.dom_family = PF_ROUTE,
   1271 	.dom_name = "route",
   1272 	.dom_init = route_init,
   1273 	.dom_protosw = routesw,
   1274 	.dom_protoswNPROTOSW = &routesw[__arraycount(routesw)],
   1275 };
   1276 
   1277 SYSCTL_SETUP(sysctl_net_route_setup, "sysctl net.route subtree setup")
   1278 {
   1279 	const struct sysctlnode *rnode = NULL;
   1280 
   1281 	sysctl_createv(clog, 0, NULL, NULL,
   1282 		       CTLFLAG_PERMANENT,
   1283 		       CTLTYPE_NODE, "net", NULL,
   1284 		       NULL, 0, NULL, 0,
   1285 		       CTL_NET, CTL_EOL);
   1286 
   1287 	sysctl_createv(clog, 0, NULL, &rnode,
   1288 		       CTLFLAG_PERMANENT,
   1289 		       CTLTYPE_NODE, "route",
   1290 		       SYSCTL_DESCR("PF_ROUTE information"),
   1291 		       NULL, 0, NULL, 0,
   1292 		       CTL_NET, PF_ROUTE, CTL_EOL);
   1293 	sysctl_createv(clog, 0, NULL, NULL,
   1294 		       CTLFLAG_PERMANENT,
   1295 		       CTLTYPE_NODE, "rtable",
   1296 		       SYSCTL_DESCR("Routing table information"),
   1297 		       sysctl_rtable, 0, NULL, 0,
   1298 		       CTL_NET, PF_ROUTE, 0 /* any protocol */, CTL_EOL);
   1299 	sysctl_createv(clog, 0, &rnode, NULL,
   1300 		       CTLFLAG_PERMANENT,
   1301 		       CTLTYPE_STRUCT, "stats",
   1302 		       SYSCTL_DESCR("Routing statistics"),
   1303 		       NULL, 0, &rtstat, sizeof(rtstat),
   1304 		       CTL_CREATE, CTL_EOL);
   1305 }
   1306