[apple/xnu.git] / bsd / netat / adsp_Open.c

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 * 
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */
/* adspOpen.c v01.20
 *
 * From v01.20 08/23/90 Mike Shoemaker for MacOS
 *    Modified for MP, 1996 by Tuyen Nguyen
 *   Modified, April 9, 1997 by Tuyen Nguyen for MacOSX.
 */

#include <sys/errno.h>
#include <sys/types.h>
#include <sys/param.h>
#include <machine/spl.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/proc.h>
#include <sys/filedesc.h>
#include <sys/fcntl.h>
#include <sys/mbuf.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <sys/time.h>

#include <netat/sysglue.h>
#include <netat/appletalk.h>
#include <netat/at_pcb.h>
#include <netat/debug.h>
#include <netat/adsp.h>
#include <netat/adsp_internal.h>

extern int *adsp_pidM;


/*
 * NextCID
 * 
 * Create a unique connection ID.
 *
 * INPUTS:
 * 		none
 * OUTPUTS:
 * 		unique connection ID
 */

unsigned short NextCID(void)
{
	unsigned short num;
	register CCB *queue;

	while (1) {
	    num = ++adspGlobal.lastCID;
	    /* qfind_w below is in 68K assembly */
	    /* point to the first element */
	    queue = (CCB *)AT_ADSP_STREAMS;
	    while (queue) {
		    /* and scan .. */
		    if (queue->locCID == num)
			break;
		    queue = queue->ccbLink;
	    }
	    if (queue == (CCBPtr)NULL)
		break;	
	}
	return num;
}

static	byte xlateStateTbl[4] =	/* The value to be given to the CCB's state. */
{				/* indexed by ocMode */
	sOpening,		/* ocRequest */
	sPassive,		/* ocPassive */
	sOpening,		/* ocAccept */
	sOpen			/* ocEstablish */
};
static	byte xlateOpenTbl[4] =	/* Value to use for open state. */
{				/* indexed by ocMode */
	O_STATE_OPENWAIT,	/* ocRequest */
	O_STATE_LISTEN,		/* ocPassive */
	O_STATE_ESTABLISHED,	/* ocAccept */
	O_STATE_OPEN		/* ocEstablish */
};

/*
 * adspOpen
 * 
 * INPUTS:
 * 	-->	ccbRefNum	refnum of connection end
 *	-->	remoteCID	connection id of remote connection end
 *	-->	remoteAddress	internet address of remote connection end
 *	-->	filterAddress	filter for incoming open connection requests
 *	-->	sendSeq		initial send sequence number to use
 *	-->	sendWindow	initial size of remote end's receive buffer
 *	--> 	recvSeq		initial receive sequence number to use
 *	--> 	attnSendSeq	initial attention send sequence number
 *	-->	attnRecvSeq	initial receive sequence number
 *	-->	ocMode		connection opening mode
 *	-->	ocMaximum	maximum retries of open connection request
 *
 * OUTPUTS:
 *	<--	localCID	connection identifier of this connection end
 *	<--	remoteCID	connection id of remote connection end
 *	<--	remoteAddress
 *	<--	sendSeq
 *	<-- 	sendWindow
 *	<--	attnSendSeq
 *
 * ERRORS:
 *		errRefNum	bad connection refnum
 *		errState	connection end must be closed
 *		errOpening	open connection attempt failed
 *		errAborted	request aborted by a remove or close call
 */
