The thread/proc pointer argument in the VFS subsystem originally existed
[dragonfly.git] / sys / net / rtsock.c
1 /*
2  * Copyright (c) 2004, 2005 The DragonFly Project.  All rights reserved.
3  *
4  * This code is derived from software contributed to The DragonFly Project
5  * by Jeffrey M. Hsu.
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 DragonFly Project nor the names of its
16  *    contributors may be used to endorse or promote products derived
17  *    from this software without specific, prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
22  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
23  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
24  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
25  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
26  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
27  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
28  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
29  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  */
32
33 /*
34  * Copyright (c) 2004, 2005 Jeffrey M. Hsu.  All rights reserved.
35  *
36  * License terms: all terms for the DragonFly license above plus the following:
37  *
38  * 4. All advertising materials mentioning features or use of this software
39  *    must display the following acknowledgement:
40  *
41  *      This product includes software developed by Jeffrey M. Hsu
42  *      for the DragonFly Project.
43  *
44  *    This requirement may be waived with permission from Jeffrey Hsu.
45  *    Permission will be granted to any DragonFly user for free.
46  *    This requirement will sunset and may be removed on Jan 31, 2006,
47  *    after which the standard DragonFly license (as shown above) will
48  *    apply.
49  */
50
51 /*
52  * Copyright (c) 1988, 1991, 1993
53  *      The Regents of the University of California.  All rights reserved.
54  *
55  * Redistribution and use in source and binary forms, with or without
56  * modification, are permitted provided that the following conditions
57  * are met:
58  * 1. Redistributions of source code must retain the above copyright
59  *    notice, this list of conditions and the following disclaimer.
60  * 2. Redistributions in binary form must reproduce the above copyright
61  *    notice, this list of conditions and the following disclaimer in the
62  *    documentation and/or other materials provided with the distribution.
63  * 3. All advertising materials mentioning features or use of this software
64  *    must display the following acknowledgement:
65  *      This product includes software developed by the University of
66  *      California, Berkeley and its contributors.
67  * 4. Neither the name of the University nor the names of its contributors
68  *    may be used to endorse or promote products derived from this software
69  *    without specific prior written permission.
70  *
71  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
72  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
73  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
74  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
75  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
76  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
77  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
78  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
79  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
80  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
81  * SUCH DAMAGE.
82  *
83  *      @(#)rtsock.c    8.7 (Berkeley) 10/12/95
84  * $FreeBSD: src/sys/net/rtsock.c,v 1.44.2.11 2002/12/04 14:05:41 ru Exp $
85  * $DragonFly: src/sys/net/rtsock.c,v 1.31 2006/05/06 02:43:12 dillon Exp $
86  */
87
88 #include "opt_sctp.h"
89
90 #include <sys/param.h>
91 #include <sys/systm.h>
92 #include <sys/kernel.h>
93 #include <sys/sysctl.h>
94 #include <sys/proc.h>
95 #include <sys/malloc.h>
96 #include <sys/mbuf.h>
97 #include <sys/protosw.h>
98 #include <sys/socket.h>
99 #include <sys/socketvar.h>
100 #include <sys/domain.h>
101 #include <sys/thread2.h>
102
103 #include <net/if.h>
104 #include <net/route.h>
105 #include <net/raw_cb.h>
106
107 #ifdef SCTP
108 extern void sctp_add_ip_address(struct ifaddr *ifa);
109 extern void sctp_delete_ip_address(struct ifaddr *ifa);
110 #endif /* SCTP */
111
112 MALLOC_DEFINE(M_RTABLE, "routetbl", "routing tables");
113
114 static struct route_cb {
115         int     ip_count;
116         int     ip6_count;
117         int     ipx_count;
118         int     ns_count;
119         int     any_count;
120 } route_cb;
121
122 static const struct sockaddr route_src = { 2, PF_ROUTE, };
123
124 struct walkarg {
125         int     w_tmemsize;
126         int     w_op, w_arg;
127         void    *w_tmem;
128         struct sysctl_req *w_req;
129 };
130
131 static struct mbuf *
132                 rt_msg_mbuf (int, struct rt_addrinfo *);
133 static void     rt_msg_buffer (int, struct rt_addrinfo *, void *buf, int len);
134 static int      rt_msgsize (int type, struct rt_addrinfo *rtinfo);
135 static int      rt_xaddrs (char *, char *, struct rt_addrinfo *);
136 static int      sysctl_dumpentry (struct radix_node *rn, void *vw);
137 static int      sysctl_iflist (int af, struct walkarg *w);
138 static int      route_output(struct mbuf *, struct socket *, ...);
139 static void     rt_setmetrics (u_long, struct rt_metrics *,
140                                struct rt_metrics *);
141
142 /*
143  * It really doesn't make any sense at all for this code to share much
144  * with raw_usrreq.c, since its functionality is so restricted.  XXX
145  */
146 static int
147 rts_abort(struct socket *so)
148 {
149         int error;
150
151         crit_enter();
152         error = raw_usrreqs.pru_abort(so);
153         crit_exit();
154         return error;
155 }
156
157 /* pru_accept is EOPNOTSUPP */
158
159 static int
160 rts_attach(struct socket *so, int proto, struct pru_attach_info *ai)
161 {
162         struct rawcb *rp;
163         int error;
164
165         if (sotorawcb(so) != NULL)
166                 return EISCONN; /* XXX panic? */
167
168         rp = malloc(sizeof *rp, M_PCB, M_WAITOK | M_ZERO);
169         if (rp == NULL)
170                 return ENOBUFS;
171
172         /*
173          * The critical section is necessary to block protocols from sending
174          * error notifications (like RTM_REDIRECT or RTM_LOSING) while
175          * this PCB is extant but incompletely initialized.
176          * Probably we should try to do more of this work beforehand and
177          * eliminate the critical section.
178          */
179         crit_enter();
180         so->so_pcb = rp;
181         error = raw_attach(so, proto, ai->sb_rlimit);
182         rp = sotorawcb(so);
183         if (error) {
184                 crit_exit();
185                 free(rp, M_PCB);
186                 return error;
187         }
188         switch(rp->rcb_proto.sp_protocol) {
189         case AF_INET:
190                 route_cb.ip_count++;
191                 break;
192         case AF_INET6:
193                 route_cb.ip6_count++;
194                 break;
195         case AF_IPX:
196                 route_cb.ipx_count++;
197                 break;
198         case AF_NS:
199                 route_cb.ns_count++;
200                 break;
201         }
202         rp->rcb_faddr = &route_src;
203         route_cb.any_count++;
204         soisconnected(so);
205         so->so_options |= SO_USELOOPBACK;
206         crit_exit();
207         return 0;
208 }
209
210 static int
211 rts_bind(struct socket *so, struct sockaddr *nam, struct thread *td)
212 {
213         int error;
214
215         crit_enter();
216         error = raw_usrreqs.pru_bind(so, nam, td); /* xxx just EINVAL */
217         crit_exit();
218         return error;
219 }
220
221 static int
222 rts_connect(struct socket *so, struct sockaddr *nam, struct thread *td)
223 {
224         int error;
225
226         crit_enter();
227         error = raw_usrreqs.pru_connect(so, nam, td); /* XXX just EINVAL */
228         crit_exit();
229         return error;
230 }
231
232 /* pru_connect2 is EOPNOTSUPP */
233 /* pru_control is EOPNOTSUPP */
234
235 static int
236 rts_detach(struct socket *so)
237 {
238         struct rawcb *rp = sotorawcb(so);
239         int error;
240
241         crit_enter();
242         if (rp != NULL) {
243                 switch(rp->rcb_proto.sp_protocol) {
244                 case AF_INET:
245                         route_cb.ip_count--;
246                         break;
247                 case AF_INET6:
248                         route_cb.ip6_count--;
249                         break;
250                 case AF_IPX:
251                         route_cb.ipx_count--;
252                         break;
253                 case AF_NS:
254                         route_cb.ns_count--;
255                         break;
256                 }
257                 route_cb.any_count--;
258         }
259         error = raw_usrreqs.pru_detach(so);
260         crit_exit();
261         return error;
262 }
263
264 static int
265 rts_disconnect(struct socket *so)
266 {
267         int error;
268
269         crit_enter();
270         error = raw_usrreqs.pru_disconnect(so);
271         crit_exit();
272         return error;
273 }
274
275 /* pru_listen is EOPNOTSUPP */
276
277 static int
278 rts_peeraddr(struct socket *so, struct sockaddr **nam)
279 {
280         int error;
281
282         crit_enter();
283         error = raw_usrreqs.pru_peeraddr(so, nam);
284         crit_exit();
285         return error;
286 }
287
288 /* pru_rcvd is EOPNOTSUPP */
289 /* pru_rcvoob is EOPNOTSUPP */
290
291 static int
292 rts_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *nam,
293          struct mbuf *control, struct thread *td)
294 {
295         int error;
296
297         crit_enter();
298         error = raw_usrreqs.pru_send(so, flags, m, nam, control, td);
299         crit_exit();
300         return error;
301 }
302
303 /* pru_sense is null */
304
305 static int
306 rts_shutdown(struct socket *so)
307 {
308         int error;
309
310         crit_enter();
311         error = raw_usrreqs.pru_shutdown(so);
312         crit_exit();
313         return error;
314 }
315
316 static int
317 rts_sockaddr(struct socket *so, struct sockaddr **nam)
318 {
319         int error;
320
321         crit_enter();
322         error = raw_usrreqs.pru_sockaddr(so, nam);
323         crit_exit();
324         return error;
325 }
326
327 static struct pr_usrreqs route_usrreqs = {
328         rts_abort, pru_accept_notsupp, rts_attach, rts_bind, rts_connect,
329         pru_connect2_notsupp, pru_control_notsupp, rts_detach, rts_disconnect,
330         pru_listen_notsupp, rts_peeraddr, pru_rcvd_notsupp, pru_rcvoob_notsupp,
331         rts_send, pru_sense_null, rts_shutdown, rts_sockaddr,
332         sosend, soreceive, sopoll
333 };
334
335 static __inline sa_family_t
336 familyof(struct sockaddr *sa)
337 {
338         return (sa != NULL ? sa->sa_family : 0);
339 }
340
341 static void
342 rts_input(struct mbuf *m, sa_family_t family)
343 {
344         static const struct sockaddr route_dst = { 2, PF_ROUTE, };
345         struct sockproto route_proto = { PF_ROUTE, family };
346
347         raw_input(m, &route_proto, &route_src, &route_dst);
348 }
349
350 static void *
351 reallocbuf(void *ptr, size_t len, size_t olen)
352 {
353         void *newptr;
354
355         newptr = malloc(len, M_RTABLE, M_INTWAIT | M_NULLOK);
356         if (newptr == NULL)
357                 return NULL;
358         bcopy(ptr, newptr, olen);
359         free(ptr, M_RTABLE);
360         return (newptr);
361 }
362
363 /*
364  * Internal helper routine for route_output().
365  */
366 static int
367 fillrtmsg(struct rt_msghdr **prtm, struct rtentry *rt,
368           struct rt_addrinfo *rtinfo)
369 {
370         int msglen;
371         struct rt_msghdr *rtm = *prtm;
372
373         /* Fill in rt_addrinfo for call to rt_msg_buffer(). */
374         rtinfo->rti_dst = rt_key(rt);
375         rtinfo->rti_gateway = rt->rt_gateway;
376         rtinfo->rti_netmask = rt_mask(rt);              /* might be NULL */
377         rtinfo->rti_genmask = rt->rt_genmask;           /* might be NULL */
378         if (rtm->rtm_addrs & (RTA_IFP | RTA_IFA)) {
379                 if (rt->rt_ifp != NULL) {
380                         rtinfo->rti_ifpaddr =
381                             TAILQ_FIRST(&rt->rt_ifp->if_addrhead)->ifa_addr;
382                         rtinfo->rti_ifaaddr = rt->rt_ifa->ifa_addr;
383                         if (rt->rt_ifp->if_flags & IFF_POINTOPOINT)
384                                 rtinfo->rti_bcastaddr = rt->rt_ifa->ifa_dstaddr;
385                         rtm->rtm_index = rt->rt_ifp->if_index;
386                 } else {
387                         rtinfo->rti_ifpaddr = NULL;
388                         rtinfo->rti_ifaaddr = NULL;
389             }
390         }
391
392         msglen = rt_msgsize(rtm->rtm_type, rtinfo);
393         if (rtm->rtm_msglen < msglen) {
394                 rtm = reallocbuf(rtm, msglen, rtm->rtm_msglen);
395                 if (rtm == NULL)
396                         return (ENOBUFS);
397                 *prtm = rtm;
398         }
399         rt_msg_buffer(rtm->rtm_type, rtinfo, rtm, msglen);
400
401         rtm->rtm_flags = rt->rt_flags;
402         rtm->rtm_rmx = rt->rt_rmx;
403         rtm->rtm_addrs = rtinfo->rti_addrs;
404
405         return (0);
406 }
407
408 static void route_output_add_callback(int, int, struct rt_addrinfo *,
409                                         struct rtentry *, void *);
410 static void route_output_delete_callback(int, int, struct rt_addrinfo *,
411                                         struct rtentry *, void *);
412 static void route_output_change_callback(int, int, struct rt_addrinfo *,
413                                         struct rtentry *, void *);
414 static void route_output_lock_callback(int, int, struct rt_addrinfo *, 
415                                         struct rtentry *, void *);
416
417 /*ARGSUSED*/
418 static int
419 route_output(struct mbuf *m, struct socket *so, ...)
420 {
421         struct rt_msghdr *rtm = NULL;
422         struct rtentry *rt;
423         struct radix_node_head *rnh;
424         struct rawcb *rp = NULL;
425         struct pr_output_info *oi;
426         struct rt_addrinfo rtinfo;
427         int len, error = 0;
428         __va_list ap;
429
430         __va_start(ap, so);
431         oi = __va_arg(ap, struct pr_output_info *);
432         __va_end(ap);
433
434 #define gotoerr(e) { error = e; goto flush;}
435
436         if (m == NULL ||
437             (m->m_len < sizeof(long) &&
438              (m = m_pullup(m, sizeof(long))) == NULL))
439                 return (ENOBUFS);
440         if (!(m->m_flags & M_PKTHDR))
441                 panic("route_output");
442         len = m->m_pkthdr.len;
443         if (len < sizeof(struct rt_msghdr) ||
444             len != mtod(m, struct rt_msghdr *)->rtm_msglen) {
445                 rtinfo.rti_dst = NULL;
446                 gotoerr(EINVAL);
447         }
448         rtm = malloc(len, M_RTABLE, M_INTWAIT | M_NULLOK);
449         if (rtm == NULL) {
450                 rtinfo.rti_dst = NULL;
451                 gotoerr(ENOBUFS);
452         }
453         m_copydata(m, 0, len, (caddr_t)rtm);
454         if (rtm->rtm_version != RTM_VERSION) {
455                 rtinfo.rti_dst = NULL;
456                 gotoerr(EPROTONOSUPPORT);
457         }
458         rtm->rtm_pid = oi->p_pid;
459         bzero(&rtinfo, sizeof(struct rt_addrinfo));
460         rtinfo.rti_addrs = rtm->rtm_addrs;
461         if (rt_xaddrs((char *)(rtm + 1), (char *)rtm + len, &rtinfo) != 0) {
462                 rtinfo.rti_dst = NULL;
463                 gotoerr(EINVAL);
464         }
465         rtinfo.rti_flags = rtm->rtm_flags;
466         if (rtinfo.rti_dst == NULL || rtinfo.rti_dst->sa_family >= AF_MAX ||
467             (rtinfo.rti_gateway && rtinfo.rti_gateway->sa_family >= AF_MAX))
468                 gotoerr(EINVAL);
469
470         if (rtinfo.rti_genmask != NULL) {
471                 struct radix_node *n;
472
473 #define clen(s) (*(u_char *)(s))
474                 n = rn_addmask((char *)rtinfo.rti_genmask, TRUE, 1);
475                 if (n != NULL &&
476                     rtinfo.rti_genmask->sa_len >= clen(n->rn_key) &&
477                     bcmp((char *)rtinfo.rti_genmask + 1,
478                          (char *)n->rn_key + 1, clen(n->rn_key) - 1) == 0)
479                         rtinfo.rti_genmask = (struct sockaddr *)n->rn_key;
480                 else
481                         gotoerr(ENOBUFS);
482         }
483
484         /*
485          * Verify that the caller has the appropriate privilege; RTM_GET
486          * is the only operation the non-superuser is allowed.
487          */
488         if (rtm->rtm_type != RTM_GET && suser_cred(so->so_cred, 0) != 0)
489                 gotoerr(EPERM);
490
491         switch (rtm->rtm_type) {
492         case RTM_ADD:
493                 if (rtinfo.rti_gateway == NULL) {
494                         error = EINVAL;
495                 } else {
496                         error = rtrequest1_global(RTM_ADD, &rtinfo, 
497                                           route_output_add_callback, rtm);
498                 }
499                 break;
500         case RTM_DELETE:
501                 /*
502                  * note: &rtm passed as argument so 'rtm' can be replaced.
503                  */
504                 error = rtrequest1_global(RTM_DELETE, &rtinfo,
505                                           route_output_delete_callback, &rtm);
506                 break;
507         case RTM_GET:
508                 rnh = rt_tables[mycpuid][rtinfo.rti_dst->sa_family];
509                 if (rnh == NULL) {
510                         error = EAFNOSUPPORT;
511                         break;
512                 }
513                 rt = (struct rtentry *)
514                     rnh->rnh_lookup((char *)rtinfo.rti_dst,
515                                     (char *)rtinfo.rti_netmask, rnh);
516                 if (rt == NULL) {
517                         error = ESRCH;
518                         break;
519                 }
520                 rt->rt_refcnt++;
521                 if (fillrtmsg(&rtm, rt, &rtinfo) != 0)
522                         gotoerr(ENOBUFS);
523                 --rt->rt_refcnt;
524                 break;
525         case RTM_CHANGE:
526                 error = rtrequest1_global(RTM_GET, &rtinfo,
527                                           route_output_change_callback, rtm);
528                 break;
529         case RTM_LOCK:
530                 error = rtrequest1_global(RTM_GET, &rtinfo,
531                                           route_output_lock_callback, rtm);
532                 break;
533         default:
534                 error = EOPNOTSUPP;
535                 break;
536         }
537
538 flush:
539         if (rtm != NULL) {
540                 if (error != 0)
541                         rtm->rtm_errno = error;
542                 else
543                         rtm->rtm_flags |= RTF_DONE;
544         }
545
546         /*
547          * Check to see if we don't want our own messages.
548          */
549         if (!(so->so_options & SO_USELOOPBACK)) {
550                 if (route_cb.any_count <= 1) {
551                         if (rtm != NULL)
552                                 free(rtm, M_RTABLE);
553                         m_freem(m);
554                         return (error);
555                 }
556                 /* There is another listener, so construct message */
557                 rp = sotorawcb(so);
558         }
559         if (rtm != NULL) {
560                 m_copyback(m, 0, rtm->rtm_msglen, (caddr_t)rtm);
561                 if (m->m_pkthdr.len < rtm->rtm_msglen) {
562                         m_freem(m);
563                         m = NULL;
564                 } else if (m->m_pkthdr.len > rtm->rtm_msglen)
565                         m_adj(m, rtm->rtm_msglen - m->m_pkthdr.len);
566                 free(rtm, M_RTABLE);
567         }
568         if (rp != NULL)
569                 rp->rcb_proto.sp_family = 0; /* Avoid us */
570         if (m != NULL)
571                 rts_input(m, familyof(rtinfo.rti_dst));
572         if (rp != NULL)
573                 rp->rcb_proto.sp_family = PF_ROUTE;
574         return (error);
575 }
576
577 static void
578 route_output_add_callback(int cmd, int error, struct rt_addrinfo *rtinfo,
579                           struct rtentry *rt, void *arg)
580 {
581         struct rt_msghdr *rtm = arg;
582
583         if (error == 0 && rt != NULL) {
584                 rt_setmetrics(rtm->rtm_inits, &rtm->rtm_rmx,
585                     &rt->rt_rmx);
586                 rt->rt_rmx.rmx_locks &= ~(rtm->rtm_inits);
587                 rt->rt_rmx.rmx_locks |=
588                     (rtm->rtm_inits & rtm->rtm_rmx.rmx_locks);
589                 rt->rt_genmask = rtinfo->rti_genmask;
590         }
591 }
592
593 static void
594 route_output_delete_callback(int cmd, int error, struct rt_addrinfo *rtinfo,
595                           struct rtentry *rt, void *arg)
596 {
597         struct rt_msghdr **rtm = arg;
598
599         if (error == 0 && rt) {
600                 ++rt->rt_refcnt;
601                 if (fillrtmsg(rtm, rt, rtinfo) != 0) {
602                         error = ENOBUFS;
603                         /* XXX no way to return the error */
604                 }
605                 --rt->rt_refcnt;
606         }
607 }
608
609 static void
610 route_output_change_callback(int cmd, int error, struct rt_addrinfo *rtinfo,
611                           struct rtentry *rt, void *arg)
612 {
613         struct rt_msghdr *rtm = arg;
614         struct ifaddr *ifa;
615
616         if (error)
617                 goto done;
618
619         /*
620          * new gateway could require new ifaddr, ifp;
621          * flags may also be different; ifp may be specified
622          * by ll sockaddr when protocol address is ambiguous
623          */
624         if (((rt->rt_flags & RTF_GATEWAY) && rtinfo->rti_gateway != NULL) ||
625             rtinfo->rti_ifpaddr != NULL || (rtinfo->rti_ifaaddr != NULL &&
626             sa_equal(rtinfo->rti_ifaaddr, rt->rt_ifa->ifa_addr))
627         ) {
628                 error = rt_getifa(rtinfo);
629                 if (error != 0)
630                         goto done;
631         }
632         if (rtinfo->rti_gateway != NULL) {
633                 error = rt_setgate(rt, rt_key(rt), rtinfo->rti_gateway);
634                 if (error != 0)
635                         goto done;
636         }
637         if ((ifa = rtinfo->rti_ifa) != NULL) {
638                 struct ifaddr *oifa = rt->rt_ifa;
639
640                 if (oifa != ifa) {
641                         if (oifa && oifa->ifa_rtrequest)
642                                 oifa->ifa_rtrequest(RTM_DELETE, rt, rtinfo);
643                         IFAFREE(rt->rt_ifa);
644                         IFAREF(ifa);
645                         rt->rt_ifa = ifa;
646                         rt->rt_ifp = rtinfo->rti_ifp;
647                 }
648         }
649         rt_setmetrics(rtm->rtm_inits, &rtm->rtm_rmx, &rt->rt_rmx);
650         if (rt->rt_ifa && rt->rt_ifa->ifa_rtrequest)
651                rt->rt_ifa->ifa_rtrequest(RTM_ADD, rt, rtinfo);
652         if (rtinfo->rti_genmask != NULL)
653                 rt->rt_genmask = rtinfo->rti_genmask;
654 done:
655         /* XXX no way to return error */
656         ;
657 }
658
659 static void
660 route_output_lock_callback(int cmd, int error, struct rt_addrinfo *rtinfo,
661                            struct rtentry *rt, void *arg)
662 {
663         struct rt_msghdr *rtm = arg;
664
665         rt->rt_rmx.rmx_locks &= ~(rtm->rtm_inits);
666         rt->rt_rmx.rmx_locks |=
667                 (rtm->rtm_inits & rtm->rtm_rmx.rmx_locks);
668 }
669
670 static void
671 rt_setmetrics(u_long which, struct rt_metrics *in, struct rt_metrics *out)
672 {
673 #define setmetric(flag, elt) if (which & (flag)) out->elt = in->elt;
674         setmetric(RTV_RPIPE, rmx_recvpipe);
675         setmetric(RTV_SPIPE, rmx_sendpipe);
676         setmetric(RTV_SSTHRESH, rmx_ssthresh);
677         setmetric(RTV_RTT, rmx_rtt);
678         setmetric(RTV_RTTVAR, rmx_rttvar);
679         setmetric(RTV_HOPCOUNT, rmx_hopcount);
680         setmetric(RTV_MTU, rmx_mtu);
681         setmetric(RTV_EXPIRE, rmx_expire);
682 #undef setmetric
683 }
684
685 #define ROUNDUP(a) \
686         ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
687
688 /*
689  * Extract the addresses of the passed sockaddrs.
690  * Do a little sanity checking so as to avoid bad memory references.
691  * This data is derived straight from userland.
692  */
693 static int
694 rt_xaddrs(char *cp, char *cplim, struct rt_addrinfo *rtinfo)
695 {
696         struct sockaddr *sa;
697         int i;
698
699         for (i = 0; (i < RTAX_MAX) && (cp < cplim); i++) {
700                 if ((rtinfo->rti_addrs & (1 << i)) == 0)
701                         continue;
702                 sa = (struct sockaddr *)cp;
703                 /*
704                  * It won't fit.
705                  */
706                 if ((cp + sa->sa_len) > cplim) {
707                         return (EINVAL);
708                 }
709
710                 /*
711                  * There are no more...  Quit now.
712                  * If there are more bits, they are in error.
713                  * I've seen this.  route(1) can evidently generate these. 
714                  * This causes kernel to core dump.
715                  * For compatibility, if we see this, point to a safe address.
716                  */
717                 if (sa->sa_len == 0) {
718                         static struct sockaddr sa_zero = {
719                                 sizeof sa_zero, AF_INET,
720                         };
721
722                         rtinfo->rti_info[i] = &sa_zero;
723                         return (0); /* should be EINVAL but for compat */
724                 }
725
726                 /* Accept the sockaddr. */
727                 rtinfo->rti_info[i] = sa;
728                 cp += ROUNDUP(sa->sa_len);
729         }
730         return (0);
731 }
732
733 static int
734 rt_msghdrsize(int type)
735 {
736         switch (type) {
737         case RTM_DELADDR:
738         case RTM_NEWADDR:
739                 return sizeof(struct ifa_msghdr);
740         case RTM_DELMADDR:
741         case RTM_NEWMADDR:
742                 return sizeof(struct ifma_msghdr);
743         case RTM_IFINFO:
744                 return sizeof(struct if_msghdr);
745         case RTM_IFANNOUNCE:
746                 return sizeof(struct if_announcemsghdr);
747         default:
748                 return sizeof(struct rt_msghdr);
749         }
750 }
751
752 static int
753 rt_msgsize(int type, struct rt_addrinfo *rtinfo)
754 {
755         int len, i;
756
757         len = rt_msghdrsize(type);
758         for (i = 0; i < RTAX_MAX; i++) {
759                 if (rtinfo->rti_info[i] != NULL)
760                         len += ROUNDUP(rtinfo->rti_info[i]->sa_len);
761         }
762         len = ALIGN(len);
763         return len;
764 }
765
766 /*
767  * Build a routing message in a buffer.
768  * Copy the addresses in the rtinfo->rti_info[] sockaddr array
769  * to the end of the buffer after the message header.
770  *
771  * Set the rtinfo->rti_addrs bitmask of addresses present in rtinfo->rti_info[].
772  * This side-effect can be avoided if we reorder the addrs bitmask field in all
773  * the route messages to line up so we can set it here instead of back in the
774  * calling routine.
775  */
776 static void
777 rt_msg_buffer(int type, struct rt_addrinfo *rtinfo, void *buf, int msglen)
778 {
779         struct rt_msghdr *rtm;
780         char *cp;
781         int dlen, i;
782
783         rtm = (struct rt_msghdr *) buf;
784         rtm->rtm_version = RTM_VERSION;
785         rtm->rtm_type = type;
786         rtm->rtm_msglen = msglen;
787
788         cp = (char *)buf + rt_msghdrsize(type);
789         rtinfo->rti_addrs = 0;
790         for (i = 0; i < RTAX_MAX; i++) {
791                 struct sockaddr *sa;
792
793                 if ((sa = rtinfo->rti_info[i]) == NULL)
794                         continue;
795                 rtinfo->rti_addrs |= (1 << i);
796                 dlen = ROUNDUP(sa->sa_len);
797                 bcopy(sa, cp, dlen);
798                 cp += dlen;
799         }
800 }
801
802 /*
803  * Build a routing message in a mbuf chain.
804  * Copy the addresses in the rtinfo->rti_info[] sockaddr array
805  * to the end of the mbuf after the message header.
806  *
807  * Set the rtinfo->rti_addrs bitmask of addresses present in rtinfo->rti_info[].
808  * This side-effect can be avoided if we reorder the addrs bitmask field in all
809  * the route messages to line up so we can set it here instead of back in the
810  * calling routine.
811  */
812 static struct mbuf *
813 rt_msg_mbuf(int type, struct rt_addrinfo *rtinfo)
814 {
815         struct mbuf *m;
816         struct rt_msghdr *rtm;
817         int hlen, len;
818         int i;
819
820         hlen = rt_msghdrsize(type);
821         KASSERT(hlen <= MCLBYTES, ("rt_msg_mbuf: hlen %d doesn't fit", hlen));
822
823         m = m_getl(hlen, MB_DONTWAIT, MT_DATA, M_PKTHDR, NULL);
824         if (m == NULL)
825                 return (NULL);
826         m->m_pkthdr.len = m->m_len = hlen;
827         m->m_pkthdr.rcvif = NULL;
828         rtinfo->rti_addrs = 0;
829         len = hlen;
830         for (i = 0; i < RTAX_MAX; i++) {
831                 struct sockaddr *sa;
832                 int dlen;
833
834                 if ((sa = rtinfo->rti_info[i]) == NULL)
835                         continue;
836                 rtinfo->rti_addrs |= (1 << i);
837                 dlen = ROUNDUP(sa->sa_len);
838                 m_copyback(m, len, dlen, (caddr_t)sa); /* can grow mbuf chain */
839                 len += dlen;
840         }
841         if (m->m_pkthdr.len != len) { /* one of the m_copyback() calls failed */
842                 m_freem(m);
843                 return (NULL);
844         }
845         rtm = mtod(m, struct rt_msghdr *);
846         bzero(rtm, hlen);
847         rtm->rtm_msglen = len;
848         rtm->rtm_version = RTM_VERSION;
849         rtm->rtm_type = type;
850         return (m);
851 }
852
853 /*
854  * This routine is called to generate a message from the routing
855  * socket indicating that a redirect has occurred, a routing lookup
856  * has failed, or that a protocol has detected timeouts to a particular
857  * destination.
858  */
859 void
860 rt_missmsg(int type, struct rt_addrinfo *rtinfo, int flags, int error)
861 {
862         struct sockaddr *dst = rtinfo->rti_info[RTAX_DST];
863         struct rt_msghdr *rtm;
864         struct mbuf *m;
865
866         if (route_cb.any_count == 0)
867                 return;
868         m = rt_msg_mbuf(type, rtinfo);
869         if (m == NULL)
870                 return;
871         rtm = mtod(m, struct rt_msghdr *);
872         rtm->rtm_flags = RTF_DONE | flags;
873         rtm->rtm_errno = error;
874         rtm->rtm_addrs = rtinfo->rti_addrs;
875         rts_input(m, familyof(dst));
876 }
877
878 void
879 rt_dstmsg(int type, struct sockaddr *dst, int error)
880 {
881         struct rt_msghdr *rtm;
882         struct rt_addrinfo addrs;
883         struct mbuf *m;
884
885         if (route_cb.any_count == 0)
886                 return;
887         bzero(&addrs, sizeof(struct rt_addrinfo));
888         addrs.rti_info[RTAX_DST] = dst;
889         m = rt_msg_mbuf(type, &addrs);
890         if (m == NULL)
891                 return;
892         rtm = mtod(m, struct rt_msghdr *);
893         rtm->rtm_flags = RTF_DONE;
894         rtm->rtm_errno = error;
895         rtm->rtm_addrs = addrs.rti_addrs;
896         rts_input(m, familyof(dst));
897 }
898
899 /*
900  * This routine is called to generate a message from the routing
901  * socket indicating that the status of a network interface has changed.
902  */
903 void
904 rt_ifmsg(struct ifnet *ifp)
905 {
906         struct if_msghdr *ifm;
907         struct mbuf *m;
908         struct rt_addrinfo rtinfo;
909
910         if (route_cb.any_count == 0)
911                 return;
912         bzero(&rtinfo, sizeof(struct rt_addrinfo));
913         m = rt_msg_mbuf(RTM_IFINFO, &rtinfo);
914         if (m == NULL)
915                 return;
916         ifm = mtod(m, struct if_msghdr *);
917         ifm->ifm_index = ifp->if_index;
918         ifm->ifm_flags = ifp->if_flags;
919         ifm->ifm_data = ifp->if_data;
920         ifm->ifm_addrs = 0;
921         rts_input(m, 0);
922 }
923
924 static void
925 rt_ifamsg(int cmd, struct ifaddr *ifa)
926 {
927         struct ifa_msghdr *ifam;
928         struct rt_addrinfo rtinfo;
929         struct mbuf *m;
930         struct ifnet *ifp = ifa->ifa_ifp;
931
932         bzero(&rtinfo, sizeof(struct rt_addrinfo));
933         rtinfo.rti_ifaaddr = ifa->ifa_addr;
934         rtinfo.rti_ifpaddr = TAILQ_FIRST(&ifp->if_addrhead)->ifa_addr;
935         rtinfo.rti_netmask = ifa->ifa_netmask;
936         rtinfo.rti_bcastaddr = ifa->ifa_dstaddr;
937
938         m = rt_msg_mbuf(cmd, &rtinfo);
939         if (m == NULL)
940                 return;
941
942         ifam = mtod(m, struct ifa_msghdr *);
943         ifam->ifam_index = ifp->if_index;
944         ifam->ifam_metric = ifa->ifa_metric;
945         ifam->ifam_flags = ifa->ifa_flags;
946         ifam->ifam_addrs = rtinfo.rti_addrs;
947
948         rts_input(m, familyof(ifa->ifa_addr));
949 }
950
951 void
952 rt_rtmsg(int cmd, struct rtentry *rt, struct ifnet *ifp, int error)
953 {
954         struct rt_msghdr *rtm;
955         struct rt_addrinfo rtinfo;
956         struct mbuf *m;
957         struct sockaddr *dst;
958
959         if (rt == NULL)
960                 return;
961
962         bzero(&rtinfo, sizeof(struct rt_addrinfo));
963         rtinfo.rti_dst = dst = rt_key(rt);
964         rtinfo.rti_gateway = rt->rt_gateway;
965         rtinfo.rti_netmask = rt_mask(rt);
966         if (ifp != NULL)
967                 rtinfo.rti_ifpaddr = TAILQ_FIRST(&ifp->if_addrhead)->ifa_addr;
968         rtinfo.rti_ifaaddr = rt->rt_ifa->ifa_addr;
969
970         m = rt_msg_mbuf(cmd, &rtinfo);
971         if (m == NULL)
972                 return;
973
974         rtm = mtod(m, struct rt_msghdr *);
975         if (ifp != NULL)
976                 rtm->rtm_index = ifp->if_index;
977         rtm->rtm_flags |= rt->rt_flags;
978         rtm->rtm_errno = error;
979         rtm->rtm_addrs = rtinfo.rti_addrs;
980
981         rts_input(m, familyof(dst));
982 }
983
984 /*
985  * This is called to generate messages from the routing socket
986  * indicating a network interface has had addresses associated with it.
987  * if we ever reverse the logic and replace messages TO the routing
988  * socket indicate a request to configure interfaces, then it will
989  * be unnecessary as the routing socket will automatically generate
990  * copies of it.
991  */
992 void
993 rt_newaddrmsg(int cmd, struct ifaddr *ifa, int error, struct rtentry *rt)
994 {
995 #ifdef SCTP
996         /*
997          * notify the SCTP stack
998          * this will only get called when an address is added/deleted
999          * XXX pass the ifaddr struct instead if ifa->ifa_addr...
1000          */
1001         if (cmd == RTM_ADD)
1002                 sctp_add_ip_address(ifa);
1003         else if (cmd == RTM_DELETE)
1004                 sctp_delete_ip_address(ifa);
1005 #endif /* SCTP */
1006
1007         if (route_cb.any_count == 0)
1008                 return;
1009
1010         if (cmd == RTM_ADD) {
1011                 rt_ifamsg(RTM_NEWADDR, ifa);
1012                 rt_rtmsg(RTM_ADD, rt, ifa->ifa_ifp, error);
1013         } else {
1014                 KASSERT((cmd == RTM_DELETE), ("unknown cmd %d", cmd));
1015                 rt_rtmsg(RTM_DELETE, rt, ifa->ifa_ifp, error);
1016                 rt_ifamsg(RTM_DELADDR, ifa);
1017         }
1018 }
1019
1020 /*
1021  * This is the analogue to the rt_newaddrmsg which performs the same
1022  * function but for multicast group memberhips.  This is easier since
1023  * there is no route state to worry about.
1024  */
1025 void
1026 rt_newmaddrmsg(int cmd, struct ifmultiaddr *ifma)
1027 {
1028         struct rt_addrinfo rtinfo;
1029         struct mbuf *m = NULL;
1030         struct ifnet *ifp = ifma->ifma_ifp;
1031         struct ifma_msghdr *ifmam;
1032
1033         if (route_cb.any_count == 0)
1034                 return;
1035
1036         bzero(&rtinfo, sizeof(struct rt_addrinfo));
1037         rtinfo.rti_ifaaddr = ifma->ifma_addr;
1038         if (ifp != NULL && !TAILQ_EMPTY(&ifp->if_addrhead))
1039                 rtinfo.rti_ifpaddr = TAILQ_FIRST(&ifp->if_addrhead)->ifa_addr;
1040         /*
1041          * If a link-layer address is present, present it as a ``gateway''
1042          * (similarly to how ARP entries, e.g., are presented).
1043          */
1044         rtinfo.rti_gateway = ifma->ifma_lladdr;
1045
1046         m = rt_msg_mbuf(cmd, &rtinfo);
1047         if (m == NULL)
1048                 return;
1049
1050         ifmam = mtod(m, struct ifma_msghdr *);
1051         ifmam->ifmam_index = ifp->if_index;
1052         ifmam->ifmam_addrs = rtinfo.rti_addrs;
1053
1054         rts_input(m, familyof(ifma->ifma_addr));
1055 }
1056
1057 /*
1058  * This is called to generate routing socket messages indicating
1059  * network interface arrival and departure.
1060  */
1061 void
1062 rt_ifannouncemsg(struct ifnet *ifp, int what)
1063 {
1064         struct rt_addrinfo addrinfo;
1065         struct mbuf *m;
1066         struct if_announcemsghdr *ifan;
1067
1068         if (route_cb.any_count == 0)
1069                 return;
1070
1071         bzero(&addrinfo, sizeof addrinfo);
1072         m = rt_msg_mbuf(RTM_IFANNOUNCE, &addrinfo);
1073         if (m == NULL)
1074                 return;
1075
1076         ifan = mtod(m, struct if_announcemsghdr *);
1077         ifan->ifan_index = ifp->if_index;
1078         strlcpy(ifan->ifan_name, ifp->if_xname, sizeof ifan->ifan_name);
1079         ifan->ifan_what = what;
1080
1081         rts_input(m, 0);
1082 }
1083
1084 static int
1085 resizewalkarg(struct walkarg *w, int len)
1086 {
1087         void *newptr;
1088
1089         newptr = malloc(len, M_RTABLE, M_INTWAIT | M_NULLOK);
1090         if (newptr == NULL)
1091                 return (ENOMEM);
1092         if (w->w_tmem != NULL)
1093                 free(w->w_tmem, M_RTABLE);
1094         w->w_tmem = newptr;
1095         w->w_tmemsize = len;
1096         return (0);
1097 }
1098
1099 /*
1100  * This is used in dumping the kernel table via sysctl().
1101  */
1102 int
1103 sysctl_dumpentry(struct radix_node *rn, void *vw)
1104 {
1105         struct walkarg *w = vw;
1106         struct rtentry *rt = (struct rtentry *)rn;
1107         struct rt_addrinfo rtinfo;
1108         int error, msglen;
1109
1110         if (w->w_op == NET_RT_FLAGS && !(rt->rt_flags & w->w_arg))
1111                 return 0;
1112
1113         bzero(&rtinfo, sizeof(struct rt_addrinfo));
1114         rtinfo.rti_dst = rt_key(rt);
1115         rtinfo.rti_gateway = rt->rt_gateway;
1116         rtinfo.rti_netmask = rt_mask(rt);
1117         rtinfo.rti_genmask = rt->rt_genmask;
1118         if (rt->rt_ifp != NULL) {
1119                 rtinfo.rti_ifpaddr =
1120                     TAILQ_FIRST(&rt->rt_ifp->if_addrhead)->ifa_addr;
1121                 rtinfo.rti_ifaaddr = rt->rt_ifa->ifa_addr;
1122                 if (rt->rt_ifp->if_flags & IFF_POINTOPOINT)
1123                         rtinfo.rti_bcastaddr = rt->rt_ifa->ifa_dstaddr;
1124         }
1125         msglen = rt_msgsize(RTM_GET, &rtinfo);
1126         if (w->w_tmemsize < msglen && resizewalkarg(w, msglen) != 0)
1127                 return (ENOMEM);
1128         rt_msg_buffer(RTM_GET, &rtinfo, w->w_tmem, msglen);
1129         if (w->w_req != NULL) {
1130                 struct rt_msghdr *rtm = w->w_tmem;
1131
1132                 rtm->rtm_flags = rt->rt_flags;
1133                 rtm->rtm_use = rt->rt_use;
1134                 rtm->rtm_rmx = rt->rt_rmx;
1135                 rtm->rtm_index = rt->rt_ifp->if_index;
1136                 rtm->rtm_errno = rtm->rtm_pid = rtm->rtm_seq = 0;
1137                 rtm->rtm_addrs = rtinfo.rti_addrs;
1138                 error = SYSCTL_OUT(w->w_req, rtm, msglen);
1139                 return (error);
1140         }
1141         return (0);
1142 }
1143
1144 static int
1145 sysctl_iflist(int af, struct walkarg *w)
1146 {
1147         struct ifnet *ifp;
1148         struct ifaddr *ifa;
1149         struct rt_addrinfo rtinfo;
1150         int msglen, error;
1151
1152         bzero(&rtinfo, sizeof(struct rt_addrinfo));
1153         TAILQ_FOREACH(ifp, &ifnet, if_link) {
1154                 if (w->w_arg && w->w_arg != ifp->if_index)
1155                         continue;
1156                 ifa = TAILQ_FIRST(&ifp->if_addrhead);
1157                 rtinfo.rti_ifpaddr = ifa->ifa_addr;
1158                 msglen = rt_msgsize(RTM_IFINFO, &rtinfo);
1159                 if (w->w_tmemsize < msglen && resizewalkarg(w, msglen) != 0)
1160                         return (ENOMEM);
1161                 rt_msg_buffer(RTM_IFINFO, &rtinfo, w->w_tmem, msglen);
1162                 rtinfo.rti_ifpaddr = NULL;
1163                 if (w->w_req != NULL && w->w_tmem != NULL) {
1164                         struct if_msghdr *ifm = w->w_tmem;
1165
1166                         ifm->ifm_index = ifp->if_index;
1167                         ifm->ifm_flags = ifp->if_flags;
1168                         ifm->ifm_data = ifp->if_data;
1169                         ifm->ifm_addrs = rtinfo.rti_addrs;
1170                         error = SYSCTL_OUT(w->w_req, ifm, msglen);
1171                         if (error)
1172                                 return (error);
1173                 }
1174                 while ((ifa = TAILQ_NEXT(ifa, ifa_link)) != NULL) {
1175                         if (af && af != ifa->ifa_addr->sa_family)
1176                                 continue;
1177                         if (curproc->p_ucred->cr_prison &&
1178                             prison_if(curproc->p_ucred, ifa->ifa_addr))
1179                                 continue;
1180                         rtinfo.rti_ifaaddr = ifa->ifa_addr;
1181                         rtinfo.rti_netmask = ifa->ifa_netmask;
1182                         rtinfo.rti_bcastaddr = ifa->ifa_dstaddr;
1183                         msglen = rt_msgsize(RTM_NEWADDR, &rtinfo);
1184                         if (w->w_tmemsize < msglen &&
1185                             resizewalkarg(w, msglen) != 0)
1186                                 return (ENOMEM);
1187                         rt_msg_buffer(RTM_NEWADDR, &rtinfo, w->w_tmem, msglen);
1188                         if (w->w_req != NULL) {
1189                                 struct ifa_msghdr *ifam = w->w_tmem;
1190
1191                                 ifam->ifam_index = ifa->ifa_ifp->if_index;
1192                                 ifam->ifam_flags = ifa->ifa_flags;
1193                                 ifam->ifam_metric = ifa->ifa_metric;
1194                                 ifam->ifam_addrs = rtinfo.rti_addrs;
1195                                 error = SYSCTL_OUT(w->w_req, w->w_tmem, msglen);
1196                                 if (error)
1197                                         return (error);
1198                         }
1199                 }
1200                 rtinfo.rti_netmask = NULL;
1201                 rtinfo.rti_ifaaddr = NULL;
1202                 rtinfo.rti_bcastaddr = NULL;
1203         }
1204         return (0);
1205 }
1206
1207 static int
1208 sysctl_rtsock(SYSCTL_HANDLER_ARGS)
1209 {
1210         int     *name = (int *)arg1;
1211         u_int   namelen = arg2;
1212         struct radix_node_head *rnh;
1213         int     i, error = EINVAL;
1214         int     origcpu;
1215         u_char  af;
1216         struct  walkarg w;
1217
1218         name ++;
1219         namelen--;
1220         if (req->newptr)
1221                 return (EPERM);
1222         if (namelen != 3 && namelen != 4)
1223                 return (EINVAL);
1224         af = name[0];
1225         bzero(&w, sizeof w);
1226         w.w_op = name[1];
1227         w.w_arg = name[2];
1228         w.w_req = req;
1229
1230         /*
1231          * Optional third argument specifies cpu, used primarily for
1232          * debugging the route table.
1233          */
1234         if (namelen == 4) {
1235                 if (name[3] < 0 || name[3] >= ncpus)
1236                         return (EINVAL);
1237                 origcpu = mycpuid;
1238                 lwkt_migratecpu(name[3]);
1239         } else {
1240                 origcpu = -1;
1241         }
1242         crit_enter();
1243         switch (w.w_op) {
1244         case NET_RT_DUMP:
1245         case NET_RT_FLAGS:
1246                 for (i = 1; i <= AF_MAX; i++)
1247                         if ((rnh = rt_tables[mycpuid][i]) &&
1248                             (af == 0 || af == i) &&
1249                             (error = rnh->rnh_walktree(rnh,
1250                                                        sysctl_dumpentry, &w)))
1251                                 break;
1252                 break;
1253
1254         case NET_RT_IFLIST:
1255                 error = sysctl_iflist(af, &w);
1256         }
1257         crit_exit();
1258         if (w.w_tmem != NULL)
1259                 free(w.w_tmem, M_RTABLE);
1260         if (origcpu >= 0)
1261                 lwkt_migratecpu(origcpu);
1262         return (error);
1263 }
1264
1265 SYSCTL_NODE(_net, PF_ROUTE, routetable, CTLFLAG_RD, sysctl_rtsock, "");
1266
1267 /*
1268  * Definitions of protocols supported in the ROUTE domain.
1269  */
1270
1271 extern struct domain routedomain;               /* or at least forward */
1272
1273 static struct protosw routesw[] = {
1274 { SOCK_RAW,     &routedomain,   0,              PR_ATOMIC|PR_ADDR,
1275   0,            route_output,   raw_ctlinput,   0,
1276   cpu0_soport,
1277   raw_init,     0,              0,              0,
1278   &route_usrreqs
1279 }
1280 };
1281
1282 static struct domain routedomain = {
1283         PF_ROUTE, "route", NULL, NULL, NULL,
1284         routesw, &routesw[(sizeof routesw)/(sizeof routesw[0])],
1285 };
1286
1287 DOMAIN_SET(route);