X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/de355530ae67247cbd0da700edb3a2a1dae884c2..7ee9d059c4eecf68ae4f8b0fb99ae2471eda79af:/bsd/netinet/raw_ip.c diff --git a/bsd/netinet/raw_ip.c b/bsd/netinet/raw_ip.c index cf4f38aa6..0b63a3c0d 100644 --- a/bsd/netinet/raw_ip.c +++ b/bsd/netinet/raw_ip.c @@ -1,23 +1,29 @@ /* - * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. + * Copyright (c) 2000-2010 Apple Inc. All rights reserved. * - * @APPLE_LICENSE_HEADER_START@ + * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ * - * The contents of this file constitute Original Code as defined in and - * are subject to the Apple Public Source License Version 1.1 (the - * "License"). You may not use this file except in compliance with the - * License. Please obtain a copy of the License at - * http://www.apple.com/publicsource and read it before using this file. + * This file contains Original Code and/or Modifications of Original Code + * as defined in and that are subject to the Apple Public Source License + * Version 2.0 (the 'License'). You may not use this file except in + * compliance with the License. The rights granted to you under the License + * may not be used to create, or enable the creation or redistribution of, + * unlawful or unlicensed copies of an Apple operating system, or to + * circumvent, violate, or enable the circumvention or violation of, any + * terms of an Apple operating system software license agreement. * - * This Original Code and all software distributed under the License are - * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * Please obtain a copy of the License at + * http://www.opensource.apple.com/apsl/ and read it before using this file. + * + * The Original Code and all software distributed under the License are + * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the - * License for the specific language governing rights and limitations - * under the License. + * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * Please see the License for the specific language governing rights and + * limitations under the License. * - * @APPLE_LICENSE_HEADER_END@ + * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ */ /* * Copyright (c) 1982, 1986, 1988, 1993 @@ -53,6 +59,12 @@ * * @(#)raw_ip.c 8.7 (Berkeley) 5/15/95 */ +/* + * NOTICE: This file was modified by SPARTA, Inc. in 2005 to introduce + * support for mandatory and extensible security protections. This notice + * is included in support of clause 2.2 (b) of the Apple Public License, + * Version 2.0. + */ #include #include @@ -60,14 +72,15 @@ #include #include #include +#include #include #include #include #include +#include +#include -#if __FreeBSD__ -#include -#endif +#include #include #include @@ -81,6 +94,10 @@ #include #include +#if INET6 +#include +#endif /* INET6 */ + #include #if IPSEC @@ -91,6 +108,18 @@ #include #endif +#if CONFIG_MACF_NET +#include +#endif /* MAC_NET */ + +int load_ipfw(void); +int rip_detach(struct socket *); +int rip_abort(struct socket *); +int rip_disconnect(struct socket *); +int rip_bind(struct socket *, struct sockaddr *, struct proc *); +int rip_connect(struct socket *, struct sockaddr *, struct proc *); +int rip_shutdown(struct socket *); + #if IPSEC extern int ipsec_bypass; #endif @@ -98,6 +127,14 @@ extern int ipsec_bypass; struct inpcbhead ripcb; struct inpcbinfo ripcbinfo; +/* control hooks for ipfw and dummynet */ +#if IPFIREWALL +ip_fw_ctl_t *ip_fw_ctl_ptr; +#if DUMMYNET +ip_dn_ctl_t *ip_dn_ctl_ptr; +#endif /* DUMMYNET */ +#endif /* IPFIREWALL */ + /* * Nominal space allocated to a raw ip socket. */ @@ -114,6 +151,8 @@ struct inpcbinfo ripcbinfo; void rip_init() { + struct inpcbinfo *pcbinfo; + LIST_INIT(&ripcb); ripcbinfo.listhead = &ripcb; /* @@ -128,9 +167,25 @@ rip_init() (4096 * sizeof(struct inpcb)), 4096, "ripzone"); + pcbinfo = &ripcbinfo; + /* + * allocate lock group attribute and group for udp pcb mutexes + */ + pcbinfo->mtx_grp_attr = lck_grp_attr_alloc_init(); + + pcbinfo->mtx_grp = lck_grp_alloc_init("ripcb", pcbinfo->mtx_grp_attr); + + /* + * allocate the lock attribute for udp pcb mutexes + */ + pcbinfo->mtx_attr = lck_attr_alloc_init(); + + if ((pcbinfo->mtx = lck_rw_alloc_init(pcbinfo->mtx_grp, pcbinfo->mtx_attr)) == NULL) + return; /* pretty much dead if this fails... */ + } -static struct sockaddr_in ripsrc = { sizeof(ripsrc), AF_INET }; +static struct sockaddr_in ripsrc = { sizeof(ripsrc), AF_INET , 0, {0}, {0,0,0,0,0,0,0,0,} }; /* * Setup generic address and protocol structures * for raw_input routine, then pass them along with @@ -145,8 +200,10 @@ rip_input(m, iphlen) register struct inpcb *inp; struct inpcb *last = 0; struct mbuf *opts = 0; + int skipit = 0, ret = 0; ripsrc.sin_addr = ip->ip_src; + lck_rw_lock_shared(ripcbinfo.mtx); LIST_FOREACH(inp, &ripcb, inp_list) { #if INET6 if ((inp->inp_vflag & INP_IPV4) == 0) @@ -162,70 +219,120 @@ rip_input(m, iphlen) continue; if (last) { struct mbuf *n = m_copy(m, 0, (int)M_COPYALL); - + + skipit = 0; #if IPSEC /* check AH/ESP integrity. */ - if (ipsec_bypass == 0 && n && ipsec4_in_reject_so(n, last->inp_socket)) { - m_freem(n); - ipsecstat.in_polvio++; - /* do not inject data to pcb */ - } else + if (ipsec_bypass == 0 && n) { + if (ipsec4_in_reject_so(n, last->inp_socket)) { + m_freem(n); + IPSEC_STAT_INCREMENT(ipsecstat.in_polvio); + /* do not inject data to pcb */ + skipit = 1; + } + } #endif /*IPSEC*/ - if (n) { - if (last->inp_flags & INP_CONTROLOPTS || - last->inp_socket->so_options & SO_TIMESTAMP) - ip_savecontrol(last, &opts, ip, n); +#if CONFIG_MACF_NET + if (n && skipit == 0) { + if (mac_inpcb_check_deliver(last, n, AF_INET, + SOCK_RAW) != 0) { + m_freem(n); + skipit = 1; + } + } +#endif + if (n && skipit == 0) { + int error = 0; + if ((last->inp_flags & INP_CONTROLOPTS) != 0 || + (last->inp_socket->so_options & SO_TIMESTAMP) != 0 || + (last->inp_socket->so_options & SO_TIMESTAMP_MONOTONIC) != 0) { + ret = ip_savecontrol(last, &opts, ip, n); + if (ret != 0) { + m_freem(n); + m_freem(opts); + last = inp; + continue; + } + } if (last->inp_flags & INP_STRIPHDR) { n->m_len -= iphlen; n->m_pkthdr.len -= iphlen; n->m_data += iphlen; } + so_recv_data_stat(last->inp_socket, m, 0); if (sbappendaddr(&last->inp_socket->so_rcv, (struct sockaddr *)&ripsrc, n, - opts) == 0) { - /* should notify about lost packet */ - kprintf("rip_input can't append to socket\n"); - m_freem(n); - if (opts) - m_freem(opts); - } else + opts, &error) != 0) { sorwakeup(last->inp_socket); + } else { + if (error) { + /* should notify about lost packet */ + kprintf("rip_input can't append to socket\n"); + } + } opts = 0; } } last = inp; } + + skipit = 0; #if IPSEC /* check AH/ESP integrity. */ - if (ipsec_bypass == 0 && last && ipsec4_in_reject_so(m, last->inp_socket)) { - m_freem(m); - ipsecstat.in_polvio++; - ipstat.ips_delivered--; - /* do not inject data to pcb */ - } else + if (ipsec_bypass == 0 && last) { + if (ipsec4_in_reject_so(m, last->inp_socket)) { + m_freem(m); + IPSEC_STAT_INCREMENT(ipsecstat.in_polvio); + OSAddAtomic(1, &ipstat.ips_delivered); + /* do not inject data to pcb */ + skipit = 1; + } + } #endif /*IPSEC*/ - if (last) { - if (last->inp_flags & INP_CONTROLOPTS || - last->inp_socket->so_options & SO_TIMESTAMP) - ip_savecontrol(last, &opts, ip, m); - if (last->inp_flags & INP_STRIPHDR) { - m->m_len -= iphlen; - m->m_pkthdr.len -= iphlen; - m->m_data += iphlen; - } - if (sbappendaddr(&last->inp_socket->so_rcv, - (struct sockaddr *)&ripsrc, m, opts) == 0) { - kprintf("rip_input(2) can't append to socket\n"); +#if CONFIG_MACF_NET + if (last && skipit == 0) { + if (mac_inpcb_check_deliver(last, m, AF_INET, SOCK_RAW) != 0) { + skipit = 1; m_freem(m); - if (opts) - m_freem(opts); - } else - sorwakeup(last->inp_socket); - } else { - m_freem(m); - ipstat.ips_noproto++; - ipstat.ips_delivered--; + } + } +#endif + if (skipit == 0) { + if (last) { + if ((last->inp_flags & INP_CONTROLOPTS) != 0 || + (last->inp_socket->so_options & SO_TIMESTAMP) != 0 || + (last->inp_socket->so_options & SO_TIMESTAMP_MONOTONIC) != 0) { + ret = ip_savecontrol(last, &opts, ip, m); + if (ret != 0) { + m_freem(m); + m_freem(opts); + goto unlock; + } + } + if (last->inp_flags & INP_STRIPHDR) { + m->m_len -= iphlen; + m->m_pkthdr.len -= iphlen; + m->m_data += iphlen; + } + so_recv_data_stat(last->inp_socket, m, 0); + if (sbappendaddr(&last->inp_socket->so_rcv, + (struct sockaddr *)&ripsrc, m, opts, NULL) != 0) { + sorwakeup(last->inp_socket); + } else { + kprintf("rip_input(2) can't append to socket\n"); + } + } else { + m_freem(m); + OSAddAtomic(1, &ipstat.ips_noproto); + OSAddAtomic(-1, &ipstat.ips_delivered); + } } +unlock: + /* + * Keep the list locked because socket filter may force the socket lock + * to be released when calling sbappendaddr() -- see rdar://7627704 + */ + lck_rw_done(ripcbinfo.mtx); } /* @@ -233,14 +340,30 @@ rip_input(m, iphlen) * Tack on options user may have setup with control call. */ int -rip_output(m, so, dst) - register struct mbuf *m; - struct socket *so; - u_long dst; +rip_output( + struct mbuf *m, + struct socket *so, + u_int32_t dst, + struct mbuf *control) { register struct ip *ip; register struct inpcb *inp = sotoinpcb(so); int flags = (so->so_options & SO_DONTROUTE) | IP_ALLOWBROADCAST; + struct ip_out_args ipoa; + struct ip_moptions *imo; + int error = 0; + mbuf_traffic_class_t mtc = MBUF_TC_UNSPEC; + + if (control != NULL) { + mtc = mbuf_traffic_class_from_control(control); + + m_freem(control); + } + /* If socket was bound to an ifindex, tell ip_output about it */ + ipoa.ipoa_boundif = (inp->inp_flags & INP_BOUND_IF) ? + inp->inp_boundif : IFSCOPE_NONE; + ipoa.ipoa_nocell = (inp->inp_flags & INP_NO_IFT_CELLULAR) ? 1 : 0; + flags |= IP_OUTARGS; /* * If the user handed us a complete IP packet, use it. @@ -252,6 +375,8 @@ rip_output(m, so, dst) return(EMSGSIZE); } M_PREPEND(m, sizeof(struct ip), M_WAIT); + if (m == NULL) + return ENOBUFS; ip = mtod(m, struct ip *); ip->ip_tos = inp->inp_ip_tos; ip->ip_off = 0; @@ -283,7 +408,7 @@ rip_output(m, so, dst) #endif /* XXX prevent ip_output from overwriting header fields */ flags |= IP_RAWOUTPUT; - ipstat.ips_rawout++; + OSAddAtomic(1, &ipstat.ips_rawout); } #if IPSEC @@ -293,10 +418,80 @@ rip_output(m, so, dst) } #endif /*IPSEC*/ - return (ip_output(m, inp->inp_options, &inp->inp_route, flags, - inp->inp_moptions)); + if (inp->inp_route.ro_rt != NULL && + inp->inp_route.ro_rt->generation_id != route_generation) { + rtfree(inp->inp_route.ro_rt); + inp->inp_route.ro_rt = NULL; + } + + set_packet_tclass(m, so, mtc, 0); + +#if CONFIG_MACF_NET + mac_mbuf_label_associate_inpcb(inp, m); +#endif + + imo = inp->inp_moptions; + if (imo != NULL) + IMO_ADDREF(imo); + /* + * The domain lock is held across ip_output, so it is okay + * to pass the PCB cached route pointer directly to IP and + * the modules beneath it. + */ + error = ip_output(m, inp->inp_options, &inp->inp_route, flags, + imo, &ipoa); + + if (imo != NULL) + IMO_REMREF(imo); + + if (inp->inp_route.ro_rt != NULL) { + struct rtentry *rt = inp->inp_route.ro_rt; + unsigned int outif; + + if ((rt->rt_flags & (RTF_MULTICAST|RTF_BROADCAST)) || + inp->inp_socket == NULL || + !(inp->inp_socket->so_state & SS_ISCONNECTED)) { + rt = NULL; /* unusable */ + } + /* + * Always discard the cached route for unconnected + * socket or if it is a multicast route. + */ + if (rt == NULL) { + rtfree(inp->inp_route.ro_rt); + inp->inp_route.ro_rt = NULL; + } + /* + * If this is a connected socket and the destination + * route is unicast, update outif with that of the route + * interface index used by IP. + */ + if (rt != NULL && + (outif = rt->rt_ifp->if_index) != inp->inp_last_outif) + inp->inp_last_outif = outif; + } + + return (error); } +#if IPFIREWALL +int +load_ipfw(void) +{ + kern_return_t err; + + ipfw_init(); + +#if DUMMYNET + if (!DUMMYNET_LOADED) + ip_dn_init(); +#endif /* DUMMYNET */ + err = 0; + + return err == 0 && ip_fw_ctl_ptr == NULL ? -1 : err; +} +#endif /* IPFIREWALL */ + /* * Raw IP socket option processing. */ @@ -326,25 +521,30 @@ rip_ctloutput(so, sopt) error = sooptcopyout(sopt, &optval, sizeof optval); break; +#if IPFIREWALL case IP_FW_ADD: case IP_FW_GET: case IP_OLD_FW_ADD: case IP_OLD_FW_GET: if (ip_fw_ctl_ptr == 0) - error = ENOPROTOOPT; - else + error = load_ipfw(); + if (ip_fw_ctl_ptr && error == 0) error = ip_fw_ctl_ptr(sopt); + else + error = ENOPROTOOPT; break; +#endif /* IPFIREWALL */ #if DUMMYNET case IP_DUMMYNET_GET: - if (ip_dn_ctl_ptr == NULL) - error = ENOPROTOOPT ; - else + if (DUMMYNET_LOADED) error = ip_dn_ctl_ptr(sopt); + else + error = ENOPROTOOPT; break ; #endif /* DUMMYNET */ +#if MROUTING case MRT_INIT: case MRT_DONE: case MRT_ADD_VIF: @@ -355,6 +555,7 @@ rip_ctloutput(so, sopt) case MRT_ASSERT: error = ip_mrouter_get(so, sopt); break; +#endif /* MROUTING */ default: error = ip_ctloutput(so, sopt); @@ -387,6 +588,7 @@ rip_ctloutput(so, sopt) break; +#if IPFIREWALL case IP_FW_ADD: case IP_FW_DEL: case IP_FW_FLUSH: @@ -398,22 +600,26 @@ rip_ctloutput(so, sopt) case IP_OLD_FW_ZERO: case IP_OLD_FW_RESETLOG: if (ip_fw_ctl_ptr == 0) - error = ENOPROTOOPT; - else + error = load_ipfw(); + if (ip_fw_ctl_ptr && error == 0) error = ip_fw_ctl_ptr(sopt); + else + error = ENOPROTOOPT; break; +#endif /* IPFIREWALL */ #if DUMMYNET case IP_DUMMYNET_CONFIGURE: case IP_DUMMYNET_DEL: case IP_DUMMYNET_FLUSH: - if (ip_dn_ctl_ptr == NULL) - error = ENOPROTOOPT ; - else + if (DUMMYNET_LOADED) error = ip_dn_ctl_ptr(sopt); + else + error = ENOPROTOOPT ; break ; #endif +#if MROUTING case IP_RSVP_ON: error = ip_rsvp_init(so); break; @@ -430,7 +636,7 @@ rip_ctloutput(so, sopt) case IP_RSVP_VIF_OFF: error = ip_rsvp_vif_done(so, sopt); break; - + case MRT_INIT: case MRT_DONE: case MRT_ADD_VIF: @@ -441,6 +647,7 @@ rip_ctloutput(so, sopt) case MRT_ASSERT: error = ip_mrouter_set(so, sopt); break; +#endif /* MROUTING */ default: error = ip_ctloutput(so, sopt); @@ -460,26 +667,33 @@ rip_ctloutput(so, sopt) * interface routes. */ void -rip_ctlinput(cmd, sa, vip) - int cmd; - struct sockaddr *sa; - void *vip; +rip_ctlinput( + int cmd, + struct sockaddr *sa, + __unused void *vip) { struct in_ifaddr *ia; struct ifnet *ifp; int err; - int flags; + int flags, done = 0; switch (cmd) { case PRC_IFDOWN: + lck_rw_lock_shared(in_ifaddr_rwlock); for (ia = in_ifaddrhead.tqh_first; ia; ia = ia->ia_link.tqe_next) { - if (ia->ia_ifa.ifa_addr == sa - && (ia->ia_flags & IFA_ROUTE)) { + IFA_LOCK(&ia->ia_ifa); + if (ia->ia_ifa.ifa_addr == sa && + (ia->ia_flags & IFA_ROUTE)) { + done = 1; + IFA_ADDREF_LOCKED(&ia->ia_ifa); + IFA_UNLOCK(&ia->ia_ifa); + lck_rw_done(in_ifaddr_rwlock); + lck_mtx_lock(rnh_lock); /* * in_ifscrub kills the interface route. */ - in_ifscrub(ia->ia_ifp, ia); + in_ifscrub(ia->ia_ifp, ia, 1); /* * in_ifadown gets rid of all the rest of * the routes. This is not quite the right @@ -487,19 +701,38 @@ rip_ctlinput(cmd, sa, vip) * a routing process they will come back. */ in_ifadown(&ia->ia_ifa, 1); + lck_mtx_unlock(rnh_lock); + IFA_REMREF(&ia->ia_ifa); break; } + IFA_UNLOCK(&ia->ia_ifa); } + if (!done) + lck_rw_done(in_ifaddr_rwlock); break; case PRC_IFUP: + lck_rw_lock_shared(in_ifaddr_rwlock); for (ia = in_ifaddrhead.tqh_first; ia; ia = ia->ia_link.tqe_next) { - if (ia->ia_ifa.ifa_addr == sa) + IFA_LOCK(&ia->ia_ifa); + if (ia->ia_ifa.ifa_addr == sa) { + /* keep it locked */ break; + } + IFA_UNLOCK(&ia->ia_ifa); } - if (ia == 0 || (ia->ia_flags & IFA_ROUTE)) + if (ia == NULL || (ia->ia_flags & IFA_ROUTE) || + (ia->ia_ifa.ifa_debug & IFD_NOTREADY)) { + if (ia != NULL) + IFA_UNLOCK(&ia->ia_ifa); + lck_rw_done(in_ifaddr_rwlock); return; + } + IFA_ADDREF_LOCKED(&ia->ia_ifa); + IFA_UNLOCK(&ia->ia_ifa); + lck_rw_done(in_ifaddr_rwlock); + flags = RTF_UP; ifp = ia->ia_ifa.ifa_ifp; @@ -508,43 +741,40 @@ rip_ctlinput(cmd, sa, vip) flags |= RTF_HOST; err = rtinit(&ia->ia_ifa, RTM_ADD, flags); - if (err == 0) + if (err == 0) { + IFA_LOCK_SPIN(&ia->ia_ifa); ia->ia_flags |= IFA_ROUTE; + IFA_UNLOCK(&ia->ia_ifa); + } + IFA_REMREF(&ia->ia_ifa); break; } } -u_long rip_sendspace = RIPSNDQ; -u_long rip_recvspace = RIPRCVQ; +u_int32_t rip_sendspace = RIPSNDQ; +u_int32_t rip_recvspace = RIPRCVQ; -SYSCTL_INT(_net_inet_raw, OID_AUTO, maxdgram, CTLFLAG_RW, +SYSCTL_INT(_net_inet_raw, OID_AUTO, maxdgram, CTLFLAG_RW | CTLFLAG_LOCKED, &rip_sendspace, 0, "Maximum outgoing raw IP datagram size"); -SYSCTL_INT(_net_inet_raw, OID_AUTO, recvspace, CTLFLAG_RW, +SYSCTL_INT(_net_inet_raw, OID_AUTO, recvspace, CTLFLAG_RW | CTLFLAG_LOCKED, &rip_recvspace, 0, "Maximum incoming raw IP datagram size"); static int rip_attach(struct socket *so, int proto, struct proc *p) { struct inpcb *inp; - int error, s; + int error; inp = sotoinpcb(so); if (inp) panic("rip_attach"); -#if __APPLE__ if ((so->so_state & SS_PRIV) == 0) return (EPERM); -#else - if (p && (error = suser(p)) != 0) - return error; -#endif error = soreserve(so, rip_sendspace, rip_recvspace); if (error) return error; - s = splnet(); error = in_pcballoc(so, &ripcbinfo, p); - splx(s); if (error) return error; inp = (struct inpcb *)so->so_pcb; @@ -562,11 +792,13 @@ rip_detach(struct socket *so) inp = sotoinpcb(so); if (inp == 0) panic("rip_detach"); +#if MROUTING if (so == ip_mrouter) ip_mrouter_done(); ip_rsvp_force_done(so); if (so == ip_rsvpd) ip_rsvp_done(); +#endif /* MROUTING */ in_pcbdetach(inp); return 0; } @@ -587,32 +819,42 @@ rip_disconnect(struct socket *so) } __private_extern__ int -rip_bind(struct socket *so, struct sockaddr *nam, struct proc *p) +rip_bind(struct socket *so, struct sockaddr *nam, __unused struct proc *p) { struct inpcb *inp = sotoinpcb(so); struct sockaddr_in *addr = (struct sockaddr_in *)nam; + struct ifaddr *ifa = NULL; + unsigned int outif = 0; if (nam->sa_len != sizeof(*addr)) return EINVAL; - if (TAILQ_EMPTY(&ifnet) || ((addr->sin_family != AF_INET) && + if (TAILQ_EMPTY(&ifnet_head) || ((addr->sin_family != AF_INET) && (addr->sin_family != AF_IMPLINK)) || (addr->sin_addr.s_addr && - ifa_ifwithaddr((struct sockaddr *)addr) == 0)) + (ifa = ifa_ifwithaddr((struct sockaddr *)addr)) == 0)) { return EADDRNOTAVAIL; + } + else if (ifa) { + IFA_LOCK(ifa); + outif = ifa->ifa_ifp->if_index; + IFA_UNLOCK(ifa); + IFA_REMREF(ifa); + } inp->inp_laddr = addr->sin_addr; + inp->inp_last_outif = outif; return 0; } __private_extern__ int -rip_connect(struct socket *so, struct sockaddr *nam, struct proc *p) +rip_connect(struct socket *so, struct sockaddr *nam, __unused struct proc *p) { struct inpcb *inp = sotoinpcb(so); struct sockaddr_in *addr = (struct sockaddr_in *)nam; if (nam->sa_len != sizeof(*addr)) return EINVAL; - if (TAILQ_EMPTY(&ifnet)) + if (TAILQ_EMPTY(&ifnet_head)) return EADDRNOTAVAIL; if ((addr->sin_family != AF_INET) && (addr->sin_family != AF_IMPLINK)) @@ -630,11 +872,11 @@ rip_shutdown(struct socket *so) } __private_extern__ int -rip_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *nam, - struct mbuf *control, struct proc *p) +rip_send(struct socket *so, __unused int flags, struct mbuf *m, struct sockaddr *nam, + struct mbuf *control, __unused struct proc *p) { struct inpcb *inp = sotoinpcb(so); - register u_long dst; + register u_int32_t dst; if (so->so_state & SS_ISCONNECTED) { if (nam) { @@ -649,13 +891,58 @@ rip_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *nam, } dst = ((struct sockaddr_in *)nam)->sin_addr.s_addr; } - return rip_output(m, so, dst); + return rip_output(m, so, dst, control); +} + +/* note: rip_unlock is called from different protos instead of the generic socket_unlock, + * it will handle the socket dealloc on last reference + * */ +int +rip_unlock(struct socket *so, int refcount, void *debug) +{ + void *lr_saved; + struct inpcb *inp = sotoinpcb(so); + + if (debug == NULL) + lr_saved = __builtin_return_address(0); + else + lr_saved = debug; + + if (refcount) { + if (so->so_usecount <= 0) { + panic("rip_unlock: bad refoucnt so=%p val=%x lrh= %s\n", + so, so->so_usecount, solockhistory_nr(so)); + /* NOTREACHED */ + } + so->so_usecount--; + if (so->so_usecount == 0 && (inp->inp_wantcnt == WNT_STOPUSING)) { + /* cleanup after last reference */ + lck_mtx_unlock(so->so_proto->pr_domain->dom_mtx); + lck_rw_lock_exclusive(ripcbinfo.mtx); + if (inp->inp_state != INPCB_STATE_DEAD) { +#if INET6 + if (INP_CHECK_SOCKAF(so, AF_INET6)) + in6_pcbdetach(inp); + else +#endif /* INET6 */ + in_pcbdetach(inp); + } + in_pcbdispose(inp); + lck_rw_done(ripcbinfo.mtx); + return(0); + } + } + so->unlock_lr[so->next_unlock_lr] = lr_saved; + so->next_unlock_lr = (so->next_unlock_lr+1) % SO_LCKDBG_MAX; + lck_mtx_unlock(so->so_proto->pr_domain->dom_mtx); + return(0); } static int rip_pcblist SYSCTL_HANDLER_ARGS { - int error, i, n, s; +#pragma unused(oidp, arg1, arg2) + int error, i, n; struct inpcb *inp, **inp_list; inp_gen_t gencnt; struct xinpgen xig; @@ -664,58 +951,67 @@ rip_pcblist SYSCTL_HANDLER_ARGS * The process of preparing the TCB list is too time-consuming and * resource-intensive to repeat twice on every request. */ - if (req->oldptr == 0) { + lck_rw_lock_exclusive(ripcbinfo.mtx); + if (req->oldptr == USER_ADDR_NULL) { n = ripcbinfo.ipi_count; req->oldidx = 2 * (sizeof xig) + (n + n/8) * sizeof(struct xinpcb); + lck_rw_done(ripcbinfo.mtx); return 0; } - if (req->newptr != 0) + if (req->newptr != USER_ADDR_NULL) { + lck_rw_done(ripcbinfo.mtx); return EPERM; + } /* * OK, now we're committed to doing something. */ - s = splnet(); gencnt = ripcbinfo.ipi_gencnt; n = ripcbinfo.ipi_count; - splx(s); - + + bzero(&xig, sizeof(xig)); xig.xig_len = sizeof xig; xig.xig_count = n; xig.xig_gen = gencnt; xig.xig_sogen = so_gencnt; error = SYSCTL_OUT(req, &xig, sizeof xig); - if (error) + if (error) { + lck_rw_done(ripcbinfo.mtx); return error; + } /* * We are done if there is no pcb */ - if (n == 0) + if (n == 0) { + lck_rw_done(ripcbinfo.mtx); return 0; + } inp_list = _MALLOC(n * sizeof *inp_list, M_TEMP, M_WAITOK); - if (inp_list == 0) + if (inp_list == 0) { + lck_rw_done(ripcbinfo.mtx); return ENOMEM; + } - s = splnet(); for (inp = ripcbinfo.listhead->lh_first, i = 0; inp && i < n; inp = inp->inp_list.le_next) { - if (inp->inp_gencnt <= gencnt) + if (inp->inp_gencnt <= gencnt && inp->inp_state != INPCB_STATE_DEAD) inp_list[i++] = inp; } - splx(s); n = i; error = 0; for (i = 0; i < n; i++) { inp = inp_list[i]; - if (inp->inp_gencnt <= gencnt) { + if (inp->inp_gencnt <= gencnt && inp->inp_state != INPCB_STATE_DEAD) { struct xinpcb xi; + + bzero(&xi, sizeof(xi)); xi.xi_len = sizeof xi; /* XXX should avoid extra copy */ - bcopy(inp, &xi.xi_inp, sizeof *inp); + inpcb_to_compat(inp, &xi.xi_inp); if (inp->inp_socket) sotoxsocket(inp->inp_socket, &xi.xi_socket); error = SYSCTL_OUT(req, &xi, sizeof xi); @@ -729,24 +1025,146 @@ rip_pcblist SYSCTL_HANDLER_ARGS * while we were processing this request, and it * might be necessary to retry. */ - s = splnet(); + bzero(&xig, sizeof(xig)); + xig.xig_len = sizeof xig; xig.xig_gen = ripcbinfo.ipi_gencnt; xig.xig_sogen = so_gencnt; xig.xig_count = ripcbinfo.ipi_count; - splx(s); error = SYSCTL_OUT(req, &xig, sizeof xig); } FREE(inp_list, M_TEMP); + lck_rw_done(ripcbinfo.mtx); return error; } -SYSCTL_PROC(_net_inet_raw, OID_AUTO/*XXX*/, pcblist, CTLFLAG_RD, 0, 0, +SYSCTL_PROC(_net_inet_raw, OID_AUTO/*XXX*/, pcblist, CTLFLAG_RD | CTLFLAG_LOCKED, 0, 0, rip_pcblist, "S,xinpcb", "List of active raw IP sockets"); +#if !CONFIG_EMBEDDED + +static int +rip_pcblist64 SYSCTL_HANDLER_ARGS +{ +#pragma unused(oidp, arg1, arg2) + int error, i, n; + struct inpcb *inp, **inp_list; + inp_gen_t gencnt; + struct xinpgen xig; + + /* + * The process of preparing the TCB list is too time-consuming and + * resource-intensive to repeat twice on every request. + */ + lck_rw_lock_exclusive(ripcbinfo.mtx); + if (req->oldptr == USER_ADDR_NULL) { + n = ripcbinfo.ipi_count; + req->oldidx = 2 * (sizeof xig) + + (n + n/8) * sizeof(struct xinpcb64); + lck_rw_done(ripcbinfo.mtx); + return 0; + } + + if (req->newptr != USER_ADDR_NULL) { + lck_rw_done(ripcbinfo.mtx); + return EPERM; + } + + /* + * OK, now we're committed to doing something. + */ + gencnt = ripcbinfo.ipi_gencnt; + n = ripcbinfo.ipi_count; + + bzero(&xig, sizeof(xig)); + xig.xig_len = sizeof xig; + xig.xig_count = n; + xig.xig_gen = gencnt; + xig.xig_sogen = so_gencnt; + error = SYSCTL_OUT(req, &xig, sizeof xig); + if (error) { + lck_rw_done(ripcbinfo.mtx); + return error; + } + /* + * We are done if there is no pcb + */ + if (n == 0) { + lck_rw_done(ripcbinfo.mtx); + return 0; + } + + inp_list = _MALLOC(n * sizeof *inp_list, M_TEMP, M_WAITOK); + if (inp_list == 0) { + lck_rw_done(ripcbinfo.mtx); + return ENOMEM; + } + + for (inp = ripcbinfo.listhead->lh_first, i = 0; inp && i < n; + inp = inp->inp_list.le_next) { + if (inp->inp_gencnt <= gencnt && inp->inp_state != INPCB_STATE_DEAD) + inp_list[i++] = inp; + } + n = i; + + error = 0; + for (i = 0; i < n; i++) { + inp = inp_list[i]; + if (inp->inp_gencnt <= gencnt && inp->inp_state != INPCB_STATE_DEAD) { + struct xinpcb64 xi; + + bzero(&xi, sizeof(xi)); + xi.xi_len = sizeof xi; + inpcb_to_xinpcb64(inp, &xi); + if (inp->inp_socket) + sotoxsocket64(inp->inp_socket, &xi.xi_socket); + error = SYSCTL_OUT(req, &xi, sizeof xi); + } + } + if (!error) { + /* + * Give the user an updated idea of our state. + * If the generation differs from what we told + * her before, she knows that something happened + * while we were processing this request, and it + * might be necessary to retry. + */ + bzero(&xig, sizeof(xig)); + xig.xig_len = sizeof xig; + xig.xig_gen = ripcbinfo.ipi_gencnt; + xig.xig_sogen = so_gencnt; + xig.xig_count = ripcbinfo.ipi_count; + error = SYSCTL_OUT(req, &xig, sizeof xig); + } + FREE(inp_list, M_TEMP); + lck_rw_done(ripcbinfo.mtx); + return error; +} + +SYSCTL_PROC(_net_inet_raw, OID_AUTO, pcblist64, CTLFLAG_RD | CTLFLAG_LOCKED, 0, 0, + rip_pcblist64, "S,xinpcb64", "List of active raw IP sockets"); + +#endif /* !CONFIG_EMBEDDED */ + + +static int +rip_pcblist_n SYSCTL_HANDLER_ARGS +{ +#pragma unused(oidp, arg1, arg2) + int error = 0; + + error = get_pcblist_n(IPPROTO_IP, req, &ripcbinfo); + + return error; +} + +SYSCTL_PROC(_net_inet_raw, OID_AUTO, pcblist_n, CTLFLAG_RD | CTLFLAG_LOCKED, 0, 0, + rip_pcblist_n, "S,xinpcb_n", "List of active raw IP sockets"); + struct pr_usrreqs rip_usrreqs = { rip_abort, pru_accept_notsupp, rip_attach, rip_bind, rip_connect, pru_connect2_notsupp, in_control, rip_detach, rip_disconnect, pru_listen_notsupp, in_setpeeraddr, pru_rcvd_notsupp, pru_rcvoob_notsupp, rip_send, pru_sense_null, rip_shutdown, - in_setsockaddr, sosend, soreceive, sopoll + in_setsockaddr, sosend, soreceive, pru_sopoll_notsupp }; +/* DSEP Review Done pl-20051213-v02 @3253 */