int adspOpen(sp, pb)		/* (DSPPBPtr pb) */
    register CCBPtr sp;
    register struct adspcmd *pb;
{
    int ocMode;
    register gbuf_t *mp;

    if (sp == 0) {
	pb->ioResult = errRefNum; /* Unknown refnum */
	return EINVAL;
    }
	
    if ((sp->state != sClosed) || 
	(sp->removing)) { /* The CCB must be closed */
	pb->ioResult = errState;
	return EALREADY;
    }

    ocMode = pb->u.openParams.ocMode; /* get a local copy of open mode */
	if (ocMode == ocRequest)
		adsp_pidM[pb->socket] = 0;
	
    /*
     * Save parameters.  Fill in defaults if zero
     */
    if (pb->u.openParams.ocInterval)
	sp->openInterval = pb->u.openParams.ocInterval;
    else
	sp->openInterval = ocIntervalDefault;
    
    if (pb->u.openParams.ocMaximum)
	sp->openRetrys = pb->u.openParams.ocMaximum;
    else
	sp->openRetrys = ocMaximumDefault;
    
    sp->remoteAddress = *((AddrUnionPtr)&pb->u.openParams.remoteAddress);
    /* Not used for passive */
    /*
     * Clear out send/receive buffers.
     */
    if (sp->sbuf_mb) { /* clear the send queue */
	gbuf_freel(sp->sbuf_mb);
	sp->sbuf_mb = 0;
    }
    if (sp->csbuf_mb) {
	gbuf_freem(sp->csbuf_mb);
	sp->csbuf_mb = 0;
    }
    if (sp->rbuf_mb) { /* clear the receive queue */
	gbuf_freel(sp->rbuf_mb);
	sp->rbuf_mb = 0;
    }
    if (sp->crbuf_mb) {
	gbuf_freem(sp->crbuf_mb);
	sp->crbuf_mb = 0;
    }

    sp->rData = 0;		/* Flag both buffers as empty */
    sp->sData = 0;
    sp->recvQPending = 0;	/* No bytes in receive queue */
    
    /*
     * Clear all of those pesky flags
     */
    sp->userFlags = 0;
    sp->sendDataAck = 0;
    sp->sendAttnAck = 0;
    sp->sendAttnData = 0;
    sp->callSend = 0;
    sp->removing = 0;
    sp->writeFlush = 0;
	
    /*
     * Reset round-trip timers
     */
    sp->roundTrip = sp->rtmtInterval;
    sp->deviation = 0;
    
    /*
     * Reset stuff for retransmit advice packet
     */
    sp->badSeqCnt = 0;
    /*
     * Reset flow control variables
     */
    sp->pktSendMax = 1;	/* Slow start says we should set this to 1 */
    sp->pktSendCnt = 0;
    sp->rbufFull = 0;
    sp->resentData = 0;
    sp->noXmitFlow = 0;
    sp->waitingAck = 0;
    
    /*
     * Copy required information out of parameter block
     */
    if (ocMode == ocAccept || ocMode == ocEstablish) {
	sp->remCID = pb->u.openParams.remoteCID;
	sp->sendSeq = sp->firstRtmtSeq = pb->u.openParams.sendSeq;
	sp->sendWdwSeq = sp->sendSeq + pb->u.openParams.sendWindow;
	sp->attnSendSeq = pb->u.openParams.attnSendSeq;
    } else {			/* accept or establish */
	sp->remCID = 0;
	sp->sendSeq = 0;
	sp->sendWdwSeq = 0;
	sp->attnSendSeq = 0;
    }
	
    if (ocMode == ocEstablish) { /* Only set these if establish mode */
	sp->recvSeq = pb->u.openParams.recvSeq;
	sp->attnRecvSeq = pb->u.openParams.attnRecvSeq;
	UAS_ASSIGN_HTON(sp->f.CID, sp->locCID); /* Preset the CID in the ADSP header */
	/* This is done elsewhere for all other modes */
	InsertTimerElem(&adspGlobal.slowTimers, &sp->ProbeTimer, 
			sp->probeInterval);
    } else {			/* establish */
	/* All other modes need a CID assigned */
	sp->locCID = NextCID();
	sp->recvSeq = 0;
	sp->attnRecvSeq = 0;
    }

    /*
     * Now set the state variables for this CCB.  
     */

    sp->openState = xlateOpenTbl[ocMode-ocRequest];
    sp->state = xlateStateTbl[ocMode-ocRequest];
	
    if (ocMode == ocEstablish) { /* For establish call, we're done */
	pb->ioResult = 0;
	adspioc_ack(0, (gbuf_t *)pb->ioc, pb->gref);
	return 0;
    }
    
    pb->qLink = 0;		/* Clear link field before putting on queue */
    mp = gbuf_copym(pb->mp);	/* Save parameter block to match later */
    
    if (mp == 0) {
	    pb->ioResult = errDSPQueueSize;
	    return ENOBUFS;
    }
    pb->ioResult = 1;	/* not open -> not done */
    adspioc_ack(0, (gbuf_t *)pb->ioc, pb->gref); /* release user */
    sp->opb = (struct adspcmd *)gbuf_rptr(mp);
    sp->opb->ioc = 0;		/* unlink saved pb from ioctl block */
    sp->opb->mp = mp;

    /*
     * For request & accept, need to send a packet
     */
    if ((ocMode == ocRequest) || (ocMode == ocAccept)) {
	sp->sendCtl |= (1 << (ocMode == ocRequest ? 
			      ADSP_CTL_OREQ : ADSP_CTL_OREQACK));
	CheckSend(sp);
    }
    return 0;
}

