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. All advertising materials mentioning features or use of this software
46 * must display the following acknowledgement:
47 * This product includes software developed by the University of
48 * California, Berkeley and its contributors.
49 * 4. Neither the name of the University nor the names of its contributors
50 * may be used to endorse or promote products derived from this software
51 * without specific prior written permission.
53 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
54 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
55 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
56 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
57 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
58 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
59 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
60 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
61 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
62 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
65 * @(#)rtsock.c 8.7 (Berkeley) 10/12/95
66 * $FreeBSD: src/sys/net/rtsock.c,v 1.44.2.11 2002/12/04 14:05:41 ru Exp $
67 * $DragonFly: src/sys/net/rtsock.c,v 1.42 2008/01/06 16:55:51 swildner Exp $
72 #include <sys/param.h>
73 #include <sys/systm.h>
74 #include <sys/kernel.h>
75 #include <sys/sysctl.h>
77 #include <sys/malloc.h>
79 #include <sys/protosw.h>
80 #include <sys/socket.h>
81 #include <sys/socketvar.h>
82 #include <sys/domain.h>
83 #include <sys/thread2.h>
86 #include <net/route.h>
87 #include <net/raw_cb.h>
88 #include <net/netmsg2.h>
91 extern void sctp_add_ip_address(struct ifaddr
*ifa
);
92 extern void sctp_delete_ip_address(struct ifaddr
*ifa
);
95 MALLOC_DEFINE(M_RTABLE
, "routetbl", "routing tables");
97 static struct route_cb
{
105 static const struct sockaddr route_src
= { 2, PF_ROUTE
, };
111 struct sysctl_req
*w_req
;
115 rt_msg_mbuf (int, struct rt_addrinfo
*);
116 static void rt_msg_buffer (int, struct rt_addrinfo
*, void *buf
, int len
);
117 static int rt_msgsize (int type
, struct rt_addrinfo
*rtinfo
);
118 static int rt_xaddrs (char *, char *, struct rt_addrinfo
*);
119 static int sysctl_dumpentry (struct radix_node
*rn
, void *vw
);
120 static int sysctl_iflist (int af
, struct walkarg
*w
);
121 static int route_output(struct mbuf
*, struct socket
*, ...);
122 static void rt_setmetrics (u_long
, struct rt_metrics
*,
123 struct rt_metrics
*);
126 * It really doesn't make any sense at all for this code to share much
127 * with raw_usrreq.c, since its functionality is so restricted. XXX
130 rts_abort(struct socket
*so
)
135 error
= raw_usrreqs
.pru_abort(so
);
140 /* pru_accept is EOPNOTSUPP */
143 rts_attach(struct socket
*so
, int proto
, struct pru_attach_info
*ai
)
148 if (sotorawcb(so
) != NULL
)
149 return EISCONN
; /* XXX panic? */
151 rp
= kmalloc(sizeof *rp
, M_PCB
, M_WAITOK
| M_ZERO
);
154 * The critical section is necessary to block protocols from sending
155 * error notifications (like RTM_REDIRECT or RTM_LOSING) while
156 * this PCB is extant but incompletely initialized.
157 * Probably we should try to do more of this work beforehand and
158 * eliminate the critical section.
162 error
= raw_attach(so
, proto
, ai
->sb_rlimit
);
169 switch(rp
->rcb_proto
.sp_protocol
) {
174 route_cb
.ip6_count
++;
177 route_cb
.ipx_count
++;
183 rp
->rcb_faddr
= &route_src
;
184 route_cb
.any_count
++;
186 so
->so_options
|= SO_USELOOPBACK
;
192 rts_bind(struct socket
*so
, struct sockaddr
*nam
, struct thread
*td
)
197 error
= raw_usrreqs
.pru_bind(so
, nam
, td
); /* xxx just EINVAL */
203 rts_connect(struct socket
*so
, struct sockaddr
*nam
, struct thread
*td
)
208 error
= raw_usrreqs
.pru_connect(so
, nam
, td
); /* XXX just EINVAL */
213 /* pru_connect2 is EOPNOTSUPP */
214 /* pru_control is EOPNOTSUPP */
217 rts_detach(struct socket
*so
)
219 struct rawcb
*rp
= sotorawcb(so
);
224 switch(rp
->rcb_proto
.sp_protocol
) {
229 route_cb
.ip6_count
--;
232 route_cb
.ipx_count
--;
238 route_cb
.any_count
--;
240 error
= raw_usrreqs
.pru_detach(so
);
246 rts_disconnect(struct socket
*so
)
251 error
= raw_usrreqs
.pru_disconnect(so
);
256 /* pru_listen is EOPNOTSUPP */
259 rts_peeraddr(struct socket
*so
, struct sockaddr
**nam
)
264 error
= raw_usrreqs
.pru_peeraddr(so
, nam
);
269 /* pru_rcvd is EOPNOTSUPP */
270 /* pru_rcvoob is EOPNOTSUPP */
273 rts_send(struct socket
*so
, int flags
, struct mbuf
*m
, struct sockaddr
*nam
,
274 struct mbuf
*control
, struct thread
*td
)
279 error
= raw_usrreqs
.pru_send(so
, flags
, m
, nam
, control
, td
);
284 /* pru_sense is null */
287 rts_shutdown(struct socket
*so
)
292 error
= raw_usrreqs
.pru_shutdown(so
);
298 rts_sockaddr(struct socket
*so
, struct sockaddr
**nam
)
303 error
= raw_usrreqs
.pru_sockaddr(so
, nam
);
308 static struct pr_usrreqs route_usrreqs
= {
309 .pru_abort
= rts_abort
,
310 .pru_accept
= pru_accept_notsupp
,
311 .pru_attach
= rts_attach
,
312 .pru_bind
= rts_bind
,
313 .pru_connect
= rts_connect
,
314 .pru_connect2
= pru_connect2_notsupp
,
315 .pru_control
= pru_control_notsupp
,
316 .pru_detach
= rts_detach
,
317 .pru_disconnect
= rts_disconnect
,
318 .pru_listen
= pru_listen_notsupp
,
319 .pru_peeraddr
= rts_peeraddr
,
320 .pru_rcvd
= pru_rcvd_notsupp
,
321 .pru_rcvoob
= pru_rcvoob_notsupp
,
322 .pru_send
= rts_send
,
323 .pru_sense
= pru_sense_null
,
324 .pru_shutdown
= rts_shutdown
,
325 .pru_sockaddr
= rts_sockaddr
,
326 .pru_sosend
= sosend
,
327 .pru_soreceive
= soreceive
,
331 static __inline sa_family_t
332 familyof(struct sockaddr
*sa
)
334 return (sa
!= NULL
? sa
->sa_family
: 0);
338 * Routing socket input function. The packet must be serialized onto cpu 0.
339 * We use the cpu0_soport() netisr processing loop to handle it.
341 * This looks messy but it means that anyone, including interrupt code,
342 * can send a message to the routing socket.
345 rts_input_handler(struct netmsg
*msg
)
347 static const struct sockaddr route_dst
= { 2, PF_ROUTE
, };
348 struct sockproto route_proto
;
349 struct netmsg_packet
*pmsg
;
355 family
= pmsg
->nm_netmsg
.nm_lmsg
.u
.ms_result
;
356 route_proto
.sp_family
= PF_ROUTE
;
357 route_proto
.sp_protocol
= family
;
359 raw_input(m
, &route_proto
, &route_src
, &route_dst
);
363 rts_input(struct mbuf
*m
, sa_family_t family
)
365 struct netmsg_packet
*pmsg
;
368 port
= cpu0_soport(NULL
, NULL
, NULL
, 0);
369 pmsg
= &m
->m_hdr
.mh_netmsg
;
370 netmsg_init(&pmsg
->nm_netmsg
, &netisr_apanic_rport
,
371 0, rts_input_handler
);
373 pmsg
->nm_netmsg
.nm_lmsg
.u
.ms_result
= family
;
374 lwkt_sendmsg(port
, &pmsg
->nm_netmsg
.nm_lmsg
);
378 reallocbuf(void *ptr
, size_t len
, size_t olen
)
382 newptr
= kmalloc(len
, M_RTABLE
, M_INTWAIT
| M_NULLOK
);
385 bcopy(ptr
, newptr
, olen
);
386 kfree(ptr
, M_RTABLE
);
391 * Internal helper routine for route_output().
394 fillrtmsg(struct rt_msghdr
**prtm
, struct rtentry
*rt
,
395 struct rt_addrinfo
*rtinfo
)
398 struct rt_msghdr
*rtm
= *prtm
;
400 /* Fill in rt_addrinfo for call to rt_msg_buffer(). */
401 rtinfo
->rti_dst
= rt_key(rt
);
402 rtinfo
->rti_gateway
= rt
->rt_gateway
;
403 rtinfo
->rti_netmask
= rt_mask(rt
); /* might be NULL */
404 rtinfo
->rti_genmask
= rt
->rt_genmask
; /* might be NULL */
405 if (rtm
->rtm_addrs
& (RTA_IFP
| RTA_IFA
)) {
406 if (rt
->rt_ifp
!= NULL
) {
407 rtinfo
->rti_ifpaddr
=
408 TAILQ_FIRST(&rt
->rt_ifp
->if_addrhead
)->ifa_addr
;
409 rtinfo
->rti_ifaaddr
= rt
->rt_ifa
->ifa_addr
;
410 if (rt
->rt_ifp
->if_flags
& IFF_POINTOPOINT
)
411 rtinfo
->rti_bcastaddr
= rt
->rt_ifa
->ifa_dstaddr
;
412 rtm
->rtm_index
= rt
->rt_ifp
->if_index
;
414 rtinfo
->rti_ifpaddr
= NULL
;
415 rtinfo
->rti_ifaaddr
= NULL
;
419 msglen
= rt_msgsize(rtm
->rtm_type
, rtinfo
);
420 if (rtm
->rtm_msglen
< msglen
) {
421 rtm
= reallocbuf(rtm
, msglen
, rtm
->rtm_msglen
);
426 rt_msg_buffer(rtm
->rtm_type
, rtinfo
, rtm
, msglen
);
428 rtm
->rtm_flags
= rt
->rt_flags
;
429 rtm
->rtm_rmx
= rt
->rt_rmx
;
430 rtm
->rtm_addrs
= rtinfo
->rti_addrs
;
435 static void route_output_add_callback(int, int, struct rt_addrinfo
*,
436 struct rtentry
*, void *);
437 static void route_output_delete_callback(int, int, struct rt_addrinfo
*,
438 struct rtentry
*, void *);
439 static void route_output_change_callback(int, int, struct rt_addrinfo
*,
440 struct rtentry
*, void *);
441 static void route_output_lock_callback(int, int, struct rt_addrinfo
*,
442 struct rtentry
*, void *);
446 route_output(struct mbuf
*m
, struct socket
*so
, ...)
448 struct rt_msghdr
*rtm
= NULL
;
450 struct radix_node_head
*rnh
;
451 struct rawcb
*rp
= NULL
;
452 struct pr_output_info
*oi
;
453 struct rt_addrinfo rtinfo
;
458 oi
= __va_arg(ap
, struct pr_output_info
*);
461 #define gotoerr(e) { error = e; goto flush;}
464 (m
->m_len
< sizeof(long) &&
465 (m
= m_pullup(m
, sizeof(long))) == NULL
))
467 if (!(m
->m_flags
& M_PKTHDR
))
468 panic("route_output");
469 len
= m
->m_pkthdr
.len
;
470 if (len
< sizeof(struct rt_msghdr
) ||
471 len
!= mtod(m
, struct rt_msghdr
*)->rtm_msglen
) {
472 rtinfo
.rti_dst
= NULL
;
475 rtm
= kmalloc(len
, M_RTABLE
, M_INTWAIT
| M_NULLOK
);
477 rtinfo
.rti_dst
= NULL
;
480 m_copydata(m
, 0, len
, (caddr_t
)rtm
);
481 if (rtm
->rtm_version
!= RTM_VERSION
) {
482 rtinfo
.rti_dst
= NULL
;
483 gotoerr(EPROTONOSUPPORT
);
485 rtm
->rtm_pid
= oi
->p_pid
;
486 bzero(&rtinfo
, sizeof(struct rt_addrinfo
));
487 rtinfo
.rti_addrs
= rtm
->rtm_addrs
;
488 if (rt_xaddrs((char *)(rtm
+ 1), (char *)rtm
+ len
, &rtinfo
) != 0) {
489 rtinfo
.rti_dst
= NULL
;
492 rtinfo
.rti_flags
= rtm
->rtm_flags
;
493 if (rtinfo
.rti_dst
== NULL
|| rtinfo
.rti_dst
->sa_family
>= AF_MAX
||
494 (rtinfo
.rti_gateway
&& rtinfo
.rti_gateway
->sa_family
>= AF_MAX
))
497 if (rtinfo
.rti_genmask
!= NULL
) {
498 struct radix_node
*n
;
500 #define clen(s) (*(u_char *)(s))
501 n
= rn_addmask((char *)rtinfo
.rti_genmask
, TRUE
, 1);
503 rtinfo
.rti_genmask
->sa_len
>= clen(n
->rn_key
) &&
504 bcmp((char *)rtinfo
.rti_genmask
+ 1,
505 (char *)n
->rn_key
+ 1, clen(n
->rn_key
) - 1) == 0)
506 rtinfo
.rti_genmask
= (struct sockaddr
*)n
->rn_key
;
512 * Verify that the caller has the appropriate privilege; RTM_GET
513 * is the only operation the non-superuser is allowed.
515 if (rtm
->rtm_type
!= RTM_GET
&& suser_cred(so
->so_cred
, 0) != 0)
518 switch (rtm
->rtm_type
) {
520 if (rtinfo
.rti_gateway
== NULL
) {
523 error
= rtrequest1_global(RTM_ADD
, &rtinfo
,
524 route_output_add_callback
, rtm
);
529 * note: &rtm passed as argument so 'rtm' can be replaced.
531 error
= rtrequest1_global(RTM_DELETE
, &rtinfo
,
532 route_output_delete_callback
, &rtm
);
535 rnh
= rt_tables
[mycpuid
][rtinfo
.rti_dst
->sa_family
];
537 error
= EAFNOSUPPORT
;
540 rt
= (struct rtentry
*)
541 rnh
->rnh_lookup((char *)rtinfo
.rti_dst
,
542 (char *)rtinfo
.rti_netmask
, rnh
);
548 if (fillrtmsg(&rtm
, rt
, &rtinfo
) != 0)
553 error
= rtrequest1_global(RTM_GET
, &rtinfo
,
554 route_output_change_callback
, rtm
);
557 error
= rtrequest1_global(RTM_GET
, &rtinfo
,
558 route_output_lock_callback
, rtm
);
568 rtm
->rtm_errno
= error
;
570 rtm
->rtm_flags
|= RTF_DONE
;
574 * Check to see if we don't want our own messages.
576 if (!(so
->so_options
& SO_USELOOPBACK
)) {
577 if (route_cb
.any_count
<= 1) {
579 kfree(rtm
, M_RTABLE
);
583 /* There is another listener, so construct message */
587 m_copyback(m
, 0, rtm
->rtm_msglen
, (caddr_t
)rtm
);
588 if (m
->m_pkthdr
.len
< rtm
->rtm_msglen
) {
591 } else if (m
->m_pkthdr
.len
> rtm
->rtm_msglen
)
592 m_adj(m
, rtm
->rtm_msglen
- m
->m_pkthdr
.len
);
593 kfree(rtm
, M_RTABLE
);
596 rp
->rcb_proto
.sp_family
= 0; /* Avoid us */
598 rts_input(m
, familyof(rtinfo
.rti_dst
));
600 rp
->rcb_proto
.sp_family
= PF_ROUTE
;
605 route_output_add_callback(int cmd
, int error
, struct rt_addrinfo
*rtinfo
,
606 struct rtentry
*rt
, void *arg
)
608 struct rt_msghdr
*rtm
= arg
;
610 if (error
== 0 && rt
!= NULL
) {
611 rt_setmetrics(rtm
->rtm_inits
, &rtm
->rtm_rmx
,
613 rt
->rt_rmx
.rmx_locks
&= ~(rtm
->rtm_inits
);
614 rt
->rt_rmx
.rmx_locks
|=
615 (rtm
->rtm_inits
& rtm
->rtm_rmx
.rmx_locks
);
616 rt
->rt_genmask
= rtinfo
->rti_genmask
;
621 route_output_delete_callback(int cmd
, int error
, struct rt_addrinfo
*rtinfo
,
622 struct rtentry
*rt
, void *arg
)
624 struct rt_msghdr
**rtm
= arg
;
626 if (error
== 0 && rt
) {
628 if (fillrtmsg(rtm
, rt
, rtinfo
) != 0) {
630 /* XXX no way to return the error */
637 route_output_change_callback(int cmd
, int error
, struct rt_addrinfo
*rtinfo
,
638 struct rtentry
*rt
, void *arg
)
640 struct rt_msghdr
*rtm
= arg
;
647 * new gateway could require new ifaddr, ifp;
648 * flags may also be different; ifp may be specified
649 * by ll sockaddr when protocol address is ambiguous
651 if (((rt
->rt_flags
& RTF_GATEWAY
) && rtinfo
->rti_gateway
!= NULL
) ||
652 rtinfo
->rti_ifpaddr
!= NULL
|| (rtinfo
->rti_ifaaddr
!= NULL
&&
653 sa_equal(rtinfo
->rti_ifaaddr
, rt
->rt_ifa
->ifa_addr
))
655 error
= rt_getifa(rtinfo
);
659 if (rtinfo
->rti_gateway
!= NULL
) {
660 error
= rt_setgate(rt
, rt_key(rt
), rtinfo
->rti_gateway
);
664 if ((ifa
= rtinfo
->rti_ifa
) != NULL
) {
665 struct ifaddr
*oifa
= rt
->rt_ifa
;
668 if (oifa
&& oifa
->ifa_rtrequest
)
669 oifa
->ifa_rtrequest(RTM_DELETE
, rt
, rtinfo
);
673 rt
->rt_ifp
= rtinfo
->rti_ifp
;
676 rt_setmetrics(rtm
->rtm_inits
, &rtm
->rtm_rmx
, &rt
->rt_rmx
);
677 if (rt
->rt_ifa
&& rt
->rt_ifa
->ifa_rtrequest
)
678 rt
->rt_ifa
->ifa_rtrequest(RTM_ADD
, rt
, rtinfo
);
679 if (rtinfo
->rti_genmask
!= NULL
)
680 rt
->rt_genmask
= rtinfo
->rti_genmask
;
682 /* XXX no way to return error */
687 route_output_lock_callback(int cmd
, int error
, struct rt_addrinfo
*rtinfo
,
688 struct rtentry
*rt
, void *arg
)
690 struct rt_msghdr
*rtm
= arg
;
692 rt
->rt_rmx
.rmx_locks
&= ~(rtm
->rtm_inits
);
693 rt
->rt_rmx
.rmx_locks
|=
694 (rtm
->rtm_inits
& rtm
->rtm_rmx
.rmx_locks
);
698 rt_setmetrics(u_long which
, struct rt_metrics
*in
, struct rt_metrics
*out
)
700 #define setmetric(flag, elt) if (which & (flag)) out->elt = in->elt;
701 setmetric(RTV_RPIPE
, rmx_recvpipe
);
702 setmetric(RTV_SPIPE
, rmx_sendpipe
);
703 setmetric(RTV_SSTHRESH
, rmx_ssthresh
);
704 setmetric(RTV_RTT
, rmx_rtt
);
705 setmetric(RTV_RTTVAR
, rmx_rttvar
);
706 setmetric(RTV_HOPCOUNT
, rmx_hopcount
);
707 setmetric(RTV_MTU
, rmx_mtu
);
708 setmetric(RTV_EXPIRE
, rmx_expire
);
713 ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
716 * Extract the addresses of the passed sockaddrs.
717 * Do a little sanity checking so as to avoid bad memory references.
718 * This data is derived straight from userland.
721 rt_xaddrs(char *cp
, char *cplim
, struct rt_addrinfo
*rtinfo
)
726 for (i
= 0; (i
< RTAX_MAX
) && (cp
< cplim
); i
++) {
727 if ((rtinfo
->rti_addrs
& (1 << i
)) == 0)
729 sa
= (struct sockaddr
*)cp
;
733 if ((cp
+ sa
->sa_len
) > cplim
) {
738 * There are no more... Quit now.
739 * If there are more bits, they are in error.
740 * I've seen this. route(1) can evidently generate these.
741 * This causes kernel to core dump.
742 * For compatibility, if we see this, point to a safe address.
744 if (sa
->sa_len
== 0) {
745 static struct sockaddr sa_zero
= {
746 sizeof sa_zero
, AF_INET
,
749 rtinfo
->rti_info
[i
] = &sa_zero
;
750 return (0); /* should be EINVAL but for compat */
753 /* Accept the sockaddr. */
754 rtinfo
->rti_info
[i
] = sa
;
755 cp
+= ROUNDUP(sa
->sa_len
);
761 rt_msghdrsize(int type
)
766 return sizeof(struct ifa_msghdr
);
769 return sizeof(struct ifma_msghdr
);
771 return sizeof(struct if_msghdr
);
774 return sizeof(struct if_announcemsghdr
);
776 return sizeof(struct rt_msghdr
);
781 rt_msgsize(int type
, struct rt_addrinfo
*rtinfo
)
785 len
= rt_msghdrsize(type
);
786 for (i
= 0; i
< RTAX_MAX
; i
++) {
787 if (rtinfo
->rti_info
[i
] != NULL
)
788 len
+= ROUNDUP(rtinfo
->rti_info
[i
]->sa_len
);
795 * Build a routing message in a buffer.
796 * Copy the addresses in the rtinfo->rti_info[] sockaddr array
797 * to the end of the buffer after the message header.
799 * Set the rtinfo->rti_addrs bitmask of addresses present in rtinfo->rti_info[].
800 * This side-effect can be avoided if we reorder the addrs bitmask field in all
801 * the route messages to line up so we can set it here instead of back in the
805 rt_msg_buffer(int type
, struct rt_addrinfo
*rtinfo
, void *buf
, int msglen
)
807 struct rt_msghdr
*rtm
;
811 rtm
= (struct rt_msghdr
*) buf
;
812 rtm
->rtm_version
= RTM_VERSION
;
813 rtm
->rtm_type
= type
;
814 rtm
->rtm_msglen
= msglen
;
816 cp
= (char *)buf
+ rt_msghdrsize(type
);
817 rtinfo
->rti_addrs
= 0;
818 for (i
= 0; i
< RTAX_MAX
; i
++) {
821 if ((sa
= rtinfo
->rti_info
[i
]) == NULL
)
823 rtinfo
->rti_addrs
|= (1 << i
);
824 dlen
= ROUNDUP(sa
->sa_len
);
831 * Build a routing message in a mbuf chain.
832 * Copy the addresses in the rtinfo->rti_info[] sockaddr array
833 * to the end of the mbuf after the message header.
835 * Set the rtinfo->rti_addrs bitmask of addresses present in rtinfo->rti_info[].
836 * This side-effect can be avoided if we reorder the addrs bitmask field in all
837 * the route messages to line up so we can set it here instead of back in the
841 rt_msg_mbuf(int type
, struct rt_addrinfo
*rtinfo
)
844 struct rt_msghdr
*rtm
;
848 hlen
= rt_msghdrsize(type
);
849 KASSERT(hlen
<= MCLBYTES
, ("rt_msg_mbuf: hlen %d doesn't fit", hlen
));
851 m
= m_getl(hlen
, MB_DONTWAIT
, MT_DATA
, M_PKTHDR
, NULL
);
855 m
->m_pkthdr
.len
= m
->m_len
= hlen
;
856 m
->m_pkthdr
.rcvif
= NULL
;
857 rtinfo
->rti_addrs
= 0;
859 for (i
= 0; i
< RTAX_MAX
; i
++) {
863 if ((sa
= rtinfo
->rti_info
[i
]) == NULL
)
865 rtinfo
->rti_addrs
|= (1 << i
);
866 dlen
= ROUNDUP(sa
->sa_len
);
867 m_copyback(m
, len
, dlen
, (caddr_t
)sa
); /* can grow mbuf chain */
870 if (m
->m_pkthdr
.len
!= len
) { /* one of the m_copyback() calls failed */
874 rtm
= mtod(m
, struct rt_msghdr
*);
876 rtm
->rtm_msglen
= len
;
877 rtm
->rtm_version
= RTM_VERSION
;
878 rtm
->rtm_type
= type
;
883 * This routine is called to generate a message from the routing
884 * socket indicating that a redirect has occurred, a routing lookup
885 * has failed, or that a protocol has detected timeouts to a particular
889 rt_missmsg(int type
, struct rt_addrinfo
*rtinfo
, int flags
, int error
)
891 struct sockaddr
*dst
= rtinfo
->rti_info
[RTAX_DST
];
892 struct rt_msghdr
*rtm
;
895 if (route_cb
.any_count
== 0)
897 m
= rt_msg_mbuf(type
, rtinfo
);
900 rtm
= mtod(m
, struct rt_msghdr
*);
901 rtm
->rtm_flags
= RTF_DONE
| flags
;
902 rtm
->rtm_errno
= error
;
903 rtm
->rtm_addrs
= rtinfo
->rti_addrs
;
904 rts_input(m
, familyof(dst
));
908 rt_dstmsg(int type
, struct sockaddr
*dst
, int error
)
910 struct rt_msghdr
*rtm
;
911 struct rt_addrinfo addrs
;
914 if (route_cb
.any_count
== 0)
916 bzero(&addrs
, sizeof(struct rt_addrinfo
));
917 addrs
.rti_info
[RTAX_DST
] = dst
;
918 m
= rt_msg_mbuf(type
, &addrs
);
921 rtm
= mtod(m
, struct rt_msghdr
*);
922 rtm
->rtm_flags
= RTF_DONE
;
923 rtm
->rtm_errno
= error
;
924 rtm
->rtm_addrs
= addrs
.rti_addrs
;
925 rts_input(m
, familyof(dst
));
929 * This routine is called to generate a message from the routing
930 * socket indicating that the status of a network interface has changed.
933 rt_ifmsg(struct ifnet
*ifp
)
935 struct if_msghdr
*ifm
;
937 struct rt_addrinfo rtinfo
;
939 if (route_cb
.any_count
== 0)
941 bzero(&rtinfo
, sizeof(struct rt_addrinfo
));
942 m
= rt_msg_mbuf(RTM_IFINFO
, &rtinfo
);
945 ifm
= mtod(m
, struct if_msghdr
*);
946 ifm
->ifm_index
= ifp
->if_index
;
947 ifm
->ifm_flags
= ifp
->if_flags
;
948 ifm
->ifm_data
= ifp
->if_data
;
954 rt_ifamsg(int cmd
, struct ifaddr
*ifa
)
956 struct ifa_msghdr
*ifam
;
957 struct rt_addrinfo rtinfo
;
959 struct ifnet
*ifp
= ifa
->ifa_ifp
;
961 bzero(&rtinfo
, sizeof(struct rt_addrinfo
));
962 rtinfo
.rti_ifaaddr
= ifa
->ifa_addr
;
963 rtinfo
.rti_ifpaddr
= TAILQ_FIRST(&ifp
->if_addrhead
)->ifa_addr
;
964 rtinfo
.rti_netmask
= ifa
->ifa_netmask
;
965 rtinfo
.rti_bcastaddr
= ifa
->ifa_dstaddr
;
967 m
= rt_msg_mbuf(cmd
, &rtinfo
);
971 ifam
= mtod(m
, struct ifa_msghdr
*);
972 ifam
->ifam_index
= ifp
->if_index
;
973 ifam
->ifam_metric
= ifa
->ifa_metric
;
974 ifam
->ifam_flags
= ifa
->ifa_flags
;
975 ifam
->ifam_addrs
= rtinfo
.rti_addrs
;
977 rts_input(m
, familyof(ifa
->ifa_addr
));
981 rt_rtmsg(int cmd
, struct rtentry
*rt
, struct ifnet
*ifp
, int error
)
983 struct rt_msghdr
*rtm
;
984 struct rt_addrinfo rtinfo
;
986 struct sockaddr
*dst
;
991 bzero(&rtinfo
, sizeof(struct rt_addrinfo
));
992 rtinfo
.rti_dst
= dst
= rt_key(rt
);
993 rtinfo
.rti_gateway
= rt
->rt_gateway
;
994 rtinfo
.rti_netmask
= rt_mask(rt
);
996 rtinfo
.rti_ifpaddr
= TAILQ_FIRST(&ifp
->if_addrhead
)->ifa_addr
;
997 rtinfo
.rti_ifaaddr
= rt
->rt_ifa
->ifa_addr
;
999 m
= rt_msg_mbuf(cmd
, &rtinfo
);
1003 rtm
= mtod(m
, struct rt_msghdr
*);
1005 rtm
->rtm_index
= ifp
->if_index
;
1006 rtm
->rtm_flags
|= rt
->rt_flags
;
1007 rtm
->rtm_errno
= error
;
1008 rtm
->rtm_addrs
= rtinfo
.rti_addrs
;
1010 rts_input(m
, familyof(dst
));
1014 * This is called to generate messages from the routing socket
1015 * indicating a network interface has had addresses associated with it.
1016 * if we ever reverse the logic and replace messages TO the routing
1017 * socket indicate a request to configure interfaces, then it will
1018 * be unnecessary as the routing socket will automatically generate
1022 rt_newaddrmsg(int cmd
, struct ifaddr
*ifa
, int error
, struct rtentry
*rt
)
1026 * notify the SCTP stack
1027 * this will only get called when an address is added/deleted
1028 * XXX pass the ifaddr struct instead if ifa->ifa_addr...
1031 sctp_add_ip_address(ifa
);
1032 else if (cmd
== RTM_DELETE
)
1033 sctp_delete_ip_address(ifa
);
1036 if (route_cb
.any_count
== 0)
1039 if (cmd
== RTM_ADD
) {
1040 rt_ifamsg(RTM_NEWADDR
, ifa
);
1041 rt_rtmsg(RTM_ADD
, rt
, ifa
->ifa_ifp
, error
);
1043 KASSERT((cmd
== RTM_DELETE
), ("unknown cmd %d", cmd
));
1044 rt_rtmsg(RTM_DELETE
, rt
, ifa
->ifa_ifp
, error
);
1045 rt_ifamsg(RTM_DELADDR
, ifa
);
1050 * This is the analogue to the rt_newaddrmsg which performs the same
1051 * function but for multicast group memberhips. This is easier since
1052 * there is no route state to worry about.
1055 rt_newmaddrmsg(int cmd
, struct ifmultiaddr
*ifma
)
1057 struct rt_addrinfo rtinfo
;
1058 struct mbuf
*m
= NULL
;
1059 struct ifnet
*ifp
= ifma
->ifma_ifp
;
1060 struct ifma_msghdr
*ifmam
;
1062 if (route_cb
.any_count
== 0)
1065 bzero(&rtinfo
, sizeof(struct rt_addrinfo
));
1066 rtinfo
.rti_ifaaddr
= ifma
->ifma_addr
;
1067 if (ifp
!= NULL
&& !TAILQ_EMPTY(&ifp
->if_addrhead
))
1068 rtinfo
.rti_ifpaddr
= TAILQ_FIRST(&ifp
->if_addrhead
)->ifa_addr
;
1070 * If a link-layer address is present, present it as a ``gateway''
1071 * (similarly to how ARP entries, e.g., are presented).
1073 rtinfo
.rti_gateway
= ifma
->ifma_lladdr
;
1075 m
= rt_msg_mbuf(cmd
, &rtinfo
);
1079 ifmam
= mtod(m
, struct ifma_msghdr
*);
1080 ifmam
->ifmam_index
= ifp
->if_index
;
1081 ifmam
->ifmam_addrs
= rtinfo
.rti_addrs
;
1083 rts_input(m
, familyof(ifma
->ifma_addr
));
1086 static struct mbuf
*
1087 rt_makeifannouncemsg(struct ifnet
*ifp
, int type
, int what
,
1088 struct rt_addrinfo
*info
)
1090 struct if_announcemsghdr
*ifan
;
1093 if (route_cb
.any_count
== 0)
1096 bzero(info
, sizeof(*info
));
1097 m
= rt_msg_mbuf(type
, info
);
1101 ifan
= mtod(m
, struct if_announcemsghdr
*);
1102 ifan
->ifan_index
= ifp
->if_index
;
1103 strlcpy(ifan
->ifan_name
, ifp
->if_xname
, sizeof ifan
->ifan_name
);
1104 ifan
->ifan_what
= what
;
1109 * This is called to generate routing socket messages indicating
1110 * IEEE80211 wireless events.
1111 * XXX we piggyback on the RTM_IFANNOUNCE msg format in a clumsy way.
1114 rt_ieee80211msg(struct ifnet
*ifp
, int what
, void *data
, size_t data_len
)
1116 struct rt_addrinfo info
;
1119 m
= rt_makeifannouncemsg(ifp
, RTM_IEEE80211
, what
, &info
);
1124 * Append the ieee80211 data. Try to stick it in the
1125 * mbuf containing the ifannounce msg; otherwise allocate
1126 * a new mbuf and append.
1128 * NB: we assume m is a single mbuf.
1130 if (data_len
> M_TRAILINGSPACE(m
)) {
1131 struct mbuf
*n
= m_get(MB_DONTWAIT
, MT_DATA
);
1136 bcopy(data
, mtod(n
, void *), data_len
);
1137 n
->m_len
= data_len
;
1139 } else if (data_len
> 0) {
1140 bcopy(data
, mtod(m
, u_int8_t
*) + m
->m_len
, data_len
);
1141 m
->m_len
+= data_len
;
1144 if (m
->m_flags
& M_PKTHDR
)
1145 m
->m_pkthdr
.len
+= data_len
;
1146 mtod(m
, struct if_announcemsghdr
*)->ifan_msglen
+= data_len
;
1151 * This is called to generate routing socket messages indicating
1152 * network interface arrival and departure.
1155 rt_ifannouncemsg(struct ifnet
*ifp
, int what
)
1157 struct rt_addrinfo addrinfo
;
1160 m
= rt_makeifannouncemsg(ifp
, RTM_IFANNOUNCE
, what
, &addrinfo
);
1166 resizewalkarg(struct walkarg
*w
, int len
)
1170 newptr
= kmalloc(len
, M_RTABLE
, M_INTWAIT
| M_NULLOK
);
1173 if (w
->w_tmem
!= NULL
)
1174 kfree(w
->w_tmem
, M_RTABLE
);
1176 w
->w_tmemsize
= len
;
1181 * This is used in dumping the kernel table via sysctl().
1184 sysctl_dumpentry(struct radix_node
*rn
, void *vw
)
1186 struct walkarg
*w
= vw
;
1187 struct rtentry
*rt
= (struct rtentry
*)rn
;
1188 struct rt_addrinfo rtinfo
;
1191 if (w
->w_op
== NET_RT_FLAGS
&& !(rt
->rt_flags
& w
->w_arg
))
1194 bzero(&rtinfo
, sizeof(struct rt_addrinfo
));
1195 rtinfo
.rti_dst
= rt_key(rt
);
1196 rtinfo
.rti_gateway
= rt
->rt_gateway
;
1197 rtinfo
.rti_netmask
= rt_mask(rt
);
1198 rtinfo
.rti_genmask
= rt
->rt_genmask
;
1199 if (rt
->rt_ifp
!= NULL
) {
1200 rtinfo
.rti_ifpaddr
=
1201 TAILQ_FIRST(&rt
->rt_ifp
->if_addrhead
)->ifa_addr
;
1202 rtinfo
.rti_ifaaddr
= rt
->rt_ifa
->ifa_addr
;
1203 if (rt
->rt_ifp
->if_flags
& IFF_POINTOPOINT
)
1204 rtinfo
.rti_bcastaddr
= rt
->rt_ifa
->ifa_dstaddr
;
1206 msglen
= rt_msgsize(RTM_GET
, &rtinfo
);
1207 if (w
->w_tmemsize
< msglen
&& resizewalkarg(w
, msglen
) != 0)
1209 rt_msg_buffer(RTM_GET
, &rtinfo
, w
->w_tmem
, msglen
);
1210 if (w
->w_req
!= NULL
) {
1211 struct rt_msghdr
*rtm
= w
->w_tmem
;
1213 rtm
->rtm_flags
= rt
->rt_flags
;
1214 rtm
->rtm_use
= rt
->rt_use
;
1215 rtm
->rtm_rmx
= rt
->rt_rmx
;
1216 rtm
->rtm_index
= rt
->rt_ifp
->if_index
;
1217 rtm
->rtm_errno
= rtm
->rtm_pid
= rtm
->rtm_seq
= 0;
1218 rtm
->rtm_addrs
= rtinfo
.rti_addrs
;
1219 error
= SYSCTL_OUT(w
->w_req
, rtm
, msglen
);
1226 sysctl_iflist(int af
, struct walkarg
*w
)
1230 struct rt_addrinfo rtinfo
;
1233 bzero(&rtinfo
, sizeof(struct rt_addrinfo
));
1234 TAILQ_FOREACH(ifp
, &ifnet
, if_link
) {
1235 if (w
->w_arg
&& w
->w_arg
!= ifp
->if_index
)
1237 ifa
= TAILQ_FIRST(&ifp
->if_addrhead
);
1238 rtinfo
.rti_ifpaddr
= ifa
->ifa_addr
;
1239 msglen
= rt_msgsize(RTM_IFINFO
, &rtinfo
);
1240 if (w
->w_tmemsize
< msglen
&& resizewalkarg(w
, msglen
) != 0)
1242 rt_msg_buffer(RTM_IFINFO
, &rtinfo
, w
->w_tmem
, msglen
);
1243 rtinfo
.rti_ifpaddr
= NULL
;
1244 if (w
->w_req
!= NULL
&& w
->w_tmem
!= NULL
) {
1245 struct if_msghdr
*ifm
= w
->w_tmem
;
1247 ifm
->ifm_index
= ifp
->if_index
;
1248 ifm
->ifm_flags
= ifp
->if_flags
;
1249 ifm
->ifm_data
= ifp
->if_data
;
1250 ifm
->ifm_addrs
= rtinfo
.rti_addrs
;
1251 error
= SYSCTL_OUT(w
->w_req
, ifm
, msglen
);
1255 while ((ifa
= TAILQ_NEXT(ifa
, ifa_link
)) != NULL
) {
1256 if (af
&& af
!= ifa
->ifa_addr
->sa_family
)
1258 if (curproc
->p_ucred
->cr_prison
&&
1259 prison_if(curproc
->p_ucred
, ifa
->ifa_addr
))
1261 rtinfo
.rti_ifaaddr
= ifa
->ifa_addr
;
1262 rtinfo
.rti_netmask
= ifa
->ifa_netmask
;
1263 rtinfo
.rti_bcastaddr
= ifa
->ifa_dstaddr
;
1264 msglen
= rt_msgsize(RTM_NEWADDR
, &rtinfo
);
1265 if (w
->w_tmemsize
< msglen
&&
1266 resizewalkarg(w
, msglen
) != 0)
1268 rt_msg_buffer(RTM_NEWADDR
, &rtinfo
, w
->w_tmem
, msglen
);
1269 if (w
->w_req
!= NULL
) {
1270 struct ifa_msghdr
*ifam
= w
->w_tmem
;
1272 ifam
->ifam_index
= ifa
->ifa_ifp
->if_index
;
1273 ifam
->ifam_flags
= ifa
->ifa_flags
;
1274 ifam
->ifam_metric
= ifa
->ifa_metric
;
1275 ifam
->ifam_addrs
= rtinfo
.rti_addrs
;
1276 error
= SYSCTL_OUT(w
->w_req
, w
->w_tmem
, msglen
);
1281 rtinfo
.rti_netmask
= NULL
;
1282 rtinfo
.rti_ifaaddr
= NULL
;
1283 rtinfo
.rti_bcastaddr
= NULL
;
1289 sysctl_rtsock(SYSCTL_HANDLER_ARGS
)
1291 int *name
= (int *)arg1
;
1292 u_int namelen
= arg2
;
1293 struct radix_node_head
*rnh
;
1294 int i
, error
= EINVAL
;
1303 if (namelen
!= 3 && namelen
!= 4)
1306 bzero(&w
, sizeof w
);
1312 * Optional third argument specifies cpu, used primarily for
1313 * debugging the route table.
1316 if (name
[3] < 0 || name
[3] >= ncpus
)
1319 lwkt_migratecpu(name
[3]);
1327 for (i
= 1; i
<= AF_MAX
; i
++)
1328 if ((rnh
= rt_tables
[mycpuid
][i
]) &&
1329 (af
== 0 || af
== i
) &&
1330 (error
= rnh
->rnh_walktree(rnh
,
1331 sysctl_dumpentry
, &w
)))
1336 error
= sysctl_iflist(af
, &w
);
1339 if (w
.w_tmem
!= NULL
)
1340 kfree(w
.w_tmem
, M_RTABLE
);
1342 lwkt_migratecpu(origcpu
);
1346 SYSCTL_NODE(_net
, PF_ROUTE
, routetable
, CTLFLAG_RD
, sysctl_rtsock
, "");
1349 * Definitions of protocols supported in the ROUTE domain.
1352 static struct domain routedomain
; /* or at least forward */
1354 static struct protosw routesw
[] = {
1355 { SOCK_RAW
, &routedomain
, 0, PR_ATOMIC
|PR_ADDR
,
1356 0, route_output
, raw_ctlinput
, 0,
1363 static struct domain routedomain
= {
1364 PF_ROUTE
, "route", NULL
, NULL
, NULL
,
1365 routesw
, &routesw
[(sizeof routesw
)/(sizeof routesw
[0])],