xref: /csrg-svn/sys/kern/uipc_socket2.c (revision 44384)
123431Smckusick /*
240706Skarels  * Copyright (c) 1982, 1986, 1988, 1990 Regents of the University of California.
333187Sbostic  * All rights reserved.
423431Smckusick  *
533187Sbostic  * Redistribution and use in source and binary forms are permitted
634858Sbostic  * provided that the above copyright notice and this paragraph are
734858Sbostic  * duplicated in all such forms and that any documentation,
834858Sbostic  * advertising materials, and other materials related to such
934858Sbostic  * distribution and use acknowledge that the software was developed
1034858Sbostic  * by the University of California, Berkeley.  The name of the
1134858Sbostic  * University may not be used to endorse or promote products derived
1234858Sbostic  * from this software without specific prior written permission.
1334858Sbostic  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
1434858Sbostic  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
1534858Sbostic  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
1633187Sbostic  *
17*44384Skarels  *	@(#)uipc_socket2.c	7.14 (Berkeley) 06/28/90
1823431Smckusick  */
194903Swnj 
2017103Sbloom #include "param.h"
2117103Sbloom #include "systm.h"
2217103Sbloom #include "user.h"
2317103Sbloom #include "proc.h"
2417103Sbloom #include "file.h"
2517103Sbloom #include "buf.h"
2635385Skarels #include "malloc.h"
2717103Sbloom #include "mbuf.h"
2817103Sbloom #include "protosw.h"
2917103Sbloom #include "socket.h"
3017103Sbloom #include "socketvar.h"
314903Swnj 
324903Swnj /*
334903Swnj  * Primitive routines for operating on sockets and socket buffers
344903Swnj  */
354903Swnj 
3640706Skarels /* strings for sleep message: */
3740706Skarels char	netio[] = "netio";
3840706Skarels char	netcon[] = "netcon";
3940706Skarels char	netcls[] = "netcls";
4040706Skarels 
4140706Skarels u_long	sb_max = SB_MAX;		/* patchable */
4240706Skarels 
434903Swnj /*
444903Swnj  * Procedures to manipulate state flags of socket
457509Sroot  * and do appropriate wakeups.  Normal sequence from the
467509Sroot  * active (originating) side is that soisconnecting() is
477509Sroot  * called during processing of connect() call,
485169Swnj  * resulting in an eventual call to soisconnected() if/when the
495169Swnj  * connection is established.  When the connection is torn down
505169Swnj  * soisdisconnecting() is called during processing of disconnect() call,
515169Swnj  * and soisdisconnected() is called when the connection to the peer
525169Swnj  * is totally severed.  The semantics of these routines are such that
535169Swnj  * connectionless protocols can call soisconnected() and soisdisconnected()
545169Swnj  * only, bypassing the in-progress calls when setting up a ``connection''
555169Swnj  * takes no time.
565169Swnj  *
5712758Ssam  * From the passive side, a socket is created with
5812758Ssam  * two queues of sockets: so_q0 for connections in progress
597509Sroot  * and so_q for connections already made and awaiting user acceptance.
607509Sroot  * As a protocol is preparing incoming connections, it creates a socket
617509Sroot  * structure queued on so_q0 by calling sonewconn().  When the connection
627509Sroot  * is established, soisconnected() is called, and transfers the
637509Sroot  * socket structure to so_q, making it available to accept().
647509Sroot  *
6512758Ssam  * If a socket is closed with sockets on either
667509Sroot  * so_q0 or so_q, these sockets are dropped.
677509Sroot  *
6812758Ssam  * If higher level protocols are implemented in
695169Swnj  * the kernel, the wakeups done here will sometimes
7012758Ssam  * cause software-interrupt process scheduling.
714903Swnj  */
725169Swnj 
734903Swnj soisconnecting(so)
7412758Ssam 	register struct socket *so;
754903Swnj {
764903Swnj 
774903Swnj 	so->so_state &= ~(SS_ISCONNECTED|SS_ISDISCONNECTING);
784903Swnj 	so->so_state |= SS_ISCONNECTING;
794903Swnj }
804903Swnj 
814903Swnj soisconnected(so)
8212758Ssam 	register struct socket *so;
834903Swnj {
847509Sroot 	register struct socket *head = so->so_head;
854903Swnj 
8640633Skarels 	so->so_state &= ~(SS_ISCONNECTING|SS_ISDISCONNECTING|SS_ISCONFIRMING);
8740633Skarels 	so->so_state |= SS_ISCONNECTED;
8840633Skarels 	if (head && soqremque(so, 0)) {
897509Sroot 		soqinsque(head, so, 1);
9012758Ssam 		sorwakeup(head);
917509Sroot 		wakeup((caddr_t)&head->so_timeo);
9240633Skarels 	} else {
9340633Skarels 		wakeup((caddr_t)&so->so_timeo);
9440633Skarels 		sorwakeup(so);
9540633Skarels 		sowwakeup(so);
967509Sroot 	}
974903Swnj }
984903Swnj 
994903Swnj soisdisconnecting(so)
10012758Ssam 	register struct socket *so;
1014903Swnj {
1024903Swnj 
1035248Sroot 	so->so_state &= ~SS_ISCONNECTING;
1044903Swnj 	so->so_state |= (SS_ISDISCONNECTING|SS_CANTRCVMORE|SS_CANTSENDMORE);
1054903Swnj 	wakeup((caddr_t)&so->so_timeo);
1065170Swnj 	sowwakeup(so);
1075169Swnj 	sorwakeup(so);
1084903Swnj }
1094903Swnj 
1104903Swnj soisdisconnected(so)
11112758Ssam 	register struct socket *so;
1124903Swnj {
1134903Swnj 
1144903Swnj 	so->so_state &= ~(SS_ISCONNECTING|SS_ISCONNECTED|SS_ISDISCONNECTING);
1154903Swnj 	so->so_state |= (SS_CANTRCVMORE|SS_CANTSENDMORE);
1164903Swnj 	wakeup((caddr_t)&so->so_timeo);
1174903Swnj 	sowwakeup(so);
1184903Swnj 	sorwakeup(so);
1194903Swnj }
1204903Swnj 
1215169Swnj /*
1227509Sroot  * When an attempt at a new connection is noted on a socket
1237509Sroot  * which accepts connections, sonewconn is called.  If the
1247509Sroot  * connection is possible (subject to space constraints, etc.)
1257509Sroot  * then we allocate a new structure, propoerly linked into the
1267509Sroot  * data structure of the original socket, and return this.
12740633Skarels  * Connstatus may be 0, or SO_ISCONFIRMING, or SO_ISCONNECTED.
12840706Skarels  *
12940706Skarels  * Currently, sonewconn() is defined as sonewconn1() in socketvar.h
13040706Skarels  * to catch calls that are missing the (new) second parameter.
1317509Sroot  */
1327509Sroot struct socket *
13340706Skarels sonewconn1(head, connstatus)
1347509Sroot 	register struct socket *head;
13540633Skarels 	int connstatus;
1367509Sroot {
1377509Sroot 	register struct socket *so;
13840633Skarels 	int soqueue = connstatus ? 1 : 0;
1397509Sroot 
1407509Sroot 	if (head->so_qlen + head->so_q0len > 3 * head->so_qlimit / 2)
14137329Skarels 		return ((struct socket *)0);
14237329Skarels 	MALLOC(so, struct socket *, sizeof(*so), M_SOCKET, M_DONTWAIT);
14337329Skarels 	if (so == NULL)
14437329Skarels 		return ((struct socket *)0);
14537329Skarels 	bzero((caddr_t)so, sizeof(*so));
1467509Sroot 	so->so_type = head->so_type;
1477509Sroot 	so->so_options = head->so_options &~ SO_ACCEPTCONN;
1487509Sroot 	so->so_linger = head->so_linger;
14910204Ssam 	so->so_state = head->so_state | SS_NOFDREF;
1507509Sroot 	so->so_proto = head->so_proto;
1517509Sroot 	so->so_timeo = head->so_timeo;
15235804Smarc 	so->so_pgid = head->so_pgid;
15335385Skarels 	(void) soreserve(so, head->so_snd.sb_hiwat, head->so_rcv.sb_hiwat);
15440633Skarels 	soqinsque(head, so, soqueue);
15512758Ssam 	if ((*so->so_proto->pr_usrreq)(so, PRU_ATTACH,
15612758Ssam 	    (struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0)) {
15740633Skarels 		(void) soqremque(so, soqueue);
15837329Skarels 		(void) free((caddr_t)so, M_SOCKET);
15937329Skarels 		return ((struct socket *)0);
1607509Sroot 	}
16140633Skarels 	if (connstatus) {
16240633Skarels 		sorwakeup(head);
16340633Skarels 		wakeup((caddr_t)&head->so_timeo);
16440633Skarels 		so->so_state |= connstatus;
16540633Skarels 	}
1667509Sroot 	return (so);
1677509Sroot }
1687509Sroot 
1697509Sroot soqinsque(head, so, q)
1707509Sroot 	register struct socket *head, *so;
1717509Sroot 	int q;
1727509Sroot {
17340706Skarels 
17440633Skarels 	register struct socket **prev;
1757509Sroot 	so->so_head = head;
1767509Sroot 	if (q == 0) {
1777509Sroot 		head->so_q0len++;
17840633Skarels 		so->so_q0 = 0;
17940633Skarels 		for (prev = &(head->so_q0); *prev; )
18040633Skarels 			prev = &((*prev)->so_q0);
1817509Sroot 	} else {
1827509Sroot 		head->so_qlen++;
18340633Skarels 		so->so_q = 0;
18440633Skarels 		for (prev = &(head->so_q); *prev; )
18540633Skarels 			prev = &((*prev)->so_q);
1867509Sroot 	}
18740633Skarels 	*prev = so;
1887509Sroot }
1897509Sroot 
1907509Sroot soqremque(so, q)
1917509Sroot 	register struct socket *so;
1927509Sroot 	int q;
1937509Sroot {
1947509Sroot 	register struct socket *head, *prev, *next;
1957509Sroot 
1967509Sroot 	head = so->so_head;
1977509Sroot 	prev = head;
1987509Sroot 	for (;;) {
1997509Sroot 		next = q ? prev->so_q : prev->so_q0;
2007509Sroot 		if (next == so)
2017509Sroot 			break;
20240633Skarels 		if (next == 0)
2037509Sroot 			return (0);
2047509Sroot 		prev = next;
2057509Sroot 	}
2067509Sroot 	if (q == 0) {
2077509Sroot 		prev->so_q0 = next->so_q0;
2087509Sroot 		head->so_q0len--;
2097509Sroot 	} else {
2107509Sroot 		prev->so_q = next->so_q;
2117509Sroot 		head->so_qlen--;
2127509Sroot 	}
2137509Sroot 	next->so_q0 = next->so_q = 0;
2147509Sroot 	next->so_head = 0;
2157509Sroot 	return (1);
2167509Sroot }
2177509Sroot 
2187509Sroot /*
2195169Swnj  * Socantsendmore indicates that no more data will be sent on the
2205169Swnj  * socket; it would normally be applied to a socket when the user
2215169Swnj  * informs the system that no more data is to be sent, by the protocol
2225169Swnj  * code (in case PRU_SHUTDOWN).  Socantrcvmore indicates that no more data
2235169Swnj  * will be received, and will normally be applied to the socket by a
2245169Swnj  * protocol when it detects that the peer will send no more data.
2255169Swnj  * Data queued for reading in the socket may yet be read.
2265169Swnj  */
2275169Swnj 
2284917Swnj socantsendmore(so)
2294917Swnj 	struct socket *so;
2304917Swnj {
2314917Swnj 
2324917Swnj 	so->so_state |= SS_CANTSENDMORE;
2334917Swnj 	sowwakeup(so);
2344917Swnj }
2354917Swnj 
2364917Swnj socantrcvmore(so)
2374917Swnj 	struct socket *so;
2384917Swnj {
2394917Swnj 
2404917Swnj 	so->so_state |= SS_CANTRCVMORE;
2414917Swnj 	sorwakeup(so);
2424917Swnj }
2434917Swnj 
2444903Swnj /*
2455169Swnj  * Socket select/wakeup routines.
2464903Swnj  */
2475169Swnj 
2485169Swnj /*
2494903Swnj  * Queue a process for a select on a socket buffer.
2504903Swnj  */
2514903Swnj sbselqueue(sb)
2524903Swnj 	struct sockbuf *sb;
2534903Swnj {
25435385Skarels 	struct proc *p;
2554903Swnj 
2564917Swnj 	if ((p = sb->sb_sel) && p->p_wchan == (caddr_t)&selwait)
2574903Swnj 		sb->sb_flags |= SB_COLL;
25844228Skarels 	else {
2594903Swnj 		sb->sb_sel = u.u_procp;
26044228Skarels 		sb->sb_flags |= SB_SEL;
26144228Skarels 	}
2624903Swnj }
2634903Swnj 
2644903Swnj /*
2654917Swnj  * Wait for data to arrive at/drain from a socket buffer.
2664917Swnj  */
2674917Swnj sbwait(sb)
2684917Swnj 	struct sockbuf *sb;
2694917Swnj {
2704917Swnj 
2714917Swnj 	sb->sb_flags |= SB_WAIT;
27240706Skarels 	return (tsleep((caddr_t)&sb->sb_cc,
27340706Skarels 	    (sb->sb_flags & SB_NOINTR) ? PSOCK : PSOCK | PCATCH, netio,
27440706Skarels 	    sb->sb_timeo));
2754917Swnj }
2764917Swnj 
27740706Skarels /*
27840706Skarels  * Lock a sockbuf already known to be locked;
27940706Skarels  * return any error returned from sleep (EINTR).
28040706Skarels  */
28140706Skarels sb_lock(sb)
28240706Skarels 	register struct sockbuf *sb;
28340706Skarels {
28440706Skarels 	int error;
28540706Skarels 
28640706Skarels 	while (sb->sb_flags & SB_LOCK) {
28740706Skarels 		sb->sb_flags |= SB_WANT;
28840706Skarels 		if (error = tsleep((caddr_t)&sb->sb_flags,
28940706Skarels 		    (sb->sb_flags & SB_NOINTR) ? PSOCK : PSOCK|PCATCH,
29040706Skarels 		    netio, 0))
29140706Skarels 			return (error);
29240706Skarels 	}
29340706Skarels 	sb->sb_flags |= SB_LOCK;
29440706Skarels 	return (0);
29540706Skarels }
29640706Skarels 
2974917Swnj /*
2984903Swnj  * Wakeup processes waiting on a socket buffer.
29935385Skarels  * Do asynchronous notification via SIGIO
30035385Skarels  * if the socket has the SS_ASYNC flag set.
3014903Swnj  */
30235385Skarels sowakeup(so, sb)
30335385Skarels 	register struct socket *so;
30412758Ssam 	register struct sockbuf *sb;
3054903Swnj {
30637329Skarels 	struct proc *p;
3074903Swnj 
3084903Swnj 	if (sb->sb_sel) {
3094903Swnj 		selwakeup(sb->sb_sel, sb->sb_flags & SB_COLL);
3104903Swnj 		sb->sb_sel = 0;
31144228Skarels 		sb->sb_flags &= ~(SB_SEL|SB_COLL);
3124903Swnj 	}
3134903Swnj 	if (sb->sb_flags & SB_WAIT) {
3144903Swnj 		sb->sb_flags &= ~SB_WAIT;
3155013Swnj 		wakeup((caddr_t)&sb->sb_cc);
3164903Swnj 	}
31715829Scooper 	if (so->so_state & SS_ASYNC) {
31835804Smarc 		if (so->so_pgid < 0)
31935804Smarc 			gsignal(-so->so_pgid, SIGIO);
32035804Smarc 		else if (so->so_pgid > 0 && (p = pfind(so->so_pgid)) != 0)
32115829Scooper 			psignal(p, SIGIO);
32215829Scooper 	}
32315829Scooper }
32415829Scooper 
32515829Scooper /*
3265169Swnj  * Socket buffer (struct sockbuf) utility routines.
3275169Swnj  *
3285169Swnj  * Each socket contains two socket buffers: one for sending data and
3295169Swnj  * one for receiving data.  Each buffer contains a queue of mbufs,
3305169Swnj  * information about the number of mbufs and amount of data in the
3315169Swnj  * queue, and other fields allowing select() statements and notification
3325169Swnj  * on data availability to be implemented.
3335169Swnj  *
33416994Skarels  * Data stored in a socket buffer is maintained as a list of records.
33516994Skarels  * Each record is a list of mbufs chained together with the m_next
33635385Skarels  * field.  Records are chained together with the m_nextpkt field. The upper
33716994Skarels  * level routine soreceive() expects the following conventions to be
33816994Skarels  * observed when placing information in the receive buffer:
33916994Skarels  *
34016994Skarels  * 1. If the protocol requires each message be preceded by the sender's
34116994Skarels  *    name, then a record containing that name must be present before
34216994Skarels  *    any associated data (mbuf's must be of type MT_SONAME).
34316994Skarels  * 2. If the protocol supports the exchange of ``access rights'' (really
34416994Skarels  *    just additional data associated with the message), and there are
34516994Skarels  *    ``rights'' to be received, then a record containing this data
34616994Skarels  *    should be present (mbuf's must be of type MT_RIGHTS).
34716994Skarels  * 3. If a name or rights record exists, then it must be followed by
34816994Skarels  *    a data record, perhaps of zero length.
34916994Skarels  *
3505169Swnj  * Before using a new socket structure it is first necessary to reserve
35133406Skarels  * buffer space to the socket, by calling sbreserve().  This should commit
3525169Swnj  * some of the available buffer space in the system buffer pool for the
35333406Skarels  * socket (currently, it does nothing but enforce limits).  The space
35433406Skarels  * should be released by calling sbrelease() when the socket is destroyed.
3555169Swnj  */
3565169Swnj 
3579027Sroot soreserve(so, sndcc, rcvcc)
35812758Ssam 	register struct socket *so;
35933406Skarels 	u_long sndcc, rcvcc;
3609027Sroot {
3619027Sroot 
3629027Sroot 	if (sbreserve(&so->so_snd, sndcc) == 0)
3639027Sroot 		goto bad;
3649027Sroot 	if (sbreserve(&so->so_rcv, rcvcc) == 0)
3659027Sroot 		goto bad2;
36640706Skarels 	if (so->so_rcv.sb_lowat == 0)
36740706Skarels 		so->so_rcv.sb_lowat = 1;
36840706Skarels 	if (so->so_snd.sb_lowat == 0)
36940706Skarels 		so->so_snd.sb_lowat = MCLBYTES;
37040706Skarels 	if (so->so_snd.sb_lowat > so->so_snd.sb_hiwat)
37140706Skarels 		so->so_snd.sb_lowat = so->so_snd.sb_hiwat;
3729027Sroot 	return (0);
3739027Sroot bad2:
3749027Sroot 	sbrelease(&so->so_snd);
3759027Sroot bad:
3769027Sroot 	return (ENOBUFS);
3779027Sroot }
3789027Sroot 
3795169Swnj /*
3804903Swnj  * Allot mbufs to a sockbuf.
38140706Skarels  * Attempt to scale mbmax so that mbcnt doesn't become limiting
38226830Skarels  * if buffering efficiency is near the normal case.
3834903Swnj  */
3844903Swnj sbreserve(sb, cc)
3854903Swnj 	struct sockbuf *sb;
38633406Skarels 	u_long cc;
3874903Swnj {
3884903Swnj 
38940706Skarels 	if (cc > sb_max * MCLBYTES / (MSIZE + MCLBYTES))
39017355Skarels 		return (0);
3914980Swnj 	sb->sb_hiwat = cc;
39240706Skarels 	sb->sb_mbmax = min(cc * 2, sb_max);
39340706Skarels 	if (sb->sb_lowat > sb->sb_hiwat)
39440706Skarels 		sb->sb_lowat = sb->sb_hiwat;
3954917Swnj 	return (1);
3964903Swnj }
3974903Swnj 
3984903Swnj /*
3994903Swnj  * Free mbufs held by a socket, and reserved mbuf space.
4004903Swnj  */
4014903Swnj sbrelease(sb)
4024903Swnj 	struct sockbuf *sb;
4034903Swnj {
4044903Swnj 
4054903Swnj 	sbflush(sb);
4064980Swnj 	sb->sb_hiwat = sb->sb_mbmax = 0;
4074903Swnj }
4084903Swnj 
4094903Swnj /*
41016994Skarels  * Routines to add and remove
41116994Skarels  * data from an mbuf queue.
41225630Skarels  *
41325630Skarels  * The routines sbappend() or sbappendrecord() are normally called to
41425630Skarels  * append new mbufs to a socket buffer, after checking that adequate
41525630Skarels  * space is available, comparing the function sbspace() with the amount
41625630Skarels  * of data to be added.  sbappendrecord() differs from sbappend() in
41725630Skarels  * that data supplied is treated as the beginning of a new record.
41825630Skarels  * To place a sender's address, optional access rights, and data in a
41925630Skarels  * socket receive buffer, sbappendaddr() should be used.  To place
42025630Skarels  * access rights and data in a socket receive buffer, sbappendrights()
42125630Skarels  * should be used.  In either case, the new data begins a new record.
42225630Skarels  * Note that unlike sbappend() and sbappendrecord(), these routines check
42325630Skarels  * for the caller that there will be enough space to store the data.
42425630Skarels  * Each fails if there is not enough space, or if it cannot find mbufs
42525630Skarels  * to store additional information in.
42625630Skarels  *
42725630Skarels  * Reliable protocols may use the socket send buffer to hold data
42825630Skarels  * awaiting acknowledgement.  Data is normally copied from a socket
42925630Skarels  * send buffer in a protocol with m_copy for output to a peer,
43025630Skarels  * and then removing the data from the socket buffer with sbdrop()
43125630Skarels  * or sbdroprecord() when the data is acknowledged by the peer.
4324903Swnj  */
4334903Swnj 
4344903Swnj /*
43516994Skarels  * Append mbuf chain m to the last record in the
43616994Skarels  * socket buffer sb.  The additional space associated
43716994Skarels  * the mbuf chain is recorded in sb.  Empty mbufs are
43816994Skarels  * discarded and mbufs are compacted where possible.
4394903Swnj  */
4404903Swnj sbappend(sb, m)
44116994Skarels 	struct sockbuf *sb;
44216994Skarels 	struct mbuf *m;
4434903Swnj {
4446092Sroot 	register struct mbuf *n;
4454903Swnj 
44616994Skarels 	if (m == 0)
44716994Skarels 		return;
44816994Skarels 	if (n = sb->sb_mb) {
44935385Skarels 		while (n->m_nextpkt)
45035385Skarels 			n = n->m_nextpkt;
4516092Sroot 		while (n->m_next)
45240633Skarels 			if (n->m_flags & M_EOR) {
45340633Skarels 				sbappendrecord(sb, m); /* XXXXXX!!!! */
45440633Skarels 				return;
45540633Skarels 			} else
45640633Skarels 				n = n->m_next;
4574903Swnj 	}
45816994Skarels 	sbcompress(sb, m, n);
4594903Swnj }
4604903Swnj 
461*44384Skarels #ifdef SOCKBUF_DEBUG
462*44384Skarels sbcheck(sb)
463*44384Skarels 	register struct sockbuf *sb;
464*44384Skarels {
465*44384Skarels 	register struct mbuf *m;
466*44384Skarels 	register int len = 0, mbcnt = 0;
467*44384Skarels 
468*44384Skarels 	for (m = sb->sb_mb; m; m = m->m_next) {
469*44384Skarels 		len += m->m_len;
470*44384Skarels 		mbcnt += MSIZE;
471*44384Skarels 		if (m->m_flags & M_EXT)
472*44384Skarels 			mbcnt += m->m_ext.ext_size;
473*44384Skarels 		if (m->m_nextpkt)
474*44384Skarels 			panic("sbcheck nextpkt");
475*44384Skarels 	}
476*44384Skarels 	if (len != sb->sb_cc || mbcnt != sb->sb_mbcnt) {
477*44384Skarels 		printf("cc %d != %d || mbcnt %d != %d\n", len, sb->sb_cc,
478*44384Skarels 		    mbcnt, sb->sb_mbcnt);
479*44384Skarels 		panic("sbcheck");
480*44384Skarels 	}
481*44384Skarels }
482*44384Skarels #endif
483*44384Skarels 
4845169Swnj /*
48516994Skarels  * As above, except the mbuf chain
48616994Skarels  * begins a new record.
4875169Swnj  */
48816994Skarels sbappendrecord(sb, m0)
48916994Skarels 	register struct sockbuf *sb;
49016994Skarels 	register struct mbuf *m0;
4914928Swnj {
4924928Swnj 	register struct mbuf *m;
4934928Swnj 
49416994Skarels 	if (m0 == 0)
49516994Skarels 		return;
49616994Skarels 	if (m = sb->sb_mb)
49735385Skarels 		while (m->m_nextpkt)
49835385Skarels 			m = m->m_nextpkt;
49916994Skarels 	/*
50016994Skarels 	 * Put the first mbuf on the queue.
50116994Skarels 	 * Note this permits zero length records.
50216994Skarels 	 */
50316994Skarels 	sballoc(sb, m0);
50416994Skarels 	if (m)
50535385Skarels 		m->m_nextpkt = m0;
50616994Skarels 	else
50716994Skarels 		sb->sb_mb = m0;
50816994Skarels 	m = m0->m_next;
50916994Skarels 	m0->m_next = 0;
51037329Skarels 	if (m && (m0->m_flags & M_EOR)) {
51137329Skarels 		m0->m_flags &= ~M_EOR;
51237329Skarels 		m->m_flags |= M_EOR;
51337329Skarels 	}
51416994Skarels 	sbcompress(sb, m, m0);
51516994Skarels }
51616994Skarels 
51716994Skarels /*
51837329Skarels  * As above except that OOB data
51937329Skarels  * is inserted at the beginning of the sockbuf,
52037329Skarels  * but after any other OOB data.
52137329Skarels  */
52237329Skarels sbinsertoob(sb, m0)
52337329Skarels 	register struct sockbuf *sb;
52437329Skarels 	register struct mbuf *m0;
52537329Skarels {
52637329Skarels 	register struct mbuf *m;
52737329Skarels 	register struct mbuf **mp;
52837329Skarels 
52937329Skarels 	if (m0 == 0)
53037329Skarels 		return;
53137329Skarels 	for (mp = &sb->sb_mb; m = *mp; mp = &((*mp)->m_nextpkt)) {
53237329Skarels 	    again:
53337329Skarels 		switch (m->m_type) {
53437329Skarels 
53537329Skarels 		case MT_OOBDATA:
53637329Skarels 			continue;		/* WANT next train */
53737329Skarels 
53837329Skarels 		case MT_CONTROL:
53937329Skarels 			if (m = m->m_next)
54037329Skarels 				goto again;	/* inspect THIS train further */
54137329Skarels 		}
54237329Skarels 		break;
54337329Skarels 	}
54437329Skarels 	/*
54537329Skarels 	 * Put the first mbuf on the queue.
54637329Skarels 	 * Note this permits zero length records.
54737329Skarels 	 */
54837329Skarels 	sballoc(sb, m0);
54937329Skarels 	m0->m_nextpkt = *mp;
55037329Skarels 	*mp = m0;
55137329Skarels 	m = m0->m_next;
55237329Skarels 	m0->m_next = 0;
55337329Skarels 	if (m && (m0->m_flags & M_EOR)) {
55437329Skarels 		m0->m_flags &= ~M_EOR;
55537329Skarels 		m->m_flags |= M_EOR;
55637329Skarels 	}
55737329Skarels 	sbcompress(sb, m, m0);
55837329Skarels }
55937329Skarels 
56037329Skarels /*
56142259Skarels  * Append address and data, and optionally, control (ancillary) data
56235385Skarels  * to the receive queue of a socket.  If present,
56342259Skarels  * m0 must include a packet header with total length.
56442259Skarels  * Returns 0 if no space in sockbuf or insufficient mbufs.
56516994Skarels  */
56642259Skarels sbappendaddr(sb, asa, m0, control)
56716994Skarels 	register struct sockbuf *sb;
56816994Skarels 	struct sockaddr *asa;
56942259Skarels 	struct mbuf *m0, *control;
57016994Skarels {
57116994Skarels 	register struct mbuf *m, *n;
57237329Skarels 	int space = asa->sa_len;
57316994Skarels 
57435385Skarels if (m0 && (m0->m_flags & M_PKTHDR) == 0)
57535385Skarels panic("sbappendaddr");
57635385Skarels 	if (m0)
57735385Skarels 		space += m0->m_pkthdr.len;
57842259Skarels 	for (n = control; n; n = n->m_next) {
57942259Skarels 		space += n->m_len;
58042259Skarels 		if (n->m_next == 0)	/* keep pointer to last control buf */
58142259Skarels 			break;
58242259Skarels 	}
58316994Skarels 	if (space > sbspace(sb))
5844928Swnj 		return (0);
58542259Skarels 	if (asa->sa_len > MLEN)
58642259Skarels 		return (0);
58725630Skarels 	MGET(m, M_DONTWAIT, MT_SONAME);
58816994Skarels 	if (m == 0)
5894928Swnj 		return (0);
59037329Skarels 	m->m_len = asa->sa_len;
59137329Skarels 	bcopy((caddr_t)asa, mtod(m, caddr_t), asa->sa_len);
59242259Skarels 	if (n)
59342259Skarels 		n->m_next = m0;		/* concatenate data to control */
59442259Skarels 	else
59542259Skarels 		control = m0;
59642259Skarels 	m->m_next = control;
59742259Skarels 	for (n = m; n; n = n->m_next)
59842259Skarels 		sballoc(sb, n);
59916994Skarels 	if (n = sb->sb_mb) {
60035385Skarels 		while (n->m_nextpkt)
60135385Skarels 			n = n->m_nextpkt;
60235385Skarels 		n->m_nextpkt = m;
60316994Skarels 	} else
60416994Skarels 		sb->sb_mb = m;
60516994Skarels 	return (1);
60616994Skarels }
60716994Skarels 
60842259Skarels sbappendcontrol(sb, m0, control)
60916994Skarels 	struct sockbuf *sb;
61042259Skarels 	struct mbuf *control, *m0;
61116994Skarels {
61216994Skarels 	register struct mbuf *m, *n;
61316994Skarels 	int space = 0;
61416994Skarels 
61542259Skarels 	if (control == 0)
61642259Skarels 		panic("sbappendcontrol");
61742259Skarels 	for (m = control; ; m = m->m_next) {
61842259Skarels 		space += m->m_len;
61942259Skarels 		if (m->m_next == 0)
62042259Skarels 			break;
62142259Skarels 	}
62242259Skarels 	n = m;			/* save pointer to last control buffer */
62325630Skarels 	for (m = m0; m; m = m->m_next)
62416994Skarels 		space += m->m_len;
62516994Skarels 	if (space > sbspace(sb))
62612758Ssam 		return (0);
62742259Skarels 	n->m_next = m0;			/* concatenate data to control */
62842259Skarels 	for (m = control; m; m = m->m_next)
62942259Skarels 		sballoc(sb, m);
63016994Skarels 	if (n = sb->sb_mb) {
63135385Skarels 		while (n->m_nextpkt)
63235385Skarels 			n = n->m_nextpkt;
63342259Skarels 		n->m_nextpkt = control;
63416994Skarels 	} else
63542259Skarels 		sb->sb_mb = control;
6364928Swnj 	return (1);
6374928Swnj }
6384928Swnj 
6394903Swnj /*
64016994Skarels  * Compress mbuf chain m into the socket
64116994Skarels  * buffer sb following mbuf n.  If n
64216994Skarels  * is null, the buffer is presumed empty.
6434903Swnj  */
64416994Skarels sbcompress(sb, m, n)
64516994Skarels 	register struct sockbuf *sb;
64616994Skarels 	register struct mbuf *m, *n;
64716994Skarels {
64842259Skarels 	register int eor = 0;
64916994Skarels 
65016994Skarels 	while (m) {
65137329Skarels 		eor |= m->m_flags & M_EOR;
65216994Skarels 		if (m->m_len == 0) {
65316994Skarels 			m = m_free(m);
65416994Skarels 			continue;
65516994Skarels 		}
65637329Skarels 		if (n && (n->m_flags & (M_EXT | M_EOR)) == 0 &&
65735385Skarels 		    (n->m_data + n->m_len + m->m_len) < &n->m_dat[MLEN] &&
65825630Skarels 		    n->m_type == m->m_type) {
65916994Skarels 			bcopy(mtod(m, caddr_t), mtod(n, caddr_t) + n->m_len,
66016994Skarels 			    (unsigned)m->m_len);
66116994Skarels 			n->m_len += m->m_len;
66216994Skarels 			sb->sb_cc += m->m_len;
66316994Skarels 			m = m_free(m);
66416994Skarels 			continue;
66516994Skarels 		}
66616994Skarels 		if (n)
66716994Skarels 			n->m_next = m;
66816994Skarels 		else
66916994Skarels 			sb->sb_mb = m;
67037329Skarels 		sballoc(sb, m);
67116994Skarels 		n = m;
67237329Skarels 		m->m_flags &= ~M_EOR;
67316994Skarels 		m = m->m_next;
67416994Skarels 		n->m_next = 0;
67516994Skarels 	}
67637329Skarels 	if (n)
67737329Skarels 		n->m_flags |= eor;
67816994Skarels }
67916994Skarels 
68016994Skarels /*
68116994Skarels  * Free all mbufs in a sockbuf.
68216994Skarels  * Check that all resources are reclaimed.
68316994Skarels  */
6844903Swnj sbflush(sb)
68512758Ssam 	register struct sockbuf *sb;
6864903Swnj {
6874903Swnj 
6884903Swnj 	if (sb->sb_flags & SB_LOCK)
6894903Swnj 		panic("sbflush");
69026105Skarels 	while (sb->sb_mbcnt)
69126363Skarels 		sbdrop(sb, (int)sb->sb_cc);
69242259Skarels 	if (sb->sb_cc || sb->sb_mb)
6934903Swnj 		panic("sbflush 2");
6944903Swnj }
6954903Swnj 
6964903Swnj /*
69716994Skarels  * Drop data from (the front of) a sockbuf.
6984903Swnj  */
6994903Swnj sbdrop(sb, len)
7004903Swnj 	register struct sockbuf *sb;
7014903Swnj 	register int len;
7024903Swnj {
70316994Skarels 	register struct mbuf *m, *mn;
70416994Skarels 	struct mbuf *next;
7054903Swnj 
70635385Skarels 	next = (m = sb->sb_mb) ? m->m_nextpkt : 0;
7074903Swnj 	while (len > 0) {
70816994Skarels 		if (m == 0) {
70916994Skarels 			if (next == 0)
71016994Skarels 				panic("sbdrop");
71116994Skarels 			m = next;
71235385Skarels 			next = m->m_nextpkt;
71316994Skarels 			continue;
71416994Skarels 		}
7155064Swnj 		if (m->m_len > len) {
7164903Swnj 			m->m_len -= len;
71735385Skarels 			m->m_data += len;
7184903Swnj 			sb->sb_cc -= len;
7194903Swnj 			break;
7204903Swnj 		}
7215064Swnj 		len -= m->m_len;
7225064Swnj 		sbfree(sb, m);
7235064Swnj 		MFREE(m, mn);
7245064Swnj 		m = mn;
7254903Swnj 	}
72617331Skarels 	while (m && m->m_len == 0) {
72717417Skarels 		sbfree(sb, m);
72817331Skarels 		MFREE(m, mn);
72917331Skarels 		m = mn;
73017331Skarels 	}
73116994Skarels 	if (m) {
73216994Skarels 		sb->sb_mb = m;
73335385Skarels 		m->m_nextpkt = next;
73416994Skarels 	} else
73516994Skarels 		sb->sb_mb = next;
7364903Swnj }
73716994Skarels 
73816994Skarels /*
73916994Skarels  * Drop a record off the front of a sockbuf
74016994Skarels  * and move the next record to the front.
74116994Skarels  */
74216994Skarels sbdroprecord(sb)
74316994Skarels 	register struct sockbuf *sb;
74416994Skarels {
74516994Skarels 	register struct mbuf *m, *mn;
74616994Skarels 
74716994Skarels 	m = sb->sb_mb;
74816994Skarels 	if (m) {
74935385Skarels 		sb->sb_mb = m->m_nextpkt;
75016994Skarels 		do {
75116994Skarels 			sbfree(sb, m);
75216994Skarels 			MFREE(m, mn);
75316994Skarels 		} while (m = mn);
75416994Skarels 	}
75516994Skarels }
756