int adspMode(pb)
    register struct adspcmd *pb;
{
    return pb->u.openParams.ocMode;
}
Commit	Line	Data
1c79356b	1	/*
5d5c5d0d A	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
5d5c5d0d A	3	*
2d21ac55	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
1c79356b	5	*
2d21ac55 A	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. The rights granted to you under the License
	10	* may not be used to create, or enable the creation or redistribution of,
	11	* unlawful or unlicensed copies of an Apple operating system, or to
	12	* circumvent, violate, or enable the circumvention or violation of, any
	13	* terms of an Apple operating system software license agreement.
8f6c56a5	14	*
2d21ac55 A	15	* Please obtain a copy of the License at
	16	* http://www.opensource.apple.com/apsl/ and read it before using this file.
	17	*
	18	* The Original Code and all software distributed under the License are
	19	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
8f6c56a5 A	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
8f6c56a5 A	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
2d21ac55 A	22	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	23	* Please see the License for the specific language governing rights and
	24	* limitations under the License.
8f6c56a5	25	*
2d21ac55	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
1c79356b A	27	*/
	28	/* adspOpen.c v01.20
	29	*
	30	* From v01.20 08/23/90 Mike Shoemaker for MacOS
	31	* Modified for MP, 1996 by Tuyen Nguyen
	32	* Modified, April 9, 1997 by Tuyen Nguyen for MacOSX.
	33	*/
	34
	35	#include <sys/errno.h>
	36	#include <sys/types.h>
	37	#include <sys/param.h>
	38	#include <machine/spl.h>
	39	#include <sys/systm.h>
	40	#include <sys/kernel.h>
	41	#include <sys/proc.h>
	42	#include <sys/filedesc.h>
	43	#include <sys/fcntl.h>
	44	#include <sys/mbuf.h>
	45	#include <sys/socket.h>
	46	#include <sys/socketvar.h>
	47	#include <sys/time.h>
	48
	49	#include <netat/sysglue.h>
	50	#include <netat/appletalk.h>
	51	#include <netat/at_pcb.h>
	52	#include <netat/debug.h>
	53	#include <netat/adsp.h>
	54	#include <netat/adsp_internal.h>
	55
2d21ac55 A	56	extern int *adsp_pidM;
2d21ac55 A	57
1c79356b A	58
	59	/*
	60	* NextCID
	61	*
	62	* Create a unique connection ID.
	63	*
	64	* INPUTS:
	65	* none
	66	* OUTPUTS:
	67	* unique connection ID
	68	*/
