![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to uipc_socket2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / kern|
Return to uipc_socket2.c CVS log | Up to [Apple XNU] / XNU / bsd / kern |
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: /* Copyright (c) 1998, 1999 Apple Computer, Inc. All Rights Reserved */
23: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
24: /*
25: * Copyright (c) 1982, 1986, 1988, 1990, 1993
26: * The Regents of the University of California. All rights reserved.
27: *
28: * Redistribution and use in source and binary forms, with or without
29: * modification, are permitted provided that the following conditions
30: * are met:
31: * 1. Redistributions of source code must retain the above copyright
32: * notice, this list of conditions and the following disclaimer.
33: * 2. Redistributions in binary form must reproduce the above copyright
34: * notice, this list of conditions and the following disclaimer in the
35: * documentation and/or other materials provided with the distribution.
36: * 3. All advertising materials mentioning features or use of this software
37: * must display the following acknowledgement:
38: * This product includes software developed by the University of
39: * California, Berkeley and its contributors.
40: * 4. Neither the name of the University nor the names of its contributors
41: * may be used to endorse or promote products derived from this software
42: * without specific prior written permission.
43: *
44: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
45: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
46: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
47: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
48: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
49: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
50: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
51: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
52: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
53: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
54: * SUCH DAMAGE.
55: *
56: * @(#)uipc_socket2.c 8.1 (Berkeley) 6/10/93
57: */
58:
59: #include <sys/param.h>
60: #include <sys/systm.h>
61: #include <sys/domain.h>
62: #include <sys/kernel.h>
63: #include <sys/proc.h>
64: #include <sys/malloc.h>
65: #include <sys/mbuf.h>
66: #include <sys/protosw.h>
67: #include <sys/stat.h>
68: #include <sys/socket.h>
69: #include <sys/socketvar.h>
70: #include <sys/signalvar.h>
71: #include <sys/sysctl.h>
72: #include <sys/ev.h>
73:
74: /*
75: * Primitive routines for operating on sockets and socket buffers
76: */
77:
78: u_long sb_max = SB_MAX; /* XXX should be static */
79:
80: static u_long sb_efficiency = 8; /* parameter for sbreserve() */
81:
82: char netcon[] = "netcon";
83:
84: /*
85: * Procedures to manipulate state flags of socket
86: * and do appropriate wakeups. Normal sequence from the
87: * active (originating) side is that soisconnecting() is
88: * called during processing of connect() call,
89: * resulting in an eventual call to soisconnected() if/when the
90: * connection is established. When the connection is torn down
91: * soisdisconnecting() is called during processing of disconnect() call,
92: * and soisdisconnected() is called when the connection to the peer
93: * is totally severed. The semantics of these routines are such that
94: * connectionless protocols can call soisconnected() and soisdisconnected()
95: * only, bypassing the in-progress calls when setting up a ``connection''
96: * takes no time.
97: *
98: * From the passive side, a socket is created with
99: * two queues of sockets: so_q0 for connections in progress
100: * and so_q for connections already made and awaiting user acceptance.
101: * As a protocol is preparing incoming connections, it creates a socket
102: * structure queued on so_q0 by calling sonewconn(). When the connection
103: * is established, soisconnected() is called, and transfers the
104: * socket structure to so_q, making it available to accept().
105: *
106: * If a socket is closed with sockets on either
107: * so_q0 or so_q, these sockets are dropped.
108: *
109: * If higher level protocols are implemented in
110: * the kernel, the wakeups done here will sometimes
111: * cause software-interrupt process scheduling.
112: */
113:
114: void
115: soisconnecting(so)
116: register struct socket *so;
117: {
118:
119: so->so_state &= ~(SS_ISCONNECTED|SS_ISDISCONNECTING);
120: so->so_state |= SS_ISCONNECTING;
121: }
122:
123: void
124: soisconnected(so)
125: register struct socket *so;
126: { register struct kextcb *kp;
127: register struct socket *head = so->so_head;
128:
129: kp = sotokextcb(so);
130: while (kp)
131: { if (kp->e_soif && kp->e_soif->sf_soisconnected)
132: { if ((*kp->e_soif->sf_soisconnected)(so, kp))
133: return;
134: }
135: kp = kp->e_next;
136: }
137:
138: so->so_state &= ~(SS_ISCONNECTING|SS_ISDISCONNECTING|SS_ISCONFIRMING);
139: so->so_state |= SS_ISCONNECTED;
140: if (head && (so->so_state & SS_INCOMP)) {
141: postevent(head,0,EV_RCONN);
142: TAILQ_REMOVE(&head->so_incomp, so, so_list);
143: head->so_incqlen--;
144: so->so_state &= ~SS_INCOMP;
145: TAILQ_INSERT_TAIL(&head->so_comp, so, so_list);
146: so->so_state |= SS_COMP;
147: sorwakeup(head);
148: wakeup((caddr_t)&head->so_timeo);
149: } else {
150: postevent(so,0,EV_WCONN);
151: wakeup((caddr_t)&so->so_timeo);
152: sorwakeup(so);
153: sowwakeup(so);
154: }
155: }
156:
157: void
158: soisdisconnecting(so)
159: register struct socket *so;
160: { register struct kextcb *kp;
161:
162: kp = sotokextcb(so);
163: while (kp)
164: { if (kp->e_soif && kp->e_soif->sf_soisdisconnecting)
165: { if ((*kp->e_soif->sf_soisdisconnecting)(so, kp))
166: return;
167: }
168: kp = kp->e_next;
169: }
170:
171: so->so_state &= ~SS_ISCONNECTING;
172: so->so_state |= (SS_ISDISCONNECTING|SS_CANTRCVMORE|SS_CANTSENDMORE);
173: wakeup((caddr_t)&so->so_timeo);
174: sowwakeup(so);
175: sorwakeup(so);
176: }
177:
178: void
179: soisdisconnected(so)
180: register struct socket *so;
181: { register struct kextcb *kp;
182:
183: kp = sotokextcb(so);
184: while (kp)
185: { if (kp->e_soif && kp->e_soif->sf_soisdisconnected)
186: { if ((*kp->e_soif->sf_soisdisconnected)(so, kp))
187: return;
188: }
189: kp = kp->e_next;
190: }
191:
192: so->so_state &= ~(SS_ISCONNECTING|SS_ISCONNECTED|SS_ISDISCONNECTING);
193: so->so_state |= (SS_CANTRCVMORE|SS_CANTSENDMORE);
194: wakeup((caddr_t)&so->so_timeo);
195: sowwakeup(so);
196: sorwakeup(so);
197: }
198:
199: /*
200: * Return a random connection that hasn't been serviced yet and
201: * is eligible for discard. There is a one in qlen chance that
202: * we will return a null, saying that there are no dropable
203: * requests. In this case, the protocol specific code should drop
204: * the new request. This insures fairness.
205: *
206: * This may be used in conjunction with protocol specific queue
207: * congestion routines.
208: */
209: struct socket *
210: sodropablereq(head)
211: register struct socket *head;
212: {
213: register struct socket *so;
214: unsigned int i, j, qlen;
215: static int rnd;
216: static struct timeval old_runtime;
217: static unsigned int cur_cnt, old_cnt;
218: struct timeval tv;
219:
220: microtime(&tv);
221: if ((i = (tv.tv_sec - old_runtime.tv_sec)) != 0) {
222: old_runtime = tv;
223: old_cnt = cur_cnt / i;
224: cur_cnt = 0;
225: }
226:
227: so = TAILQ_FIRST(&head->so_incomp);
228: if (!so)
229: return (so);
230:
231: qlen = head->so_incqlen;
232: if (++cur_cnt > qlen || old_cnt > qlen) {
233: rnd = (314159 * rnd + 66329) & 0xffff;
234: j = ((qlen + 1) * rnd) >> 16;
235:
236: while (j-- && so)
237: so = TAILQ_NEXT(so, so_list);
238: }
239:
240: return (so);
241: }
242:
243: /*
244: * When an attempt at a new connection is noted on a socket
245: * which accepts connections, sonewconn is called. If the
246: * connection is possible (subject to space constraints, etc.)
247: * then we allocate a new structure, propoerly linked into the
248: * data structure of the original socket, and return this.
249: * Connstatus may be 0, or SO_ISCONFIRMING, or SO_ISCONNECTED.
250: */
251: struct socket *
252: sonewconn(head, connstatus)
253: register struct socket *head;
254: int connstatus;
255: { int error = 0;
256: register struct socket *so;
257:
258: if (head->so_qlen > 3 * head->so_qlimit / 2)
259: return ((struct socket *)0);
260: so = soalloc(0);
261: if (so == NULL)
262: return ((struct socket *)0);
263: so->so_head = head;
264: so->so_type = head->so_type;
265: so->so_options = head->so_options &~ SO_ACCEPTCONN;
266: so->so_linger = head->so_linger;
267: so->so_state = head->so_state | SS_NOFDREF;
268: so->so_proto = head->so_proto;
269: so->so_timeo = head->so_timeo;
270: so->so_pgid = head->so_pgid;
271: so->so_uid = head->so_uid;
272: so->so_rcv.sb_flags |= SB_RECV; /* XXX */
273: (void) soreserve(so, head->so_snd.sb_hiwat, head->so_rcv.sb_hiwat);
274:
275: if (so->so_proto->pr_sfilter.tqh_first)
276: error = sfilter_init(so);
277: if (error == 0 && (*so->so_proto->pr_usrreqs->pru_attach)(so, 0, NULL)) {
278: sfilter_term(so);
279: sodealloc(so);
280: return ((struct socket *)0);
281: }
282:
283: if (connstatus) {
284: TAILQ_INSERT_TAIL(&head->so_comp, so, so_list);
285: so->so_state |= SS_COMP;
286: } else {
287: TAILQ_INSERT_TAIL(&head->so_incomp, so, so_list);
288: so->so_state |= SS_INCOMP;
289: head->so_incqlen++;
290: }
291: head->so_qlen++;
292: if (connstatus) {
293: sorwakeup(head);
294: wakeup((caddr_t)&head->so_timeo);
295: so->so_state |= connstatus;
296: }
297: so->so_rcv.sb_so = so->so_snd.sb_so = so;
298: TAILQ_INIT(&so->so_evlist);
299: return (so);
300: }
301:
302: /*
303: * Socantsendmore indicates that no more data will be sent on the
304: * socket; it would normally be applied to a socket when the user
305: * informs the system that no more data is to be sent, by the protocol
306: * code (in case PRU_SHUTDOWN). Socantrcvmore indicates that no more data
307: * will be received, and will normally be applied to the socket by a
308: * protocol when it detects that the peer will send no more data.
309: * Data queued for reading in the socket may yet be read.
310: */
311:
312: void
313: socantsendmore(so)
314: struct socket *so;
315: { register struct kextcb *kp;
316:
317: kp = sotokextcb(so);
318: while (kp)
319: { if (kp->e_soif && kp->e_soif->sf_socantsendmore)
320: { if ((*kp->e_soif->sf_socantsendmore)(so, kp))
321: return;
322: }
323: kp = kp->e_next;
324: }
325:
326:
327: so->so_state |= SS_CANTSENDMORE;
328: sowwakeup(so);
329: }
330:
331: void
332: socantrcvmore(so)
333: struct socket *so;
334: { register struct kextcb *kp;
335:
336: kp = sotokextcb(so);
337: while (kp)
338: { if (kp->e_soif && kp->e_soif->sf_socantrcvmore)
339: { if ((*kp->e_soif->sf_socantrcvmore)(so, kp))
340: return;
341: }
342: kp = kp->e_next;
343: }
344:
345:
346: so->so_state |= SS_CANTRCVMORE;
347: sorwakeup(so);
348: }
349:
350: /*
351: * Wait for data to arrive at/drain from a socket buffer.
352: */
353: int
354: sbwait(sb)
355: struct sockbuf *sb;
356: {
357:
358: sb->sb_flags |= SB_WAIT;
359: return (tsleep((caddr_t)&sb->sb_cc,
360: (sb->sb_flags & SB_NOINTR) ? PSOCK : PSOCK | PCATCH, "sbwait",
361: sb->sb_timeo));
362: }
363:
364: /*
365: * Lock a sockbuf already known to be locked;
366: * return any error returned from sleep (EINTR).
367: */
368: int
369: sb_lock(sb)
370: register struct sockbuf *sb;
371: {
372: int error;
373:
374: while (sb->sb_flags & SB_LOCK) {
375: sb->sb_flags |= SB_WANT;
376: error = tsleep((caddr_t)&sb->sb_flags,
377: (sb->sb_flags & SB_NOINTR) ? PSOCK : PSOCK|PCATCH,
378: "sblock", 0);
379: if (error)
380: return (error);
381: }
382: sb->sb_flags |= SB_LOCK;
383: return (0);
384: }
385:
386: /*
387: * Wakeup processes waiting on a socket buffer.
388: * Do asynchronous notification via SIGIO
389: * if the socket has the SS_ASYNC flag set.
390: */
391: void
392: sowakeup(so, sb)
393: register struct socket *so;
394: register struct sockbuf *sb;
395: {
396: struct proc *p = current_proc();
397:
398:
399: selwakeup(&sb->sb_sel);
400: sb->sb_flags &= ~SB_SEL;
401: if (sb->sb_flags & SB_WAIT) {
402: sb->sb_flags &= ~SB_WAIT;
403: wakeup((caddr_t)&sb->sb_cc);
404: }
405: if (so->so_state & SS_ASYNC) {
406: if (so->so_pgid < 0)
407: gsignal(-so->so_pgid, SIGIO);
408: else if (so->so_pgid > 0 && (p = pfind(so->so_pgid)) != 0)
409: psignal(p, SIGIO);
410: }
411:
412: if (sb->sb_flags & SB_UPCALL)
413: (*so->so_upcall)(so, so->so_upcallarg, M_DONTWAIT);
414: }
415:
416: /*
417: * Socket buffer (struct sockbuf) utility routines.
418: *
419: * Each socket contains two socket buffers: one for sending data and
420: * one for receiving data. Each buffer contains a queue of mbufs,
421: * information about the number of mbufs and amount of data in the
422: * queue, and other fields allowing select() statements and notification
423: * on data availability to be implemented.
424: *
425: * Data stored in a socket buffer is maintained as a list of records.
426: * Each record is a list of mbufs chained together with the m_next
427: * field. Records are chained together with the m_nextpkt field. The upper
428: * level routine soreceive() expects the following conventions to be
429: * observed when placing information in the receive buffer:
430: *
431: * 1. If the protocol requires each message be preceded by the sender's
432: * name, then a record containing that name must be present before
433: * any associated data (mbuf's must be of type MT_SONAME).
434: * 2. If the protocol supports the exchange of ``access rights'' (really
435: * just additional data associated with the message), and there are
436: * ``rights'' to be received, then a record containing this data
437: * should be present (mbuf's must be of type MT_RIGHTS).
438: * 3. If a name or rights record exists, then it must be followed by
439: * a data record, perhaps of zero length.
440: *
441: * Before using a new socket structure it is first necessary to reserve
442: * buffer space to the socket, by calling sbreserve(). This should commit
443: * some of the available buffer space in the system buffer pool for the
444: * socket (currently, it does nothing but enforce limits). The space
445: * should be released by calling sbrelease() when the socket is destroyed.
446: */
447:
448: int
449: soreserve(so, sndcc, rcvcc)
450: register struct socket *so;
451: u_long sndcc, rcvcc;
452: {
453:
454: if (sbreserve(&so->so_snd, sndcc) == 0)
455: goto bad;
456: if (sbreserve(&so->so_rcv, rcvcc) == 0)
457: goto bad2;
458: if (so->so_rcv.sb_lowat == 0)
459: so->so_rcv.sb_lowat = 1;
460: if (so->so_snd.sb_lowat == 0)
461: so->so_snd.sb_lowat = MCLBYTES;
462: if (so->so_snd.sb_lowat > so->so_snd.sb_hiwat)
463: so->so_snd.sb_lowat = so->so_snd.sb_hiwat;
464: return (0);
465: bad2:
466: sbrelease(&so->so_snd);
467: bad:
468: return (ENOBUFS);
469: }
470:
471: /*
472: * Allot mbufs to a sockbuf.
473: * Attempt to scale mbmax so that mbcnt doesn't become limiting
474: * if buffering efficiency is near the normal case.
475: */
476: int
477: sbreserve(sb, cc)
478: struct sockbuf *sb;
479: u_long cc;
480: {
481: if ((u_quad_t)cc > (u_quad_t)sb_max * MCLBYTES / (MSIZE + MCLBYTES))
482: return (0);
483: sb->sb_hiwat = cc;
484: sb->sb_mbmax = min(cc * sb_efficiency, sb_max);
485: if (sb->sb_lowat > sb->sb_hiwat)
486: sb->sb_lowat = sb->sb_hiwat;
487: return (1);
488: }
489:
490: /*
491: * Free mbufs held by a socket, and reserved mbuf space.
492: */
493: void
494: sbrelease(sb)
495: struct sockbuf *sb;
496: {
497:
498: sbflush(sb);
499: sb->sb_hiwat = sb->sb_mbmax = 0;
500:
501: {
502: int oldpri = splimp();
503: selthreadclear(&sb->sb_sel);
504: splx(oldpri);
505: }
506: }
507:
508: /*
509: * Routines to add and remove
510: * data from an mbuf queue.
511: *
512: * The routines sbappend() or sbappendrecord() are normally called to
513: * append new mbufs to a socket buffer, after checking that adequate
514: * space is available, comparing the function sbspace() with the amount
515: * of data to be added. sbappendrecord() differs from sbappend() in
516: * that data supplied is treated as the beginning of a new record.
517: * To place a sender's address, optional access rights, and data in a
518: * socket receive buffer, sbappendaddr() should be used. To place
519: * access rights and data in a socket receive buffer, sbappendrights()
520: * should be used. In either case, the new data begins a new record.
521: * Note that unlike sbappend() and sbappendrecord(), these routines check
522: * for the caller that there will be enough space to store the data.
523: * Each fails if there is not enough space, or if it cannot find mbufs
524: * to store additional information in.
525: *
526: * Reliable protocols may use the socket send buffer to hold data
527: * awaiting acknowledgement. Data is normally copied from a socket
528: * send buffer in a protocol with m_copy for output to a peer,
529: * and then removing the data from the socket buffer with sbdrop()
530: * or sbdroprecord() when the data is acknowledged by the peer.
531: */
532:
533: /*
534: * Append mbuf chain m to the last record in the
535: * socket buffer sb. The additional space associated
536: * the mbuf chain is recorded in sb. Empty mbufs are
537: * discarded and mbufs are compacted where possible.
538: */
539: void
540: sbappend(sb, m)
541: struct sockbuf *sb;
542: struct mbuf *m;
543: { register struct kextcb *kp;
544: register struct mbuf *n;
545:
546: if (m == 0)
547: return;
548: kp = sotokextcb(sbtoso(sb));
549: while (kp)
550: { if (kp->e_sout && kp->e_sout->su_sbappend)
551: { if ((*kp->e_sout->su_sbappend)(sb, m, kp))
552: return;
553: }
554: kp = kp->e_next;
555: }
556:
557: if (n = sb->sb_mb) {
558: while (n->m_nextpkt)
559: n = n->m_nextpkt;
560: do {
561: if (n->m_flags & M_EOR) {
562: sbappendrecord(sb, m); /* XXXXXX!!!! */
563: return;
564: }
565: } while (n->m_next && (n = n->m_next));
566: }
567: sbcompress(sb, m, n);
568: }
569:
570: #ifdef SOCKBUF_DEBUG
571: void
572: sbcheck(sb)
573: register struct sockbuf *sb;
574: {
575: register struct mbuf *m;
576: register struct mbuf *n = 0;
577: register u_long len = 0, mbcnt = 0;
578:
579: for (m = sb->sb_mb; m; m = n) {
580: n = m->m_nextpkt;
581: for (; m; m = m->m_next) {
582: len += m->m_len;
583: mbcnt += MSIZE;
584: if (m->m_flags & M_EXT) /*XXX*/ /* pretty sure this is bogus */
585: mbcnt += m->m_ext.ext_size;
586: if (m->m_nextpkt)
587: panic("sbcheck nextpkt");
588: }
589: if (len != sb->sb_cc || mbcnt != sb->sb_mbcnt) {
590: printf("cc %ld != %ld || mbcnt %ld != %ld\n", len, sb->sb_cc,
591: mbcnt, sb->sb_mbcnt);
592: panic("sbcheck");
593: }
594: }
595: #endif
596:
597: /*
598: * As above, except the mbuf chain
599: * begins a new record.
600: */
601: void
602: sbappendrecord(sb, m0)
603: register struct sockbuf *sb;
604: register struct mbuf *m0;
605: {
606: register struct mbuf *m;
607:
608: if (m0 == 0)
609: return;
610: m = sb->sb_mb;
611: if (m)
612: while (m->m_nextpkt)
613: m = m->m_nextpkt;
614: /*
615: * Put the first mbuf on the queue.
616: * Note this permits zero length records.
617: */
618: sballoc(sb, m0);
619: if (m)
620: m->m_nextpkt = m0;
621: else
622: sb->sb_mb = m0;
623: m = m0->m_next;
624: m0->m_next = 0;
625: if (m && (m0->m_flags & M_EOR)) {
626: m0->m_flags &= ~M_EOR;
627: m->m_flags |= M_EOR;
628: }
629: sbcompress(sb, m, m0);
630: }
631:
632: /*
633: * As above except that OOB data
634: * is inserted at the beginning of the sockbuf,
635: * but after any other OOB data.
636: */
637: void
638: sbinsertoob(sb, m0)
639: register struct sockbuf *sb;
640: register struct mbuf *m0;
641: {
642: register struct mbuf *m;
643: register struct mbuf **mp;
644:
645: if (m0 == 0)
646: return;
647: for (mp = &sb->sb_mb; *mp ; mp = &((*mp)->m_nextpkt)) {
648: m = *mp;
649: again:
650: switch (m->m_type) {
651:
652: case MT_OOBDATA:
653: continue; /* WANT next train */
654:
655: case MT_CONTROL:
656: m = m->m_next;
657: if (m)
658: goto again; /* inspect THIS train further */
659: }
660: break;
661: }
662: /*
663: * Put the first mbuf on the queue.
664: * Note this permits zero length records.
665: */
666: sballoc(sb, m0);
667: m0->m_nextpkt = *mp;
668: *mp = m0;
669: m = m0->m_next;
670: m0->m_next = 0;
671: if (m && (m0->m_flags & M_EOR)) {
672: m0->m_flags &= ~M_EOR;
673: m->m_flags |= M_EOR;
674: }
675: sbcompress(sb, m, m0);
676: }
677:
678: /*
679: * Append address and data, and optionally, control (ancillary) data
680: * to the receive queue of a socket. If present,
681: * m0 must include a packet header with total length.
682: * Returns 0 if no space in sockbuf or insufficient mbufs.
683: */
684: int
685: sbappendaddr(sb, asa, m0, control)
686: register struct sockbuf *sb;
687: struct sockaddr *asa;
688: struct mbuf *m0, *control;
689: {
690: register struct mbuf *m, *n;
691: int space = asa->sa_len;
692:
693: if (m0 && (m0->m_flags & M_PKTHDR) == 0)
694: panic("sbappendaddr");
695: if (m0)
696: space += m0->m_pkthdr.len;
697: for (n = control; n; n = n->m_next) {
698: space += n->m_len;
699: if (n->m_next == 0) /* keep pointer to last control buf */
700: break;
701: }
702: if (space > sbspace(sb))
703: return (0);
704: if (asa->sa_len > MLEN)
705: return (0);
706: MGET(m, M_DONTWAIT, MT_SONAME);
707: if (m == 0)
708: return (0);
709: m->m_len = asa->sa_len;
710: bcopy((caddr_t)asa, mtod(m, caddr_t), asa->sa_len);
711: if (n)
712: n->m_next = m0; /* concatenate data to control */
713: else
714: control = m0;
715: m->m_next = control;
716: for (n = m; n; n = n->m_next)
717: sballoc(sb, n);
718: n = sb->sb_mb;
719: if (n) {
720: while (n->m_nextpkt)
721: n = n->m_nextpkt;
722: n->m_nextpkt = m;
723: } else
724: sb->sb_mb = m;
725: postevent(0,sb,EV_RWBYTES);
726: return (1);
727: }
728:
729: int
730: sbappendcontrol(sb, m0, control)
731: struct sockbuf *sb;
732: struct mbuf *control, *m0;
733: {
734: register struct mbuf *m, *n;
735: int space = 0;
736:
737: if (control == 0)
738: panic("sbappendcontrol");
739: for (m = control; ; m = m->m_next) {
740: space += m->m_len;
741: if (m->m_next == 0)
742: break;
743: }
744: n = m; /* save pointer to last control buffer */
745: for (m = m0; m; m = m->m_next)
746: space += m->m_len;
747: if (space > sbspace(sb))
748: return (0);
749: n->m_next = m0; /* concatenate data to control */
750: for (m = control; m; m = m->m_next)
751: sballoc(sb, m);
752: n = sb->sb_mb;
753: if (n) {
754: while (n->m_nextpkt)
755: n = n->m_nextpkt;
756: n->m_nextpkt = control;
757: } else
758: sb->sb_mb = control;
759: postevent(0,sb,EV_RWBYTES);
760: return (1);
761: }
762:
763: /*
764: * Compress mbuf chain m into the socket
765: * buffer sb following mbuf n. If n
766: * is null, the buffer is presumed empty.
767: */
768: void
769: sbcompress(sb, m, n)
770: register struct sockbuf *sb;
771: register struct mbuf *m, *n;
772: {
773: register int eor = 0;
774: register struct mbuf *o;
775:
776: while (m) {
777: eor |= m->m_flags & M_EOR;
778: if (m->m_len == 0 &&
779: (eor == 0 ||
780: (((o = m->m_next) || (o = n)) &&
781: o->m_type == m->m_type))) {
782: m = m_free(m);
783: continue;
784: }
785: if (n && (n->m_flags & (M_EXT | M_EOR)) == 0 &&
786: (n->m_data + n->m_len + m->m_len) < &n->m_dat[MLEN] &&
787: n->m_type == m->m_type) {
788: bcopy(mtod(m, caddr_t), mtod(n, caddr_t) + n->m_len,
789: (unsigned)m->m_len);
790: n->m_len += m->m_len;
791: sb->sb_cc += m->m_len;
792: m = m_free(m);
793: continue;
794: }
795: if (n)
796: n->m_next = m;
797: else
798: sb->sb_mb = m;
799: sballoc(sb, m);
800: n = m;
801: m->m_flags &= ~M_EOR;
802: m = m->m_next;
803: n->m_next = 0;
804: }
805: if (eor) {
806: if (n)
807: n->m_flags |= eor;
808: else
809: printf("semi-panic: sbcompress\n");
810: }
811: postevent(0,sb, EV_RWBYTES);
812: }
813:
814: /*
815: * Free all mbufs in a sockbuf.
816: * Check that all resources are reclaimed.
817: */
818: void
819: sbflush(sb)
820: register struct sockbuf *sb;
821: {
822:
823: if (sb->sb_flags & SB_LOCK)
824: panic("sbflush: locked");
825: while (sb->sb_mbcnt && sb->sb_cc)
826: sbdrop(sb, (int)sb->sb_cc);
827: if (sb->sb_cc || sb->sb_mb || sb->sb_mbcnt)
828: panic("sbflush: cc %ld || mb %p || mbcnt %ld", sb->sb_cc, (void *)sb->sb_mb, sb->sb_mbcnt);
829: postevent(0, sb, EV_RWBYTES);
830: }
831:
832: /*
833: * Drop data from (the front of) a sockbuf.
834: */
835: void
836: sbdrop(sb, len)
837: register struct sockbuf *sb;
838: register int len;
839: {
840: register struct mbuf *m, *mn;
841: struct mbuf *next;
842:
843: next = (m = sb->sb_mb) ? m->m_nextpkt : 0;
844: while (len > 0) {
845: if (m == 0) {
846: if (next == 0)
847: panic("sbdrop");
848: m = next;
849: next = m->m_nextpkt;
850: continue;
851: }
852: if (m->m_len > len) {
853: m->m_len -= len;
854: m->m_data += len;
855: sb->sb_cc -= len;
856: break;
857: }
858: len -= m->m_len;
859: sbfree(sb, m);
860: MFREE(m, mn);
861: m = mn;
862: }
863: while (m && m->m_len == 0) {
864: sbfree(sb, m);
865: MFREE(m, mn);
866: m = mn;
867: }
868: if (m) {
869: sb->sb_mb = m;
870: m->m_nextpkt = next;
871: } else
872: sb->sb_mb = next;
873: postevent(0, sb, EV_RWBYTES);
874: }
875:
876: /*
877: * Drop a record off the front of a sockbuf
878: * and move the next record to the front.
879: */
880: void
881: sbdroprecord(sb)
882: register struct sockbuf *sb;
883: {
884: register struct mbuf *m, *mn;
885:
886: m = sb->sb_mb;
887: if (m) {
888: sb->sb_mb = m->m_nextpkt;
889: do {
890: sbfree(sb, m);
891: MFREE(m, mn);
892: } while (m = mn);
893: }
894: postevent(0, sb, EV_RWBYTES);
895: }
896:
897: /*
898: * Create a "control" mbuf containing the specified data
899: * with the specified type for presentation on a socket buffer.
900: */
901: struct mbuf *
902: sbcreatecontrol(p, size, type, level)
903: caddr_t p;
904: register int size;
905: int type, level;
906: {
907: register struct cmsghdr *cp;
908: struct mbuf *m;
909:
910: if ((m = m_get(M_DONTWAIT, MT_CONTROL)) == NULL)
911: return ((struct mbuf *) NULL);
912: cp = mtod(m, struct cmsghdr *);
913: /* XXX check size? */
914: (void)memcpy(CMSG_DATA(cp), p, size);
915: size += sizeof(*cp);
916: m->m_len = size;
917: cp->cmsg_len = size;
918: cp->cmsg_level = level;
919: cp->cmsg_type = type;
920: return (m);
921: }
922:
923: /*
924: * Some routines that return EOPNOTSUPP for entry points that are not
925: * supported by a protocol. Fill in as needed.
926: */
927: int
928: pru_abort_notsupp(struct socket *so)
929: {
930: return EOPNOTSUPP;
931: }
932:
933:
934: int
935: pru_accept_notsupp(struct socket *so, struct sockaddr **nam)
936: {
937: return EOPNOTSUPP;
938: }
939:
940: int
941: pru_attach_notsupp(struct socket *so, int proto, struct proc *p)
942: {
943: return EOPNOTSUPP;
944: }
945:
946: int
947: pru_bind_notsupp(struct socket *so, struct sockaddr *nam, struct proc *p)
948: {
949: return EOPNOTSUPP;
950: }
951:
952: int
953: pru_connect_notsupp(struct socket *so, struct sockaddr *nam, struct proc *p)
954: {
955: return EOPNOTSUPP;
956: }
957:
958: int
959: pru_connect2_notsupp(struct socket *so1, struct socket *so2)
960: {
961: return EOPNOTSUPP;
962: }
963:
964: int
965: pru_control_notsupp(struct socket *so, u_long cmd, caddr_t data,
966: struct ifnet *ifp, struct proc *p)
967: {
968: return EOPNOTSUPP;
969: }
970:
971: int
972: pru_detach_notsupp(struct socket *so)
973: {
974: return EOPNOTSUPP;
975: }
976:
977: int
978: pru_disconnect_notsupp(struct socket *so)
979: {
980: return EOPNOTSUPP;
981: }
982:
983: int
984: pru_listen_notsupp(struct socket *so, struct proc *p)
985: {
986: return EOPNOTSUPP;
987: }
988:
989: int
990: pru_peeraddr_notsupp(struct socket *so, struct sockaddr **nam)
991: {
992: return EOPNOTSUPP;
993: }
994:
995: int
996: pru_rcvd_notsupp(struct socket *so, int flags)
997: {
998: return EOPNOTSUPP;
999: }
1000:
1001: int
1002: pru_rcvoob_notsupp(struct socket *so, struct mbuf *m, int flags)
1003: {
1004: return EOPNOTSUPP;
1005: }
1006:
1007: int
1008: pru_send_notsupp(struct socket *so, int flags, struct mbuf *m,
1009: struct sockaddr *addr, struct mbuf *control,
1010: struct proc *p)
1011:
1012: {
1013: return EOPNOTSUPP;
1014: }
1015:
1016:
1017: /*
1018: * This isn't really a ``null'' operation, but it's the default one
1019: * and doesn't do anything destructive.
1020: */
1021: int
1022: pru_sense_null(struct socket *so, struct stat *sb)
1023: {
1024: sb->st_blksize = so->so_snd.sb_hiwat;
1025: return 0;
1026: }
1027:
1028:
1029: int pru_sosend_notsupp(struct socket *so, struct sockaddr *addr,
1030: struct uio *uio, struct mbuf *top,
1031: struct mbuf *control, int flags)
1032:
1033: {
1034: return EOPNOTSUPP;
1035: }
1036:
1037: int pru_soreceive_notsupp(struct socket *so,
1038: struct sockaddr **paddr,
1039: struct uio *uio, struct mbuf **mp0,
1040: struct mbuf **controlp, int *flagsp)
1041: {
1042: return EOPNOTSUPP;
1043: }
1044:
1045: int
1046:
1047: pru_shutdown_notsupp(struct socket *so)
1048: {
1049: return EOPNOTSUPP;
1050: }
1051:
1052: int
1053: pru_sockaddr_notsupp(struct socket *so, struct sockaddr **nam)
1054: {
1055: return EOPNOTSUPP;
1056: }
1057:
1058: int pru_sosend(struct socket *so, struct sockaddr *addr,
1059: struct uio *uio, struct mbuf *top,
1060: struct mbuf *control, int flags)
1061: {
1062: return EOPNOTSUPP;
1063: }
1064:
1065: int pru_soreceive(struct socket *so,
1066: struct sockaddr **paddr,
1067: struct uio *uio, struct mbuf **mp0,
1068: struct mbuf **controlp, int *flagsp)
1069: {
1070: return EOPNOTSUPP;
1071: }
1072:
1073:
1074: int pru_sopoll_notsupp(struct socket *so, int events,
1075: struct ucred *cred)
1076: {
1077: return EOPNOTSUPP;
1078: }
1079:
1080:
1081:
1082: /*
1083: * Make a copy of a sockaddr in a malloced buffer of type M_SONAME.
1084: */
1085: struct sockaddr *
1086: dup_sockaddr(sa, canwait)
1087: struct sockaddr *sa;
1088: int canwait;
1089: {
1090: struct sockaddr *sa2;
1091:
1092: MALLOC(sa2, struct sockaddr *, sa->sa_len, M_SONAME,
1093: canwait ? M_WAITOK : M_NOWAIT);
1094: if (sa2)
1095: bcopy(sa, sa2, sa->sa_len);
1096: return sa2;
1097: }
1098:
1099: /*
1100: * Create an external-format (``xsocket'') structure using the information
1101: * in the kernel-format socket structure pointed to by so. This is done
1102: * to reduce the spew of irrelevant information over this interface,
1103: * to isolate user code from changes in the kernel structure, and
1104: * potentially to provide information-hiding if we decide that
1105: * some of this information should be hidden from users.
1106: */
1107: void
1108: sotoxsocket(struct socket *so, struct xsocket *xso)
1109: {
1110: xso->xso_len = sizeof *xso;
1111: xso->xso_so = so;
1112: xso->so_type = so->so_type;
1113: xso->so_options = so->so_options;
1114: xso->so_linger = so->so_linger;
1115: xso->so_state = so->so_state;
1116: xso->so_pcb = so->so_pcb;
1117: xso->xso_protocol = so->so_proto->pr_protocol;
1118: xso->xso_family = so->so_proto->pr_domain->dom_family;
1119: xso->so_qlen = so->so_qlen;
1120: xso->so_incqlen = so->so_incqlen;
1121: xso->so_qlimit = so->so_qlimit;
1122: xso->so_timeo = so->so_timeo;
1123: xso->so_error = so->so_error;
1124: xso->so_pgid = so->so_pgid;
1125: xso->so_oobmark = so->so_oobmark;
1126: sbtoxsockbuf(&so->so_snd, &xso->so_snd);
1127: sbtoxsockbuf(&so->so_rcv, &xso->so_rcv);
1128: xso->so_uid = so->so_uid;
1129: }
1130:
1131: /*
1132: * This does the same for sockbufs. Note that the xsockbuf structure,
1133: * since it is always embedded in a socket, does not include a self
1134: * pointer nor a length. We make this entry point public in case
1135: * some other mechanism needs it.
1136: */
1137: void
1138: sbtoxsockbuf(struct sockbuf *sb, struct xsockbuf *xsb)
1139: {
1140: xsb->sb_cc = sb->sb_cc;
1141: xsb->sb_hiwat = sb->sb_hiwat;
1142: xsb->sb_mbcnt = sb->sb_mbcnt;
1143: xsb->sb_mbmax = sb->sb_mbmax;
1144: xsb->sb_lowat = sb->sb_lowat;
1145: xsb->sb_flags = sb->sb_flags;
1146: xsb->sb_timeo = sb->sb_timeo;
1147: }
1148:
1149: /*
1150: * Here is the definition of some of the basic objects in the kern.ipc
1151: * branch of the MIB.
1152: */
1153:
1154:
1155: SYSCTL_NODE(_kern, KERN_IPC, ipc, CTLFLAG_RW, 0, "IPC");
1156:
1157: /* This takes the place of kern.maxsockbuf, which moved to kern.ipc. */
1158: static int dummy;
1159: SYSCTL_INT(_kern, KERN_DUMMY, dummy, CTLFLAG_RW, &dummy, 0, "");
1160:
1161: SYSCTL_INT(_kern_ipc, KIPC_MAXSOCKBUF, maxsockbuf, CTLFLAG_RW, &sb_max, 0, "");
1162: SYSCTL_INT(_kern_ipc, OID_AUTO, maxsockets, CTLFLAG_RD, &maxsockets, 0, "");
1163: SYSCTL_INT(_kern_ipc, KIPC_SOCKBUF_WASTE, sockbuf_waste_factor, CTLFLAG_RW,
1164: &sb_efficiency, 0, "");
1165: SYSCTL_INT(_kern_ipc, KIPC_NMBCLUSTERS, nmbclusters, CTLFLAG_RD, &nmbclusters, 0, "");
1166:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.