/*
- * Copyright (c) 2000-2010 Apple Inc. All rights reserved.
+ * Copyright (c) 2000-2013 Apple Inc. All rights reserved.
*
* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
*
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/mbuf.h>
+#include <sys/mcache.h>
#include <sys/proc.h>
#include <sys/domain.h>
#include <sys/protosw.h>
/* control hooks for ipfw and dummynet */
#if IPFIREWALL
ip_fw_ctl_t *ip_fw_ctl_ptr;
+#endif /* IPFIREWALL */
#if DUMMYNET
ip_dn_ctl_t *ip_dn_ctl_ptr;
#endif /* DUMMYNET */
-#endif /* IPFIREWALL */
/*
* Nominal space allocated to a raw ip socket.
* Initialize raw connection block q.
*/
void
-rip_init()
+rip_init(struct protosw *pp, struct domain *dp)
{
- struct inpcbinfo *pcbinfo;
+#pragma unused(dp)
+ static int rip_initialized = 0;
+ struct inpcbinfo *pcbinfo;
+
+ VERIFY((pp->pr_flags & (PR_INITIALIZED|PR_ATTACHED)) == PR_ATTACHED);
+
+ if (rip_initialized)
+ return;
+ rip_initialized = 1;
LIST_INIT(&ripcb);
- ripcbinfo.listhead = &ripcb;
+ ripcbinfo.ipi_listhead = &ripcb;
/*
* XXX We don't use the hash list for raw IP, but it's easier
* to allocate a one entry hash list than it is to check all
- * over the place for hashbase == NULL.
+ * over the place for ipi_hashbase == NULL.
*/
- ripcbinfo.hashbase = hashinit(1, M_PCB, &ripcbinfo.hashmask);
- ripcbinfo.porthashbase = hashinit(1, M_PCB, &ripcbinfo.porthashmask);
+ ripcbinfo.ipi_hashbase = hashinit(1, M_PCB, &ripcbinfo.ipi_hashmask);
+ ripcbinfo.ipi_porthashbase = hashinit(1, M_PCB, &ripcbinfo.ipi_porthashmask);
- ripcbinfo.ipi_zone = (void *) zinit(sizeof(struct inpcb),
- (4096 * sizeof(struct inpcb)),
- 4096, "ripzone");
+ ripcbinfo.ipi_zone = zinit(sizeof(struct inpcb),
+ (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->ipi_lock_grp_attr = lck_grp_attr_alloc_init();
+ pcbinfo->ipi_lock_grp = lck_grp_alloc_init("ripcb", pcbinfo->ipi_lock_grp_attr);
- 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... */
+ pcbinfo->ipi_lock_attr = lck_attr_alloc_init();
+ if ((pcbinfo->ipi_lock = lck_rw_alloc_init(pcbinfo->ipi_lock_grp,
+ pcbinfo->ipi_lock_attr)) == NULL) {
+ panic("%s: unable to allocate PCB lock\n", __func__);
+ /* NOTREACHED */
+ }
+ in_pcbinfo_attach(&ripcbinfo);
}
static struct sockaddr_in ripsrc = { sizeof(ripsrc), AF_INET , 0, {0}, {0,0,0,0,0,0,0,0,} };
struct mbuf *m;
int iphlen;
{
- register struct ip *ip = mtod(m, struct ip *);
- register struct inpcb *inp;
+ struct ip *ip = mtod(m, struct ip *);
+ struct inpcb *inp;
struct inpcb *last = 0;
struct mbuf *opts = 0;
int skipit = 0, ret = 0;
+ struct ifnet *ifp = m->m_pkthdr.rcvif;
+
+ /* Expect 32-bit aligned data pointer on strict-align platforms */
+ MBUF_STRICT_DATA_ALIGNMENT_CHECK_32(m);
ripsrc.sin_addr = ip->ip_src;
- lck_rw_lock_shared(ripcbinfo.mtx);
+ lck_rw_lock_shared(ripcbinfo.ipi_lock);
LIST_FOREACH(inp, &ripcb, inp_list) {
#if INET6
if ((inp->inp_vflag & INP_IPV4) == 0)
if (inp->inp_faddr.s_addr &&
inp->inp_faddr.s_addr != ip->ip_src.s_addr)
continue;
+
+ if (inp_restricted(inp, ifp))
+ continue;
+
+ if (ifp != NULL && IFNET_IS_CELLULAR(ifp) &&
+ (inp->inp_flags & INP_NO_IFT_CELLULAR))
+ continue;
+
if (last) {
struct mbuf *n = m_copy(m, 0, (int)M_COPYALL);
* 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);
+ lck_rw_done(ripcbinfo.ipi_lock);
}
/*
u_int32_t dst,
struct mbuf *control)
{
- register struct ip *ip;
- register struct inpcb *inp = sotoinpcb(so);
+ struct ip *ip;
+ struct inpcb *inp = sotoinpcb(so);
int flags = (so->so_options & SO_DONTROUTE) | IP_ALLOWBROADCAST;
- struct ip_out_args ipoa;
+ struct ip_out_args ipoa =
+ { IFSCOPE_NONE, { 0 }, IPOAF_SELECT_SRCIF, 0 };
struct ip_moptions *imo;
int error = 0;
- mbuf_traffic_class_t mtc = MBUF_TC_UNSPEC;
+ mbuf_svc_class_t msc = MBUF_SC_UNSPEC;
if (control != NULL) {
- mtc = mbuf_traffic_class_from_control(control);
+ msc = mbuf_service_class_from_control(control);
m_freem(control);
+ control = NULL;
}
- /* 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;
+
+ if (inp == NULL || (inp->inp_flags2 & INP2_WANT_FLOW_DIVERT)) {
+ if (m != NULL)
+ m_freem(m);
+ VERIFY(control == NULL);
+ return (inp == NULL ? EINVAL : EPROTOTYPE);
+ }
+
flags |= IP_OUTARGS;
+ /* If socket was bound to an ifindex, tell ip_output about it */
+ if (inp->inp_flags & INP_BOUND_IF) {
+ ipoa.ipoa_boundif = inp->inp_boundifp->if_index;
+ ipoa.ipoa_flags |= IPOAF_BOUND_IF;
+ }
+ if (inp->inp_flags & INP_NO_IFT_CELLULAR)
+ ipoa.ipoa_flags |= IPOAF_NO_CELLULAR;
+
+ if (inp->inp_flowhash == 0)
+ inp->inp_flowhash = inp_calc_flowhash(inp);
/*
* If the user handed us a complete IP packet, use it.
return EINVAL;
}
if (ip->ip_id == 0)
-#if RANDOM_IP_ID
ip->ip_id = ip_randomid();
-#else
- ip->ip_id = htons(ip_id++);
-#endif
/* XXX prevent ip_output from overwriting header fields */
flags |= IP_RAWOUTPUT;
OSAddAtomic(1, &ipstat.ips_rawout);
}
+ if (inp->inp_laddr.s_addr != INADDR_ANY)
+ ipoa.ipoa_flags |= IPOAF_BOUND_SRCADDR;
+
#if IPSEC
if (ipsec_bypass == 0 && ipsec_setsocket(m, so) != 0) {
m_freem(m);
}
#endif /*IPSEC*/
- 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;
- }
+ if (ROUTE_UNUSABLE(&inp->inp_route))
+ ROUTE_RELEASE(&inp->inp_route);
- set_packet_tclass(m, so, mtc, 0);
+ set_packet_service_class(m, so, msc, 0);
+ m->m_pkthdr.pkt_flowsrc = FLOWSRC_INPCB;
+ m->m_pkthdr.pkt_flowid = inp->inp_flowhash;
+ m->m_pkthdr.pkt_flags |= (PKTF_FLOW_ID | PKTF_FLOW_LOCALSRC |
+ PKTF_FLOW_RAWSOCK);
+ m->m_pkthdr.pkt_proto = inp->inp_ip_p;
#if CONFIG_MACF_NET
mac_mbuf_label_associate_inpcb(inp, m);
if (inp->inp_route.ro_rt != NULL) {
struct rtentry *rt = inp->inp_route.ro_rt;
- unsigned int outif;
+ struct ifnet *outif;
if ((rt->rt_flags & (RTF_MULTICAST|RTF_BROADCAST)) ||
inp->inp_socket == NULL ||
* 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 (rt == NULL)
+ ROUTE_RELEASE(&inp->inp_route);
+
/*
* If this is a connected socket and the destination
- * route is unicast, update outif with that of the route
- * interface index used by IP.
+ * route is unicast, update outif with that of the
+ * route interface used by IP.
*/
- if (rt != NULL &&
- (outif = rt->rt_ifp->if_index) != inp->inp_last_outif)
- inp->inp_last_outif = outif;
+ if (rt != NULL && (outif = rt->rt_ifp) != inp->inp_last_outifp)
+ inp->inp_last_outifp = outif;
+ } else {
+ ROUTE_RELEASE(&inp->inp_route);
}
+ /*
+ * If output interface was cellular, and this socket is denied
+ * access to it, generate an event.
+ */
+ if (error != 0 && (ipoa.ipoa_retflags & IPOARF_IFDENIED) &&
+ (inp->inp_flags & INP_NO_IFT_CELLULAR))
+ soevent(so, (SO_FILT_HINT_LOCKED|SO_FILT_HINT_IFDENIED));
+
return (error);
}
struct inpcb *inp = sotoinpcb(so);
int error, optval;
- if (sopt->sopt_level != IPPROTO_IP)
+ /* Allow <SOL_SOCKET,SO_FLUSH> at this level */
+ if (sopt->sopt_level != IPPROTO_IP &&
+ !(sopt->sopt_level == SOL_SOCKET && sopt->sopt_name == SO_FLUSH))
return (EINVAL);
error = 0;
error = sooptcopyout(sopt, &optval, sizeof optval);
break;
- case IP_STRIPHDR:
- optval = inp->inp_flags & INP_STRIPHDR;
- error = sooptcopyout(sopt, &optval, sizeof optval);
- break;
+ case IP_STRIPHDR:
+ optval = inp->inp_flags & INP_STRIPHDR;
+ error = sooptcopyout(sopt, &optval, sizeof optval);
+ break;
#if IPFIREWALL
case IP_FW_ADD:
#if DUMMYNET
case IP_DUMMYNET_GET:
+ if (!DUMMYNET_LOADED)
+ ip_dn_init();
if (DUMMYNET_LOADED)
error = ip_dn_ctl_ptr(sopt);
else
inp->inp_flags &= ~INP_HDRINCL;
break;
- case IP_STRIPHDR:
- error = sooptcopyin(sopt, &optval, sizeof optval,
- sizeof optval);
- if (error)
- break;
- if (optval)
- inp->inp_flags |= INP_STRIPHDR;
- else
- inp->inp_flags &= ~INP_STRIPHDR;
- break;
-
+ case IP_STRIPHDR:
+ error = sooptcopyin(sopt, &optval, sizeof optval,
+ sizeof optval);
+ if (error)
+ break;
+ if (optval)
+ inp->inp_flags |= INP_STRIPHDR;
+ else
+ inp->inp_flags &= ~INP_STRIPHDR;
+ break;
#if IPFIREWALL
case IP_FW_ADD:
case IP_DUMMYNET_CONFIGURE:
case IP_DUMMYNET_DEL:
case IP_DUMMYNET_FLUSH:
+ if (!DUMMYNET_LOADED)
+ ip_dn_init();
if (DUMMYNET_LOADED)
error = ip_dn_ctl_ptr(sopt);
else
case IP_RSVP_VIF_ON:
error = ip_rsvp_vif_init(so, sopt);
break;
-
+
case IP_RSVP_VIF_OFF:
error = ip_rsvp_vif_done(so, sopt);
break;
-
+
case MRT_INIT:
case MRT_DONE:
case MRT_ADD_VIF:
break;
#endif /* MROUTING */
+ case SO_FLUSH:
+ if ((error = sooptcopyin(sopt, &optval, sizeof (optval),
+ sizeof (optval))) != 0)
+ break;
+
+ error = inp_flush(inp, optval);
+ break;
+
default:
error = ip_ctloutput(so, sopt);
break;
&rip_sendspace, 0, "Maximum outgoing raw IP datagram size");
SYSCTL_INT(_net_inet_raw, OID_AUTO, recvspace, CTLFLAG_RW | CTLFLAG_LOCKED,
&rip_recvspace, 0, "Maximum incoming raw IP datagram size");
+SYSCTL_UINT(_net_inet_raw, OID_AUTO, pcbcount, CTLFLAG_RD | CTLFLAG_LOCKED,
+ &ripcbinfo.ipi_count, 0, "Number of active PCBs");
static int
rip_attach(struct socket *so, int proto, struct proc *p)
}
__private_extern__ int
-rip_bind(struct socket *so, struct sockaddr *nam, __unused struct proc *p)
+rip_bind(struct socket *so, struct sockaddr *nam, struct proc *p)
{
+#pragma unused(p)
struct inpcb *inp = sotoinpcb(so);
- struct sockaddr_in *addr = (struct sockaddr_in *)nam;
+ struct sockaddr_in sin;
struct ifaddr *ifa = NULL;
- unsigned int outif = 0;
+ struct ifnet *outif = NULL;
- if (nam->sa_len != sizeof(*addr))
- return EINVAL;
+ if (inp == NULL || (inp->inp_flags2 & INP2_WANT_FLOW_DIVERT))
+ return (inp == NULL ? EINVAL : EPROTOTYPE);
- if (TAILQ_EMPTY(&ifnet_head) || ((addr->sin_family != AF_INET) &&
- (addr->sin_family != AF_IMPLINK)) ||
- (addr->sin_addr.s_addr &&
- (ifa = ifa_ifwithaddr((struct sockaddr *)addr)) == 0)) {
- return EADDRNOTAVAIL;
- }
- else if (ifa) {
+ if (nam->sa_len != sizeof (struct sockaddr_in))
+ return (EINVAL);
+
+ /* Sanitized local copy for interface address searches */
+ bzero(&sin, sizeof (sin));
+ sin.sin_family = AF_INET;
+ sin.sin_len = sizeof (struct sockaddr_in);
+ sin.sin_addr.s_addr = SIN(nam)->sin_addr.s_addr;
+
+ if (TAILQ_EMPTY(&ifnet_head) ||
+ (sin.sin_family != AF_INET && sin.sin_family != AF_IMPLINK) ||
+ (sin.sin_addr.s_addr && (ifa = ifa_ifwithaddr(SA(&sin))) == 0)) {
+ return (EADDRNOTAVAIL);
+ } else if (ifa) {
+ /*
+ * Opportunistically determine the outbound
+ * interface that may be used; this may not
+ * hold true if we end up using a route
+ * going over a different interface, e.g.
+ * when sending to a local address. This
+ * will get updated again after sending.
+ */
IFA_LOCK(ifa);
- outif = ifa->ifa_ifp->if_index;
+ outif = ifa->ifa_ifp;
IFA_UNLOCK(ifa);
IFA_REMREF(ifa);
}
- inp->inp_laddr = addr->sin_addr;
- inp->inp_last_outif = outif;
- return 0;
+ inp->inp_laddr = sin.sin_addr;
+ inp->inp_last_outifp = outif;
+ return (0);
}
__private_extern__ int
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;
+ struct sockaddr_in *addr = (struct sockaddr_in *)(void *)nam;
+ if (inp == NULL || (inp->inp_flags2 & INP2_WANT_FLOW_DIVERT))
+ return (inp == NULL ? EINVAL : EPROTOTYPE);
if (nam->sa_len != sizeof(*addr))
return EINVAL;
if (TAILQ_EMPTY(&ifnet_head))
return EAFNOSUPPORT;
inp->inp_faddr = addr->sin_addr;
soisconnected(so);
+
return 0;
}
}
__private_extern__ int
-rip_send(struct socket *so, __unused int flags, struct mbuf *m, struct sockaddr *nam,
- struct mbuf *control, __unused struct proc *p)
+rip_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *nam,
+ struct mbuf *control, struct proc *p)
{
+#pragma unused(flags, p)
struct inpcb *inp = sotoinpcb(so);
- register u_int32_t dst;
+ u_int32_t dst;
+ int error = 0;
+
+ if (inp == NULL || (inp->inp_flags2 & INP2_WANT_FLOW_DIVERT)) {
+ error = (inp == NULL ? EINVAL : EPROTOTYPE);
+ goto bad;
+ }
if (so->so_state & SS_ISCONNECTED) {
- if (nam) {
- m_freem(m);
- return EISCONN;
+ if (nam != NULL) {
+ error = EISCONN;
+ goto bad;
}
dst = inp->inp_faddr.s_addr;
} else {
if (nam == NULL) {
- m_freem(m);
- return ENOTCONN;
+ error = ENOTCONN;
+ goto bad;
}
- dst = ((struct sockaddr_in *)nam)->sin_addr.s_addr;
+ dst = ((struct sockaddr_in *)(void *)nam)->sin_addr.s_addr;
}
- return rip_output(m, so, dst, control);
+ return (rip_output(m, so, dst, control));
+
+bad:
+ VERIFY(error != 0);
+
+ if (m != NULL)
+ m_freem(m);
+ if (control != NULL)
+ m_freem(control);
+
+ return (error);
}
/* note: rip_unlock is called from different protos instead of the generic socket_unlock,
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);
+ lck_rw_lock_exclusive(ripcbinfo.ipi_lock);
if (inp->inp_state != INPCB_STATE_DEAD) {
#if INET6
- if (INP_CHECK_SOCKAF(so, AF_INET6))
+ if (SOCK_CHECK_DOM(so, PF_INET6))
in6_pcbdetach(inp);
else
#endif /* INET6 */
in_pcbdetach(inp);
}
in_pcbdispose(inp);
- lck_rw_done(ripcbinfo.mtx);
+ lck_rw_done(ripcbinfo.ipi_lock);
return(0);
}
}
* 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);
+ lck_rw_lock_exclusive(ripcbinfo.ipi_lock);
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);
+ lck_rw_done(ripcbinfo.ipi_lock);
return 0;
}
if (req->newptr != USER_ADDR_NULL) {
- lck_rw_done(ripcbinfo.mtx);
+ lck_rw_done(ripcbinfo.ipi_lock);
return EPERM;
}
xig.xig_sogen = so_gencnt;
error = SYSCTL_OUT(req, &xig, sizeof xig);
if (error) {
- lck_rw_done(ripcbinfo.mtx);
+ lck_rw_done(ripcbinfo.ipi_lock);
return error;
}
/*
* We are done if there is no pcb
*/
if (n == 0) {
- lck_rw_done(ripcbinfo.mtx);
+ lck_rw_done(ripcbinfo.ipi_lock);
return 0;
}
inp_list = _MALLOC(n * sizeof *inp_list, M_TEMP, M_WAITOK);
if (inp_list == 0) {
- lck_rw_done(ripcbinfo.mtx);
+ lck_rw_done(ripcbinfo.ipi_lock);
return ENOMEM;
}
- for (inp = ripcbinfo.listhead->lh_first, i = 0; inp && i < n;
+ for (inp = ripcbinfo.ipi_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;
error = SYSCTL_OUT(req, &xig, sizeof xig);
}
FREE(inp_list, M_TEMP);
- lck_rw_done(ripcbinfo.mtx);
+ lck_rw_done(ripcbinfo.ipi_lock);
return error;
}
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
* 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);
+ lck_rw_lock_exclusive(ripcbinfo.ipi_lock);
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);
+ lck_rw_done(ripcbinfo.ipi_lock);
return 0;
}
if (req->newptr != USER_ADDR_NULL) {
- lck_rw_done(ripcbinfo.mtx);
+ lck_rw_done(ripcbinfo.ipi_lock);
return EPERM;
}
xig.xig_sogen = so_gencnt;
error = SYSCTL_OUT(req, &xig, sizeof xig);
if (error) {
- lck_rw_done(ripcbinfo.mtx);
+ lck_rw_done(ripcbinfo.ipi_lock);
return error;
}
/*
* We are done if there is no pcb
*/
if (n == 0) {
- lck_rw_done(ripcbinfo.mtx);
+ lck_rw_done(ripcbinfo.ipi_lock);
return 0;
}
inp_list = _MALLOC(n * sizeof *inp_list, M_TEMP, M_WAITOK);
if (inp_list == 0) {
- lck_rw_done(ripcbinfo.mtx);
+ lck_rw_done(ripcbinfo.ipi_lock);
return ENOMEM;
}
- for (inp = ripcbinfo.listhead->lh_first, i = 0; inp && i < n;
+ for (inp = ripcbinfo.ipi_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;
error = SYSCTL_OUT(req, &xig, sizeof xig);
}
FREE(inp_list, M_TEMP);
- lck_rw_done(ripcbinfo.mtx);
+ lck_rw_done(ripcbinfo.ipi_lock);
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
{
#pragma unused(oidp, arg1, arg2)
int error = 0;
-
+
error = get_pcblist_n(IPPROTO_IP, req, &ripcbinfo);
-
+
return error;
}
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, pru_sopoll_notsupp
+ .pru_abort = rip_abort,
+ .pru_attach = rip_attach,
+ .pru_bind = rip_bind,
+ .pru_connect = rip_connect,
+ .pru_control = in_control,
+ .pru_detach = rip_detach,
+ .pru_disconnect = rip_disconnect,
+ .pru_peeraddr = in_getpeeraddr,
+ .pru_send = rip_send,
+ .pru_shutdown = rip_shutdown,
+ .pru_sockaddr = in_getsockaddr,
+ .pru_sosend = sosend,
+ .pru_soreceive = soreceive,
};
/* DSEP Review Done pl-20051213-v02 @3253 */
projects / apple / xnu.git / blobdiff