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.45 2008/10/27 02:56:30 sephe Exp $
72 #include <sys/param.h>
73 #include <sys/systm.h>
74 #include <sys/kernel.h>
75 #include <sys/sysctl.h>
78 #include <sys/malloc.h>
80 #include <sys/protosw.h>
81 #include <sys/socket.h>
82 #include <sys/socketvar.h>
83 #include <sys/domain.h>
84 #include <sys/thread2.h>
87 #include <net/route.h>
88 #include <net/raw_cb.h>
89 #include <net/netmsg2.h>
92 extern void sctp_add_ip_address(struct ifaddr
*ifa
);
93 extern void sctp_delete_ip_address(struct ifaddr
*ifa
);
96 MALLOC_DEFINE(M_RTABLE
, "routetbl", "routing tables");
98 static struct route_cb
{
106 static const struct sockaddr route_src
= { 2, PF_ROUTE
, };
112 struct sysctl_req
*w_req
;
116 rt_msg_mbuf (int, struct rt_addrinfo
*);
117 static void rt_msg_buffer (int, struct rt_addrinfo
*, void *buf
, int len
);
118 static int rt_msgsize (int type
, struct rt_addrinfo
*rtinfo
);
119 static int rt_xaddrs (char *, char *, struct rt_addrinfo
*);
120 static int sysctl_dumpentry (struct radix_node
*rn
, void *vw
);
121 static int sysctl_iflist (int af
, struct walkarg
*w
);
122 static int route_output(struct mbuf
*, struct socket
*, ...);
123 static void rt_setmetrics (u_long
, struct rt_metrics
*,
124 struct rt_metrics
*);
127 * It really doesn't make any sense at all for this code to share much
128 * with raw_usrreq.c, since its functionality is so restricted. XXX
131 rts_abort(struct socket
*so
)
136 error
= raw_usrreqs
.pru_abort(so
);
141 /* pru_accept is EOPNOTSUPP */
144 rts_attach(struct socket
*so
, int proto
, struct pru_attach_info
*ai
)
149 if (sotorawcb(so
) != NULL
)
150 return EISCONN
; /* XXX panic? */
152 rp
= kmalloc(sizeof *rp
, M_PCB
, M_WAITOK
| M_ZERO
);
155 * The critical section is necessary to block protocols from sending
156 * error notifications (like RTM_REDIRECT or RTM_LOSING) while
157 * this PCB is extant but incompletely initialized.
158 * Probably we should try to do more of this work beforehand and
159 * eliminate the critical section.
163 error
= raw_attach(so
, proto
, ai
->sb_rlimit
);
170 switch(rp
->rcb_proto
.sp_protocol
) {
175 route_cb
.ip6_count
++;
178 route_cb
.ipx_count
++;
184 rp
->rcb_faddr
= &route_src
;
185 route_cb
.any_count
++;
187 so
->so_options
|= SO_USELOOPBACK
;
193 rts_bind(struct socket
*so
, struct sockaddr
*nam
, struct thread
*td
)
198 error
= raw_usrreqs
.pru_bind(so
, nam
, td
); /* xxx just EINVAL */
204 rts_connect(struct socket
*so
, struct sockaddr
*nam
, struct thread
*td
)
209 error
= raw_usrreqs
.pru_connect(so
, nam
, td
); /* XXX just EINVAL */
214 /* pru_connect2 is EOPNOTSUPP */
215 /* pru_control is EOPNOTSUPP */
218 rts_detach(struct socket
*so
)
220 struct rawcb
*rp
= sotorawcb(so
);
225 switch(rp
->rcb_proto
.sp_protocol
) {
230 route_cb
.ip6_count
--;
233 route_cb
.ipx_count
--;
239 route_cb
.any_count
--;
241 error
= raw_usrreqs
.pru_detach(so
);
247 rts_disconnect(struct socket
*so
)
252 error
= raw_usrreqs
.pru_disconnect(so
);
257 /* pru_listen is EOPNOTSUPP */
260 rts_peeraddr(struct socket
*so
, struct sockaddr
**nam
)
265 error
= raw_usrreqs
.pru_peeraddr(so
, nam
);
270 /* pru_rcvd is EOPNOTSUPP */
271 /* pru_rcvoob is EOPNOTSUPP */
274 rts_send(struct socket
*so
, int flags
, struct mbuf
*m
, struct sockaddr
*nam
,
275 struct mbuf
*control
, struct thread
*td
)
280 error
= raw_usrreqs
.pru_send(so
, flags
, m
, nam
, control
, td
);
285 /* pru_sense is null */
288 rts_shutdown(struct socket
*so
)
293 error
= raw_usrreqs
.pru_shutdown(so
);
299 rts_sockaddr(struct socket
*so
, struct sockaddr
**nam
)
304 error
= raw_usrreqs
.pru_sockaddr(so
, nam
);
309 static struct pr_usrreqs route_usrreqs
= {
310 .pru_abort
= rts_abort
,
311 .pru_accept
= pru_accept_notsupp
,
312 .pru_attach
= rts_attach
,
313 .pru_bind
= rts_bind
,
314 .pru_connect
= rts_connect
,
315 .pru_connect2
= pru_connect2_notsupp
,
316 .pru_control
= pru_control_notsupp
,
317 .pru_detach
= rts_detach
,
318 .pru_disconnect
= rts_disconnect
,
319 .pru_listen
= pru_listen_notsupp
,
320 .pru_peeraddr
= rts_peeraddr
,
321 .pru_rcvd
= pru_rcvd_notsupp
,
322 .pru_rcvoob
= pru_rcvoob_notsupp
,
323 .pru_send
= rts_send
,
324 .pru_sense
= pru_sense_null
,
325 .pru_shutdown
= rts_shutdown
,
326 .pru_sockaddr
= rts_sockaddr
,
327 .pru_sosend
= sosend
,
328 .pru_soreceive
= soreceive
,
332 static __inline sa_family_t
333 familyof(struct sockaddr
*sa
)
335 return (sa
!= NULL
? sa
->sa_family
: 0);
339 * Routing socket input function. The packet must be serialized onto cpu 0.
340 * We use the cpu0_soport() netisr processing loop to handle it.
342 * This looks messy but it means that anyone, including interrupt code,
343 * can send a message to the routing socket.
346 rts_input_handler(struct netmsg
*msg
)
348 static const struct sockaddr route_dst
= { 2, PF_ROUTE
, };
349 struct sockproto route_proto
;
350 struct netmsg_packet
*pmsg
;
356 family
= pmsg
->nm_netmsg
.nm_lmsg
.u
.ms_result
;
357 route_proto
.sp_family
= PF_ROUTE
;
358 route_proto
.sp_protocol
= family
;
360 raw_input(m
, &route_proto
, &route_src
, &route_dst
);
364 rts_input(struct mbuf
*m
, sa_family_t family
)
366 struct netmsg_packet
*pmsg
;
369 port
= cpu0_soport(NULL
, NULL
, NULL
, 0);
370 pmsg
= &m
->m_hdr
.mh_netmsg
;
371 netmsg_init(&pmsg
->nm_netmsg
, &netisr_apanic_rport
,
372 0, rts_input_handler
);
374 pmsg
->nm_netmsg
.nm_lmsg
.u
.ms_result
= family
;
375 lwkt_sendmsg(port
, &pmsg
->nm_netmsg
.nm_lmsg
);
379 reallocbuf(void *ptr
, size_t len
, size_t olen
)
383 newptr
= kmalloc(len
, M_RTABLE
, M_INTWAIT
| M_NULLOK
);
386 bcopy(ptr
, newptr
, olen
);
387 kfree(ptr
, M_RTABLE
);
392 * Internal helper routine for route_output().
395 fillrtmsg(struct rt_msghdr
**prtm
, struct rtentry
*rt
,
396 struct rt_addrinfo
*rtinfo
)
399 struct rt_msghdr
*rtm
= *prtm
;
401 /* Fill in rt_addrinfo for call to rt_msg_buffer(). */
402 rtinfo
->rti_dst
= rt_key(rt
);
403 rtinfo
->rti_gateway
= rt
->rt_gateway
;
404 rtinfo
->rti_netmask
= rt_mask(rt
); /* might be NULL */
405 rtinfo
->rti_genmask
= rt
->rt_genmask
; /* might be NULL */
406 if (rtm
->rtm_addrs
& (RTA_IFP
| RTA_IFA
)) {
407 if (rt
->rt_ifp
!= NULL
) {
408 rtinfo
->rti_ifpaddr
=
409 TAILQ_FIRST(&rt
->rt_ifp
->if_addrheads
[mycpuid
])
411 rtinfo
->rti_ifaaddr
= rt
->rt_ifa
->ifa_addr
;
412 if (rt
->rt_ifp
->if_flags
& IFF_POINTOPOINT
)
413 rtinfo
->rti_bcastaddr
= rt
->rt_ifa
->ifa_dstaddr
;
414 rtm
->rtm_index
= rt
->rt_ifp
->if_index
;
416 rtinfo
->rti_ifpaddr
= NULL
;
417 rtinfo
->rti_ifaaddr
= NULL
;
421 msglen
= rt_msgsize(rtm
->rtm_type
, rtinfo
);
422 if (rtm
->rtm_msglen
< msglen
) {
423 rtm
= reallocbuf(rtm
, msglen
, rtm
->rtm_msglen
);
428 rt_msg_buffer(rtm
->rtm_type
, rtinfo
, rtm
, msglen
);
430 rtm
->rtm_flags
= rt
->rt_flags
;
431 rtm
->rtm_rmx
= rt
->rt_rmx
;
432 rtm
->rtm_addrs
= rtinfo
->rti_addrs
;
437 static void route_output_add_callback(int, int, struct rt_addrinfo
*,
438 struct rtentry
*, void *);
439 static void route_output_delete_callback(int, int, struct rt_addrinfo
*,
440 struct rtentry
*, void *);
441 static void route_output_change_callback(int, int, struct rt_addrinfo
*,
442 struct rtentry
*, void *);
443 static void route_output_lock_callback(int, int, struct rt_addrinfo
*,
444 struct rtentry
*, void *);
448 route_output(struct mbuf
*m
, struct socket
*so
, ...)
450 struct rt_msghdr
*rtm
= NULL
;
452 struct radix_node_head
*rnh
;
453 struct rawcb
*rp
= NULL
;
454 struct pr_output_info
*oi
;
455 struct rt_addrinfo rtinfo
;
460 oi
= __va_arg(ap
, struct pr_output_info
*);
463 #define gotoerr(e) { error = e; goto flush;}
466 (m
->m_len
< sizeof(long) &&
467 (m
= m_pullup(m
, sizeof(long))) == NULL
))
469 if (!(m
->m_flags
& M_PKTHDR
))
470 panic("route_output");
471 len
= m
->m_pkthdr
.len
;
472 if (len
< sizeof(struct rt_msghdr
) ||
473 len
!= mtod(m
, struct rt_msghdr
*)->rtm_msglen
) {
474 rtinfo
.rti_dst
= NULL
;
477 rtm
= kmalloc(len
, M_RTABLE
, M_INTWAIT
| M_NULLOK
);
479 rtinfo
.rti_dst
= NULL
;
482 m_copydata(m
, 0, len
, (caddr_t
)rtm
);
483 if (rtm
->rtm_version
!= RTM_VERSION
) {
484 rtinfo
.rti_dst
= NULL
;
485 gotoerr(EPROTONOSUPPORT
);
487 rtm
->rtm_pid
= oi
->p_pid
;
488 bzero(&rtinfo
, sizeof(struct rt_addrinfo
));
489 rtinfo
.rti_addrs
= rtm
->rtm_addrs
;
490 if (rt_xaddrs((char *)(rtm
+ 1), (char *)rtm
+ len
, &rtinfo
) != 0) {
491 rtinfo
.rti_dst
= NULL
;
494 rtinfo
.rti_flags
= rtm
->rtm_flags
;
495 if (rtinfo
.rti_dst
== NULL
|| rtinfo
.rti_dst
->sa_family
>= AF_MAX
||
496 (rtinfo
.rti_gateway
&& rtinfo
.rti_gateway
->sa_family
>= AF_MAX
))
499 if (rtinfo
.rti_genmask
!= NULL
) {
500 struct radix_node
*n
;
502 #define clen(s) (*(u_char *)(s))
503 n
= rn_addmask((char *)rtinfo
.rti_genmask
, TRUE
, 1);
505 rtinfo
.rti_genmask
->sa_len
>= clen(n
->rn_key
) &&
506 bcmp((char *)rtinfo
.rti_genmask
+ 1,
507 (char *)n
->rn_key
+ 1, clen(n
->rn_key
) - 1) == 0)
508 rtinfo
.rti_genmask
= (struct sockaddr
*)n
->rn_key
;
514 * Verify that the caller has the appropriate privilege; RTM_GET
515 * is the only operation the non-superuser is allowed.
517 if (rtm
->rtm_type
!= RTM_GET
&& priv_check_cred(so
->so_cred
, PRIV_ROOT
, 0) != 0)
520 switch (rtm
->rtm_type
) {
522 if (rtinfo
.rti_gateway
== NULL
) {
525 error
= rtrequest1_global(RTM_ADD
, &rtinfo
,
526 route_output_add_callback
, rtm
);
531 * note: &rtm passed as argument so 'rtm' can be replaced.
533 error
= rtrequest1_global(RTM_DELETE
, &rtinfo
,
534 route_output_delete_callback
, &rtm
);
537 rnh
= rt_tables
[mycpuid
][rtinfo
.rti_dst
->sa_family
];
539 error
= EAFNOSUPPORT
;
542 rt
= (struct rtentry
*)
543 rnh
->rnh_lookup((char *)rtinfo
.rti_dst
,
544 (char *)rtinfo
.rti_netmask
, rnh
);
550 if (fillrtmsg(&rtm
, rt
, &rtinfo
) != 0)
555 error
= rtrequest1_global(RTM_GET
, &rtinfo
,
556 route_output_change_callback
, rtm
);
559 error
= rtrequest1_global(RTM_GET
, &rtinfo
,
560 route_output_lock_callback
, rtm
);
570 rtm
->rtm_errno
= error
;
572 rtm
->rtm_flags
|= RTF_DONE
;
576 * Check to see if we don't want our own messages.
578 if (!(so
->so_options
& SO_USELOOPBACK
)) {
579 if (route_cb
.any_count
<= 1) {
581 kfree(rtm
, M_RTABLE
);
585 /* There is another listener, so construct message */
589 m_copyback(m
, 0, rtm
->rtm_msglen
, (caddr_t
)rtm
);
590 if (m
->m_pkthdr
.len
< rtm
->rtm_msglen
) {
593 } else if (m
->m_pkthdr
.len
> rtm
->rtm_msglen
)
594 m_adj(m
, rtm
->rtm_msglen
- m
->m_pkthdr
.len
);
595 kfree(rtm
, M_RTABLE
);
598 rp
->rcb_proto
.sp_family
= 0; /* Avoid us */
600 rts_input(m
, familyof(rtinfo
.rti_dst
));
602 rp
->rcb_proto
.sp_family
= PF_ROUTE
;
607 route_output_add_callback(int cmd
, int error
, struct rt_addrinfo
*rtinfo
,
608 struct rtentry
*rt
, void *arg
)
610 struct rt_msghdr
*rtm
= arg
;
612 if (error
== 0 && rt
!= NULL
) {
613 rt_setmetrics(rtm
->rtm_inits
, &rtm
->rtm_rmx
,
615 rt
->rt_rmx
.rmx_locks
&= ~(rtm
->rtm_inits
);
616 rt
->rt_rmx
.rmx_locks
|=
617 (rtm
->rtm_inits
& rtm
->rtm_rmx
.rmx_locks
);
618 rt
->rt_genmask
= rtinfo
->rti_genmask
;
623 route_output_delete_callback(int cmd
, int error
, struct rt_addrinfo
*rtinfo
,
624 struct rtentry
*rt
, void *arg
)
626 struct rt_msghdr
**rtm
= arg
;
628 if (error
== 0 && rt
) {
630 if (fillrtmsg(rtm
, rt
, rtinfo
) != 0) {
632 /* XXX no way to return the error */
639 route_output_change_callback(int cmd
, int error
, struct rt_addrinfo
*rtinfo
,
640 struct rtentry
*rt
, void *arg
)
642 struct rt_msghdr
*rtm
= arg
;
649 * new gateway could require new ifaddr, ifp;
650 * flags may also be different; ifp may be specified
651 * by ll sockaddr when protocol address is ambiguous
653 if (((rt
->rt_flags
& RTF_GATEWAY
) && rtinfo
->rti_gateway
!= NULL
) ||
654 rtinfo
->rti_ifpaddr
!= NULL
|| (rtinfo
->rti_ifaaddr
!= NULL
&&
655 sa_equal(rtinfo
->rti_ifaaddr
, rt
->rt_ifa
->ifa_addr
))
657 error
= rt_getifa(rtinfo
);
661 if (rtinfo
->rti_gateway
!= NULL
) {
662 error
= rt_setgate(rt
, rt_key(rt
), rtinfo
->rti_gateway
);
666 if ((ifa
= rtinfo
->rti_ifa
) != NULL
) {
667 struct ifaddr
*oifa
= rt
->rt_ifa
;
670 if (oifa
&& oifa
->ifa_rtrequest
)
671 oifa
->ifa_rtrequest(RTM_DELETE
, rt
, rtinfo
);
675 rt
->rt_ifp
= rtinfo
->rti_ifp
;
678 rt_setmetrics(rtm
->rtm_inits
, &rtm
->rtm_rmx
, &rt
->rt_rmx
);
679 if (rt
->rt_ifa
&& rt
->rt_ifa
->ifa_rtrequest
)
680 rt
->rt_ifa
->ifa_rtrequest(RTM_ADD
, rt
, rtinfo
);
681 if (rtinfo
->rti_genmask
!= NULL
)
682 rt
->rt_genmask
= rtinfo
->rti_genmask
;
684 /* XXX no way to return error */
689 route_output_lock_callback(int cmd
, int error
, struct rt_addrinfo
*rtinfo
,
690 struct rtentry
*rt
, void *arg
)
692 struct rt_msghdr
*rtm
= arg
;
694 rt
->rt_rmx
.rmx_locks
&= ~(rtm
->rtm_inits
);
695 rt
->rt_rmx
.rmx_locks
|=
696 (rtm
->rtm_inits
& rtm
->rtm_rmx
.rmx_locks
);
700 rt_setmetrics(u_long which
, struct rt_metrics
*in
, struct rt_metrics
*out
)
702 #define setmetric(flag, elt) if (which & (flag)) out->elt = in->elt;
703 setmetric(RTV_RPIPE
, rmx_recvpipe
);
704 setmetric(RTV_SPIPE
, rmx_sendpipe
);
705 setmetric(RTV_SSTHRESH
, rmx_ssthresh
);
706 setmetric(RTV_RTT
, rmx_rtt
);
707 setmetric(RTV_RTTVAR
, rmx_rttvar
);
708 setmetric(RTV_HOPCOUNT
, rmx_hopcount
);
709 setmetric(RTV_MTU
, rmx_mtu
);
710 setmetric(RTV_EXPIRE
, rmx_expire
);
715 ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
718 * Extract the addresses of the passed sockaddrs.
719 * Do a little sanity checking so as to avoid bad memory references.
720 * This data is derived straight from userland.
723 rt_xaddrs(char *cp
, char *cplim
, struct rt_addrinfo
*rtinfo
)
728 for (i
= 0; (i
< RTAX_MAX
) && (cp
< cplim
); i
++) {
729 if ((rtinfo
->rti_addrs
& (1 << i
)) == 0)
731 sa
= (struct sockaddr
*)cp
;
735 if ((cp
+ sa
->sa_len
) > cplim
) {
740 * There are no more... Quit now.
741 * If there are more bits, they are in error.
742 * I've seen this. route(1) can evidently generate these.
743 * This causes kernel to core dump.
744 * For compatibility, if we see this, point to a safe address.
746 if (sa
->sa_len
== 0) {
747 static struct sockaddr sa_zero
= {
748 sizeof sa_zero
, AF_INET
,
751 rtinfo
->rti_info
[i
] = &sa_zero
;
752 kprintf("rtsock: received more addr bits than sockaddrs.\n");
753 return (0); /* should be EINVAL but for compat */
756 /* Accept the sockaddr. */
757 rtinfo
->rti_info
[i
] = sa
;
758 cp
+= ROUNDUP(sa
->sa_len
);
764 rt_msghdrsize(int type
)
769 return sizeof(struct ifa_msghdr
);
772 return sizeof(struct ifma_msghdr
);
774 return sizeof(struct if_msghdr
);
777 return sizeof(struct if_announcemsghdr
);
779 return sizeof(struct rt_msghdr
);
784 rt_msgsize(int type
, struct rt_addrinfo
*rtinfo
)
788 len
= rt_msghdrsize(type
);
789 for (i
= 0; i
< RTAX_MAX
; i
++) {
790 if (rtinfo
->rti_info
[i
] != NULL
)
791 len
+= ROUNDUP(rtinfo
->rti_info
[i
]->sa_len
);
798 * Build a routing message in a buffer.
799 * Copy the addresses in the rtinfo->rti_info[] sockaddr array
800 * to the end of the buffer after the message header.
802 * Set the rtinfo->rti_addrs bitmask of addresses present in rtinfo->rti_info[].
803 * This side-effect can be avoided if we reorder the addrs bitmask field in all
804 * the route messages to line up so we can set it here instead of back in the
808 rt_msg_buffer(int type
, struct rt_addrinfo
*rtinfo
, void *buf
, int msglen
)
810 struct rt_msghdr
*rtm
;
814 rtm
= (struct rt_msghdr
*) buf
;
815 rtm
->rtm_version
= RTM_VERSION
;
816 rtm
->rtm_type
= type
;
817 rtm
->rtm_msglen
= msglen
;
819 cp
= (char *)buf
+ rt_msghdrsize(type
);
820 rtinfo
->rti_addrs
= 0;
821 for (i
= 0; i
< RTAX_MAX
; i
++) {
824 if ((sa
= rtinfo
->rti_info
[i
]) == NULL
)
826 rtinfo
->rti_addrs
|= (1 << i
);
827 dlen
= ROUNDUP(sa
->sa_len
);
834 * Build a routing message in a mbuf chain.
835 * Copy the addresses in the rtinfo->rti_info[] sockaddr array
836 * to the end of the mbuf after the message header.
838 * Set the rtinfo->rti_addrs bitmask of addresses present in rtinfo->rti_info[].
839 * This side-effect can be avoided if we reorder the addrs bitmask field in all
840 * the route messages to line up so we can set it here instead of back in the
844 rt_msg_mbuf(int type
, struct rt_addrinfo
*rtinfo
)
847 struct rt_msghdr
*rtm
;
851 hlen
= rt_msghdrsize(type
);
852 KASSERT(hlen
<= MCLBYTES
, ("rt_msg_mbuf: hlen %d doesn't fit", hlen
));
854 m
= m_getl(hlen
, MB_DONTWAIT
, MT_DATA
, M_PKTHDR
, NULL
);
858 m
->m_pkthdr
.len
= m
->m_len
= hlen
;
859 m
->m_pkthdr
.rcvif
= NULL
;
860 rtinfo
->rti_addrs
= 0;
862 for (i
= 0; i
< RTAX_MAX
; i
++) {
866 if ((sa
= rtinfo
->rti_info
[i
]) == NULL
)
868 rtinfo
->rti_addrs
|= (1 << i
);
869 dlen
= ROUNDUP(sa
->sa_len
);
870 m_copyback(m
, len
, dlen
, (caddr_t
)sa
); /* can grow mbuf chain */
873 if (m
->m_pkthdr
.len
!= len
) { /* one of the m_copyback() calls failed */
877 rtm
= mtod(m
, struct rt_msghdr
*);
879 rtm
->rtm_msglen
= len
;
880 rtm
->rtm_version
= RTM_VERSION
;
881 rtm
->rtm_type
= type
;
886 * This routine is called to generate a message from the routing
887 * socket indicating that a redirect has occurred, a routing lookup
888 * has failed, or that a protocol has detected timeouts to a particular
892 rt_missmsg(int type
, struct rt_addrinfo
*rtinfo
, int flags
, int error
)
894 struct sockaddr
*dst
= rtinfo
->rti_info
[RTAX_DST
];
895 struct rt_msghdr
*rtm
;
898 if (route_cb
.any_count
== 0)
900 m
= rt_msg_mbuf(type
, rtinfo
);
903 rtm
= mtod(m
, struct rt_msghdr
*);
904 rtm
->rtm_flags
= RTF_DONE
| flags
;
905 rtm
->rtm_errno
= error
;
906 rtm
->rtm_addrs
= rtinfo
->rti_addrs
;
907 rts_input(m
, familyof(dst
));
911 rt_dstmsg(int type
, struct sockaddr
*dst
, int error
)
913 struct rt_msghdr
*rtm
;
914 struct rt_addrinfo addrs
;
917 if (route_cb
.any_count
== 0)
919 bzero(&addrs
, sizeof(struct rt_addrinfo
));
920 addrs
.rti_info
[RTAX_DST
] = dst
;
921 m
= rt_msg_mbuf(type
, &addrs
);
924 rtm
= mtod(m
, struct rt_msghdr
*);
925 rtm
->rtm_flags
= RTF_DONE
;
926 rtm
->rtm_errno
= error
;
927 rtm
->rtm_addrs
= addrs
.rti_addrs
;
928 rts_input(m
, familyof(dst
));
932 * This routine is called to generate a message from the routing
933 * socket indicating that the status of a network interface has changed.
936 rt_ifmsg(struct ifnet
*ifp
)
938 struct if_msghdr
*ifm
;
940 struct rt_addrinfo rtinfo
;
942 if (route_cb
.any_count
== 0)
944 bzero(&rtinfo
, sizeof(struct rt_addrinfo
));
945 m
= rt_msg_mbuf(RTM_IFINFO
, &rtinfo
);
948 ifm
= mtod(m
, struct if_msghdr
*);
949 ifm
->ifm_index
= ifp
->if_index
;
950 ifm
->ifm_flags
= ifp
->if_flags
;
951 ifm
->ifm_data
= ifp
->if_data
;
957 rt_ifamsg(int cmd
, struct ifaddr
*ifa
)
959 struct ifa_msghdr
*ifam
;
960 struct rt_addrinfo rtinfo
;
962 struct ifnet
*ifp
= ifa
->ifa_ifp
;
964 bzero(&rtinfo
, sizeof(struct rt_addrinfo
));
965 rtinfo
.rti_ifaaddr
= ifa
->ifa_addr
;
967 TAILQ_FIRST(&ifp
->if_addrheads
[mycpuid
])->ifa
->ifa_addr
;
968 rtinfo
.rti_netmask
= ifa
->ifa_netmask
;
969 rtinfo
.rti_bcastaddr
= ifa
->ifa_dstaddr
;
971 m
= rt_msg_mbuf(cmd
, &rtinfo
);
975 ifam
= mtod(m
, struct ifa_msghdr
*);
976 ifam
->ifam_index
= ifp
->if_index
;
977 ifam
->ifam_metric
= ifa
->ifa_metric
;
978 ifam
->ifam_flags
= ifa
->ifa_flags
;
979 ifam
->ifam_addrs
= rtinfo
.rti_addrs
;
981 rts_input(m
, familyof(ifa
->ifa_addr
));
985 rt_rtmsg(int cmd
, struct rtentry
*rt
, struct ifnet
*ifp
, int error
)
987 struct rt_msghdr
*rtm
;
988 struct rt_addrinfo rtinfo
;
990 struct sockaddr
*dst
;
995 bzero(&rtinfo
, sizeof(struct rt_addrinfo
));
996 rtinfo
.rti_dst
= dst
= rt_key(rt
);
997 rtinfo
.rti_gateway
= rt
->rt_gateway
;
998 rtinfo
.rti_netmask
= rt_mask(rt
);
1000 rtinfo
.rti_ifpaddr
=
1001 TAILQ_FIRST(&ifp
->if_addrheads
[mycpuid
])->ifa
->ifa_addr
;
1003 rtinfo
.rti_ifaaddr
= rt
->rt_ifa
->ifa_addr
;
1005 m
= rt_msg_mbuf(cmd
, &rtinfo
);
1009 rtm
= mtod(m
, struct rt_msghdr
*);
1011 rtm
->rtm_index
= ifp
->if_index
;
1012 rtm
->rtm_flags
|= rt
->rt_flags
;
1013 rtm
->rtm_errno
= error
;
1014 rtm
->rtm_addrs
= rtinfo
.rti_addrs
;
1016 rts_input(m
, familyof(dst
));
1020 * This is called to generate messages from the routing socket
1021 * indicating a network interface has had addresses associated with it.
1022 * if we ever reverse the logic and replace messages TO the routing
1023 * socket indicate a request to configure interfaces, then it will
1024 * be unnecessary as the routing socket will automatically generate
1028 rt_newaddrmsg(int cmd
, struct ifaddr
*ifa
, int error
, struct rtentry
*rt
)
1032 * notify the SCTP stack
1033 * this will only get called when an address is added/deleted
1034 * XXX pass the ifaddr struct instead if ifa->ifa_addr...
1037 sctp_add_ip_address(ifa
);
1038 else if (cmd
== RTM_DELETE
)
1039 sctp_delete_ip_address(ifa
);
1042 if (route_cb
.any_count
== 0)
1045 if (cmd
== RTM_ADD
) {
1046 rt_ifamsg(RTM_NEWADDR
, ifa
);
1047 rt_rtmsg(RTM_ADD
, rt
, ifa
->ifa_ifp
, error
);
1049 KASSERT((cmd
== RTM_DELETE
), ("unknown cmd %d", cmd
));
1050 rt_rtmsg(RTM_DELETE
, rt
, ifa
->ifa_ifp
, error
);
1051 rt_ifamsg(RTM_DELADDR
, ifa
);
1056 * This is the analogue to the rt_newaddrmsg which performs the same
1057 * function but for multicast group memberhips. This is easier since
1058 * there is no route state to worry about.
1061 rt_newmaddrmsg(int cmd
, struct ifmultiaddr
*ifma
)
1063 struct rt_addrinfo rtinfo
;
1064 struct mbuf
*m
= NULL
;
1065 struct ifnet
*ifp
= ifma
->ifma_ifp
;
1066 struct ifma_msghdr
*ifmam
;
1068 if (route_cb
.any_count
== 0)
1071 bzero(&rtinfo
, sizeof(struct rt_addrinfo
));
1072 rtinfo
.rti_ifaaddr
= ifma
->ifma_addr
;
1073 if (ifp
!= NULL
&& !TAILQ_EMPTY(&ifp
->if_addrheads
[mycpuid
])) {
1074 rtinfo
.rti_ifpaddr
=
1075 TAILQ_FIRST(&ifp
->if_addrheads
[mycpuid
])->ifa
->ifa_addr
;
1078 * If a link-layer address is present, present it as a ``gateway''
1079 * (similarly to how ARP entries, e.g., are presented).
1081 rtinfo
.rti_gateway
= ifma
->ifma_lladdr
;
1083 m
= rt_msg_mbuf(cmd
, &rtinfo
);
1087 ifmam
= mtod(m
, struct ifma_msghdr
*);
1088 ifmam
->ifmam_index
= ifp
->if_index
;
1089 ifmam
->ifmam_addrs
= rtinfo
.rti_addrs
;
1091 rts_input(m
, familyof(ifma
->ifma_addr
));
1094 static struct mbuf
*
1095 rt_makeifannouncemsg(struct ifnet
*ifp
, int type
, int what
,
1096 struct rt_addrinfo
*info
)
1098 struct if_announcemsghdr
*ifan
;
1101 if (route_cb
.any_count
== 0)
1104 bzero(info
, sizeof(*info
));
1105 m
= rt_msg_mbuf(type
, info
);
1109 ifan
= mtod(m
, struct if_announcemsghdr
*);
1110 ifan
->ifan_index
= ifp
->if_index
;
1111 strlcpy(ifan
->ifan_name
, ifp
->if_xname
, sizeof ifan
->ifan_name
);
1112 ifan
->ifan_what
= what
;
1117 * This is called to generate routing socket messages indicating
1118 * IEEE80211 wireless events.
1119 * XXX we piggyback on the RTM_IFANNOUNCE msg format in a clumsy way.
1122 rt_ieee80211msg(struct ifnet
*ifp
, int what
, void *data
, size_t data_len
)
1124 struct rt_addrinfo info
;
1127 m
= rt_makeifannouncemsg(ifp
, RTM_IEEE80211
, what
, &info
);
1132 * Append the ieee80211 data. Try to stick it in the
1133 * mbuf containing the ifannounce msg; otherwise allocate
1134 * a new mbuf and append.
1136 * NB: we assume m is a single mbuf.
1138 if (data_len
> M_TRAILINGSPACE(m
)) {
1139 struct mbuf
*n
= m_get(MB_DONTWAIT
, MT_DATA
);
1144 bcopy(data
, mtod(n
, void *), data_len
);
1145 n
->m_len
= data_len
;
1147 } else if (data_len
> 0) {
1148 bcopy(data
, mtod(m
, u_int8_t
*) + m
->m_len
, data_len
);
1149 m
->m_len
+= data_len
;
1152 if (m
->m_flags
& M_PKTHDR
)
1153 m
->m_pkthdr
.len
+= data_len
;
1154 mtod(m
, struct if_announcemsghdr
*)->ifan_msglen
+= data_len
;
1159 * This is called to generate routing socket messages indicating
1160 * network interface arrival and departure.
1163 rt_ifannouncemsg(struct ifnet
*ifp
, int what
)
1165 struct rt_addrinfo addrinfo
;
1168 m
= rt_makeifannouncemsg(ifp
, RTM_IFANNOUNCE
, what
, &addrinfo
);
1174 resizewalkarg(struct walkarg
*w
, int len
)
1178 newptr
= kmalloc(len
, M_RTABLE
, M_INTWAIT
| M_NULLOK
);
1181 if (w
->w_tmem
!= NULL
)
1182 kfree(w
->w_tmem
, M_RTABLE
);
1184 w
->w_tmemsize
= len
;
1189 * This is used in dumping the kernel table via sysctl().
1192 sysctl_dumpentry(struct radix_node
*rn
, void *vw
)
1194 struct walkarg
*w
= vw
;
1195 struct rtentry
*rt
= (struct rtentry
*)rn
;
1196 struct rt_addrinfo rtinfo
;
1199 if (w
->w_op
== NET_RT_FLAGS
&& !(rt
->rt_flags
& w
->w_arg
))
1202 bzero(&rtinfo
, sizeof(struct rt_addrinfo
));
1203 rtinfo
.rti_dst
= rt_key(rt
);
1204 rtinfo
.rti_gateway
= rt
->rt_gateway
;
1205 rtinfo
.rti_netmask
= rt_mask(rt
);
1206 rtinfo
.rti_genmask
= rt
->rt_genmask
;
1207 if (rt
->rt_ifp
!= NULL
) {
1208 rtinfo
.rti_ifpaddr
=
1209 TAILQ_FIRST(&rt
->rt_ifp
->if_addrheads
[mycpuid
])->ifa
->ifa_addr
;
1210 rtinfo
.rti_ifaaddr
= rt
->rt_ifa
->ifa_addr
;
1211 if (rt
->rt_ifp
->if_flags
& IFF_POINTOPOINT
)
1212 rtinfo
.rti_bcastaddr
= rt
->rt_ifa
->ifa_dstaddr
;
1214 msglen
= rt_msgsize(RTM_GET
, &rtinfo
);
1215 if (w
->w_tmemsize
< msglen
&& resizewalkarg(w
, msglen
) != 0)
1217 rt_msg_buffer(RTM_GET
, &rtinfo
, w
->w_tmem
, msglen
);
1218 if (w
->w_req
!= NULL
) {
1219 struct rt_msghdr
*rtm
= w
->w_tmem
;
1221 rtm
->rtm_flags
= rt
->rt_flags
;
1222 rtm
->rtm_use
= rt
->rt_use
;
1223 rtm
->rtm_rmx
= rt
->rt_rmx
;
1224 rtm
->rtm_index
= rt
->rt_ifp
->if_index
;
1225 rtm
->rtm_errno
= rtm
->rtm_pid
= rtm
->rtm_seq
= 0;
1226 rtm
->rtm_addrs
= rtinfo
.rti_addrs
;
1227 error
= SYSCTL_OUT(w
->w_req
, rtm
, msglen
);
1234 sysctl_iflist(int af
, struct walkarg
*w
)
1237 struct rt_addrinfo rtinfo
;
1240 bzero(&rtinfo
, sizeof(struct rt_addrinfo
));
1241 TAILQ_FOREACH(ifp
, &ifnet
, if_link
) {
1242 struct ifaddr_container
*ifac
;
1245 if (w
->w_arg
&& w
->w_arg
!= ifp
->if_index
)
1247 ifac
= TAILQ_FIRST(&ifp
->if_addrheads
[mycpuid
]);
1249 rtinfo
.rti_ifpaddr
= ifa
->ifa_addr
;
1250 msglen
= rt_msgsize(RTM_IFINFO
, &rtinfo
);
1251 if (w
->w_tmemsize
< msglen
&& resizewalkarg(w
, msglen
) != 0)
1253 rt_msg_buffer(RTM_IFINFO
, &rtinfo
, w
->w_tmem
, msglen
);
1254 rtinfo
.rti_ifpaddr
= NULL
;
1255 if (w
->w_req
!= NULL
&& w
->w_tmem
!= NULL
) {
1256 struct if_msghdr
*ifm
= w
->w_tmem
;
1258 ifm
->ifm_index
= ifp
->if_index
;
1259 ifm
->ifm_flags
= ifp
->if_flags
;
1260 ifm
->ifm_data
= ifp
->if_data
;
1261 ifm
->ifm_addrs
= rtinfo
.rti_addrs
;
1262 error
= SYSCTL_OUT(w
->w_req
, ifm
, msglen
);
1266 while ((ifac
= TAILQ_NEXT(ifac
, ifa_link
)) != NULL
) {
1269 if (af
&& af
!= ifa
->ifa_addr
->sa_family
)
1271 if (curproc
->p_ucred
->cr_prison
&&
1272 prison_if(curproc
->p_ucred
, ifa
->ifa_addr
))
1274 rtinfo
.rti_ifaaddr
= ifa
->ifa_addr
;
1275 rtinfo
.rti_netmask
= ifa
->ifa_netmask
;
1276 rtinfo
.rti_bcastaddr
= ifa
->ifa_dstaddr
;
1277 msglen
= rt_msgsize(RTM_NEWADDR
, &rtinfo
);
1278 if (w
->w_tmemsize
< msglen
&&
1279 resizewalkarg(w
, msglen
) != 0)
1281 rt_msg_buffer(RTM_NEWADDR
, &rtinfo
, w
->w_tmem
, msglen
);
1282 if (w
->w_req
!= NULL
) {
1283 struct ifa_msghdr
*ifam
= w
->w_tmem
;
1285 ifam
->ifam_index
= ifa
->ifa_ifp
->if_index
;
1286 ifam
->ifam_flags
= ifa
->ifa_flags
;
1287 ifam
->ifam_metric
= ifa
->ifa_metric
;
1288 ifam
->ifam_addrs
= rtinfo
.rti_addrs
;
1289 error
= SYSCTL_OUT(w
->w_req
, w
->w_tmem
, msglen
);
1294 rtinfo
.rti_netmask
= NULL
;
1295 rtinfo
.rti_ifaaddr
= NULL
;
1296 rtinfo
.rti_bcastaddr
= NULL
;
1302 sysctl_rtsock(SYSCTL_HANDLER_ARGS
)
1304 int *name
= (int *)arg1
;
1305 u_int namelen
= arg2
;
1306 struct radix_node_head
*rnh
;
1307 int i
, error
= EINVAL
;
1316 if (namelen
!= 3 && namelen
!= 4)
1319 bzero(&w
, sizeof w
);
1325 * Optional third argument specifies cpu, used primarily for
1326 * debugging the route table.
1329 if (name
[3] < 0 || name
[3] >= ncpus
)
1332 lwkt_migratecpu(name
[3]);
1340 for (i
= 1; i
<= AF_MAX
; i
++)
1341 if ((rnh
= rt_tables
[mycpuid
][i
]) &&
1342 (af
== 0 || af
== i
) &&
1343 (error
= rnh
->rnh_walktree(rnh
,
1344 sysctl_dumpentry
, &w
)))
1349 error
= sysctl_iflist(af
, &w
);
1352 if (w
.w_tmem
!= NULL
)
1353 kfree(w
.w_tmem
, M_RTABLE
);
1355 lwkt_migratecpu(origcpu
);
1359 SYSCTL_NODE(_net
, PF_ROUTE
, routetable
, CTLFLAG_RD
, sysctl_rtsock
, "");
1362 * Definitions of protocols supported in the ROUTE domain.
1365 static struct domain routedomain
; /* or at least forward */
1367 static struct protosw routesw
[] = {
1368 { SOCK_RAW
, &routedomain
, 0, PR_ATOMIC
|PR_ADDR
,
1369 0, route_output
, raw_ctlinput
, 0,
1370 cpu0_soport
, cpu0_ctlport
,
1376 static struct domain routedomain
= {
1377 PF_ROUTE
, "route", NULL
, NULL
, NULL
,
1378 routesw
, &routesw
[(sizeof routesw
)/(sizeof routesw
[0])],