uipc_sock2.c

完整的TCP/IP源代码

/* 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 # 22966
01e,19sep97,vin  changed m_ext.ext_size to m_extSize
01d,11aug97,vin  adjusted sb_max to 5 *cc and low water mark to CL_SIZE_64
01c,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.
 */

void
soisconnecting(so)
	register struct socket *so;
{

	so->so_state &= ~(SS_ISCONNECTED|SS_ISDISCONNECTING);
	so->so_state |= SS_ISCONNECTING;
}

void
soisconnected(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);
	}
}

void
soisdisconnecting(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);
}

void
soisdisconnected(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);
}

void
soqinsque(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;
}

int
soqremque(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.
 */

void
socantsendmore(so)
	struct socket *so;
{

	so->so_state |= SS_CANTSENDMORE;
	sowwakeup(so);
}

void
socantrcvmore(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.
 */
void
sbwait(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).
 */
int
sb_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