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