/* uipc_sock2.c - uipc primitive socket routines *//* Copyright 1984-1996 Wind River Systems, Inc. */#include "copyright_wrs.h"/* * Copyright (c) 1982, 1986, 1988, 1990, 1993 *	The Regents of the University of California.  All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright *    notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright *    notice, this list of conditions and the following disclaimer in the *    documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software *    must display the following acknowledgement: *	This product includes software developed by the University of *	California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors *    may be used to endorse or promote products derived from this software *    without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * *	@(#)uipc_socket2.c	8.2 (Berkeley) 2/14/95 *//*modification history--------------------01f,12nov98,n_s  fixed sbcompress to work with netBufLib buffers. spr # 2296601e,19sep97,vin  changed m_ext.ext_size to m_extSize01d,11aug97,vin  adjusted sb_max to 5 *cc and low water mark to CL_SIZE_6401c,03dec96,vin	 changed calloc(..) to MALLOC(..) and free(..) to FREE(..)		 to use network buffers.01b,22nov96,vin	 added cluster support, replace m_get(..) with mBufClGet(..). 01a,03mar96,vin  created from BSD4.4lite2. Integrated with 02t of uipc_sock2.c*//*DESCRIPTION*/#ifdef BSDUNIX44 #include <sys/param.h>#include <sys/systm.h>#include <sys/proc.h>#include <sys/file.h>#include <sys/buf.h>#include <sys/malloc.h>#include <sys/mbuf.h>#include <sys/protosw.h>#include <sys/socket.h>#include <sys/socketvar.h>#else#include "vxWorks.h"#include "semLib.h"#include "memLib.h"#include "errno.h"#include "net/mbuf.h"#include "net/protosw.h"#include "sys/socket.h"#include "net/socketvar.h"#include "net/systm.h"#include "net/unixLib.h"#endif /* BSDUNIX44 *//* globals */VOIDFUNCPTR sowakeupHook = NULL;	/* user callback in sowakeup() */u_long	sb_max = SB_MAX;		/* patchable max socket buffer size*//* * Primitive routines for operating on sockets and socket buffers *//* * Procedures to manipulate state flags of socket * and do appropriate wakeups.  Normal sequence from the * active (originating) side is that soisconnecting() is * called during processing of connect() call, * resulting in an eventual call to soisconnected() if/when the * connection is established.  When the connection is torn down * soisdisconnecting() is called during processing of disconnect() call, * and soisdisconnected() is called when the connection to the peer * is totally severed.  The semantics of these routines are such that * connectionless protocols can call soisconnected() and soisdisconnected() * only, bypassing the in-progress calls when setting up a ``connection'' * takes no time. * * From the passive side, a socket is created with * two queues of sockets: so_q0 for connections in progress * and so_q for connections already made and awaiting user acceptance. * As a protocol is preparing incoming connections, it creates a socket * structure queued on so_q0 by calling sonewconn().  When the connection * is established, soisconnected() is called, and transfers the * socket structure to so_q, making it available to accept(). *  * If a socket is closed with sockets on either * so_q0 or so_q, these sockets are dropped. * * If higher level protocols are implemented in * the kernel, the wakeups done here will sometimes * cause software-interrupt process scheduling. */voidsoisconnecting(so)	register struct socket *so;{	so->so_state &= ~(SS_ISCONNECTED|SS_ISDISCONNECTING);	so->so_state |= SS_ISCONNECTING;}voidsoisconnected(so)	register struct socket *so;{	register struct socket *head = so->so_head;	so->so_state &= ~(SS_ISCONNECTING|SS_ISDISCONNECTING|SS_ISCONFIRMING);	so->so_state |= SS_ISCONNECTED;	if (head && soqremque(so, 0)) {		soqinsque(head, so, 1);		sorwakeup(head);		wakeup(&head->so_timeoSem);	} else {	        wakeup(&so->so_timeoSem);		sorwakeup(so);		sowwakeup(so);	}}voidsoisdisconnecting(so)	register struct socket *so;{	so->so_state &= ~SS_ISCONNECTING;	so->so_state |= (SS_ISDISCONNECTING|SS_CANTRCVMORE|SS_CANTSENDMORE);	wakeup(&so->so_timeoSem);	sowwakeup(so);	sorwakeup(so);}voidsoisdisconnected(so)	register struct socket *so;{	so->so_state &= ~(SS_ISCONNECTING|SS_ISCONNECTED|SS_ISDISCONNECTING);	so->so_state |= (SS_CANTRCVMORE|SS_CANTSENDMORE);	wakeup(&so->so_timeoSem);	sowwakeup(so);	sorwakeup(so);}/* * When an attempt at a new connection is noted on a socket * which accepts connections, sonewconn is called.  If the * connection is possible (subject to space constraints, etc.) * then we allocate a new structure, propoerly linked into the * data structure of the original socket, and return this. * Connstatus may be 0, or SO_ISCONFIRMING, or SO_ISCONNECTED. * * Currently, sonewconn() is defined as sonewconn1() in socketvar.h * to catch calls that are missing the (new) second parameter. */struct socket *sonewconn1(head, connstatus)	register struct socket *head;	int connstatus;{	register struct socket *so;	int soqueue = connstatus ? 1 : 0;	if (head->so_qlen + head->so_q0len > 3 * head->so_qlimit / 2)		return ((struct socket *)0);        MALLOC(so, struct socket *, sizeof(*so), MT_SOCKET, M_DONTWAIT);        if (so == NULL)                return ((struct socket *)0);        bzero((caddr_t)so, sizeof(*so));	so->so_type = head->so_type;	so->so_options = head->so_options &~ SO_ACCEPTCONN;	so->so_linger = head->so_linger;	so->so_state = head->so_state | SS_NOFDREF;	so->so_proto = head->so_proto;	so->so_timeo = head->so_timeo;	so->so_pgrp = head->so_pgrp;	/* initialize the socket's semaphores */	semBInit (&so->so_timeoSem, SEM_Q_PRIORITY, SEM_EMPTY);	semBInit (&so->so_rcv.sb_Sem, SEM_Q_PRIORITY, SEM_EMPTY);	semBInit (&so->so_snd.sb_Sem, SEM_Q_PRIORITY, SEM_EMPTY);        /* initialize the select stuff */	selWakeupListInit (&so->so_selWakeupList);	(void) soreserve(so, head->so_snd.sb_hiwat, head->so_rcv.sb_hiwat);	soqinsque(head, so, soqueue);	if ((*so->so_proto->pr_usrreq)(so, PRU_ATTACH,	    (struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0)) {		(void) soqremque(so, soqueue);		FREE(so, MT_SOCKET);		return ((struct socket *)0);	}	if (connstatus) {		sorwakeup(head);		wakeup(&head->so_timeoSem);		so->so_state |= connstatus;	}	return (so);}voidsoqinsque(head, so, q)	register struct socket *head, *so;	int q;{	register struct socket **prev;	so->so_head = head;	if (q == 0) {		head->so_q0len++;		so->so_q0 = 0;		for (prev = &(head->so_q0); *prev; )			prev = &((*prev)->so_q0);	} else {		head->so_qlen++;		so->so_q = 0;		for (prev = &(head->so_q); *prev; )			prev = &((*prev)->so_q);	}	*prev = so;}intsoqremque(so, q)	register struct socket *so;	int q;{	register struct socket *head, *prev, *next;	head = so->so_head;	prev = head;	for (;;) {		next = q ? prev->so_q : prev->so_q0;		if (next == so)			break;		if (next == 0)			return (0);		prev = next;	}	if (q == 0) {		prev->so_q0 = next->so_q0;		head->so_q0len--;	} else {		prev->so_q = next->so_q;		head->so_qlen--;	}	next->so_q0 = next->so_q = 0;	next->so_head = 0;	return (1);}/* * Socantsendmore indicates that no more data will be sent on the * socket; it would normally be applied to a socket when the user * informs the system that no more data is to be sent, by the protocol * code (in case PRU_SHUTDOWN).  Socantrcvmore indicates that no more data * will be received, and will normally be applied to the socket by a * protocol when it detects that the peer will send no more data. * Data queued for reading in the socket may yet be read. */voidsocantsendmore(so)	struct socket *so;{	so->so_state |= SS_CANTSENDMORE;	sowwakeup(so);}voidsocantrcvmore(so)	struct socket *so;{	so->so_state |= SS_CANTRCVMORE;	sorwakeup(so);}/* * Queue a process for a select on a socket buffer. */sbselqueue(so, sb, wakeupNode)	struct socket *so;        struct sockbuf *sb;	SEL_WAKEUP_NODE *wakeupNode;{	if (selNodeAdd (&so->so_selWakeupList, wakeupNode) == ERROR)	    return;	/* this is race free ONLY if we assume we're at splnet - rdc */	sb->sb_sel = (struct proc *) 1;}sbseldequeue(so, sb, wakeupNode)    struct socket *so;    struct sockbuf *sb;    SEL_WAKEUP_NODE *wakeupNode;    {    selNodeDelete (&so->so_selWakeupList, wakeupNode);    /* this is race free ONLY if we assume we're at splnet - rdc */    if (selWakeupListLen (&so->so_selWakeupList) == 0)	sb->sb_sel = (struct proc *) 0;    }/* * Wait for data to arrive at/drain from a socket buffer. */voidsbwait(sb)	struct sockbuf *sb;{	sb->sb_want++;	sb->sb_flags |= SB_WAIT;	ksleep (&sb->sb_Sem);}/*  * Lock a sockbuf already known to be locked; * return any error returned from sleep (EINTR). */intsb_lock(sb)	register struct sockbuf *sb;{	while (sb->sb_flags & SB_LOCK) {		sb->sb_flags |= SB_WANT;		ksleep(&sb->sb_Sem);	}	sb->sb_flags |= SB_LOCK;	return (0);}/* * Wakeup processes waiting on a socket buffer. */void sbwakeup(so, sb, wakeupType)	struct socket *so;	register struct sockbuf *sb;	SELECT_TYPE wakeupType;{	if (sb->sb_want > 0)	    {	    sb->sb_want--;	    wakeup(&sb->sb_Sem);	    }        else	    sb->sb_want = 0;	if (sb->sb_sel) {	    /* wake up everybody on selectTask List */	    /* assume this is running in netTask context */	    selWakeupAll (&so->so_selWakeupList, wakeupType);	    }}/* * Wakeup socket readers and writers. *//* ARGSUSED */void sowakeup(so, sb, wakeupType)	struct socket *so;	struct sockbuf *sb;	SELECT_TYPE wakeupType;{        sbwakeup(so, sb, wakeupType);	/* user callback, instead of full signals implementation */	if (sowakeupHook != NULL)	     (*sowakeupHook) (so, wakeupType);#ifdef	BERKELEY	/* XXX one day asynchronous IO will work... -gae */        register struct proc *p;        if (so->so_state & SS_ASYNC) {                if (so->so_pgrp < 0)                        gsignal(-so->so_pgrp, SIGIO);                else if (so->so_pgrp > 0 && (p = pfind(so->so_pgrp)) != 0)                        psignal(p, SIGIO);        }#endif	/* BERKELEY */}/* * Socket buffer (struct sockbuf) utility routines. * * Each socket contains two socket buffers: one for sending data and * one for receiving data.  Each buffer contains a queue of mbufs, * information about the number of mbufs and amount of data in the * queue, and other fields allowing select() statements and notification * on data availability to be implemented. * * Data stored in a socket buffer is maintained as a list of records. * Each record is a list of mbufs chained together with the m_next * field.  Records are chained together with the m_nextpkt field. The upper * level routine soreceive() expects the following conventions to be * observed when placing information in the receive buffer: * * 1. If the protocol requires each message be preceded by the sender's *    name, then a record containing that name must be present before *    any associated data (mbuf's must be of type MT_SONAME). * 2. If the protocol supports the exchange of ``access rights'' (really *    just additional data associated with the message), and there are *    ``rights'' to be received, then a record containing this data *    should be present (mbuf's must be of type MT_RIGHTS). * 3. If a name or rights record exists, then it must be followed by