![[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 [Net/2] / Net2 / kern|
Return to uipc_socket2.c CVS log | Up to [Net/2] / Net2 / kern |
1.1 root 1: /*
2: * Copyright (c) 1982, 1986, 1988, 1990 Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms, with or without
6: * modification, are permitted provided that the following conditions
7: * are met:
8: * 1. Redistributions of source code must retain the above copyright
9: * notice, this list of conditions and the following disclaimer.
10: * 2. Redistributions in binary form must reproduce the above copyright
11: * notice, this list of conditions and the following disclaimer in the
12: * documentation and/or other materials provided with the distribution.
13: * 3. All advertising materials mentioning features or use of this software
14: * must display the following acknowledgement:
15: * This product includes software developed by the University of
16: * California, Berkeley and its contributors.
17: * 4. Neither the name of the University nor the names of its contributors
18: * may be used to endorse or promote products derived from this software
19: * without specific prior written permission.
20: *
21: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31: * SUCH DAMAGE.
32: *
33: * @(#)uipc_socket2.c 7.17 (Berkeley) 5/4/91
34: */
35:
36: #include "param.h"
37: #include "systm.h"
38: #include "proc.h"
39: #include "file.h"
40: #include "buf.h"
41: #include "malloc.h"
42: #include "mbuf.h"
43: #include "protosw.h"
44: #include "socket.h"
45: #include "socketvar.h"
46:
47: /*
48: * Primitive routines for operating on sockets and socket buffers
49: */
50:
51: /* strings for sleep message: */
52: char netio[] = "netio";
53: char netcon[] = "netcon";
54: char netcls[] = "netcls";
55:
56: u_long sb_max = SB_MAX; /* patchable */
57:
58: /*
59: * Procedures to manipulate state flags of socket
60: * and do appropriate wakeups. Normal sequence from the
61: * active (originating) side is that soisconnecting() is
62: * called during processing of connect() call,
63: * resulting in an eventual call to soisconnected() if/when the
64: * connection is established. When the connection is torn down
65: * soisdisconnecting() is called during processing of disconnect() call,
66: * and soisdisconnected() is called when the connection to the peer
67: * is totally severed. The semantics of these routines are such that
68: * connectionless protocols can call soisconnected() and soisdisconnected()
69: * only, bypassing the in-progress calls when setting up a ``connection''
70: * takes no time.
71: *
72: * From the passive side, a socket is created with
73: * two queues of sockets: so_q0 for connections in progress
74: * and so_q for connections already made and awaiting user acceptance.
75: * As a protocol is preparing incoming connections, it creates a socket
76: * structure queued on so_q0 by calling sonewconn(). When the connection
77: * is established, soisconnected() is called, and transfers the
78: * socket structure to so_q, making it available to accept().
79: *
80: * If a socket is closed with sockets on either
81: * so_q0 or so_q, these sockets are dropped.
82: *
83: * If higher level protocols are implemented in
84: * the kernel, the wakeups done here will sometimes
85: * cause software-interrupt process scheduling.
86: */
87:
88: soisconnecting(so)
89: register struct socket *so;
90: {
91:
92: so->so_state &= ~(SS_ISCONNECTED|SS_ISDISCONNECTING);
93: so->so_state |= SS_ISCONNECTING;
94: }
95:
96: soisconnected(so)
97: register struct socket *so;
98: {
99: register struct socket *head = so->so_head;
100:
101: so->so_state &= ~(SS_ISCONNECTING|SS_ISDISCONNECTING|SS_ISCONFIRMING);
102: so->so_state |= SS_ISCONNECTED;
103: if (head && soqremque(so, 0)) {
104: soqinsque(head, so, 1);
105: sorwakeup(head);
106: wakeup((caddr_t)&head->so_timeo);
107: } else {
108: wakeup((caddr_t)&so->so_timeo);
109: sorwakeup(so);
110: sowwakeup(so);
111: }
112: }
113:
114: soisdisconnecting(so)
115: register struct socket *so;
116: {
117:
118: so->so_state &= ~SS_ISCONNECTING;
119: so->so_state |= (SS_ISDISCONNECTING|SS_CANTRCVMORE|SS_CANTSENDMORE);
120: wakeup((caddr_t)&so->so_timeo);
121: sowwakeup(so);
122: sorwakeup(so);
123: }
124:
125: soisdisconnected(so)
126: register struct socket *so;
127: {
128:
129: so->so_state &= ~(SS_ISCONNECTING|SS_ISCONNECTED|SS_ISDISCONNECTING);
130: so->so_state |= (SS_CANTRCVMORE|SS_CANTSENDMORE);
131: wakeup((caddr_t)&so->so_timeo);
132: sowwakeup(so);
133: sorwakeup(so);
134: }
135:
136: /*
137: * When an attempt at a new connection is noted on a socket
138: * which accepts connections, sonewconn is called. If the
139: * connection is possible (subject to space constraints, etc.)
140: * then we allocate a new structure, propoerly linked into the
141: * data structure of the original socket, and return this.
142: * Connstatus may be 0, or SO_ISCONFIRMING, or SO_ISCONNECTED.
143: *
144: * Currently, sonewconn() is defined as sonewconn1() in socketvar.h
145: * to catch calls that are missing the (new) second parameter.
146: */
147: struct socket *
148: sonewconn1(head, connstatus)
149: register struct socket *head;
150: int connstatus;
151: {
152: register struct socket *so;
153: int soqueue = connstatus ? 1 : 0;
154:
155: if (head->so_qlen + head->so_q0len > 3 * head->so_qlimit / 2)
156: return ((struct socket *)0);
157: MALLOC(so, struct socket *, sizeof(*so), M_SOCKET, M_DONTWAIT);
158: if (so == NULL)
159: return ((struct socket *)0);
160: bzero((caddr_t)so, sizeof(*so));
161: so->so_type = head->so_type;
162: so->so_options = head->so_options &~ SO_ACCEPTCONN;
163: so->so_linger = head->so_linger;
164: so->so_state = head->so_state | SS_NOFDREF;
165: so->so_proto = head->so_proto;
166: so->so_timeo = head->so_timeo;
167: so->so_pgid = head->so_pgid;
168: (void) soreserve(so, head->so_snd.sb_hiwat, head->so_rcv.sb_hiwat);
169: soqinsque(head, so, soqueue);
170: if ((*so->so_proto->pr_usrreq)(so, PRU_ATTACH,
171: (struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0)) {
172: (void) soqremque(so, soqueue);
173: (void) free((caddr_t)so, M_SOCKET);
174: return ((struct socket *)0);
175: }
176: if (connstatus) {
177: sorwakeup(head);
178: wakeup((caddr_t)&head->so_timeo);
179: so->so_state |= connstatus;
180: }
181: return (so);
182: }
183:
184: soqinsque(head, so, q)
185: register struct socket *head, *so;
186: int q;
187: {
188:
189: register struct socket **prev;
190: so->so_head = head;
191: if (q == 0) {
192: head->so_q0len++;
193: so->so_q0 = 0;
194: for (prev = &(head->so_q0); *prev; )
195: prev = &((*prev)->so_q0);
196: } else {
197: head->so_qlen++;
198: so->so_q = 0;
199: for (prev = &(head->so_q); *prev; )
200: prev = &((*prev)->so_q);
201: }
202: *prev = so;
203: }
204:
205: soqremque(so, q)
206: register struct socket *so;
207: int q;
208: {
209: register struct socket *head, *prev, *next;
210:
211: head = so->so_head;
212: prev = head;
213: for (;;) {
214: next = q ? prev->so_q : prev->so_q0;
215: if (next == so)
216: break;
217: if (next == 0)
218: return (0);
219: prev = next;
220: }
221: if (q == 0) {
222: prev->so_q0 = next->so_q0;
223: head->so_q0len--;
224: } else {
225: prev->so_q = next->so_q;
226: head->so_qlen--;
227: }
228: next->so_q0 = next->so_q = 0;
229: next->so_head = 0;
230: return (1);
231: }
232:
233: /*
234: * Socantsendmore indicates that no more data will be sent on the
235: * socket; it would normally be applied to a socket when the user
236: * informs the system that no more data is to be sent, by the protocol
237: * code (in case PRU_SHUTDOWN). Socantrcvmore indicates that no more data
238: * will be received, and will normally be applied to the socket by a
239: * protocol when it detects that the peer will send no more data.
240: * Data queued for reading in the socket may yet be read.
241: */
242:
243: socantsendmore(so)
244: struct socket *so;
245: {
246:
247: so->so_state |= SS_CANTSENDMORE;
248: sowwakeup(so);
249: }
250:
251: socantrcvmore(so)
252: struct socket *so;
253: {
254:
255: so->so_state |= SS_CANTRCVMORE;
256: sorwakeup(so);
257: }
258:
259: /*
260: * Socket select/wakeup routines.
261: */
262:
263: /*
264: * Queue a process for a select on a socket buffer.
265: */
266: sbselqueue(sb, cp)
267: struct sockbuf *sb;
268: struct proc *cp;
269: {
270: struct proc *p;
271:
272: if ((p = sb->sb_sel) && p->p_wchan == (caddr_t)&selwait)
273: sb->sb_flags |= SB_COLL;
274: else {
275: sb->sb_sel = cp;
276: sb->sb_flags |= SB_SEL;
277: }
278: }
279:
280: /*
281: * Wait for data to arrive at/drain from a socket buffer.
282: */
283: sbwait(sb)
284: struct sockbuf *sb;
285: {
286:
287: sb->sb_flags |= SB_WAIT;
288: return (tsleep((caddr_t)&sb->sb_cc,
289: (sb->sb_flags & SB_NOINTR) ? PSOCK : PSOCK | PCATCH, netio,
290: sb->sb_timeo));
291: }
292:
293: /*
294: * Lock a sockbuf already known to be locked;
295: * return any error returned from sleep (EINTR).
296: */
297: sb_lock(sb)
298: register struct sockbuf *sb;
299: {
300: int error;
301:
302: while (sb->sb_flags & SB_LOCK) {
303: sb->sb_flags |= SB_WANT;
304: if (error = tsleep((caddr_t)&sb->sb_flags,
305: (sb->sb_flags & SB_NOINTR) ? PSOCK : PSOCK|PCATCH,
306: netio, 0))
307: return (error);
308: }
309: sb->sb_flags |= SB_LOCK;
310: return (0);
311: }
312:
313: /*
314: * Wakeup processes waiting on a socket buffer.
315: * Do asynchronous notification via SIGIO
316: * if the socket has the SS_ASYNC flag set.
317: */
318: sowakeup(so, sb)
319: register struct socket *so;
320: register struct sockbuf *sb;
321: {
322: struct proc *p;
323:
324: if (sb->sb_sel) {
325: selwakeup(sb->sb_sel, sb->sb_flags & SB_COLL);
326: sb->sb_sel = 0;
327: sb->sb_flags &= ~(SB_SEL|SB_COLL);
328: }
329: if (sb->sb_flags & SB_WAIT) {
330: sb->sb_flags &= ~SB_WAIT;
331: wakeup((caddr_t)&sb->sb_cc);
332: }
333: if (so->so_state & SS_ASYNC) {
334: if (so->so_pgid < 0)
335: gsignal(-so->so_pgid, SIGIO);
336: else if (so->so_pgid > 0 && (p = pfind(so->so_pgid)) != 0)
337: psignal(p, SIGIO);
338: }
339: }
340:
341: /*
342: * Socket buffer (struct sockbuf) utility routines.
343: *
344: * Each socket contains two socket buffers: one for sending data and
345: * one for receiving data. Each buffer contains a queue of mbufs,
346: * information about the number of mbufs and amount of data in the
347: * queue, and other fields allowing select() statements and notification
348: * on data availability to be implemented.
349: *
350: * Data stored in a socket buffer is maintained as a list of records.
351: * Each record is a list of mbufs chained together with the m_next
352: * field. Records are chained together with the m_nextpkt field. The upper
353: * level routine soreceive() expects the following conventions to be
354: * observed when placing information in the receive buffer:
355: *
356: * 1. If the protocol requires each message be preceded by the sender's
357: * name, then a record containing that name must be present before
358: * any associated data (mbuf's must be of type MT_SONAME).
359: * 2. If the protocol supports the exchange of ``access rights'' (really
360: * just additional data associated with the message), and there are
361: * ``rights'' to be received, then a record containing this data
362: * should be present (mbuf's must be of type MT_RIGHTS).
363: * 3. If a name or rights record exists, then it must be followed by
364: * a data record, perhaps of zero length.
365: *
366: * Before using a new socket structure it is first necessary to reserve
367: * buffer space to the socket, by calling sbreserve(). This should commit
368: * some of the available buffer space in the system buffer pool for the
369: * socket (currently, it does nothing but enforce limits). The space
370: * should be released by calling sbrelease() when the socket is destroyed.
371: */
372:
373: soreserve(so, sndcc, rcvcc)
374: register struct socket *so;
375: u_long sndcc, rcvcc;
376: {
377:
378: if (sbreserve(&so->so_snd, sndcc) == 0)
379: goto bad;
380: if (sbreserve(&so->so_rcv, rcvcc) == 0)
381: goto bad2;
382: if (so->so_rcv.sb_lowat == 0)
383: so->so_rcv.sb_lowat = 1;
384: if (so->so_snd.sb_lowat == 0)
385: so->so_snd.sb_lowat = MCLBYTES;
386: if (so->so_snd.sb_lowat > so->so_snd.sb_hiwat)
387: so->so_snd.sb_lowat = so->so_snd.sb_hiwat;
388: return (0);
389: bad2:
390: sbrelease(&so->so_snd);
391: bad:
392: return (ENOBUFS);
393: }
394:
395: /*
396: * Allot mbufs to a sockbuf.
397: * Attempt to scale mbmax so that mbcnt doesn't become limiting
398: * if buffering efficiency is near the normal case.
399: */
400: sbreserve(sb, cc)
401: struct sockbuf *sb;
402: u_long cc;
403: {
404:
405: if (cc > sb_max * MCLBYTES / (MSIZE + MCLBYTES))
406: return (0);
407: sb->sb_hiwat = cc;
408: sb->sb_mbmax = min(cc * 2, sb_max);
409: if (sb->sb_lowat > sb->sb_hiwat)
410: sb->sb_lowat = sb->sb_hiwat;
411: return (1);
412: }
413:
414: /*
415: * Free mbufs held by a socket, and reserved mbuf space.
416: */
417: sbrelease(sb)
418: struct sockbuf *sb;
419: {
420:
421: sbflush(sb);
422: sb->sb_hiwat = sb->sb_mbmax = 0;
423: }
424:
425: /*
426: * Routines to add and remove
427: * data from an mbuf queue.
428: *
429: * The routines sbappend() or sbappendrecord() are normally called to
430: * append new mbufs to a socket buffer, after checking that adequate
431: * space is available, comparing the function sbspace() with the amount
432: * of data to be added. sbappendrecord() differs from sbappend() in
433: * that data supplied is treated as the beginning of a new record.
434: * To place a sender's address, optional access rights, and data in a
435: * socket receive buffer, sbappendaddr() should be used. To place
436: * access rights and data in a socket receive buffer, sbappendrights()
437: * should be used. In either case, the new data begins a new record.
438: * Note that unlike sbappend() and sbappendrecord(), these routines check
439: * for the caller that there will be enough space to store the data.
440: * Each fails if there is not enough space, or if it cannot find mbufs
441: * to store additional information in.
442: *
443: * Reliable protocols may use the socket send buffer to hold data
444: * awaiting acknowledgement. Data is normally copied from a socket
445: * send buffer in a protocol with m_copy for output to a peer,
446: * and then removing the data from the socket buffer with sbdrop()
447: * or sbdroprecord() when the data is acknowledged by the peer.
448: */
449:
450: /*
451: * Append mbuf chain m to the last record in the
452: * socket buffer sb. The additional space associated
453: * the mbuf chain is recorded in sb. Empty mbufs are
454: * discarded and mbufs are compacted where possible.
455: */
456: sbappend(sb, m)
457: struct sockbuf *sb;
458: struct mbuf *m;
459: {
460: register struct mbuf *n;
461:
462: if (m == 0)
463: return;
464: if (n = sb->sb_mb) {
465: while (n->m_nextpkt)
466: n = n->m_nextpkt;
467: do {
468: if (n->m_flags & M_EOR) {
469: sbappendrecord(sb, m); /* XXXXXX!!!! */
470: return;
471: }
472: } while (n->m_next && (n = n->m_next));
473: }
474: sbcompress(sb, m, n);
475: }
476:
477: #ifdef SOCKBUF_DEBUG
478: sbcheck(sb)
479: register struct sockbuf *sb;
480: {
481: register struct mbuf *m;
482: register int len = 0, mbcnt = 0;
483:
484: for (m = sb->sb_mb; m; m = m->m_next) {
485: len += m->m_len;
486: mbcnt += MSIZE;
487: if (m->m_flags & M_EXT)
488: mbcnt += m->m_ext.ext_size;
489: if (m->m_nextpkt)
490: panic("sbcheck nextpkt");
491: }
492: if (len != sb->sb_cc || mbcnt != sb->sb_mbcnt) {
493: printf("cc %d != %d || mbcnt %d != %d\n", len, sb->sb_cc,
494: mbcnt, sb->sb_mbcnt);
495: panic("sbcheck");
496: }
497: }
498: #endif
499:
500: /*
501: * As above, except the mbuf chain
502: * begins a new record.
503: */
504: sbappendrecord(sb, m0)
505: register struct sockbuf *sb;
506: register struct mbuf *m0;
507: {
508: register struct mbuf *m;
509:
510: if (m0 == 0)
511: return;
512: if (m = sb->sb_mb)
513: while (m->m_nextpkt)
514: m = m->m_nextpkt;
515: /*
516: * Put the first mbuf on the queue.
517: * Note this permits zero length records.
518: */
519: sballoc(sb, m0);
520: if (m)
521: m->m_nextpkt = m0;
522: else
523: sb->sb_mb = m0;
524: m = m0->m_next;
525: m0->m_next = 0;
526: if (m && (m0->m_flags & M_EOR)) {
527: m0->m_flags &= ~M_EOR;
528: m->m_flags |= M_EOR;
529: }
530: sbcompress(sb, m, m0);
531: }
532:
533: /*
534: * As above except that OOB data
535: * is inserted at the beginning of the sockbuf,
536: * but after any other OOB data.
537: */
538: sbinsertoob(sb, m0)
539: register struct sockbuf *sb;
540: register struct mbuf *m0;
541: {
542: register struct mbuf *m;
543: register struct mbuf **mp;
544:
545: if (m0 == 0)
546: return;
547: for (mp = &sb->sb_mb; m = *mp; mp = &((*mp)->m_nextpkt)) {
548: again:
549: switch (m->m_type) {
550:
551: case MT_OOBDATA:
552: continue; /* WANT next train */
553:
554: case MT_CONTROL:
555: if (m = m->m_next)
556: goto again; /* inspect THIS train further */
557: }
558: break;
559: }
560: /*
561: * Put the first mbuf on the queue.
562: * Note this permits zero length records.
563: */
564: sballoc(sb, m0);
565: m0->m_nextpkt = *mp;
566: *mp = m0;
567: m = m0->m_next;
568: m0->m_next = 0;
569: if (m && (m0->m_flags & M_EOR)) {
570: m0->m_flags &= ~M_EOR;
571: m->m_flags |= M_EOR;
572: }
573: sbcompress(sb, m, m0);
574: }
575:
576: /*
577: * Append address and data, and optionally, control (ancillary) data
578: * to the receive queue of a socket. If present,
579: * m0 must include a packet header with total length.
580: * Returns 0 if no space in sockbuf or insufficient mbufs.
581: */
582: sbappendaddr(sb, asa, m0, control)
583: register struct sockbuf *sb;
584: struct sockaddr *asa;
585: struct mbuf *m0, *control;
586: {
587: register struct mbuf *m, *n;
588: int space = asa->sa_len;
589:
590: if (m0 && (m0->m_flags & M_PKTHDR) == 0)
591: panic("sbappendaddr");
592: if (m0)
593: space += m0->m_pkthdr.len;
594: for (n = control; n; n = n->m_next) {
595: space += n->m_len;
596: if (n->m_next == 0) /* keep pointer to last control buf */
597: break;
598: }
599: if (space > sbspace(sb))
600: return (0);
601: if (asa->sa_len > MLEN)
602: return (0);
603: MGET(m, M_DONTWAIT, MT_SONAME);
604: if (m == 0)
605: return (0);
606: m->m_len = asa->sa_len;
607: bcopy((caddr_t)asa, mtod(m, caddr_t), asa->sa_len);
608: if (n)
609: n->m_next = m0; /* concatenate data to control */
610: else
611: control = m0;
612: m->m_next = control;
613: for (n = m; n; n = n->m_next)
614: sballoc(sb, n);
615: if (n = sb->sb_mb) {
616: while (n->m_nextpkt)
617: n = n->m_nextpkt;
618: n->m_nextpkt = m;
619: } else
620: sb->sb_mb = m;
621: return (1);
622: }
623:
624: sbappendcontrol(sb, m0, control)
625: struct sockbuf *sb;
626: struct mbuf *control, *m0;
627: {
628: register struct mbuf *m, *n;
629: int space = 0;
630:
631: if (control == 0)
632: panic("sbappendcontrol");
633: for (m = control; ; m = m->m_next) {
634: space += m->m_len;
635: if (m->m_next == 0)
636: break;
637: }
638: n = m; /* save pointer to last control buffer */
639: for (m = m0; m; m = m->m_next)
640: space += m->m_len;
641: if (space > sbspace(sb))
642: return (0);
643: n->m_next = m0; /* concatenate data to control */
644: for (m = control; m; m = m->m_next)
645: sballoc(sb, m);
646: if (n = sb->sb_mb) {
647: while (n->m_nextpkt)
648: n = n->m_nextpkt;
649: n->m_nextpkt = control;
650: } else
651: sb->sb_mb = control;
652: return (1);
653: }
654:
655: /*
656: * Compress mbuf chain m into the socket
657: * buffer sb following mbuf n. If n
658: * is null, the buffer is presumed empty.
659: */
660: sbcompress(sb, m, n)
661: register struct sockbuf *sb;
662: register struct mbuf *m, *n;
663: {
664: register int eor = 0;
665: register struct mbuf *o;
666:
667: while (m) {
668: eor |= m->m_flags & M_EOR;
669: if (m->m_len == 0 &&
670: (eor == 0 ||
671: (((o = m->m_next) || (o = n)) &&
672: o->m_type == m->m_type))) {
673: m = m_free(m);
674: continue;
675: }
676: if (n && (n->m_flags & (M_EXT | M_EOR)) == 0 &&
677: (n->m_data + n->m_len + m->m_len) < &n->m_dat[MLEN] &&
678: n->m_type == m->m_type) {
679: bcopy(mtod(m, caddr_t), mtod(n, caddr_t) + n->m_len,
680: (unsigned)m->m_len);
681: n->m_len += m->m_len;
682: sb->sb_cc += m->m_len;
683: m = m_free(m);
684: continue;
685: }
686: if (n)
687: n->m_next = m;
688: else
689: sb->sb_mb = m;
690: sballoc(sb, m);
691: n = m;
692: m->m_flags &= ~M_EOR;
693: m = m->m_next;
694: n->m_next = 0;
695: }
696: if (eor) {
697: if (n)
698: n->m_flags |= eor;
699: else
700: printf("semi-panic: sbcompress\n");
701: }
702: }
703:
704: /*
705: * Free all mbufs in a sockbuf.
706: * Check that all resources are reclaimed.
707: */
708: sbflush(sb)
709: register struct sockbuf *sb;
710: {
711:
712: if (sb->sb_flags & SB_LOCK)
713: panic("sbflush");
714: while (sb->sb_mbcnt)
715: sbdrop(sb, (int)sb->sb_cc);
716: if (sb->sb_cc || sb->sb_mb)
717: panic("sbflush 2");
718: }
719:
720: /*
721: * Drop data from (the front of) a sockbuf.
722: */
723: sbdrop(sb, len)
724: register struct sockbuf *sb;
725: register int len;
726: {
727: register struct mbuf *m, *mn;
728: struct mbuf *next;
729:
730: next = (m = sb->sb_mb) ? m->m_nextpkt : 0;
731: while (len > 0) {
732: if (m == 0) {
733: if (next == 0)
734: panic("sbdrop");
735: m = next;
736: next = m->m_nextpkt;
737: continue;
738: }
739: if (m->m_len > len) {
740: m->m_len -= len;
741: m->m_data += len;
742: sb->sb_cc -= len;
743: break;
744: }
745: len -= m->m_len;
746: sbfree(sb, m);
747: MFREE(m, mn);
748: m = mn;
749: }
750: while (m && m->m_len == 0) {
751: sbfree(sb, m);
752: MFREE(m, mn);
753: m = mn;
754: }
755: if (m) {
756: sb->sb_mb = m;
757: m->m_nextpkt = next;
758: } else
759: sb->sb_mb = next;
760: }
761:
762: /*
763: * Drop a record off the front of a sockbuf
764: * and move the next record to the front.
765: */
766: sbdroprecord(sb)
767: register struct sockbuf *sb;
768: {
769: register struct mbuf *m, *mn;
770:
771: m = sb->sb_mb;
772: if (m) {
773: sb->sb_mb = m->m_nextpkt;
774: do {
775: sbfree(sb, m);
776: MFREE(m, mn);
777: } while (m = mn);
778: }
779: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.