2d21ac55 A	69
2d21ac55 A	70	unsigned short NextCID(void)
1c79356b	71	{
1c79356b A	72	unsigned short num;
	73	register CCB *queue;
	74
	75	while (1) {
1c79356b A	76	num = ++adspGlobal.lastCID;
	77	/* qfind_w below is in 68K assembly */
	78	/* point to the first element */
	79	queue = (CCB *)AT_ADSP_STREAMS;
	80	while (queue) {
	81	/* and scan .. */
	82	if (queue->locCID == num)
	83	break;
	84	queue = queue->ccbLink;
	85	}
1c79356b A	86	if (queue == (CCBPtr)NULL)
	87	break;
	88	}
	89	return num;
	90	}
	91
	92	static byte xlateStateTbl[4] = /* The value to be given to the CCB's state. */
	93	{ /* indexed by ocMode */
	94	sOpening, /* ocRequest */
	95	sPassive, /* ocPassive */
	96	sOpening, /* ocAccept */
	97	sOpen /* ocEstablish */
	98	};
	99	static byte xlateOpenTbl[4] = /* Value to use for open state. */
	100	{ /* indexed by ocMode */
	101	O_STATE_OPENWAIT, /* ocRequest */
	102	O_STATE_LISTEN, /* ocPassive */
	103	O_STATE_ESTABLISHED, /* ocAccept */
	104	O_STATE_OPEN /* ocEstablish */
	105	};
	106
	107	/*
	108	* adspOpen
	109	*
	110	* INPUTS:
	111	* --> ccbRefNum refnum of connection end
	112	* --> remoteCID connection id of remote connection end
	113	* --> remoteAddress internet address of remote connection end
	114	* --> filterAddress filter for incoming open connection requests
	115	* --> sendSeq initial send sequence number to use
	116	* --> sendWindow initial size of remote end's receive buffer
	117	* --> recvSeq initial receive sequence number to use
	118	* --> attnSendSeq initial attention send sequence number
	119	* --> attnRecvSeq initial receive sequence number
	120	* --> ocMode connection opening mode
	121	* --> ocMaximum maximum retries of open connection request
	122	*
	123	* OUTPUTS:
	124	* <-- localCID connection identifier of this connection end
	125	* <-- remoteCID connection id of remote connection end
	126	* <-- remoteAddress
	127	* <-- sendSeq
	128	* <-- sendWindow
	129	* <-- attnSendSeq
	130	*
	131	* ERRORS:
	132	* errRefNum bad connection refnum
	133	* errState connection end must be closed
	134	* errOpening open connection attempt failed
	135	* errAborted request aborted by a remove or close call
	136	*/
	137	int adspOpen(sp, pb) /* (DSPPBPtr pb) */
	138	register CCBPtr sp;
	139	register struct adspcmd *pb;
	140	{
1c79356b A	141	int ocMode;
	142	register gbuf_t *mp;
	143
	144	if (sp == 0) {
	145	pb->ioResult = errRefNum; /* Unknown refnum */
	146	return EINVAL;
	147	}
	148
	149	if ((sp->state != sClosed) \|\|
	150	(sp->removing)) { /* The CCB must be closed */
	151	pb->ioResult = errState;
	152	return EALREADY;
	153	}
	154
	155	ocMode = pb->u.openParams.ocMode; /* get a local copy of open mode */
	156	if (ocMode == ocRequest)
	157	adsp_pidM[pb->socket] = 0;
	158
	159	/*
	160	* Save parameters. Fill in defaults if zero
	161	*/
	162	if (pb->u.openParams.ocInterval)
	163	sp->openInterval = pb->u.openParams.ocInterval;
	164	else
	165	sp->openInterval = ocIntervalDefault;
	166
	167	if (pb->u.openParams.ocMaximum)
	168	sp->openRetrys = pb->u.openParams.ocMaximum;
	169	else
	170	sp->openRetrys = ocMaximumDefault;
	171
	172	sp->remoteAddress = *((AddrUnionPtr)&pb->u.openParams.remoteAddress);
	173	/* Not used for passive */
	174	/*
	175	* Clear out send/receive buffers.
	176	*/
	177	if (sp->sbuf_mb) { /* clear the send queue */
	178	gbuf_freel(sp->sbuf_mb);
	179	sp->sbuf_mb = 0;
	180	}
	181	if (sp->csbuf_mb) {
	182	gbuf_freem(sp->csbuf_mb);
	183	sp->csbuf_mb = 0;
	184	}
	185	if (sp->rbuf_mb) { /* clear the receive queue */
	186	gbuf_freel(sp->rbuf_mb);
	187	sp->rbuf_mb = 0;
	188	}
	189	if (sp->crbuf_mb) {
	190	gbuf_freem(sp->crbuf_mb);
	191	sp->crbuf_mb = 0;
	192	}
	193
	194	sp->rData = 0; /* Flag both buffers as empty */
	195	sp->sData = 0;
	196	sp->recvQPending = 0; /* No bytes in receive queue */
	197
	198	/*
	199	* Clear all of those pesky flags
	200	*/
	201	sp->userFlags = 0;
	202	sp->sendDataAck = 0;
	203	sp->sendAttnAck = 0;
	204	sp->sendAttnData = 0;
205	sp->callSend = 0;
206	sp->removing = 0;
207	sp->writeFlush = 0;
208
209	/*
210	* Reset round-trip timers
211	*/
212	sp->roundTrip = sp->rtmtInterval;
213	sp->deviation = 0;
214
215	/*
216	* Reset stuff for retransmit advice packet
217	*/
218	sp->badSeqCnt = 0;
219	/*
220	* Reset flow control variables
221	*/
222	sp->pktSendMax = 1; /* Slow start says we should set this to 1 */
223	sp->pktSendCnt = 0;
224	sp->rbufFull = 0;
225	sp->resentData = 0;
226	sp->noXmitFlow = 0;
227	sp->waitingAck = 0;
228
229	/*
230	* Copy required information out of parameter block
231	*/
232	if (ocMode == ocAccept \|\| ocMode == ocEstablish) {
233	sp->remCID = pb->u.openParams.remoteCID;
234	sp->sendSeq = sp->firstRtmtSeq = pb->u.openParams.sendSeq;
235	sp->sendWdwSeq = sp->sendSeq + pb->u.openParams.sendWindow;
236	sp->attnSendSeq = pb->u.openParams.attnSendSeq;
237	} else { /* accept or establish */
238	sp->remCID = 0;
239	sp->sendSeq = 0;
240	sp->sendWdwSeq = 0;
241	sp->attnSendSeq = 0;
242	}
243
244	if (ocMode == ocEstablish) { /* Only set these if establish mode */
245	sp->recvSeq = pb->u.openParams.recvSeq;
246	sp->attnRecvSeq = pb->u.openParams.attnRecvSeq;
0c530ab8	247	UAS_ASSIGN_HTON(sp->f.CID, sp->locCID); /* Preset the CID in the ADSP header */
1c79356b A	248	/* This is done elsewhere for all other modes */
	249	InsertTimerElem(&adspGlobal.slowTimers, &sp->ProbeTimer,
	250	sp->probeInterval);
	251	} else { /* establish */
	252	/* All other modes need a CID assigned */
	253	sp->locCID = NextCID();
	254	sp->recvSeq = 0;
	255	sp->attnRecvSeq = 0;
	256	}
	257
	258	/*
	259	* Now set the state variables for this CCB.
	260	*/
	261
	262	sp->openState = xlateOpenTbl[ocMode-ocRequest];
	263	sp->state = xlateStateTbl[ocMode-ocRequest];
	264
	265	if (ocMode == ocEstablish) { /* For establish call, we're done */
	266	pb->ioResult = 0;
2d21ac55	267	adspioc_ack(0, (gbuf_t *)pb->ioc, pb->gref);
1c79356b A	268	return 0;
	269	}
	270
	271	pb->qLink = 0; /* Clear link field before putting on queue */
	272	mp = gbuf_copym(pb->mp); /* Save parameter block to match later */
	273
	274	if (mp == 0) {
	275	pb->ioResult = errDSPQueueSize;
	276	return ENOBUFS;
	277	}
	278	pb->ioResult = 1; /* not open -> not done */
2d21ac55	279	adspioc_ack(0, (gbuf_t )pb->ioc, pb->gref); / release user */
1c79356b A	280	sp->opb = (struct adspcmd *)gbuf_rptr(mp);
	281	sp->opb->ioc = 0; /* unlink saved pb from ioctl block */
	282	sp->opb->mp = mp;
	283
	284	/*
	285	* For request & accept, need to send a packet
	286	*/
	287	if ((ocMode == ocRequest) \|\| (ocMode == ocAccept)) {
	288	sp->sendCtl \|= (1 << (ocMode == ocRequest ?
	289	ADSP_CTL_OREQ : ADSP_CTL_OREQACK));
	290	CheckSend(sp);
	291	}
	292	return 0;
	293	}
	294
	295	int adspMode(pb)
	296	register struct adspcmd *pb;
	297	{
	298	return pb->u.openParams.ocMode;
	299	}