2 * Copyright (c) 2004, 2005 The DragonFly Project. All rights reserved.
4 * This code is derived from software contributed to The DragonFly Project
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
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.
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
34 * Copyright (c) 1988, 1991, 1993
35 * The Regents of the University of California. All rights reserved.
37 * Redistribution and use in source and binary forms, with or without
38 * modification, are permitted provided that the following conditions
40 * 1. Redistributions of source code must retain the above copyright
41 * notice, this list of conditions and the following disclaimer.
42 * 2. Redistributions in binary form must reproduce the above copyright
43 * notice, this list of conditions and the following disclaimer in the
44 * documentation and/or other materials provided with the distribution.
45 * 3. Neither the name of the University nor the names of its contributors
46 * may be used to endorse or promote products derived from this software
47 * without specific prior written permission.
49 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
50 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
51 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
52 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
53 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
54 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
55 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
56 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
57 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
58 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
61 * @(#)rtsock.c 8.7 (Berkeley) 10/12/95
62 * $FreeBSD: src/sys/net/rtsock.c,v 1.44.2.11 2002/12/04 14:05:41 ru Exp $
65 #include "opt_inet6.h"
67 #include <sys/param.h>
68 #include <sys/systm.h>
69 #include <sys/kernel.h>
70 #include <sys/sysctl.h>
73 #include <sys/malloc.h>
75 #include <sys/protosw.h>
76 #include <sys/socket.h>
77 #include <sys/socketvar.h>
78 #include <sys/domain.h>
81 #include <sys/thread2.h>
82 #include <sys/socketvar2.h>
85 #include <net/if_var.h>
86 #include <net/route.h>
87 #include <net/raw_cb.h>
88 #include <net/netmsg2.h>
89 #include <net/netisr2.h>
92 #include <netinet/in_var.h>
95 /* sa_family is after sa_len, rest is data */
96 #define _SA_MINSIZE (offsetof(struct sockaddr, sa_family) + \
97 sizeof(((struct sockaddr *)0)->sa_family))
99 MALLOC_DEFINE(M_RTABLE
, "routetbl", "routing tables");
101 static struct route_cb
{
107 static const struct sockaddr route_src
= { 2, PF_ROUTE
, };
113 struct sysctl_req
*w_req
;
116 #ifndef RTTABLE_DUMP_MSGCNT_MAX
117 /* Should be large enough for dupkeys */
118 #define RTTABLE_DUMP_MSGCNT_MAX 64
121 struct rttable_walkarg
{
132 struct sockaddr_storage w_key0
;
133 struct sockaddr_storage w_mask0
;
136 struct netmsg_rttable_walk
{
137 struct netmsg_base base
;
139 struct rttable_walkarg
*w
;
143 struct rawcb rocb_rcb
;
144 unsigned int rocb_msgfilter
;
145 char *rocb_missfilter
;
146 size_t rocb_missfilterlen
;
148 #define sotoroutecb(so) ((struct routecb *)(so)->so_pcb)
151 rt_msg_mbuf (int, struct rt_addrinfo
*);
152 static void rt_msg_buffer (int, struct rt_addrinfo
*, void *buf
, int len
);
153 static int rt_msgsize(int type
, const struct rt_addrinfo
*rtinfo
);
154 static int rt_xaddrs (char *, char *, struct rt_addrinfo
*);
155 static int sysctl_rttable(int af
, struct sysctl_req
*req
, int op
, int arg
);
156 static int if_addrflags(const struct ifaddr
*ifa
);
157 static int sysctl_iflist (int af
, struct walkarg
*w
);
158 static int route_output(struct mbuf
*, struct socket
*, ...);
159 static void rt_setmetrics (u_long
, struct rt_metrics
*,
160 struct rt_metrics
*);
163 * It really doesn't make any sense at all for this code to share much
164 * with raw_usrreq.c, since its functionality is so restricted. XXX
167 rts_abort(netmsg_t msg
)
170 raw_usrreqs
.pru_abort(msg
);
171 /* msg invalid now */
176 rts_filter(struct mbuf
*m
, const struct sockproto
*proto
,
177 const struct rawcb
*rp
)
179 const struct routecb
*rop
= (const struct routecb
*)rp
;
180 const struct rt_msghdr
*rtm
;
183 KKASSERT(proto
!= NULL
);
184 KKASSERT(rp
!= NULL
);
186 /* Wrong family for this socket. */
187 if (proto
->sp_family
!= PF_ROUTE
)
190 /* If no filter set, just return. */
191 if (rop
->rocb_msgfilter
== 0 && rop
->rocb_missfilterlen
== 0)
194 /* Ensure we can access rtm_type */
196 offsetof(struct rt_msghdr
, rtm_type
) + sizeof(rtm
->rtm_type
))
199 rtm
= mtod(m
, const struct rt_msghdr
*);
200 /* If the rtm type is filtered out, return a positive. */
201 if (rop
->rocb_msgfilter
!= 0 &&
202 !(rop
->rocb_msgfilter
& ROUTE_FILTER(rtm
->rtm_type
)))
205 if (rop
->rocb_missfilterlen
!= 0 && rtm
->rtm_type
== RTM_MISS
) {
206 CTASSERT(RTAX_DST
== 0);
208 struct sockaddr_storage ss
;
209 struct sockaddr
*dst
= (struct sockaddr
*)&ss
;
210 char *cp
= rop
->rocb_missfilter
;
211 char *ep
= cp
+ rop
->rocb_missfilterlen
;
213 /* Ensure we can access sa_len */
214 if (m
->m_pkthdr
.len
< sizeof(*rtm
) + _SA_MINSIZE
)
216 m_copydata(m
, sizeof(*rtm
) + offsetof(struct sockaddr
, sa_len
),
217 sizeof(ss
.ss_len
), (caddr_t
)&ss
);
218 if (ss
.ss_len
< _SA_MINSIZE
||
219 ss
.ss_len
> sizeof(ss
) ||
220 m
->m_pkthdr
.len
< sizeof(*rtm
) + ss
.ss_len
)
222 /* Copy out the destination sockaddr */
223 m_copydata(m
, sizeof(*rtm
), ss
.ss_len
, (caddr_t
)&ss
);
225 /* Find a matching sockaddr in the filter */
227 sa
= (struct sockaddr
*)cp
;
228 if (sa
->sa_len
== dst
->sa_len
&&
229 memcmp(sa
, dst
, sa
->sa_len
) == 0)
231 cp
+= RT_ROUNDUP(sa
->sa_len
);
237 /* Passed the filter. */
242 /* pru_accept is EOPNOTSUPP */
245 rts_attach(netmsg_t msg
)
247 struct socket
*so
= msg
->base
.nm_so
;
248 struct pru_attach_info
*ai
= msg
->attach
.nm_ai
;
251 int proto
= msg
->attach
.nm_proto
;
255 if (sotorawcb(so
) != NULL
) {
260 rop
= kmalloc(sizeof *rop
, M_PCB
, M_WAITOK
| M_ZERO
);
264 * The critical section is necessary to block protocols from sending
265 * error notifications (like RTM_REDIRECT or RTM_LOSING) while
266 * this PCB is extant but incompletely initialized.
267 * Probably we should try to do more of this work beforehand and
268 * eliminate the critical section.
271 soreference(so
); /* so_pcb assignment */
272 error
= raw_attach(so
, proto
, ai
->sb_rlimit
);
278 switch(rp
->rcb_proto
.sp_protocol
) {
283 route_cb
.ip6_count
++;
286 rp
->rcb_faddr
= &route_src
;
287 rp
->rcb_filter
= rts_filter
;
288 route_cb
.any_count
++;
290 so
->so_options
|= SO_USELOOPBACK
;
294 lwkt_replymsg(&msg
->lmsg
, error
);
298 rts_bind(netmsg_t msg
)
301 raw_usrreqs
.pru_bind(msg
); /* xxx just EINVAL */
302 /* msg invalid now */
307 rts_connect(netmsg_t msg
)
310 raw_usrreqs
.pru_connect(msg
); /* XXX just EINVAL */
311 /* msg invalid now */
315 /* pru_connect2 is EOPNOTSUPP */
316 /* pru_control is EOPNOTSUPP */
319 rts_detach(netmsg_t msg
)
321 struct socket
*so
= msg
->base
.nm_so
;
322 struct rawcb
*rp
= sotorawcb(so
);
323 struct routecb
*rop
= (struct routecb
*)rp
;
326 if (rop
->rocb_missfilterlen
!= 0)
327 kfree(rop
->rocb_missfilter
, M_PCB
);
329 switch(rp
->rcb_proto
.sp_protocol
) {
334 route_cb
.ip6_count
--;
337 route_cb
.any_count
--;
339 raw_usrreqs
.pru_detach(msg
);
340 /* msg invalid now */
345 rts_disconnect(netmsg_t msg
)
348 raw_usrreqs
.pru_disconnect(msg
);
349 /* msg invalid now */
353 /* pru_listen is EOPNOTSUPP */
356 rts_peeraddr(netmsg_t msg
)
359 raw_usrreqs
.pru_peeraddr(msg
);
360 /* msg invalid now */
364 /* pru_rcvd is EOPNOTSUPP */
365 /* pru_rcvoob is EOPNOTSUPP */
368 rts_send(netmsg_t msg
)
371 raw_usrreqs
.pru_send(msg
);
372 /* msg invalid now */
376 /* pru_sense is null */
379 rts_shutdown(netmsg_t msg
)
382 raw_usrreqs
.pru_shutdown(msg
);
383 /* msg invalid now */
388 rts_sockaddr(netmsg_t msg
)
391 raw_usrreqs
.pru_sockaddr(msg
);
392 /* msg invalid now */
396 static struct pr_usrreqs route_usrreqs
= {
397 .pru_abort
= rts_abort
,
398 .pru_accept
= pr_generic_notsupp
,
399 .pru_attach
= rts_attach
,
400 .pru_bind
= rts_bind
,
401 .pru_connect
= rts_connect
,
402 .pru_connect2
= pr_generic_notsupp
,
403 .pru_control
= pr_generic_notsupp
,
404 .pru_detach
= rts_detach
,
405 .pru_disconnect
= rts_disconnect
,
406 .pru_listen
= pr_generic_notsupp
,
407 .pru_peeraddr
= rts_peeraddr
,
408 .pru_rcvd
= pr_generic_notsupp
,
409 .pru_rcvoob
= pr_generic_notsupp
,
410 .pru_send
= rts_send
,
411 .pru_sense
= pru_sense_null
,
412 .pru_shutdown
= rts_shutdown
,
413 .pru_sockaddr
= rts_sockaddr
,
414 .pru_sosend
= sosend
,
415 .pru_soreceive
= soreceive
418 static __inline sa_family_t
419 familyof(struct sockaddr
*sa
)
421 return (sa
!= NULL
? sa
->sa_family
: 0);
425 * Routing socket input function. The packet must be serialized onto cpu 0.
426 * We use the cpu0_soport() netisr processing loop to handle it.
428 * This looks messy but it means that anyone, including interrupt code,
429 * can send a message to the routing socket.
432 rts_input_handler(netmsg_t msg
)
434 static const struct sockaddr route_dst
= { 2, PF_ROUTE
, };
435 struct sockproto route_proto
;
436 struct netmsg_packet
*pmsg
= &msg
->packet
;
441 family
= pmsg
->base
.lmsg
.u
.ms_result
;
442 route_proto
.sp_family
= PF_ROUTE
;
443 route_proto
.sp_protocol
= family
;
448 skip
= m
->m_pkthdr
.header
;
449 m
->m_pkthdr
.header
= NULL
;
451 raw_input(m
, &route_proto
, &route_src
, &route_dst
, skip
);
455 rts_input_skip(struct mbuf
*m
, sa_family_t family
, struct rawcb
*skip
)
457 struct netmsg_packet
*pmsg
;
462 port
= netisr_cpuport(0); /* XXX same as for routing socket */
463 pmsg
= &m
->m_hdr
.mh_netmsg
;
464 netmsg_init(&pmsg
->base
, NULL
, &netisr_apanic_rport
,
465 0, rts_input_handler
);
467 pmsg
->base
.lmsg
.u
.ms_result
= family
;
468 m
->m_pkthdr
.header
= skip
; /* XXX steal field in pkthdr */
469 lwkt_sendmsg(port
, &pmsg
->base
.lmsg
);
473 rts_input(struct mbuf
*m
, sa_family_t family
)
475 rts_input_skip(m
, family
, NULL
);
479 route_ctloutput(netmsg_t msg
)
481 struct socket
*so
= msg
->ctloutput
.base
.nm_so
;
482 struct sockopt
*sopt
= msg
->ctloutput
.nm_sopt
;
483 struct routecb
*rop
= sotoroutecb(so
);
485 unsigned int msgfilter
;
486 unsigned char *cp
, *ep
;
490 if (sopt
->sopt_level
!= AF_ROUTE
) {
497 switch (sopt
->sopt_dir
) {
499 switch (sopt
->sopt_name
) {
500 case ROUTE_MSGFILTER
:
501 error
= soopt_to_kbuf(sopt
, &msgfilter
,
502 sizeof(msgfilter
), sizeof(msgfilter
));
504 rop
->rocb_msgfilter
= msgfilter
;
507 /* Validate the data */
510 ep
= cp
+ sopt
->sopt_valsize
;
513 offsetof(struct sockaddr
, sa_len
) +
516 if (++len
> RO_FILTSA_MAX
) {
520 sa
= (struct sockaddr
*)cp
;
521 if (sa
->sa_len
< _SA_MINSIZE
||
522 sa
->sa_len
> sizeof(struct sockaddr_storage
))
524 cp
+= RT_ROUNDUP(sa
->sa_len
);
531 if (rop
->rocb_missfilterlen
!= 0)
532 kfree(rop
->rocb_missfilter
, M_PCB
);
533 if (sopt
->sopt_valsize
!= 0) {
534 rop
->rocb_missfilter
=
535 kmalloc(sopt
->sopt_valsize
,
536 M_PCB
, M_WAITOK
| M_NULLOK
);
537 if (rop
->rocb_missfilter
== NULL
) {
538 rop
->rocb_missfilterlen
= 0;
543 rop
->rocb_missfilter
= NULL
;
544 rop
->rocb_missfilterlen
= sopt
->sopt_valsize
;
545 if (rop
->rocb_missfilterlen
!= 0)
546 memcpy(rop
->rocb_missfilter
, sopt
->sopt_val
,
547 rop
->rocb_missfilterlen
);
555 switch (sopt
->sopt_name
) {
556 case ROUTE_MSGFILTER
:
557 msgfilter
= rop
->rocb_msgfilter
;
558 soopt_from_kbuf(sopt
, &msgfilter
, sizeof(msgfilter
));
561 soopt_from_kbuf(sopt
, rop
->rocb_missfilter
,
562 rop
->rocb_missfilterlen
);
570 lwkt_replymsg(&msg
->ctloutput
.base
.lmsg
, error
);
576 reallocbuf_nofree(void *ptr
, size_t len
, size_t olen
)
580 newptr
= kmalloc(len
, M_RTABLE
, M_INTWAIT
| M_NULLOK
);
583 bcopy(ptr
, newptr
, olen
);
585 bzero((char *)newptr
+ olen
, len
- olen
);
591 * Internal helper routine for route_output().
594 _fillrtmsg(struct rt_msghdr
**prtm
, struct rtentry
*rt
,
595 struct rt_addrinfo
*rtinfo
)
598 struct rt_msghdr
*rtm
= *prtm
;
600 /* Fill in rt_addrinfo for call to rt_msg_buffer(). */
601 rtinfo
->rti_dst
= rt_key(rt
);
602 rtinfo
->rti_gateway
= rt
->rt_gateway
;
603 rtinfo
->rti_netmask
= rt_mask(rt
); /* might be NULL */
604 rtinfo
->rti_genmask
= rt
->rt_genmask
; /* might be NULL */
605 if (rtm
->rtm_addrs
& (RTA_IFP
| RTA_IFA
)) {
606 if (rt
->rt_ifp
!= NULL
) {
607 rtinfo
->rti_ifpaddr
=
608 TAILQ_FIRST(&rt
->rt_ifp
->if_addrheads
[mycpuid
])
610 rtinfo
->rti_ifaaddr
= rt
->rt_ifa
->ifa_addr
;
611 if (rt
->rt_ifp
->if_flags
& IFF_POINTOPOINT
)
612 rtinfo
->rti_bcastaddr
= rt
->rt_ifa
->ifa_dstaddr
;
613 rtm
->rtm_index
= rt
->rt_ifp
->if_index
;
615 rtinfo
->rti_ifpaddr
= NULL
;
616 rtinfo
->rti_ifaaddr
= NULL
;
618 } else if (rt
->rt_ifp
!= NULL
) {
619 rtm
->rtm_index
= rt
->rt_ifp
->if_index
;
622 msglen
= rt_msgsize(rtm
->rtm_type
, rtinfo
);
623 if (rtm
->rtm_msglen
< msglen
) {
624 /* NOTE: Caller will free the old rtm accordingly */
625 rtm
= reallocbuf_nofree(rtm
, msglen
, rtm
->rtm_msglen
);
630 rt_msg_buffer(rtm
->rtm_type
, rtinfo
, rtm
, msglen
);
632 rtm
->rtm_flags
= rt
->rt_flags
;
633 rtm
->rtm_rmx
= rt
->rt_rmx
;
634 rtm
->rtm_addrs
= rtinfo
->rti_addrs
;
640 struct rt_msghdr
*bak_rtm
;
641 struct rt_msghdr
*new_rtm
;
645 fillrtmsg(struct rtm_arg
*arg
, struct rtentry
*rt
,
646 struct rt_addrinfo
*rtinfo
)
648 struct rt_msghdr
*rtm
= arg
->new_rtm
;
651 error
= _fillrtmsg(&rtm
, rt
, rtinfo
);
653 if (arg
->new_rtm
!= rtm
) {
655 * _fillrtmsg() just allocated a new rtm;
656 * if the previously allocated rtm is not
657 * the backing rtm, it should be freed.
659 if (arg
->new_rtm
!= arg
->bak_rtm
)
660 kfree(arg
->new_rtm
, M_RTABLE
);
667 static void route_output_add_callback(int, int, struct rt_addrinfo
*,
668 struct rtentry
*, void *);
669 static void route_output_delete_callback(int, int, struct rt_addrinfo
*,
670 struct rtentry
*, void *);
671 static int route_output_get_callback(int, struct rt_addrinfo
*,
672 struct rtentry
*, void *, int);
673 static int route_output_change_callback(int, struct rt_addrinfo
*,
674 struct rtentry
*, void *, int);
675 static int route_output_lock_callback(int, struct rt_addrinfo
*,
676 struct rtentry
*, void *, int);
680 route_output(struct mbuf
*m
, struct socket
*so
, ...)
683 struct rt_msghdr
*rtm
= NULL
;
684 struct rawcb
*rp
= NULL
;
685 struct pr_output_info
*oi
;
686 struct rt_addrinfo rtinfo
;
694 oi
= __va_arg(ap
, struct pr_output_info
*);
697 family
= familyof(NULL
);
699 #define gotoerr(e) { error = e; goto flush;}
702 (m
->m_len
< sizeof(long) &&
703 (m
= m_pullup(m
, sizeof(long))) == NULL
))
705 len
= m
->m_pkthdr
.len
;
706 if (len
< sizeof(struct rt_msghdr
) ||
707 len
!= mtod(m
, struct rt_msghdr
*)->rtm_msglen
)
710 rtm
= kmalloc(len
, M_RTABLE
, M_INTWAIT
| M_NULLOK
);
714 m_copydata(m
, 0, len
, (caddr_t
)rtm
);
715 if (rtm
->rtm_version
!= RTM_VERSION
)
716 gotoerr(EPROTONOSUPPORT
);
718 rtm
->rtm_pid
= oi
->p_pid
;
719 bzero(&rtinfo
, sizeof(struct rt_addrinfo
));
720 rtinfo
.rti_addrs
= rtm
->rtm_addrs
;
721 if (rt_xaddrs((char *)(rtm
+ 1), (char *)rtm
+ len
, &rtinfo
) != 0)
724 rtinfo
.rti_flags
= rtm
->rtm_flags
;
725 if (rtinfo
.rti_dst
== NULL
|| rtinfo
.rti_dst
->sa_family
>= AF_MAX
||
726 (rtinfo
.rti_gateway
&& rtinfo
.rti_gateway
->sa_family
>= AF_MAX
))
729 family
= familyof(rtinfo
.rti_dst
);
732 * Verify that the caller has the appropriate privilege; RTM_GET
733 * is the only operation the non-superuser is allowed.
735 if (rtm
->rtm_type
!= RTM_GET
&&
736 priv_check_cred(so
->so_cred
, PRIV_ROOT
, 0) != 0)
739 if (rtinfo
.rti_genmask
!= NULL
) {
740 error
= rtmask_add_global(rtinfo
.rti_genmask
,
741 rtm
->rtm_type
!= RTM_GET
?
742 RTREQ_PRIO_HIGH
: RTREQ_PRIO_NORM
);
747 switch (rtm
->rtm_type
) {
749 if (rtinfo
.rti_gateway
== NULL
) {
752 error
= rtrequest1_global(RTM_ADD
, &rtinfo
,
753 route_output_add_callback
, rtm
, RTREQ_PRIO_HIGH
);
758 * Backing rtm (bak_rtm) could _not_ be freed during
759 * rtrequest1_global or rtsearch_global, even if the
760 * callback reallocates the rtm due to its size changes,
761 * since rtinfo points to the backing rtm's memory area.
762 * After rtrequest1_global or rtsearch_global returns,
763 * it is safe to free the backing rtm, since rtinfo will
764 * not be used anymore.
766 * new_rtm will be used to save the new rtm allocated
767 * by rtrequest1_global or rtsearch_global.
771 error
= rtrequest1_global(RTM_DELETE
, &rtinfo
,
772 route_output_delete_callback
, &arg
, RTREQ_PRIO_HIGH
);
774 if (rtm
!= arg
.bak_rtm
)
775 kfree(arg
.bak_rtm
, M_RTABLE
);
778 /* See the comment in RTM_DELETE */
781 error
= rtsearch_global(RTM_GET
, &rtinfo
,
782 route_output_get_callback
, &arg
, RTS_NOEXACTMATCH
,
785 if (rtm
!= arg
.bak_rtm
)
786 kfree(arg
.bak_rtm
, M_RTABLE
);
789 error
= rtsearch_global(RTM_CHANGE
, &rtinfo
,
790 route_output_change_callback
, rtm
, RTS_EXACTMATCH
,
794 error
= rtsearch_global(RTM_LOCK
, &rtinfo
,
795 route_output_lock_callback
, rtm
, RTS_EXACTMATCH
,
805 rtm
->rtm_errno
= error
;
807 rtm
->rtm_flags
|= RTF_DONE
;
811 * Check to see if we don't want our own messages.
813 if (!(so
->so_options
& SO_USELOOPBACK
)) {
814 if (route_cb
.any_count
<= 1) {
816 kfree(rtm
, M_RTABLE
);
820 /* There is another listener, so construct message */
824 m_copyback(m
, 0, rtm
->rtm_msglen
, (caddr_t
)rtm
);
825 if (m
->m_pkthdr
.len
< rtm
->rtm_msglen
) {
828 } else if (m
->m_pkthdr
.len
> rtm
->rtm_msglen
)
829 m_adj(m
, rtm
->rtm_msglen
- m
->m_pkthdr
.len
);
830 kfree(rtm
, M_RTABLE
);
833 rts_input_skip(m
, family
, rp
);
838 route_output_add_callback(int cmd
, int error
, struct rt_addrinfo
*rtinfo
,
839 struct rtentry
*rt
, void *arg
)
841 struct rt_msghdr
*rtm
= arg
;
843 if (error
== 0 && rt
!= NULL
) {
844 rt_setmetrics(rtm
->rtm_inits
, &rtm
->rtm_rmx
,
846 rt
->rt_rmx
.rmx_locks
&= ~(rtm
->rtm_inits
);
847 rt
->rt_rmx
.rmx_locks
|=
848 (rtm
->rtm_inits
& rtm
->rtm_rmx
.rmx_locks
);
849 if (rtinfo
->rti_genmask
!= NULL
) {
850 rt
->rt_genmask
= rtmask_purelookup(rtinfo
->rti_genmask
);
851 if (rt
->rt_genmask
== NULL
) {
853 * This should not happen, since we
854 * have already installed genmask
855 * on each CPU before we reach here.
857 panic("genmask is gone!?");
860 rt
->rt_genmask
= NULL
;
862 rtm
->rtm_index
= rt
->rt_ifp
->if_index
;
867 route_output_delete_callback(int cmd
, int error
, struct rt_addrinfo
*rtinfo
,
868 struct rtentry
*rt
, void *arg
)
870 if (error
== 0 && rt
) {
872 if (fillrtmsg(arg
, rt
, rtinfo
) != 0) {
874 /* XXX no way to return the error */
878 if (rt
&& rt
->rt_refcnt
== 0) {
885 route_output_get_callback(int cmd
, struct rt_addrinfo
*rtinfo
,
886 struct rtentry
*rt
, void *arg
, int found_cnt
)
888 int error
, found
= 0;
890 if (((rtinfo
->rti_flags
^ rt
->rt_flags
) & RTF_HOST
) == 0)
893 error
= fillrtmsg(arg
, rt
, rtinfo
);
894 if (!error
&& found
) {
895 /* Got the exact match, we could return now! */
902 route_output_change_callback(int cmd
, struct rt_addrinfo
*rtinfo
,
903 struct rtentry
*rt
, void *arg
, int found_cnt
)
905 struct rt_msghdr
*rtm
= arg
;
910 * new gateway could require new ifaddr, ifp;
911 * flags may also be different; ifp may be specified
912 * by ll sockaddr when protocol address is ambiguous
914 if (((rt
->rt_flags
& RTF_GATEWAY
) && rtinfo
->rti_gateway
!= NULL
) ||
915 rtinfo
->rti_ifpaddr
!= NULL
||
916 (rtinfo
->rti_ifaaddr
!= NULL
&&
917 !sa_equal(rtinfo
->rti_ifaaddr
, rt
->rt_ifa
->ifa_addr
))) {
918 error
= rt_getifa(rtinfo
);
922 if (rtinfo
->rti_gateway
!= NULL
) {
924 * We only need to generate rtmsg upon the
925 * first route to be changed.
927 error
= rt_setgate(rt
, rt_key(rt
), rtinfo
->rti_gateway
);
931 if ((ifa
= rtinfo
->rti_ifa
) != NULL
) {
932 struct ifaddr
*oifa
= rt
->rt_ifa
;
935 if (oifa
&& oifa
->ifa_rtrequest
)
936 oifa
->ifa_rtrequest(RTM_DELETE
, rt
);
940 rt
->rt_ifp
= rtinfo
->rti_ifp
;
943 rt_setmetrics(rtm
->rtm_inits
, &rtm
->rtm_rmx
, &rt
->rt_rmx
);
944 if (rt
->rt_ifa
&& rt
->rt_ifa
->ifa_rtrequest
)
945 rt
->rt_ifa
->ifa_rtrequest(RTM_ADD
, rt
);
946 if (rtinfo
->rti_genmask
!= NULL
) {
947 rt
->rt_genmask
= rtmask_purelookup(rtinfo
->rti_genmask
);
948 if (rt
->rt_genmask
== NULL
) {
950 * This should not happen, since we
951 * have already installed genmask
952 * on each CPU before we reach here.
954 panic("genmask is gone!?");
957 rtm
->rtm_index
= rt
->rt_ifp
->if_index
;
959 rt_rtmsg(RTM_CHANGE
, rt
, rt
->rt_ifp
, 0);
965 route_output_lock_callback(int cmd
, struct rt_addrinfo
*rtinfo
,
966 struct rtentry
*rt
, void *arg
,
967 int found_cnt __unused
)
969 struct rt_msghdr
*rtm
= arg
;
971 rt
->rt_rmx
.rmx_locks
&= ~(rtm
->rtm_inits
);
972 rt
->rt_rmx
.rmx_locks
|=
973 (rtm
->rtm_inits
& rtm
->rtm_rmx
.rmx_locks
);
978 rt_setmetrics(u_long which
, struct rt_metrics
*in
, struct rt_metrics
*out
)
980 #define setmetric(flag, elt) if (which & (flag)) out->elt = in->elt;
981 setmetric(RTV_RPIPE
, rmx_recvpipe
);
982 setmetric(RTV_SPIPE
, rmx_sendpipe
);
983 setmetric(RTV_SSTHRESH
, rmx_ssthresh
);
984 setmetric(RTV_RTT
, rmx_rtt
);
985 setmetric(RTV_RTTVAR
, rmx_rttvar
);
986 setmetric(RTV_HOPCOUNT
, rmx_hopcount
);
987 setmetric(RTV_MTU
, rmx_mtu
);
988 setmetric(RTV_EXPIRE
, rmx_expire
);
989 setmetric(RTV_MSL
, rmx_msl
);
990 setmetric(RTV_IWMAXSEGS
, rmx_iwmaxsegs
);
991 setmetric(RTV_IWCAPSEGS
, rmx_iwcapsegs
);
996 * Extract the addresses of the passed sockaddrs.
997 * Do a little sanity checking so as to avoid bad memory references.
998 * This data is derived straight from userland.
1001 rt_xaddrs(char *cp
, char *cplim
, struct rt_addrinfo
*rtinfo
)
1003 struct sockaddr
*sa
;
1006 for (i
= 0; (i
< RTAX_MAX
) && (cp
< cplim
); i
++) {
1007 if ((rtinfo
->rti_addrs
& (1 << i
)) == 0)
1009 sa
= (struct sockaddr
*)cp
;
1013 if ((cp
+ sa
->sa_len
) > cplim
) {
1018 * There are no more... Quit now.
1019 * If there are more bits, they are in error.
1020 * I've seen this. route(1) can evidently generate these.
1021 * This causes kernel to core dump.
1022 * For compatibility, if we see this, point to a safe address.
1024 if (sa
->sa_len
== 0) {
1025 static struct sockaddr sa_zero
= {
1026 sizeof sa_zero
, AF_INET
,
1029 rtinfo
->rti_info
[i
] = &sa_zero
;
1030 kprintf("rtsock: received more addr bits than sockaddrs.\n");
1031 return (0); /* should be EINVAL but for compat */
1034 /* Accept the sockaddr. */
1035 rtinfo
->rti_info
[i
] = sa
;
1036 cp
+= RT_ROUNDUP(sa
->sa_len
);
1042 rt_msghdrsize(int type
)
1047 return sizeof(struct ifa_msghdr
);
1050 return sizeof(struct ifma_msghdr
);
1052 return sizeof(struct if_msghdr
);
1053 case RTM_IFANNOUNCE
:
1055 return sizeof(struct if_announcemsghdr
);
1057 return sizeof(struct rt_msghdr
);
1062 rt_msgsize(int type
, const struct rt_addrinfo
*rtinfo
)
1066 len
= rt_msghdrsize(type
);
1067 for (i
= 0; i
< RTAX_MAX
; i
++) {
1068 if (rtinfo
->rti_info
[i
] != NULL
)
1069 len
+= RT_ROUNDUP(rtinfo
->rti_info
[i
]->sa_len
);
1076 * Build a routing message in a buffer.
1077 * Copy the addresses in the rtinfo->rti_info[] sockaddr array
1078 * to the end of the buffer after the message header.
1080 * Set the rtinfo->rti_addrs bitmask of addresses present in rtinfo->rti_info[].
1081 * This side-effect can be avoided if we reorder the addrs bitmask field in all
1082 * the route messages to line up so we can set it here instead of back in the
1085 * NOTE! The buffer may already contain a partially filled-out rtm via
1089 rt_msg_buffer(int type
, struct rt_addrinfo
*rtinfo
, void *buf
, int msglen
)
1091 struct rt_msghdr
*rtm
;
1095 rtm
= (struct rt_msghdr
*) buf
;
1096 rtm
->rtm_version
= RTM_VERSION
;
1097 rtm
->rtm_type
= type
;
1098 rtm
->rtm_msglen
= msglen
;
1100 cp
= (char *)buf
+ rt_msghdrsize(type
);
1101 rtinfo
->rti_addrs
= 0;
1102 for (i
= 0; i
< RTAX_MAX
; i
++) {
1103 struct sockaddr
*sa
;
1105 if ((sa
= rtinfo
->rti_info
[i
]) == NULL
)
1107 rtinfo
->rti_addrs
|= (1 << i
);
1108 dlen
= RT_ROUNDUP(sa
->sa_len
);
1109 bcopy(sa
, cp
, dlen
);
1115 * Build a routing message in a mbuf chain.
1116 * Copy the addresses in the rtinfo->rti_info[] sockaddr array
1117 * to the end of the mbuf after the message header.
1119 * Set the rtinfo->rti_addrs bitmask of addresses present in rtinfo->rti_info[].
1120 * This side-effect can be avoided if we reorder the addrs bitmask field in all
1121 * the route messages to line up so we can set it here instead of back in the
1124 static struct mbuf
*
1125 rt_msg_mbuf(int type
, struct rt_addrinfo
*rtinfo
)
1128 struct rt_msghdr
*rtm
;
1132 hlen
= rt_msghdrsize(type
);
1133 KASSERT(hlen
<= MCLBYTES
, ("rt_msg_mbuf: hlen %d doesn't fit", hlen
));
1135 m
= m_getl(hlen
, M_NOWAIT
, MT_DATA
, M_PKTHDR
, NULL
);
1139 m
->m_pkthdr
.len
= m
->m_len
= hlen
;
1140 m
->m_pkthdr
.rcvif
= NULL
;
1141 rtinfo
->rti_addrs
= 0;
1143 for (i
= 0; i
< RTAX_MAX
; i
++) {
1144 struct sockaddr
*sa
;
1147 if ((sa
= rtinfo
->rti_info
[i
]) == NULL
)
1149 rtinfo
->rti_addrs
|= (1 << i
);
1150 dlen
= RT_ROUNDUP(sa
->sa_len
);
1151 m_copyback(m
, len
, dlen
, (caddr_t
)sa
); /* can grow mbuf chain */
1154 if (m
->m_pkthdr
.len
!= len
) { /* one of the m_copyback() calls failed */
1158 rtm
= mtod(m
, struct rt_msghdr
*);
1160 rtm
->rtm_msglen
= len
;
1161 rtm
->rtm_version
= RTM_VERSION
;
1162 rtm
->rtm_type
= type
;
1167 * This routine is called to generate a message from the routing
1168 * socket indicating that a redirect has occurred, a routing lookup
1169 * has failed, or that a protocol has detected timeouts to a particular
1173 rt_missmsg(int type
, struct rt_addrinfo
*rtinfo
, int flags
, int error
)
1175 struct sockaddr
*dst
= rtinfo
->rti_info
[RTAX_DST
];
1176 struct rt_msghdr
*rtm
;
1179 if (route_cb
.any_count
== 0)
1181 m
= rt_msg_mbuf(type
, rtinfo
);
1184 rtm
= mtod(m
, struct rt_msghdr
*);
1185 rtm
->rtm_flags
= RTF_DONE
| flags
;
1186 rtm
->rtm_errno
= error
;
1187 rtm
->rtm_addrs
= rtinfo
->rti_addrs
;
1188 rts_input(m
, familyof(dst
));
1192 rt_dstmsg(int type
, struct sockaddr
*dst
, int error
)
1194 struct rt_msghdr
*rtm
;
1195 struct rt_addrinfo addrs
;
1198 if (route_cb
.any_count
== 0)
1200 bzero(&addrs
, sizeof(struct rt_addrinfo
));
1201 addrs
.rti_info
[RTAX_DST
] = dst
;
1202 m
= rt_msg_mbuf(type
, &addrs
);
1205 rtm
= mtod(m
, struct rt_msghdr
*);
1206 rtm
->rtm_flags
= RTF_DONE
;
1207 rtm
->rtm_errno
= error
;
1208 rtm
->rtm_addrs
= addrs
.rti_addrs
;
1209 rts_input(m
, familyof(dst
));
1213 * This routine is called to generate a message from the routing
1214 * socket indicating that the status of a network interface has changed.
1217 rt_ifmsg(struct ifnet
*ifp
)
1219 struct if_msghdr
*ifm
;
1221 struct rt_addrinfo rtinfo
;
1223 if (route_cb
.any_count
== 0)
1225 bzero(&rtinfo
, sizeof(struct rt_addrinfo
));
1226 m
= rt_msg_mbuf(RTM_IFINFO
, &rtinfo
);
1229 ifm
= mtod(m
, struct if_msghdr
*);
1230 ifm
->ifm_index
= ifp
->if_index
;
1231 ifm
->ifm_flags
= ifp
->if_flags
;
1232 ifm
->ifm_data
= ifp
->if_data
;
1238 rt_ifamsg(int cmd
, struct ifaddr
*ifa
)
1240 struct ifa_msghdr
*ifam
;
1241 struct rt_addrinfo rtinfo
;
1243 struct ifnet
*ifp
= ifa
->ifa_ifp
;
1245 bzero(&rtinfo
, sizeof(struct rt_addrinfo
));
1246 rtinfo
.rti_ifaaddr
= ifa
->ifa_addr
;
1247 rtinfo
.rti_ifpaddr
=
1248 TAILQ_FIRST(&ifp
->if_addrheads
[mycpuid
])->ifa
->ifa_addr
;
1249 rtinfo
.rti_netmask
= ifa
->ifa_netmask
;
1250 rtinfo
.rti_bcastaddr
= ifa
->ifa_dstaddr
;
1252 m
= rt_msg_mbuf(cmd
, &rtinfo
);
1256 ifam
= mtod(m
, struct ifa_msghdr
*);
1257 ifam
->ifam_index
= ifp
->if_index
;
1258 ifam
->ifam_flags
= ifa
->ifa_flags
;
1259 ifam
->ifam_addrs
= rtinfo
.rti_addrs
;
1260 ifam
->ifam_addrflags
= if_addrflags(ifa
);
1261 ifam
->ifam_metric
= ifa
->ifa_metric
;
1263 rts_input(m
, familyof(ifa
->ifa_addr
));
1267 rt_rtmsg(int cmd
, struct rtentry
*rt
, struct ifnet
*ifp
, int error
)
1269 struct rt_msghdr
*rtm
;
1270 struct rt_addrinfo rtinfo
;
1272 struct sockaddr
*dst
;
1277 bzero(&rtinfo
, sizeof(struct rt_addrinfo
));
1278 rtinfo
.rti_dst
= dst
= rt_key(rt
);
1279 rtinfo
.rti_gateway
= rt
->rt_gateway
;
1280 rtinfo
.rti_netmask
= rt_mask(rt
);
1282 rtinfo
.rti_ifpaddr
=
1283 TAILQ_FIRST(&ifp
->if_addrheads
[mycpuid
])->ifa
->ifa_addr
;
1285 if (rt
->rt_ifa
!= NULL
)
1286 rtinfo
.rti_ifaaddr
= rt
->rt_ifa
->ifa_addr
;
1288 m
= rt_msg_mbuf(cmd
, &rtinfo
);
1292 rtm
= mtod(m
, struct rt_msghdr
*);
1294 rtm
->rtm_index
= ifp
->if_index
;
1295 rtm
->rtm_flags
|= rt
->rt_flags
;
1296 rtm
->rtm_errno
= error
;
1297 rtm
->rtm_addrs
= rtinfo
.rti_addrs
;
1299 rts_input(m
, familyof(dst
));
1303 * This is called to generate messages from the routing socket
1304 * indicating a network interface has had addresses associated with it.
1305 * if we ever reverse the logic and replace messages TO the routing
1306 * socket indicate a request to configure interfaces, then it will
1307 * be unnecessary as the routing socket will automatically generate
1311 rt_newaddrmsg(int cmd
, struct ifaddr
*ifa
, int error
, struct rtentry
*rt
)
1313 if (route_cb
.any_count
== 0)
1316 if (cmd
== RTM_ADD
) {
1317 rt_ifamsg(RTM_NEWADDR
, ifa
);
1318 rt_rtmsg(RTM_ADD
, rt
, ifa
->ifa_ifp
, error
);
1320 KASSERT((cmd
== RTM_DELETE
), ("unknown cmd %d", cmd
));
1321 rt_rtmsg(RTM_DELETE
, rt
, ifa
->ifa_ifp
, error
);
1322 rt_ifamsg(RTM_DELADDR
, ifa
);
1327 * This is the analogue to the rt_newaddrmsg which performs the same
1328 * function but for multicast group memberhips. This is easier since
1329 * there is no route state to worry about.
1332 rt_newmaddrmsg(int cmd
, struct ifmultiaddr
*ifma
)
1334 struct rt_addrinfo rtinfo
;
1335 struct mbuf
*m
= NULL
;
1336 struct ifnet
*ifp
= ifma
->ifma_ifp
;
1337 struct ifma_msghdr
*ifmam
;
1339 if (route_cb
.any_count
== 0)
1342 bzero(&rtinfo
, sizeof(struct rt_addrinfo
));
1343 rtinfo
.rti_ifaaddr
= ifma
->ifma_addr
;
1344 if (ifp
!= NULL
&& !TAILQ_EMPTY(&ifp
->if_addrheads
[mycpuid
])) {
1345 rtinfo
.rti_ifpaddr
=
1346 TAILQ_FIRST(&ifp
->if_addrheads
[mycpuid
])->ifa
->ifa_addr
;
1349 * If a link-layer address is present, present it as a ``gateway''
1350 * (similarly to how ARP entries, e.g., are presented).
1352 rtinfo
.rti_gateway
= ifma
->ifma_lladdr
;
1354 m
= rt_msg_mbuf(cmd
, &rtinfo
);
1358 ifmam
= mtod(m
, struct ifma_msghdr
*);
1359 ifmam
->ifmam_index
= ifp
->if_index
;
1360 ifmam
->ifmam_addrs
= rtinfo
.rti_addrs
;
1362 rts_input(m
, familyof(ifma
->ifma_addr
));
1365 static struct mbuf
*
1366 rt_makeifannouncemsg(struct ifnet
*ifp
, int type
, int what
,
1367 struct rt_addrinfo
*info
)
1369 struct if_announcemsghdr
*ifan
;
1372 if (route_cb
.any_count
== 0)
1375 bzero(info
, sizeof(*info
));
1376 m
= rt_msg_mbuf(type
, info
);
1380 ifan
= mtod(m
, struct if_announcemsghdr
*);
1381 ifan
->ifan_index
= ifp
->if_index
;
1382 strlcpy(ifan
->ifan_name
, ifp
->if_xname
, sizeof ifan
->ifan_name
);
1383 ifan
->ifan_what
= what
;
1388 * This is called to generate routing socket messages indicating
1389 * IEEE80211 wireless events.
1390 * XXX we piggyback on the RTM_IFANNOUNCE msg format in a clumsy way.
1393 rt_ieee80211msg(struct ifnet
*ifp
, int what
, void *data
, size_t data_len
)
1395 struct rt_addrinfo info
;
1398 m
= rt_makeifannouncemsg(ifp
, RTM_IEEE80211
, what
, &info
);
1403 * Append the ieee80211 data. Try to stick it in the
1404 * mbuf containing the ifannounce msg; otherwise allocate
1405 * a new mbuf and append.
1407 * NB: we assume m is a single mbuf.
1409 if (data_len
> M_TRAILINGSPACE(m
)) {
1410 /* XXX use m_getb(data_len, M_NOWAIT, MT_DATA, 0); */
1411 struct mbuf
*n
= m_get(M_NOWAIT
, MT_DATA
);
1416 KKASSERT(data_len
<= M_TRAILINGSPACE(n
));
1417 bcopy(data
, mtod(n
, void *), data_len
);
1418 n
->m_len
= data_len
;
1420 } else if (data_len
> 0) {
1421 bcopy(data
, mtod(m
, u_int8_t
*) + m
->m_len
, data_len
);
1422 m
->m_len
+= data_len
;
1425 if (m
->m_flags
& M_PKTHDR
)
1426 m
->m_pkthdr
.len
+= data_len
;
1427 mtod(m
, struct if_announcemsghdr
*)->ifan_msglen
+= data_len
;
1432 * This is called to generate routing socket messages indicating
1433 * network interface arrival and departure.
1436 rt_ifannouncemsg(struct ifnet
*ifp
, int what
)
1438 struct rt_addrinfo addrinfo
;
1441 m
= rt_makeifannouncemsg(ifp
, RTM_IFANNOUNCE
, what
, &addrinfo
);
1447 resizewalkarg(struct walkarg
*w
, int len
)
1451 newptr
= kmalloc(len
, M_RTABLE
, M_INTWAIT
| M_NULLOK
);
1454 if (w
->w_tmem
!= NULL
)
1455 kfree(w
->w_tmem
, M_RTABLE
);
1457 w
->w_tmemsize
= len
;
1464 ifnet_compute_stats(struct ifnet
*ifp
)
1466 IFNET_STAT_GET(ifp
, ipackets
, ifp
->if_ipackets
);
1467 IFNET_STAT_GET(ifp
, ierrors
, ifp
->if_ierrors
);
1468 IFNET_STAT_GET(ifp
, opackets
, ifp
->if_opackets
);
1469 IFNET_STAT_GET(ifp
, collisions
, ifp
->if_collisions
);
1470 IFNET_STAT_GET(ifp
, ibytes
, ifp
->if_ibytes
);
1471 IFNET_STAT_GET(ifp
, obytes
, ifp
->if_obytes
);
1472 IFNET_STAT_GET(ifp
, imcasts
, ifp
->if_imcasts
);
1473 IFNET_STAT_GET(ifp
, omcasts
, ifp
->if_omcasts
);
1474 IFNET_STAT_GET(ifp
, iqdrops
, ifp
->if_iqdrops
);
1475 IFNET_STAT_GET(ifp
, noproto
, ifp
->if_noproto
);
1476 IFNET_STAT_GET(ifp
, oqdrops
, ifp
->if_oqdrops
);
1480 if_addrflags(const struct ifaddr
*ifa
)
1482 switch (ifa
->ifa_addr
->sa_family
) {
1485 return ((const struct in6_ifaddr
*)ifa
)->ia6_flags
;
1493 sysctl_iflist(int af
, struct walkarg
*w
)
1496 struct rt_addrinfo rtinfo
;
1499 bzero(&rtinfo
, sizeof(struct rt_addrinfo
));
1502 TAILQ_FOREACH(ifp
, &ifnetlist
, if_link
) {
1503 struct ifaddr_container
*ifac
, *ifac_mark
;
1504 struct ifaddr_marker mark
;
1505 struct ifaddrhead
*head
;
1508 if (w
->w_arg
&& w
->w_arg
!= ifp
->if_index
)
1510 head
= &ifp
->if_addrheads
[mycpuid
];
1512 * There is no need to reference the first ifaddr
1513 * even if the following resizewalkarg() blocks,
1514 * since the first ifaddr will not be destroyed
1515 * when the ifnet lock is held.
1517 ifac
= TAILQ_FIRST(head
);
1519 rtinfo
.rti_ifpaddr
= ifa
->ifa_addr
;
1520 msglen
= rt_msgsize(RTM_IFINFO
, &rtinfo
);
1521 if (w
->w_tmemsize
< msglen
&& resizewalkarg(w
, msglen
) != 0) {
1525 rt_msg_buffer(RTM_IFINFO
, &rtinfo
, w
->w_tmem
, msglen
);
1526 rtinfo
.rti_ifpaddr
= NULL
;
1527 if (w
->w_req
!= NULL
&& w
->w_tmem
!= NULL
) {
1528 struct if_msghdr
*ifm
= w
->w_tmem
;
1530 ifm
->ifm_index
= ifp
->if_index
;
1531 ifm
->ifm_flags
= ifp
->if_flags
;
1532 ifnet_compute_stats(ifp
);
1533 ifm
->ifm_data
= ifp
->if_data
;
1534 ifm
->ifm_addrs
= rtinfo
.rti_addrs
;
1535 error
= SYSCTL_OUT(w
->w_req
, ifm
, msglen
);
1542 * Add a marker, since SYSCTL_OUT() could block and during
1543 * that period the list could be changed.
1545 ifa_marker_init(&mark
, ifp
);
1546 ifac_mark
= &mark
.ifac
;
1547 TAILQ_INSERT_AFTER(head
, ifac
, ifac_mark
, ifa_link
);
1548 while ((ifac
= TAILQ_NEXT(ifac_mark
, ifa_link
)) != NULL
) {
1549 TAILQ_REMOVE(head
, ifac_mark
, ifa_link
);
1550 TAILQ_INSERT_AFTER(head
, ifac
, ifac_mark
, ifa_link
);
1555 if (ifa
->ifa_addr
->sa_family
== AF_UNSPEC
)
1558 if (af
&& af
!= ifa
->ifa_addr
->sa_family
)
1560 if (curproc
->p_ucred
->cr_prison
&&
1561 prison_if(curproc
->p_ucred
, ifa
->ifa_addr
))
1563 rtinfo
.rti_ifaaddr
= ifa
->ifa_addr
;
1564 rtinfo
.rti_netmask
= ifa
->ifa_netmask
;
1565 rtinfo
.rti_bcastaddr
= ifa
->ifa_dstaddr
;
1566 msglen
= rt_msgsize(RTM_NEWADDR
, &rtinfo
);
1568 * Keep a reference on this ifaddr, so that it will
1569 * not be destroyed if the following resizewalkarg()
1573 if (w
->w_tmemsize
< msglen
&&
1574 resizewalkarg(w
, msglen
) != 0) {
1576 TAILQ_REMOVE(head
, ifac_mark
, ifa_link
);
1580 rt_msg_buffer(RTM_NEWADDR
, &rtinfo
, w
->w_tmem
, msglen
);
1581 if (w
->w_req
!= NULL
) {
1582 struct ifa_msghdr
*ifam
= w
->w_tmem
;
1584 ifam
->ifam_index
= ifa
->ifa_ifp
->if_index
;
1585 ifam
->ifam_flags
= ifa
->ifa_flags
;
1586 ifam
->ifam_addrs
= rtinfo
.rti_addrs
;
1587 ifam
->ifam_addrflags
= if_addrflags(ifa
);
1588 ifam
->ifam_metric
= ifa
->ifa_metric
;
1589 error
= SYSCTL_OUT(w
->w_req
, w
->w_tmem
, msglen
);
1592 TAILQ_REMOVE(head
, ifac_mark
, ifa_link
);
1599 TAILQ_REMOVE(head
, ifac_mark
, ifa_link
);
1600 rtinfo
.rti_netmask
= NULL
;
1601 rtinfo
.rti_ifaaddr
= NULL
;
1602 rtinfo
.rti_bcastaddr
= NULL
;
1609 rttable_walkarg_create(struct rttable_walkarg
*w
, int op
, int arg
)
1611 struct rt_addrinfo rtinfo
;
1612 struct sockaddr_storage ss
;
1615 memset(w
, 0, sizeof(*w
));
1619 memset(&ss
, 0, sizeof(ss
));
1620 ss
.ss_len
= sizeof(ss
);
1622 memset(&rtinfo
, 0, sizeof(rtinfo
));
1623 for (i
= 0; i
< RTAX_MAX
; ++i
)
1624 rtinfo
.rti_info
[i
] = (struct sockaddr
*)&ss
;
1625 msglen
= rt_msgsize(RTM_GET
, &rtinfo
);
1627 w
->w_bufsz
= msglen
* RTTABLE_DUMP_MSGCNT_MAX
;
1628 w
->w_buf
= kmalloc(w
->w_bufsz
, M_TEMP
, M_WAITOK
| M_NULLOK
);
1629 if (w
->w_buf
== NULL
)
1635 rttable_walkarg_destroy(struct rttable_walkarg
*w
)
1637 kfree(w
->w_buf
, M_TEMP
);
1641 rttable_entry_rtinfo(struct rt_addrinfo
*rtinfo
, struct radix_node
*rn
)
1643 struct rtentry
*rt
= (struct rtentry
*)rn
;
1645 bzero(rtinfo
, sizeof(*rtinfo
));
1646 rtinfo
->rti_dst
= rt_key(rt
);
1647 rtinfo
->rti_gateway
= rt
->rt_gateway
;
1648 rtinfo
->rti_netmask
= rt_mask(rt
);
1649 rtinfo
->rti_genmask
= rt
->rt_genmask
;
1650 if (rt
->rt_ifp
!= NULL
) {
1651 rtinfo
->rti_ifpaddr
=
1652 TAILQ_FIRST(&rt
->rt_ifp
->if_addrheads
[mycpuid
])->ifa
->ifa_addr
;
1653 rtinfo
->rti_ifaaddr
= rt
->rt_ifa
->ifa_addr
;
1654 if (rt
->rt_ifp
->if_flags
& IFF_POINTOPOINT
)
1655 rtinfo
->rti_bcastaddr
= rt
->rt_ifa
->ifa_dstaddr
;
1660 rttable_walk_entry(struct radix_node
*rn
, void *xw
)
1662 struct rttable_walkarg
*w
= xw
;
1663 struct rtentry
*rt
= (struct rtentry
*)rn
;
1664 struct rt_addrinfo rtinfo
;
1665 struct rt_msghdr
*rtm
;
1666 boolean_t save
= FALSE
;
1667 int msglen
, w_bufleft
;
1670 rttable_entry_rtinfo(&rtinfo
, rn
);
1671 msglen
= rt_msgsize(RTM_GET
, &rtinfo
);
1673 w_bufleft
= w
->w_bufsz
- w
->w_buflen
;
1675 if (rn
->rn_dupedkey
!= NULL
) {
1676 struct radix_node
*rn1
= rn
;
1677 int total_msglen
= msglen
;
1680 * Make sure that we have enough space left for all
1681 * dupedkeys, since rn_walktree_at always starts
1682 * from the first dupedkey.
1684 while ((rn1
= rn1
->rn_dupedkey
) != NULL
) {
1685 struct rt_addrinfo rtinfo1
;
1688 if (rn1
->rn_flags
& RNF_ROOT
)
1691 rttable_entry_rtinfo(&rtinfo1
, rn1
);
1692 msglen1
= rt_msgsize(RTM_GET
, &rtinfo1
);
1693 total_msglen
+= msglen1
;
1696 if (total_msglen
> w_bufleft
) {
1697 if (total_msglen
> w
->w_bufsz
) {
1698 static int logged
= 0;
1701 kprintf("buffer is too small for "
1702 "all dupedkeys, increase "
1703 "RTTABLE_DUMP_MSGCNT_MAX\n");
1710 } else if (msglen
> w_bufleft
) {
1716 * Not enough buffer left; remember the position
1717 * to start from upon next round.
1719 KASSERT(msglen
<= w
->w_bufsz
, ("msg too long %d", msglen
));
1721 KASSERT(rtinfo
.rti_dst
->sa_len
<= sizeof(w
->w_key0
),
1722 ("key too long %d", rtinfo
.rti_dst
->sa_len
));
1723 memset(&w
->w_key0
, 0, sizeof(w
->w_key0
));
1724 memcpy(&w
->w_key0
, rtinfo
.rti_dst
, rtinfo
.rti_dst
->sa_len
);
1725 w
->w_key
= (const char *)&w
->w_key0
;
1727 if (rtinfo
.rti_netmask
!= NULL
) {
1729 rtinfo
.rti_netmask
->sa_len
<= sizeof(w
->w_mask0
),
1730 ("mask too long %d", rtinfo
.rti_netmask
->sa_len
));
1731 memset(&w
->w_mask0
, 0, sizeof(w
->w_mask0
));
1732 memcpy(&w
->w_mask0
, rtinfo
.rti_netmask
,
1733 rtinfo
.rti_netmask
->sa_len
);
1734 w
->w_mask
= (const char *)&w
->w_mask0
;
1741 if (w
->w_op
== NET_RT_FLAGS
&& !(rt
->rt_flags
& w
->w_arg
))
1744 ptr
= ((uint8_t *)w
->w_buf
) + w
->w_buflen
;
1745 rt_msg_buffer(RTM_GET
, &rtinfo
, ptr
, msglen
);
1747 rtm
= (struct rt_msghdr
*)ptr
;
1748 rtm
->rtm_flags
= rt
->rt_flags
;
1749 rtm
->rtm_use
= rt
->rt_use
;
1750 rtm
->rtm_rmx
= rt
->rt_rmx
;
1751 rtm
->rtm_index
= rt
->rt_ifp
->if_index
;
1752 rtm
->rtm_errno
= rtm
->rtm_pid
= rtm
->rtm_seq
= 0;
1753 rtm
->rtm_addrs
= rtinfo
.rti_addrs
;
1755 w
->w_buflen
+= msglen
;
1761 rttable_walk_dispatch(netmsg_t msg
)
1763 struct netmsg_rttable_walk
*nmsg
= (struct netmsg_rttable_walk
*)msg
;
1764 struct radix_node_head
*rnh
= rt_tables
[mycpuid
][nmsg
->af
];
1765 struct rttable_walkarg
*w
= nmsg
->w
;
1768 error
= rnh
->rnh_walktree_at(rnh
, w
->w_key
, w
->w_mask
,
1769 rttable_walk_entry
, w
);
1770 lwkt_replymsg(&nmsg
->base
.lmsg
, error
);
1774 sysctl_rttable(int af
, struct sysctl_req
*req
, int op
, int arg
)
1776 struct rttable_walkarg w
;
1779 error
= rttable_walkarg_create(&w
, op
, arg
);
1784 for (i
= 1; i
<= AF_MAX
; i
++) {
1785 if (rt_tables
[mycpuid
][i
] != NULL
&& (af
== 0 || af
== i
)) {
1789 struct netmsg_rttable_walk nmsg
;
1791 netmsg_init(&nmsg
.base
, NULL
,
1792 &curthread
->td_msgport
, 0,
1793 rttable_walk_dispatch
);
1799 error
= lwkt_domsg(netisr_cpuport(mycpuid
),
1800 &nmsg
.base
.lmsg
, 0);
1801 if (error
&& error
!= EJUSTRETURN
)
1804 if (req
!= NULL
&& w
.w_buflen
> 0) {
1807 error1
= SYSCTL_OUT(req
, w
.w_buf
,
1814 if (error
== 0) /* done */
1820 rttable_walkarg_destroy(&w
);
1825 sysctl_rtsock(SYSCTL_HANDLER_ARGS
)
1827 int *name
= (int *)arg1
;
1828 u_int namelen
= arg2
;
1838 if (namelen
!= 3 && namelen
!= 4)
1841 bzero(&w
, sizeof w
);
1847 * Optional third argument specifies cpu, used primarily for
1848 * debugging the route table.
1851 if (name
[3] < 0 || name
[3] >= netisr_ncpus
)
1856 * Target cpu is not specified, use cpu0 then, so that
1857 * the result set will be relatively stable.
1862 lwkt_migratecpu(cpu
);
1867 error
= sysctl_rttable(af
, w
.w_req
, w
.w_op
, w
.w_arg
);
1871 error
= sysctl_iflist(af
, &w
);
1874 if (w
.w_tmem
!= NULL
)
1875 kfree(w
.w_tmem
, M_RTABLE
);
1877 lwkt_migratecpu(origcpu
);
1881 SYSCTL_NODE(_net
, PF_ROUTE
, routetable
, CTLFLAG_RD
, sysctl_rtsock
, "");
1884 * Definitions of protocols supported in the ROUTE domain.
1887 static struct domain routedomain
; /* or at least forward */
1889 static struct protosw routesw
[] = {
1891 .pr_type
= SOCK_RAW
,
1892 .pr_domain
= &routedomain
,
1894 .pr_flags
= PR_ATOMIC
|PR_ADDR
,
1896 .pr_output
= route_output
,
1897 .pr_ctlinput
= raw_ctlinput
,
1898 .pr_ctloutput
= route_ctloutput
,
1899 .pr_ctlport
= cpu0_ctlport
,
1901 .pr_init
= raw_init
,
1902 .pr_usrreqs
= &route_usrreqs
1906 static struct domain routedomain
= {
1907 .dom_family
= AF_ROUTE
,
1908 .dom_name
= "route",
1910 .dom_externalize
= NULL
,
1911 .dom_dispose
= NULL
,
1912 .dom_protosw
= routesw
,
1913 .dom_protoswNPROTOSW
= &routesw
[(sizeof routesw
)/(sizeof routesw
[0])],
1914 .dom_next
= SLIST_ENTRY_INITIALIZER
,
1915 .dom_rtattach
= NULL
,
1918 .dom_ifattach
= NULL
,
1919 .dom_ifdetach
= NULL