![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to raw_ip.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / netinet|
Return to raw_ip.c CVS log | Up to [Apple XNU] / XNU / bsd / netinet |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * Copyright (c) 1982, 1986, 1988, 1993
24: * The Regents of the University of California. All rights reserved.
25: *
26: * Redistribution and use in source and binary forms, with or without
27: * modification, are permitted provided that the following conditions
28: * are met:
29: * 1. Redistributions of source code must retain the above copyright
30: * notice, this list of conditions and the following disclaimer.
31: * 2. Redistributions in binary form must reproduce the above copyright
32: * notice, this list of conditions and the following disclaimer in the
33: * documentation and/or other materials provided with the distribution.
34: * 3. All advertising materials mentioning features or use of this software
35: * must display the following acknowledgement:
36: * This product includes software developed by the University of
37: * California, Berkeley and its contributors.
38: * 4. Neither the name of the University nor the names of its contributors
39: * may be used to endorse or promote products derived from this software
40: * without specific prior written permission.
41: *
42: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
43: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
44: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
45: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
46: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
47: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
48: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
49: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
50: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
51: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
52: * SUCH DAMAGE.
53: *
54: * @(#)raw_ip.c 8.7 (Berkeley) 5/15/95
55: */
56:
57: #include <sys/param.h>
58: #include <sys/systm.h>
59: #include <sys/kernel.h>
60: #include <sys/malloc.h>
61: #include <sys/mbuf.h>
62: #include <sys/proc.h>
63: #include <sys/protosw.h>
64: #include <sys/socket.h>
65: #include <sys/socketvar.h>
66: #include <sys/sysctl.h>
67:
68: #if ISFB31
69: #include <vm/vm_zone.h>
70: #endif
71:
72: #include <net/if.h>
73: #include <net/route.h>
74:
75: #define _IP_VHL
76: #include <netinet/in.h>
77: #include <netinet/in_systm.h>
78: #include <netinet/ip.h>
79: #include <netinet/in_pcb.h>
80: #include <netinet/in_var.h>
81: #include <netinet/ip_var.h>
82: #include <netinet/ip_mroute.h>
83:
84: #include <netinet/ip_fw.h>
85:
86: #if ISFB31
87: #include "opt_ipdn.h"
88: #endif
89:
90: #if DUMMYNET
91: #include <netinet/ip_dummynet.h>
92: #endif
93: #if !defined(COMPAT_IPFW) || COMPAT_IPFW == 1
94: #undef COMPAT_IPFW
95: #define COMPAT_IPFW 1
96: #else
97: #undef COMPAT_IPFW
98: #endif
99:
100: static struct inpcbhead ripcb;
101: static struct inpcbinfo ripcbinfo;
102:
103: /*
104: * Nominal space allocated to a raw ip socket.
105: */
106: #define RIPSNDQ 8192
107: #define RIPRCVQ 8192
108:
109: /*
110: * Raw interface to IP protocol.
111: */
112:
113: /*
114: * Initialize raw connection block q.
115: */
116: void
117: rip_init()
118: {
119: LIST_INIT(&ripcb);
120: ripcbinfo.listhead = &ripcb;
121: /*
122: * XXX We don't use the hash list for raw IP, but it's easier
123: * to allocate a one entry hash list than it is to check all
124: * over the place for hashbase == NULL.
125: */
126: ripcbinfo.hashbase = hashinit(1, M_PCB, &ripcbinfo.hashmask);
127: ripcbinfo.porthashbase = hashinit(1, M_PCB, &ripcbinfo.porthashmask);
128:
129: ripcbinfo.ipi_zone = (void *) zinit(sizeof(struct inpcb),
130: (4096 * sizeof(struct inpcb)),
131: 4096, "ripzone");
132:
133: }
134:
135: static struct sockaddr_in ripsrc = { sizeof(ripsrc), AF_INET };
136: /*
137: * Setup generic address and protocol structures
138: * for raw_input routine, then pass them along with
139: * mbuf chain.
140: */
141: void
142: rip_input(m, iphlen)
143: struct mbuf *m;
144: int iphlen;
145: {
146: register struct ip *ip = mtod(m, struct ip *);
147: register struct inpcb *inp;
148: struct inpcb *last = 0;
149: struct mbuf *opts = 0;
150:
151: ripsrc.sin_addr = ip->ip_src;
152: for (inp = ripcb.lh_first; inp != NULL; inp = inp->inp_list.le_next) {
153: if (inp->inp_ip_p && inp->inp_ip_p != ip->ip_p)
154: continue;
155: if (inp->inp_laddr.s_addr &&
156: inp->inp_laddr.s_addr != ip->ip_dst.s_addr)
157: continue;
158: if (inp->inp_faddr.s_addr &&
159: inp->inp_faddr.s_addr != ip->ip_src.s_addr)
160: continue;
161: if (last) {
162: struct mbuf *n = m_copy(m, 0, (int)M_COPYALL);
163: if (n) {
164: if (last->inp_flags & INP_CONTROLOPTS ||
165: last->inp_socket->so_options & SO_TIMESTAMP)
166: ip_savecontrol(last, &opts, ip, n);
167: if (last->inp_flags & INP_STRIPHDR) {
168: n->m_len -= iphlen;
169: n->m_pkthdr.len -= iphlen;
170: n->m_data += iphlen;
171: }
172: if (sbappendaddr(&last->inp_socket->so_rcv,
173: (struct sockaddr *)&ripsrc, n,
174: opts) == 0) {
175: /* should notify about lost packet */
176: kprintf("rip_input can't append to socket\n");
177: m_freem(n);
178: if (opts)
179: m_freem(opts);
180: } else {
181: /* kprintf("rip_input calling sorwakeup\n"); */
182: sorwakeup(last->inp_socket);
183: }
184: opts = 0;
185: }
186: }
187: last = inp;
188: }
189: if (last) {
190: if (last->inp_flags & INP_CONTROLOPTS ||
191: last->inp_socket->so_options & SO_TIMESTAMP)
192: ip_savecontrol(last, &opts, ip, m);
193: if (last->inp_flags & INP_STRIPHDR) {
194: m->m_len -= iphlen;
195: m->m_pkthdr.len -= iphlen;
196: m->m_data += iphlen;
197: }
198: if (sbappendaddr(&last->inp_socket->so_rcv,
199: (struct sockaddr *)&ripsrc, m, opts) == 0) {
200: kprintf("rip_input(2) can't append to socket\n");
201: m_freem(m);
202: if (opts)
203: m_freem(opts);
204: } else {
205: /* kprintf("rip_input calling sorwakeup\n"); */
206: sorwakeup(last->inp_socket);
207: }
208: } else {
209: m_freem(m);
210: ipstat.ips_noproto++;
211: ipstat.ips_delivered--;
212: }
213: }
214:
215: /*
216: * Generate IP header and pass packet to ip_output.
217: * Tack on options user may have setup with control call.
218: */
219: int
220: rip_output(m, so, dst)
221: register struct mbuf *m;
222: struct socket *so;
223: u_long dst;
224: {
225: register struct ip *ip;
226: register struct inpcb *inp = sotoinpcb(so);
227: int flags = (so->so_options & SO_DONTROUTE) | IP_ALLOWBROADCAST;
228:
229: /*
230: * If the user handed us a complete IP packet, use it.
231: * Otherwise, allocate an mbuf for a header and fill it in.
232: */
233: if ((inp->inp_flags & INP_HDRINCL) == 0) {
234: if (m->m_pkthdr.len + sizeof(struct ip) > IP_MAXPACKET) {
235: m_freem(m);
236: return(EMSGSIZE);
237: }
238: M_PREPEND(m, sizeof(struct ip), M_WAIT);
239: ip = mtod(m, struct ip *);
240: ip->ip_tos = 0;
241: ip->ip_off = 0;
242: ip->ip_p = inp->inp_ip_p;
243: ip->ip_len = m->m_pkthdr.len;
244: ip->ip_src = inp->inp_laddr;
245: ip->ip_dst.s_addr = dst;
246: ip->ip_ttl = MAXTTL;
247: } else {
248: if (m->m_pkthdr.len > IP_MAXPACKET) {
249: m_freem(m);
250: return(EMSGSIZE);
251: }
252: ip = mtod(m, struct ip *);
253: /* don't allow both user specified and setsockopt options,
254: and don't allow packet length sizes that will crash */
255: if (((IP_VHL_HL(ip->ip_vhl) != (sizeof (*ip) >> 2))
256: && inp->inp_options)
257: || (ip->ip_len > m->m_pkthdr.len)
258: || (ip->ip_len < (IP_VHL_HL(ip->ip_vhl) << 2))) {
259: m_freem(m);
260: return EINVAL;
261: }
262: if (ip->ip_id == 0)
263: ip->ip_id = htons(ip_id++);
264: /* XXX prevent ip_output from overwriting header fields */
265: flags |= IP_RAWOUTPUT;
266: ipstat.ips_rawout++;
267: }
268: return (ip_output(m, inp->inp_options, &inp->inp_route, flags,
269: inp->inp_moptions));
270: }
271:
272: /*
273: * Raw IP socket option processing.
274: */
275: int
276: rip_ctloutput(so, sopt)
277: struct socket *so;
278: struct sockopt *sopt;
279: {
280: struct inpcb *inp = sotoinpcb(so);
281: int error, optval;
282:
283: if (sopt->sopt_level != IPPROTO_IP)
284: return (EINVAL);
285:
286: error = 0;
287:
288: switch (sopt->sopt_dir) {
289: case SOPT_GET:
290: switch (sopt->sopt_name) {
291: case IP_HDRINCL:
292: optval = inp->inp_flags & INP_HDRINCL;
293: error = sooptcopyout(sopt, &optval, sizeof optval);
294: break;
295:
296: case IP_STRIPHDR:
297: optval = inp->inp_flags & INP_STRIPHDR;
298: error = sooptcopyout(sopt, &optval, sizeof optval);
299: break;
300:
301: #if COMPAT_IPFW
302: case IP_FW_GET:
303: if (ip_fw_ctl_ptr == 0)
304: error = ENOPROTOOPT;
305: else
306: error = ip_fw_ctl_ptr(sopt);
307: break;
308:
309: case IP_NAT:
310: if (ip_nat_ctl_ptr == 0)
311: error = ENOPROTOOPT;
312: else
313: error = ip_nat_ctl_ptr(sopt);
314: break;
315: #if DUMMYNET
316: case IP_DUMMYNET_GET:
317: if (ip_dn_ctl_ptr == NULL)
318: error = ENOPROTOOPT ;
319: else
320: error = ip_dn_ctl_ptr(sopt);
321: break ;
322: #endif /* DUMMYNET */
323: #endif /* COMPAT_IPFW */
324:
325: case MRT_INIT:
326: case MRT_DONE:
327: case MRT_ADD_VIF:
328: case MRT_DEL_VIF:
329: case MRT_ADD_MFC:
330: case MRT_DEL_MFC:
331: case MRT_VERSION:
332: case MRT_ASSERT:
333: error = ip_mrouter_get(so, sopt);
334: break;
335:
336: default:
337: error = ip_ctloutput(so, sopt);
338: break;
339: }
340: break;
341:
342: case SOPT_SET:
343: switch (sopt->sopt_name) {
344: case IP_HDRINCL:
345: error = sooptcopyin(sopt, &optval, sizeof optval,
346: sizeof optval);
347: if (error)
348: break;
349: if (optval)
350: inp->inp_flags |= INP_HDRINCL;
351: else
352: inp->inp_flags &= ~INP_HDRINCL;
353: break;
354:
355: case IP_STRIPHDR:
356: error = sooptcopyin(sopt, &optval, sizeof optval,
357: sizeof optval);
358: if (error)
359: break;
360: if (optval)
361: inp->inp_flags |= INP_STRIPHDR;
362: else
363: inp->inp_flags &= ~INP_STRIPHDR;
364: break;
365:
366:
367: #if COMPAT_IPFW
368: case IP_FW_ADD:
369: case IP_FW_DEL:
370: case IP_FW_FLUSH:
371: case IP_FW_ZERO:
372: if (ip_fw_ctl_ptr == 0)
373: error = ENOPROTOOPT;
374: else
375: error = ip_fw_ctl_ptr(sopt);
376: break;
377:
378: case IP_NAT:
379: if (ip_nat_ctl_ptr == 0)
380: error = ENOPROTOOPT;
381: else
382: error = ip_nat_ctl_ptr(sopt);
383: break;
384: #if DUMMYNET
385: case IP_DUMMYNET_CONFIGURE:
386: case IP_DUMMYNET_DEL:
387: case IP_DUMMYNET_FLUSH:
388: if (ip_dn_ctl_ptr == NULL)
389: error = ENOPROTOOPT ;
390: else
391: error = ip_dn_ctl_ptr(sopt);
392: break ;
393: #endif
394: #endif /* COMPAT_IPFW */
395:
396: case IP_RSVP_ON:
397: error = ip_rsvp_init(so);
398: break;
399:
400: case IP_RSVP_OFF:
401: error = ip_rsvp_done();
402: break;
403:
404: /* XXX - should be combined */
405: case IP_RSVP_VIF_ON:
406: error = ip_rsvp_vif_init(so, sopt);
407: break;
408:
409: case IP_RSVP_VIF_OFF:
410: error = ip_rsvp_vif_done(so, sopt);
411: break;
412:
413: case MRT_INIT:
414: case MRT_DONE:
415: case MRT_ADD_VIF:
416: case MRT_DEL_VIF:
417: case MRT_ADD_MFC:
418: case MRT_DEL_MFC:
419: case MRT_VERSION:
420: case MRT_ASSERT:
421: error = ip_mrouter_set(so, sopt);
422: break;
423:
424: default:
425: error = ip_ctloutput(so, sopt);
426: break;
427: }
428: break;
429: }
430:
431: return (error);
432: }
433:
434: /*
435: * This function exists solely to receive the PRC_IFDOWN messages which
436: * are sent by if_down(). It looks for an ifaddr whose ifa_addr is sa,
437: * and calls in_ifadown() to remove all routes corresponding to that address.
438: * It also receives the PRC_IFUP messages from if_up() and reinstalls the
439: * interface routes.
440: */
441: void
442: rip_ctlinput(cmd, sa, vip)
443: int cmd;
444: struct sockaddr *sa;
445: void *vip;
446: {
447: struct in_ifaddr *ia;
448: struct ifnet *ifp;
449: int err;
450: int flags;
451:
452: switch (cmd) {
453: case PRC_IFDOWN:
454: for (ia = in_ifaddrhead.tqh_first; ia;
455: ia = ia->ia_link.tqe_next) {
456: if (ia->ia_ifa.ifa_addr == sa
457: && (ia->ia_flags & IFA_ROUTE)) {
458: /*
459: * in_ifscrub kills the interface route.
460: */
461: in_ifscrub(ia->ia_ifp, ia);
462: /*
463: * in_ifadown gets rid of all the rest of
464: * the routes. This is not quite the right
465: * thing to do, but at least if we are running
466: * a routing process they will come back.
467: */
468: in_ifadown(&ia->ia_ifa);
469: break;
470: }
471: }
472: break;
473:
474: case PRC_IFUP:
475: for (ia = in_ifaddrhead.tqh_first; ia;
476: ia = ia->ia_link.tqe_next) {
477: if (ia->ia_ifa.ifa_addr == sa)
478: break;
479: }
480: if (ia == 0 || (ia->ia_flags & IFA_ROUTE))
481: return;
482: flags = RTF_UP;
483: ifp = ia->ia_ifa.ifa_ifp;
484:
485: if ((ifp->if_flags & IFF_LOOPBACK)
486: || (ifp->if_flags & IFF_POINTOPOINT))
487: flags |= RTF_HOST;
488:
489: err = rtinit(&ia->ia_ifa, RTM_ADD, flags);
490: if (err == 0)
491: ia->ia_flags |= IFA_ROUTE;
492: break;
493: }
494: }
495:
496: static u_long rip_sendspace = RIPSNDQ;
497: static u_long rip_recvspace = RIPRCVQ;
498:
499:
500: SYSCTL_INT(_net_inet_raw, OID_AUTO, maxdgram, CTLFLAG_RW, &rip_sendspace,
501: 0, "");
502: SYSCTL_INT(_net_inet_raw, OID_AUTO, recvspace, CTLFLAG_RW, &rip_recvspace,
503: 0, "");
504:
505: static int
506: rip_attach(struct socket *so, int proto, struct proc *p)
507: {
508: struct inpcb *inp;
509: int error, s;
510:
511: inp = sotoinpcb(so);
512: if (inp)
513: panic("rip_attach");
514:
515:
516: #if ISFB31
517: if (p && (error = suser(p->p_ucred, &p->p_acflag)) != 0)
518: return error;
519: #else
520: if ((so->so_state & SS_PRIV) == 0)
521: return (EPERM);
522: #endif
523:
524: s = splnet();
525: error = in_pcballoc(so, &ripcbinfo, p);
526: splx(s);
527: if (error)
528: return error;
529: error = soreserve(so, rip_sendspace, rip_recvspace);
530: if (error)
531: return error;
532: inp = (struct inpcb *)so->so_pcb;
533: inp->inp_ip_p = proto;
534: return 0;
535: }
536:
537: static int
538: rip_detach(struct socket *so)
539: {
540: struct inpcb *inp;
541:
542: inp = sotoinpcb(so);
543: if (inp == 0)
544: panic("rip_detach");
545: if (so == ip_mrouter)
546: ip_mrouter_done();
547: ip_rsvp_force_done(so);
548: if (so == ip_rsvpd)
549: ip_rsvp_done();
550: in_pcbdetach(inp);
551: return 0;
552: }
553:
554: static int
555: rip_abort(struct socket *so)
556: {
557: soisdisconnected(so);
558: return rip_detach(so);
559: }
560:
561: static int
562: rip_disconnect(struct socket *so)
563: {
564: if ((so->so_state & SS_ISCONNECTED) == 0)
565: return ENOTCONN;
566: return rip_abort(so);
567: }
568:
569: static int
570: rip_bind(struct socket *so, struct sockaddr *nam, struct proc *p)
571: {
572: struct inpcb *inp = sotoinpcb(so);
573: struct sockaddr_in *addr = (struct sockaddr_in *)nam;
574:
575: if (nam->sa_len != sizeof(*addr))
576: return EINVAL;
577:
578: if (TAILQ_EMPTY(&ifnet) || ((addr->sin_family != AF_INET) &&
579: (addr->sin_family != AF_IMPLINK)) ||
580: (addr->sin_addr.s_addr &&
581: ifa_ifwithaddr((struct sockaddr *)addr) == 0))
582: return EADDRNOTAVAIL;
583: inp->inp_laddr = addr->sin_addr;
584: return 0;
585: }
586:
587: static int
588: rip_connect(struct socket *so, struct sockaddr *nam, struct proc *p)
589: {
590: struct inpcb *inp = sotoinpcb(so);
591: struct sockaddr_in *addr = (struct sockaddr_in *)nam;
592:
593: if (nam->sa_len != sizeof(*addr))
594: return EINVAL;
595: if (TAILQ_EMPTY(&ifnet))
596: return EADDRNOTAVAIL;
597: if ((addr->sin_family != AF_INET) &&
598: (addr->sin_family != AF_IMPLINK))
599: return EAFNOSUPPORT;
600: inp->inp_faddr = addr->sin_addr;
601: soisconnected(so);
602: return 0;
603: }
604:
605: static int
606: rip_shutdown(struct socket *so)
607: {
608: socantsendmore(so);
609: return 0;
610: }
611:
612: static int
613: rip_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *nam,
614: struct mbuf *control, struct proc *p)
615: {
616: struct inpcb *inp = sotoinpcb(so);
617: register u_long dst;
618:
619: if (so->so_state & SS_ISCONNECTED) {
620: if (nam) {
621: m_freem(m);
622: return EISCONN;
623: }
624: dst = inp->inp_faddr.s_addr;
625: } else {
626: if (nam == NULL) {
627: m_freem(m);
628: return ENOTCONN;
629: }
630: dst = ((struct sockaddr_in *)nam)->sin_addr.s_addr;
631: }
632: return rip_output(m, so, dst);
633: }
634:
635:
636: static int
637: rip_pcblist SYSCTL_HANDLER_ARGS
638: {
639: int error, i, n, s;
640: struct inpcb *inp, **inp_list;
641: inp_gen_t gencnt;
642: struct xinpgen xig;
643:
644: /*
645: * The process of preparing the TCB list is too time-consuming and
646: * resource-intensive to repeat twice on every request.
647: */
648: if (req->oldptr == 0) {
649: n = ripcbinfo.ipi_count;
650: req->oldidx = 2 * (sizeof xig)
651: + (n + n/8) * sizeof(struct xinpcb);
652: return 0;
653: }
654:
655: if (req->newptr != 0)
656: return EPERM;
657:
658: /*
659: * OK, now we're committed to doing something.
660: */
661: s = splnet();
662: gencnt = ripcbinfo.ipi_gencnt;
663: n = ripcbinfo.ipi_count;
664: splx(s);
665:
666: xig.xig_len = sizeof xig;
667: xig.xig_count = n;
668: xig.xig_gen = gencnt;
669: xig.xig_sogen = so_gencnt;
670: error = SYSCTL_OUT(req, &xig, sizeof xig);
671: if (error)
672: return error;
673:
674: inp_list = _MALLOC(n * sizeof *inp_list, M_TEMP, M_WAITOK);
675: if (inp_list == 0)
676: return ENOMEM;
677:
678: s = splnet();
679: for (inp = ripcbinfo.listhead->lh_first, i = 0; inp && i < n;
680: inp = inp->inp_list.le_next) {
681: if (inp->inp_gencnt <= gencnt)
682: inp_list[i++] = inp;
683: }
684: splx(s);
685: n = i;
686:
687: error = 0;
688: for (i = 0; i < n; i++) {
689: inp = inp_list[i];
690: if (inp->inp_gencnt <= gencnt) {
691: struct xinpcb xi;
692: xi.xi_len = sizeof xi;
693: /* XXX should avoid extra copy */
694: bcopy(inp, &xi.xi_inp, sizeof *inp);
695: if (inp->inp_socket)
696: sotoxsocket(inp->inp_socket, &xi.xi_socket);
697: error = SYSCTL_OUT(req, &xi, sizeof xi);
698: }
699: }
700: if (!error) {
701: /*
702: * Give the user an updated idea of our state.
703: * If the generation differs from what we told
704: * her before, she knows that something happened
705: * while we were processing this request, and it
706: * might be necessary to retry.
707: */
708: s = splnet();
709: xig.xig_gen = ripcbinfo.ipi_gencnt;
710: xig.xig_sogen = so_gencnt;
711: xig.xig_count = ripcbinfo.ipi_count;
712: splx(s);
713: error = SYSCTL_OUT(req, &xig, sizeof xig);
714: }
715: FREE(inp_list, M_TEMP);
716: return error;
717: }
718:
719:
720: SYSCTL_PROC(_net_inet_raw, OID_AUTO/*XXX*/, pcblist, CTLFLAG_RD, 0, 0,
721: rip_pcblist, "S,xinpcb", "List of active raw IP sockets");
722:
723: struct pr_usrreqs rip_usrreqs = {
724: rip_abort, pru_accept_notsupp, rip_attach, rip_bind, rip_connect,
725: pru_connect2_notsupp, in_control, rip_detach, rip_disconnect,
726: pru_listen_notsupp, in_setpeeraddr, pru_rcvd_notsupp,
727: pru_rcvoob_notsupp, rip_send, pru_sense_null, rip_shutdown,
728: in_setsockaddr, sosend, soreceive, sopoll
729: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.