xref: /csrg-svn/sys/kern/uipc_socket2.c (revision 68328)
123431Smckusick /*
263180Sbostic  * Copyright (c) 1982, 1986, 1988, 1990, 1993
363180Sbostic  *	The Regents of the University of California.  All rights reserved.
423431Smckusick  *
544451Sbostic  * %sccs.include.redist.c%
633187Sbostic  *
7*68328Scgd  *	@(#)uipc_socket2.c	8.2 (Berkeley) 02/14/95
823431Smckusick  */
94903Swnj 
1056517Sbostic #include <sys/param.h>
1156517Sbostic #include <sys/systm.h>
1256517Sbostic #include <sys/proc.h>
1356517Sbostic #include <sys/file.h>
1456517Sbostic #include <sys/buf.h>
1556517Sbostic #include <sys/malloc.h>
1656517Sbostic #include <sys/mbuf.h>
1756517Sbostic #include <sys/protosw.h>
1856517Sbostic #include <sys/socket.h>
1956517Sbostic #include <sys/socketvar.h>
204903Swnj 
214903Swnj /*
224903Swnj  * Primitive routines for operating on sockets and socket buffers
234903Swnj  */
244903Swnj 
2540706Skarels /* strings for sleep message: */
2640706Skarels char	netio[] = "netio";
2740706Skarels char	netcon[] = "netcon";
2840706Skarels char	netcls[] = "netcls";
2940706Skarels 
3040706Skarels u_long	sb_max = SB_MAX;		/* patchable */
3140706Skarels 
324903Swnj /*
334903Swnj  * Procedures to manipulate state flags of socket
347509Sroot  * and do appropriate wakeups.  Normal sequence from the
357509Sroot  * active (originating) side is that soisconnecting() is
367509Sroot  * called during processing of connect() call,
375169Swnj  * resulting in an eventual call to soisconnected() if/when the
385169Swnj  * connection is established.  When the connection is torn down
395169Swnj  * soisdisconnecting() is called during processing of disconnect() call,
405169Swnj  * and soisdisconnected() is called when the connection to the peer
415169Swnj  * is totally severed.  The semantics of these routines are such that
425169Swnj  * connectionless protocols can call soisconnected() and soisdisconnected()
435169Swnj  * only, bypassing the in-progress calls when setting up a ``connection''
445169Swnj  * takes no time.
455169Swnj  *
4612758Ssam  * From the passive side, a socket is created with
4712758Ssam  * two queues of sockets: so_q0 for connections in progress
487509Sroot  * and so_q for connections already made and awaiting user acceptance.
497509Sroot  * As a protocol is preparing incoming connections, it creates a socket
507509Sroot  * structure queued on so_q0 by calling sonewconn().  When the connection
517509Sroot  * is established, soisconnected() is called, and transfers the
527509Sroot  * socket structure to so_q, making it available to accept().
537509Sroot  *
5412758Ssam  * If a socket is closed with sockets on either
557509Sroot  * so_q0 or so_q, these sockets are dropped.
567509Sroot  *
5712758Ssam  * If higher level protocols are implemented in
585169Swnj  * the kernel, the wakeups done here will sometimes
5912758Ssam  * cause software-interrupt process scheduling.
604903Swnj  */
615169Swnj 
62*68328Scgd void
soisconnecting(so)634903Swnj soisconnecting(so)
6412758Ssam 	register struct socket *so;
654903Swnj {
664903Swnj 
674903Swnj 	so->so_state &= ~(SS_ISCONNECTED|SS_ISDISCONNECTING);
684903Swnj 	so->so_state |= SS_ISCONNECTING;
694903Swnj }
704903Swnj 
71*68328Scgd void
soisconnected(so)724903Swnj soisconnected(so)
7312758Ssam 	register struct socket *so;
744903Swnj {
757509Sroot 	register struct socket *head = so->so_head;
764903Swnj 
7740633Skarels 	so->so_state &= ~(SS_ISCONNECTING|SS_ISDISCONNECTING|SS_ISCONFIRMING);
7840633Skarels 	so->so_state |= SS_ISCONNECTED;
7940633Skarels 	if (head && soqremque(so, 0)) {
807509Sroot 		soqinsque(head, so, 1);
8112758Ssam 		sorwakeup(head);
827509Sroot 		wakeup((caddr_t)&head->so_timeo);
8340633Skarels 	} else {
8440633Skarels 		wakeup((caddr_t)&so->so_timeo);
8540633Skarels 		sorwakeup(so);
8640633Skarels 		sowwakeup(so);
877509Sroot 	}
884903Swnj }
894903Swnj 
90*68328Scgd void
soisdisconnecting(so)914903Swnj soisdisconnecting(so)
9212758Ssam 	register struct socket *so;
934903Swnj {
944903Swnj 
955248Sroot 	so->so_state &= ~SS_ISCONNECTING;
964903Swnj 	so->so_state |= (SS_ISDISCONNECTING|SS_CANTRCVMORE|SS_CANTSENDMORE);
974903Swnj 	wakeup((caddr_t)&so->so_timeo);
985170Swnj 	sowwakeup(so);
995169Swnj 	sorwakeup(so);
1004903Swnj }
1014903Swnj 
102*68328Scgd void
soisdisconnected(so)1034903Swnj soisdisconnected(so)
10412758Ssam 	register struct socket *so;
1054903Swnj {
1064903Swnj 
1074903Swnj 	so->so_state &= ~(SS_ISCONNECTING|SS_ISCONNECTED|SS_ISDISCONNECTING);
1084903Swnj 	so->so_state |= (SS_CANTRCVMORE|SS_CANTSENDMORE);
1094903Swnj 	wakeup((caddr_t)&so->so_timeo);
1104903Swnj 	sowwakeup(so);
1114903Swnj 	sorwakeup(so);
1124903Swnj }
1134903Swnj 
1145169Swnj /*
1157509Sroot  * When an attempt at a new connection is noted on a socket
1167509Sroot  * which accepts connections, sonewconn is called.  If the
1177509Sroot  * connection is possible (subject to space constraints, etc.)
1187509Sroot  * then we allocate a new structure, propoerly linked into the
1197509Sroot  * data structure of the original socket, and return this.
12040633Skarels  * Connstatus may be 0, or SO_ISCONFIRMING, or SO_ISCONNECTED.
12140706Skarels  *
12240706Skarels  * Currently, sonewconn() is defined as sonewconn1() in socketvar.h
12340706Skarels  * to catch calls that are missing the (new) second parameter.
1247509Sroot  */
1257509Sroot struct socket *
sonewconn1(head,connstatus)12640706Skarels sonewconn1(head, connstatus)
1277509Sroot 	register struct socket *head;
12840633Skarels 	int connstatus;
1297509Sroot {
1307509Sroot 	register struct socket *so;
13140633Skarels 	int soqueue = connstatus ? 1 : 0;
1327509Sroot 
1337509Sroot 	if (head->so_qlen + head->so_q0len > 3 * head->so_qlimit / 2)
13437329Skarels 		return ((struct socket *)0);
13537329Skarels 	MALLOC(so, struct socket *, sizeof(*so), M_SOCKET, M_DONTWAIT);
13637329Skarels 	if (so == NULL)
13737329Skarels 		return ((struct socket *)0);
13837329Skarels 	bzero((caddr_t)so, sizeof(*so));
1397509Sroot 	so->so_type = head->so_type;
1407509Sroot 	so->so_options = head->so_options &~ SO_ACCEPTCONN;
1417509Sroot 	so->so_linger = head->so_linger;
14210204Ssam 	so->so_state = head->so_state | SS_NOFDREF;
1437509Sroot 	so->so_proto = head->so_proto;
1447509Sroot 	so->so_timeo = head->so_timeo;
14535804Smarc 	so->so_pgid = head->so_pgid;
14635385Skarels 	(void) soreserve(so, head->so_snd.sb_hiwat, head->so_rcv.sb_hiwat);
14740633Skarels 	soqinsque(head, so, soqueue);
14812758Ssam 	if ((*so->so_proto->pr_usrreq)(so, PRU_ATTACH,
14912758Ssam 	    (struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0)) {
15040633Skarels 		(void) soqremque(so, soqueue);
15137329Skarels 		(void) free((caddr_t)so, M_SOCKET);
15237329Skarels 		return ((struct socket *)0);
1537509Sroot 	}
15440633Skarels 	if (connstatus) {
15540633Skarels 		sorwakeup(head);
15640633Skarels 		wakeup((caddr_t)&head->so_timeo);
15740633Skarels 		so->so_state |= connstatus;
15840633Skarels 	}
1597509Sroot 	return (so);
1607509Sroot }
1617509Sroot 
162*68328Scgd void
soqinsque(head,so,q)1637509Sroot soqinsque(head, so, q)
1647509Sroot 	register struct socket *head, *so;
1657509Sroot 	int q;
1667509Sroot {
16740706Skarels 
16840633Skarels 	register struct socket **prev;
1697509Sroot 	so->so_head = head;
1707509Sroot 	if (q == 0) {
1717509Sroot 		head->so_q0len++;
17240633Skarels 		so->so_q0 = 0;
17340633Skarels 		for (prev = &(head->so_q0); *prev; )
17440633Skarels 			prev = &((*prev)->so_q0);
1757509Sroot 	} else {
1767509Sroot 		head->so_qlen++;
17740633Skarels 		so->so_q = 0;
17840633Skarels 		for (prev = &(head->so_q); *prev; )
17940633Skarels 			prev = &((*prev)->so_q);
1807509Sroot 	}
18140633Skarels 	*prev = so;
1827509Sroot }
1837509Sroot 
184*68328Scgd int
soqremque(so,q)1857509Sroot soqremque(so, q)
1867509Sroot 	register struct socket *so;
1877509Sroot 	int q;
1887509Sroot {
1897509Sroot 	register struct socket *head, *prev, *next;
1907509Sroot 
1917509Sroot 	head = so->so_head;
1927509Sroot 	prev = head;
1937509Sroot 	for (;;) {
1947509Sroot 		next = q ? prev->so_q : prev->so_q0;
1957509Sroot 		if (next == so)
1967509Sroot 			break;
19740633Skarels 		if (next == 0)
1987509Sroot 			return (0);
1997509Sroot 		prev = next;
2007509Sroot 	}
2017509Sroot 	if (q == 0) {
2027509Sroot 		prev->so_q0 = next->so_q0;
2037509Sroot 		head->so_q0len--;
2047509Sroot 	} else {
2057509Sroot 		prev->so_q = next->so_q;
2067509Sroot 		head->so_qlen--;
2077509Sroot 	}
2087509Sroot 	next->so_q0 = next->so_q = 0;
2097509Sroot 	next->so_head = 0;
2107509Sroot 	return (1);
2117509Sroot }
2127509Sroot 
2137509Sroot /*
2145169Swnj  * Socantsendmore indicates that no more data will be sent on the
2155169Swnj  * socket; it would normally be applied to a socket when the user
2165169Swnj  * informs the system that no more data is to be sent, by the protocol
2175169Swnj  * code (in case PRU_SHUTDOWN).  Socantrcvmore indicates that no more data
2185169Swnj  * will be received, and will normally be applied to the socket by a
2195169Swnj  * protocol when it detects that the peer will send no more data.
2205169Swnj  * Data queued for reading in the socket may yet be read.
2215169Swnj  */
2225169Swnj 
223*68328Scgd void
socantsendmore(so)2244917Swnj socantsendmore(so)
2254917Swnj 	struct socket *so;
2264917Swnj {
2274917Swnj 
2284917Swnj 	so->so_state |= SS_CANTSENDMORE;
2294917Swnj 	sowwakeup(so);
2304917Swnj }
2314917Swnj 
232*68328Scgd void
socantrcvmore(so)2334917Swnj socantrcvmore(so)
2344917Swnj 	struct socket *so;
2354917Swnj {
2364917Swnj 
2374917Swnj 	so->so_state |= SS_CANTRCVMORE;
2384917Swnj 	sorwakeup(so);
2394917Swnj }
2404917Swnj 
2414903Swnj /*
2424917Swnj  * Wait for data to arrive at/drain from a socket buffer.
2434917Swnj  */
244*68328Scgd int
sbwait(sb)2454917Swnj sbwait(sb)
2464917Swnj 	struct sockbuf *sb;
2474917Swnj {
2484917Swnj 
2494917Swnj 	sb->sb_flags |= SB_WAIT;
25040706Skarels 	return (tsleep((caddr_t)&sb->sb_cc,
25140706Skarels 	    (sb->sb_flags & SB_NOINTR) ? PSOCK : PSOCK | PCATCH, netio,
25240706Skarels 	    sb->sb_timeo));
2534917Swnj }
2544917Swnj 
25540706Skarels /*
25640706Skarels  * Lock a sockbuf already known to be locked;
25740706Skarels  * return any error returned from sleep (EINTR).
25840706Skarels  */
259*68328Scgd int
sb_lock(sb)26040706Skarels sb_lock(sb)
26140706Skarels 	register struct sockbuf *sb;
26240706Skarels {
26340706Skarels 	int error;
26440706Skarels 
26540706Skarels 	while (sb->sb_flags & SB_LOCK) {
26640706Skarels 		sb->sb_flags |= SB_WANT;
26740706Skarels 		if (error = tsleep((caddr_t)&sb->sb_flags,
26840706Skarels 		    (sb->sb_flags & SB_NOINTR) ? PSOCK : PSOCK|PCATCH,
26940706Skarels 		    netio, 0))
27040706Skarels 			return (error);
27140706Skarels 	}
27240706Skarels 	sb->sb_flags |= SB_LOCK;
27340706Skarels 	return (0);
27440706Skarels }
27540706Skarels 
2764917Swnj /*
2774903Swnj  * Wakeup processes waiting on a socket buffer.
27835385Skarels  * Do asynchronous notification via SIGIO
27935385Skarels  * if the socket has the SS_ASYNC flag set.
2804903Swnj  */
281*68328Scgd void
sowakeup(so,sb)28235385Skarels sowakeup(so, sb)
28335385Skarels 	register struct socket *so;
28412758Ssam 	register struct sockbuf *sb;
2854903Swnj {
28637329Skarels 	struct proc *p;
2874903Swnj 
28852527Smckusick 	selwakeup(&sb->sb_sel);
28952527Smckusick 	sb->sb_flags &= ~SB_SEL;
2904903Swnj 	if (sb->sb_flags & SB_WAIT) {
2914903Swnj 		sb->sb_flags &= ~SB_WAIT;
2925013Swnj 		wakeup((caddr_t)&sb->sb_cc);
2934903Swnj 	}
29415829Scooper 	if (so->so_state & SS_ASYNC) {
29535804Smarc 		if (so->so_pgid < 0)
29635804Smarc 			gsignal(-so->so_pgid, SIGIO);
29735804Smarc 		else if (so->so_pgid > 0 && (p = pfind(so->so_pgid)) != 0)
29815829Scooper 			psignal(p, SIGIO);
29915829Scooper 	}
30015829Scooper }
30115829Scooper 
30215829Scooper /*
3035169Swnj  * Socket buffer (struct sockbuf) utility routines.
3045169Swnj  *
3055169Swnj  * Each socket contains two socket buffers: one for sending data and
3065169Swnj  * one for receiving data.  Each buffer contains a queue of mbufs,
3075169Swnj  * information about the number of mbufs and amount of data in the
3085169Swnj  * queue, and other fields allowing select() statements and notification
3095169Swnj  * on data availability to be implemented.
3105169Swnj  *
31116994Skarels  * Data stored in a socket buffer is maintained as a list of records.
31216994Skarels  * Each record is a list of mbufs chained together with the m_next
31335385Skarels  * field.  Records are chained together with the m_nextpkt field. The upper
31416994Skarels  * level routine soreceive() expects the following conventions to be
31516994Skarels  * observed when placing information in the receive buffer:
31616994Skarels  *
31716994Skarels  * 1. If the protocol requires each message be preceded by the sender's
31816994Skarels  *    name, then a record containing that name must be present before
31916994Skarels  *    any associated data (mbuf's must be of type MT_SONAME).
32016994Skarels  * 2. If the protocol supports the exchange of ``access rights'' (really
32116994Skarels  *    just additional data associated with the message), and there are
32216994Skarels  *    ``rights'' to be received, then a record containing this data
32316994Skarels  *    should be present (mbuf's must be of type MT_RIGHTS).
32416994Skarels  * 3. If a name or rights record exists, then it must be followed by
32516994Skarels  *    a data record, perhaps of zero length.
32616994Skarels  *
3275169Swnj  * Before using a new socket structure it is first necessary to reserve
32833406Skarels  * buffer space to the socket, by calling sbreserve().  This should commit
3295169Swnj  * some of the available buffer space in the system buffer pool for the
33033406Skarels  * socket (currently, it does nothing but enforce limits).  The space
33133406Skarels  * should be released by calling sbrelease() when the socket is destroyed.
3325169Swnj  */
3335169Swnj 
334*68328Scgd int
soreserve(so,sndcc,rcvcc)3359027Sroot soreserve(so, sndcc, rcvcc)
33612758Ssam 	register struct socket *so;
33733406Skarels 	u_long sndcc, rcvcc;
3389027Sroot {
3399027Sroot 
3409027Sroot 	if (sbreserve(&so->so_snd, sndcc) == 0)
3419027Sroot 		goto bad;
3429027Sroot 	if (sbreserve(&so->so_rcv, rcvcc) == 0)
3439027Sroot 		goto bad2;
34440706Skarels 	if (so->so_rcv.sb_lowat == 0)
34540706Skarels 		so->so_rcv.sb_lowat = 1;
34640706Skarels 	if (so->so_snd.sb_lowat == 0)
34740706Skarels 		so->so_snd.sb_lowat = MCLBYTES;
34840706Skarels 	if (so->so_snd.sb_lowat > so->so_snd.sb_hiwat)
34940706Skarels 		so->so_snd.sb_lowat = so->so_snd.sb_hiwat;
3509027Sroot 	return (0);
3519027Sroot bad2:
3529027Sroot 	sbrelease(&so->so_snd);
3539027Sroot bad:
3549027Sroot 	return (ENOBUFS);
3559027Sroot }
3569027Sroot 
3575169Swnj /*
3584903Swnj  * Allot mbufs to a sockbuf.
35940706Skarels  * Attempt to scale mbmax so that mbcnt doesn't become limiting
36026830Skarels  * if buffering efficiency is near the normal case.
3614903Swnj  */
362*68328Scgd int
sbreserve(sb,cc)3634903Swnj sbreserve(sb, cc)
3644903Swnj 	struct sockbuf *sb;
36533406Skarels 	u_long cc;
3664903Swnj {
3674903Swnj 
36840706Skarels 	if (cc > sb_max * MCLBYTES / (MSIZE + MCLBYTES))
36917355Skarels 		return (0);
3704980Swnj 	sb->sb_hiwat = cc;
37140706Skarels 	sb->sb_mbmax = min(cc * 2, sb_max);
37240706Skarels 	if (sb->sb_lowat > sb->sb_hiwat)
37340706Skarels 		sb->sb_lowat = sb->sb_hiwat;
3744917Swnj 	return (1);
3754903Swnj }
3764903Swnj 
3774903Swnj /*
3784903Swnj  * Free mbufs held by a socket, and reserved mbuf space.
3794903Swnj  */
380*68328Scgd void
sbrelease(sb)3814903Swnj sbrelease(sb)
3824903Swnj 	struct sockbuf *sb;
3834903Swnj {
3844903Swnj 
3854903Swnj 	sbflush(sb);
3864980Swnj 	sb->sb_hiwat = sb->sb_mbmax = 0;
3874903Swnj }
3884903Swnj 
3894903Swnj /*
39016994Skarels  * Routines to add and remove
39116994Skarels  * data from an mbuf queue.
39225630Skarels  *
39325630Skarels  * The routines sbappend() or sbappendrecord() are normally called to
39425630Skarels  * append new mbufs to a socket buffer, after checking that adequate
39525630Skarels  * space is available, comparing the function sbspace() with the amount
39625630Skarels  * of data to be added.  sbappendrecord() differs from sbappend() in
39725630Skarels  * that data supplied is treated as the beginning of a new record.
39825630Skarels  * To place a sender's address, optional access rights, and data in a
39925630Skarels  * socket receive buffer, sbappendaddr() should be used.  To place
40025630Skarels  * access rights and data in a socket receive buffer, sbappendrights()
40125630Skarels  * should be used.  In either case, the new data begins a new record.
40225630Skarels  * Note that unlike sbappend() and sbappendrecord(), these routines check
40325630Skarels  * for the caller that there will be enough space to store the data.
40425630Skarels  * Each fails if there is not enough space, or if it cannot find mbufs
40525630Skarels  * to store additional information in.
40625630Skarels  *
40725630Skarels  * Reliable protocols may use the socket send buffer to hold data
40825630Skarels  * awaiting acknowledgement.  Data is normally copied from a socket
40925630Skarels  * send buffer in a protocol with m_copy for output to a peer,
41025630Skarels  * and then removing the data from the socket buffer with sbdrop()
41125630Skarels  * or sbdroprecord() when the data is acknowledged by the peer.
4124903Swnj  */
4134903Swnj 
4144903Swnj /*
41516994Skarels  * Append mbuf chain m to the last record in the
41616994Skarels  * socket buffer sb.  The additional space associated
41716994Skarels  * the mbuf chain is recorded in sb.  Empty mbufs are
41816994Skarels  * discarded and mbufs are compacted where possible.
4194903Swnj  */
420*68328Scgd void
sbappend(sb,m)4214903Swnj sbappend(sb, m)
42216994Skarels 	struct sockbuf *sb;
42316994Skarels 	struct mbuf *m;
4244903Swnj {
42552527Smckusick 	register struct mbuf *n;
4264903Swnj 
42716994Skarels 	if (m == 0)
42816994Skarels 		return;
42916994Skarels 	if (n = sb->sb_mb) {
43035385Skarels 		while (n->m_nextpkt)
43135385Skarels 			n = n->m_nextpkt;
43252527Smckusick 		do {
43352527Smckusick 			if (n->m_flags & M_EOR) {
43452527Smckusick 				sbappendrecord(sb, m); /* XXXXXX!!!! */
43552527Smckusick 				return;
43652527Smckusick 			}
43752527Smckusick 		} while (n->m_next && (n = n->m_next));
4384903Swnj 	}
43916994Skarels 	sbcompress(sb, m, n);
4404903Swnj }
4414903Swnj 
44244384Skarels #ifdef SOCKBUF_DEBUG
443*68328Scgd void
sbcheck(sb)44444384Skarels sbcheck(sb)
44544384Skarels 	register struct sockbuf *sb;
44644384Skarels {
44744384Skarels 	register struct mbuf *m;
44844384Skarels 	register int len = 0, mbcnt = 0;
44944384Skarels 
45044384Skarels 	for (m = sb->sb_mb; m; m = m->m_next) {
45144384Skarels 		len += m->m_len;
45244384Skarels 		mbcnt += MSIZE;
45344384Skarels 		if (m->m_flags & M_EXT)
45444384Skarels 			mbcnt += m->m_ext.ext_size;
45544384Skarels 		if (m->m_nextpkt)
45644384Skarels 			panic("sbcheck nextpkt");
45744384Skarels 	}
45844384Skarels 	if (len != sb->sb_cc || mbcnt != sb->sb_mbcnt) {
45944384Skarels 		printf("cc %d != %d || mbcnt %d != %d\n", len, sb->sb_cc,
46044384Skarels 		    mbcnt, sb->sb_mbcnt);
46144384Skarels 		panic("sbcheck");
46244384Skarels 	}
46344384Skarels }
46444384Skarels #endif
46544384Skarels 
4665169Swnj /*
46716994Skarels  * As above, except the mbuf chain
46816994Skarels  * begins a new record.
4695169Swnj  */
470*68328Scgd void
sbappendrecord(sb,m0)47116994Skarels sbappendrecord(sb, m0)
47216994Skarels 	register struct sockbuf *sb;
47316994Skarels 	register struct mbuf *m0;
4744928Swnj {
4754928Swnj 	register struct mbuf *m;
4764928Swnj 
47716994Skarels 	if (m0 == 0)
47816994Skarels 		return;
47916994Skarels 	if (m = sb->sb_mb)
48035385Skarels 		while (m->m_nextpkt)
48135385Skarels 			m = m->m_nextpkt;
48216994Skarels 	/*
48316994Skarels 	 * Put the first mbuf on the queue.
48416994Skarels 	 * Note this permits zero length records.
48516994Skarels 	 */
48616994Skarels 	sballoc(sb, m0);
48716994Skarels 	if (m)
48835385Skarels 		m->m_nextpkt = m0;
48916994Skarels 	else
49016994Skarels 		sb->sb_mb = m0;
49116994Skarels 	m = m0->m_next;
49216994Skarels 	m0->m_next = 0;
49352527Smckusick 	if (m && (m0->m_flags & M_EOR)) {
49452527Smckusick 		m0->m_flags &= ~M_EOR;
49552527Smckusick 		m->m_flags |= M_EOR;
49652527Smckusick 	}
49716994Skarels 	sbcompress(sb, m, m0);
49816994Skarels }
49916994Skarels 
50016994Skarels /*
50137329Skarels  * As above except that OOB data
50237329Skarels  * is inserted at the beginning of the sockbuf,
50337329Skarels  * but after any other OOB data.
50437329Skarels  */
505*68328Scgd void
sbinsertoob(sb,m0)50637329Skarels sbinsertoob(sb, m0)
50737329Skarels 	register struct sockbuf *sb;
50837329Skarels 	register struct mbuf *m0;
50937329Skarels {
51037329Skarels 	register struct mbuf *m;
51137329Skarels 	register struct mbuf **mp;
51237329Skarels 
51337329Skarels 	if (m0 == 0)
51437329Skarels 		return;
51537329Skarels 	for (mp = &sb->sb_mb; m = *mp; mp = &((*mp)->m_nextpkt)) {
51637329Skarels 	    again:
51737329Skarels 		switch (m->m_type) {
51837329Skarels 
51937329Skarels 		case MT_OOBDATA:
52037329Skarels 			continue;		/* WANT next train */
52137329Skarels 
52237329Skarels 		case MT_CONTROL:
52337329Skarels 			if (m = m->m_next)
52437329Skarels 				goto again;	/* inspect THIS train further */
52537329Skarels 		}
52637329Skarels 		break;
52737329Skarels 	}
52837329Skarels 	/*
52937329Skarels 	 * Put the first mbuf on the queue.
53037329Skarels 	 * Note this permits zero length records.
53137329Skarels 	 */
53252527Smckusick 	sballoc(sb, m0);
53337329Skarels 	m0->m_nextpkt = *mp;
53437329Skarels 	*mp = m0;
53552527Smckusick 	m = m0->m_next;
53652527Smckusick 	m0->m_next = 0;
53752527Smckusick 	if (m && (m0->m_flags & M_EOR)) {
53852527Smckusick 		m0->m_flags &= ~M_EOR;
53952527Smckusick 		m->m_flags |= M_EOR;
54052527Smckusick 	}
54152527Smckusick 	sbcompress(sb, m, m0);
54237329Skarels }
54337329Skarels 
54437329Skarels /*
54542259Skarels  * Append address and data, and optionally, control (ancillary) data
54635385Skarels  * to the receive queue of a socket.  If present,
54742259Skarels  * m0 must include a packet header with total length.
54842259Skarels  * Returns 0 if no space in sockbuf or insufficient mbufs.
54916994Skarels  */
550*68328Scgd int
sbappendaddr(sb,asa,m0,control)55142259Skarels sbappendaddr(sb, asa, m0, control)
55216994Skarels 	register struct sockbuf *sb;
55316994Skarels 	struct sockaddr *asa;
55442259Skarels 	struct mbuf *m0, *control;
55516994Skarels {
55616994Skarels 	register struct mbuf *m, *n;
55752527Smckusick 	int space = asa->sa_len;
55816994Skarels 
55935385Skarels if (m0 && (m0->m_flags & M_PKTHDR) == 0)
56035385Skarels panic("sbappendaddr");
56135385Skarels 	if (m0)
56235385Skarels 		space += m0->m_pkthdr.len;
56342259Skarels 	for (n = control; n; n = n->m_next) {
56442259Skarels 		space += n->m_len;
56542259Skarels 		if (n->m_next == 0)	/* keep pointer to last control buf */
56642259Skarels 			break;
56742259Skarels 	}
56816994Skarels 	if (space > sbspace(sb))
5694928Swnj 		return (0);
57042259Skarels 	if (asa->sa_len > MLEN)
57142259Skarels 		return (0);
57225630Skarels 	MGET(m, M_DONTWAIT, MT_SONAME);
57316994Skarels 	if (m == 0)
5744928Swnj 		return (0);
57537329Skarels 	m->m_len = asa->sa_len;
57637329Skarels 	bcopy((caddr_t)asa, mtod(m, caddr_t), asa->sa_len);
57742259Skarels 	if (n)
57842259Skarels 		n->m_next = m0;		/* concatenate data to control */
57942259Skarels 	else
58042259Skarels 		control = m0;
58142259Skarels 	m->m_next = control;
58252527Smckusick 	for (n = m; n; n = n->m_next)
58342259Skarels 		sballoc(sb, n);
58416994Skarels 	if (n = sb->sb_mb) {
58535385Skarels 		while (n->m_nextpkt)
58635385Skarels 			n = n->m_nextpkt;
58735385Skarels 		n->m_nextpkt = m;
58816994Skarels 	} else
58916994Skarels 		sb->sb_mb = m;
59016994Skarels 	return (1);
59116994Skarels }
59216994Skarels 
593*68328Scgd int
sbappendcontrol(sb,m0,control)59442259Skarels sbappendcontrol(sb, m0, control)
59516994Skarels 	struct sockbuf *sb;
596*68328Scgd 	struct mbuf *m0, *control;
59716994Skarels {
59816994Skarels 	register struct mbuf *m, *n;
59952527Smckusick 	int space = 0;
60016994Skarels 
60142259Skarels 	if (control == 0)
60242259Skarels 		panic("sbappendcontrol");
60342259Skarels 	for (m = control; ; m = m->m_next) {
60442259Skarels 		space += m->m_len;
60542259Skarels 		if (m->m_next == 0)
60642259Skarels 			break;
60742259Skarels 	}
60842259Skarels 	n = m;			/* save pointer to last control buffer */
60925630Skarels 	for (m = m0; m; m = m->m_next)
61016994Skarels 		space += m->m_len;
61116994Skarels 	if (space > sbspace(sb))
61212758Ssam 		return (0);
61342259Skarels 	n->m_next = m0;			/* concatenate data to control */
61452527Smckusick 	for (m = control; m; m = m->m_next)
61542259Skarels 		sballoc(sb, m);
61616994Skarels 	if (n = sb->sb_mb) {
61735385Skarels 		while (n->m_nextpkt)
61835385Skarels 			n = n->m_nextpkt;
61942259Skarels 		n->m_nextpkt = control;
62016994Skarels 	} else
62142259Skarels 		sb->sb_mb = control;
6224928Swnj 	return (1);
6234928Swnj }
6244928Swnj 
6254903Swnj /*
62616994Skarels  * Compress mbuf chain m into the socket
62716994Skarels  * buffer sb following mbuf n.  If n
62816994Skarels  * is null, the buffer is presumed empty.
6294903Swnj  */
630*68328Scgd void
sbcompress(sb,m,n)63152527Smckusick sbcompress(sb, m, n)
63216994Skarels 	register struct sockbuf *sb;
63352527Smckusick 	register struct mbuf *m, *n;
63416994Skarels {
63542259Skarels 	register int eor = 0;
63652527Smckusick 	register struct mbuf *o;
63716994Skarels 
63816994Skarels 	while (m) {
63937329Skarels 		eor |= m->m_flags & M_EOR;
64052527Smckusick 		if (m->m_len == 0 &&
64152527Smckusick 		    (eor == 0 ||
64252527Smckusick 		     (((o = m->m_next) || (o = n)) &&
64352527Smckusick 		      o->m_type == m->m_type))) {
64452527Smckusick 			m = m_free(m);
64552527Smckusick 			continue;
64616994Skarels 		}
64752527Smckusick 		if (n && (n->m_flags & (M_EXT | M_EOR)) == 0 &&
64835385Skarels 		    (n->m_data + n->m_len + m->m_len) < &n->m_dat[MLEN] &&
64925630Skarels 		    n->m_type == m->m_type) {
65016994Skarels 			bcopy(mtod(m, caddr_t), mtod(n, caddr_t) + n->m_len,
65116994Skarels 			    (unsigned)m->m_len);
65216994Skarels 			n->m_len += m->m_len;
65316994Skarels 			sb->sb_cc += m->m_len;
65416994Skarels 			m = m_free(m);
65516994Skarels 			continue;
65616994Skarels 		}
65752527Smckusick 		if (n)
65816994Skarels 			n->m_next = m;
65952527Smckusick 		else
66052527Smckusick 			sb->sb_mb = m;
66137329Skarels 		sballoc(sb, m);
66216994Skarels 		n = m;
66352527Smckusick 		m->m_flags &= ~M_EOR;
66416994Skarels 		m = m->m_next;
66516994Skarels 		n->m_next = 0;
66616994Skarels 	}
66746480Ssklower 	if (eor) {
66852527Smckusick 		if (n)
66952527Smckusick 			n->m_flags |= eor;
67046480Ssklower 		else
67152527Smckusick 			printf("semi-panic: sbcompress\n");
67246480Ssklower 	}
67316994Skarels }
67416994Skarels 
67516994Skarels /*
67616994Skarels  * Free all mbufs in a sockbuf.
67716994Skarels  * Check that all resources are reclaimed.
67816994Skarels  */
679*68328Scgd void
sbflush(sb)6804903Swnj sbflush(sb)
68112758Ssam 	register struct sockbuf *sb;
6824903Swnj {
6834903Swnj 
6844903Swnj 	if (sb->sb_flags & SB_LOCK)
6854903Swnj 		panic("sbflush");
68626105Skarels 	while (sb->sb_mbcnt)
68726363Skarels 		sbdrop(sb, (int)sb->sb_cc);
68842259Skarels 	if (sb->sb_cc || sb->sb_mb)
6894903Swnj 		panic("sbflush 2");
6904903Swnj }
6914903Swnj 
6924903Swnj /*
69316994Skarels  * Drop data from (the front of) a sockbuf.
6944903Swnj  */
695*68328Scgd void
sbdrop(sb,len)6964903Swnj sbdrop(sb, len)
6974903Swnj 	register struct sockbuf *sb;
6984903Swnj 	register int len;
6994903Swnj {
70016994Skarels 	register struct mbuf *m, *mn;
70116994Skarels 	struct mbuf *next;
7024903Swnj 
70335385Skarels 	next = (m = sb->sb_mb) ? m->m_nextpkt : 0;
7044903Swnj 	while (len > 0) {
70516994Skarels 		if (m == 0) {
70616994Skarels 			if (next == 0)
70716994Skarels 				panic("sbdrop");
70816994Skarels 			m = next;
70935385Skarels 			next = m->m_nextpkt;
71016994Skarels 			continue;
71116994Skarels 		}
7125064Swnj 		if (m->m_len > len) {
7134903Swnj 			m->m_len -= len;
71435385Skarels 			m->m_data += len;
7154903Swnj 			sb->sb_cc -= len;
7164903Swnj 			break;
7174903Swnj 		}
7185064Swnj 		len -= m->m_len;
7195064Swnj 		sbfree(sb, m);
7205064Swnj 		MFREE(m, mn);
7215064Swnj 		m = mn;
7224903Swnj 	}
72317331Skarels 	while (m && m->m_len == 0) {
72417417Skarels 		sbfree(sb, m);
72517331Skarels 		MFREE(m, mn);
72617331Skarels 		m = mn;
72717331Skarels 	}
72816994Skarels 	if (m) {
72916994Skarels 		sb->sb_mb = m;
73035385Skarels 		m->m_nextpkt = next;
73116994Skarels 	} else
73216994Skarels 		sb->sb_mb = next;
7334903Swnj }
73416994Skarels 
73516994Skarels /*
73616994Skarels  * Drop a record off the front of a sockbuf
73716994Skarels  * and move the next record to the front.
73816994Skarels  */
739*68328Scgd void
sbdroprecord(sb)74016994Skarels sbdroprecord(sb)
74116994Skarels 	register struct sockbuf *sb;
74216994Skarels {
74316994Skarels 	register struct mbuf *m, *mn;
74416994Skarels 
74516994Skarels 	m = sb->sb_mb;
74616994Skarels 	if (m) {
74735385Skarels 		sb->sb_mb = m->m_nextpkt;
74816994Skarels 		do {
74916994Skarels 			sbfree(sb, m);
75016994Skarels 			MFREE(m, mn);
75116994Skarels 		} while (m = mn);
75216994Skarels 	}
75316994Skarels }
754