[apple/xnu.git] / bsd / netat / adsp_Write.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@
 */
/* dspWrite.c 
 * From Mike Shoemaker v01.13 06/21/90 mbs for MacOS
 */
/*
 * Change log:
 *   06/29/95 - Modified to handle flow control for writing (Tuyen Nguyen)
 *   09/07/95 - Modified for performance (Tuyen Nguyen)
 *    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 <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>

void completepb();

/*
 * FillSendQueue
 * 
 * INPUTS:
 * 		sp	stream
 * OUTPUTS:
 * 		none
 */
int FillSendQueue(sp, pb)		/* (CCBPtr sp) */
    register CCBPtr sp;
    register struct adspcmd *pb; /* The write PB we're playing with */
{
	gbuf_t *mb, *nmb;
	int eom;		/* True if should set eom in header */
	int cnt;		/* # of bytes in this write */
	int err = 0;

	cnt = pb->u.ioParams.reqCount - pb->u.ioParams.actCount;
	eom = pb->u.ioParams.eom ? F_EOM : 0;

	if (cnt == 0 && eom == 0)	/* Nothing to do here, complete it */
	  	goto unlink;

	/* The 1st mbuf in the pb->mp chain (mb) is the adspcmd structure. 
	   The 2nd mbuf (nmb) will be the beginning of the data. */
	mb = pb->mp;
	nmb = gbuf_cont(mb);
	if (gbuf_len(mb) > sizeof(struct adspcmd)) {
	    if ((nmb = gbuf_dupb(mb)) == 0) {
		gbuf_wset(mb,sizeof(struct adspcmd));
		err = errDSPQueueSize;
		goto unlink;
	    }
	    gbuf_wset(mb,sizeof(struct adspcmd));
	    gbuf_rinc(nmb,sizeof(struct adspcmd));
	    gbuf_cont(nmb) = gbuf_cont(mb);
	} else if (nmb == 0) {
	    if ((nmb = gbuf_alloc(1, PRI_LO)) == 0) {
		err = errENOBUFS;
		goto unlink;
	    }
	}
	gbuf_cont(mb) = 0;

	sp->sData = 1;		/* note that there is data to send */
	if ((mb = sp->csbuf_mb)) {	/* add to the current message */
	    gbuf_linkb(mb, nmb);
	} else
	    sp->csbuf_mb = nmb;	/* mark the buffer we are currently filling */
	if (eom) {
	    if ((mb = sp->sbuf_mb)) {
		while (gbuf_next(mb))
		    mb = gbuf_next(mb);
		gbuf_next(mb) = sp->csbuf_mb; /* add the current item */
	    } else
		sp->sbuf_mb = sp->csbuf_mb;
	    sp->csbuf_mb = 0;	/* if its done, no current buffer */
	}
	pb->u.ioParams.actCount += cnt; /* Update count field in param blk */
	
	if (pb->u.ioParams.actCount == pb->u.ioParams.reqCount) {
	    /* Write is complete */
unlink:
	    if (pb->u.ioParams.flush) /* flush the send Q? */
		sp->writeFlush = 1;
		
	    pb->ioResult = err;
	    if (err)
	        atalk_notify(sp->gref, EIO);
	    gbuf_freem(pb->mp);
	}

    return 0;
} /* FillSendQueue */

/*
 * dspWrite
 * 
 * INPUTS:
 * 	-->	ccbRefNum	refnum of connection end
 *	-->	reqCount	requested number of bytes to write
 *	--> 	dataPtr		pointer to buffer for reading bytes into
 *	-->	eom		one if end-of-message, zero otherwise
 *
 * OUTPUTS:
 *	<--	actCount	actual number of bytes written
 *
 * ERRORS:
 *		errRefNum	bad connection refnum
 *		errState	connection is not open
 *		errAborted	request aborted by Remove or Close call
 */
int adspWrite(sp, pb)		/* (DSPPBPtr pb) */
    CCBPtr sp;
    struct adspcmd *pb;
{
	
    if (sp == 0) {
	pb->ioResult = errRefNum;
	return EINVAL;		/* no stream, so drop the message */
    }
	
    if (sp->state != sOpen) {	/* Not allowed */
	pb->ioResult = errState;
	atalk_notify(sp->gref, ENOTCONN);
	gbuf_freem(pb->mp);
	return 0;
    }
	
    pb->u.ioParams.actCount = 0; /* Set # of bytes so far to zero */
    
    FillSendQueue(sp, pb);	/* Copy from write param block to send queue */

    CheckSend(sp);		/* See if we should send anything */
    return 0;
}

#ifdef notdef
int adsp_check = 1;

CheckQueue(sp)
    CCBPtr sp;
{
    register gbuf_t *mp, *tmp;
    unsigned char current;
    int current_valid = 0;

    if (adsp_check == 0)
	return;
    if (mp = sp->sbuf_mb) {
	current = *mp->b_rptr;
	current_valid = 1;
	while (mp) {
	    tmp = mp;
	    while (tmp) {
		current = CheckData(tmp->b_rptr, tmp->b_wptr - tmp->b_rptr, 
				    current);
		tmp = tmp->b_cont;
	    }
	    mp = mp->b_next;
	}
    }
    if (mp = sp->csbuf_mb) {
	if (current_valid == 0)
	    current = *mp->b_rptr;
	tmp = mp;
	while (tmp) {
	    current = CheckData(tmp->b_rptr, tmp->b_wptr - tmp->b_rptr, 
				    current);
	    tmp = tmp->b_cont;
	}
    }
}


int adsp_bad_block_count;
char *adsp_bad_block;

CheckData(block, size, current)
    char *block;
    int size;
    u_char current;
{
    register int anError = 0;
    register int i;

    for (i = 0; i < size; i++) {
	if ((block[i] & 0xff) != (current & 0xff)) {
	    if (!anError) {
		adsp_bad_block = block;
	    }
	    anError++;
	}
	current++;
    }

    if (anError) {
	adsp_bad_block_count++;
    }
    return current;
}
#endif
Commit	Line	Data
1c79356b	1	/*
5d5c5d0d A	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
5d5c5d0d A	3	*
8f6c56a5	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
1c79356b	5	*
8f6c56a5 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.
	14	*
	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
	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	22	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	23	* Please see the License for the specific language governing rights and
8ad349bb	24	* limitations under the License.
8f6c56a5 A	25	*
8f6c56a5 A	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
1c79356b A	27	*/
	28	/* dspWrite.c
	29	* From Mike Shoemaker v01.13 06/21/90 mbs for MacOS
	30	*/
	31	/*
	32	* Change log:
	33	* 06/29/95 - Modified to handle flow control for writing (Tuyen Nguyen)
	34	* 09/07/95 - Modified for performance (Tuyen Nguyen)
	35	* Modified for MP, 1996 by Tuyen Nguyen
	36	* Modified, April 9, 1997 by Tuyen Nguyen for MacOSX.
	37	*/
	38
	39	#include <sys/errno.h>
	40	#include <sys/types.h>
	41	#include <sys/param.h>
	42	#include <machine/spl.h>
	43	#include <sys/systm.h>
	44	#include <sys/kernel.h>
	45	#include <sys/proc.h>
	46	#include <sys/filedesc.h>
	47	#include <sys/fcntl.h>
	48	#include <sys/mbuf.h>
	49	#include <sys/socket.h>
	50
	51	#include <netat/sysglue.h>
	52	#include <netat/appletalk.h>
	53	#include <netat/at_pcb.h>
	54	#include <netat/debug.h>
	55	#include <netat/adsp.h>
	56	#include <netat/adsp_internal.h>
	57
	58	void completepb();
	59
	60	/*
	61	* FillSendQueue
	62	*
	63	* INPUTS:
	64	* sp stream
	65	* OUTPUTS:
	66	* none
	67	*/
	68	int FillSendQueue(sp, pb) /* (CCBPtr sp) */
	69	register CCBPtr sp;
	70	register struct adspcmd pb; / The write PB we're playing with */
	71	{
	72	gbuf_t mb, nmb;
	73	int eom; /* True if should set eom in header */
	74	int cnt; /* # of bytes in this write */
	75	int err = 0;
1c79356b A	76
	77	cnt = pb->u.ioParams.reqCount - pb->u.ioParams.actCount;
	78	eom = pb->u.ioParams.eom ? F_EOM : 0;
	79
	80	if (cnt == 0 && eom == 0) /* Nothing to do here, complete it */
	81	goto unlink;
	82
	83	/* The 1st mbuf in the pb->mp chain (mb) is the adspcmd structure.
	84	The 2nd mbuf (nmb) will be the beginning of the data. */
	85	mb = pb->mp;
	86	nmb = gbuf_cont(mb);
	87	if (gbuf_len(mb) > sizeof(struct adspcmd)) {
	88	if ((nmb = gbuf_dupb(mb)) == 0) {
	89	gbuf_wset(mb,sizeof(struct adspcmd));
	90	err = errDSPQueueSize;
	91	goto unlink;
	92	}
	93	gbuf_wset(mb,sizeof(struct adspcmd));
	94	gbuf_rinc(nmb,sizeof(struct adspcmd));
	95	gbuf_cont(nmb) = gbuf_cont(mb);
	96	} else if (nmb == 0) {
	97	if ((nmb = gbuf_alloc(1, PRI_LO)) == 0) {
	98	err = errENOBUFS;
	99	goto unlink;
	100	}
	101	}
	102	gbuf_cont(mb) = 0;
	103
1c79356b A	104	sp->sData = 1; /* note that there is data to send */
	105	if ((mb = sp->csbuf_mb)) { /* add to the current message */
	106	gbuf_linkb(mb, nmb);
	107	} else
	108	sp->csbuf_mb = nmb; /* mark the buffer we are currently filling */
	109	if (eom) {
	110	if ((mb = sp->sbuf_mb)) {
	111	while (gbuf_next(mb))
	112	mb = gbuf_next(mb);
	113	gbuf_next(mb) = sp->csbuf_mb; /* add the current item */
	114	} else
	115	sp->sbuf_mb = sp->csbuf_mb;
	116	sp->csbuf_mb = 0; /* if its done, no current buffer */
	117	}
	118	pb->u.ioParams.actCount += cnt; /* Update count field in param blk */
1c79356b A	119
	120	if (pb->u.ioParams.actCount == pb->u.ioParams.reqCount) {
	121	/* Write is complete */
	122	unlink:
	123	if (pb->u.ioParams.flush) /* flush the send Q? */
	124	sp->writeFlush = 1;
	125
	126	pb->ioResult = err;
	127	if (err)
	128	atalk_notify(sp->gref, EIO);
	129	gbuf_freem(pb->mp);
	130	}
	131
	132	return 0;
	133	} /* FillSendQueue */
	134
	135	/*
	136	* dspWrite
	137	*
	138	* INPUTS:
	139	* --> ccbRefNum refnum of connection end
	140	* --> reqCount requested number of bytes to write
	141	* --> dataPtr pointer to buffer for reading bytes into
	142	* --> eom one if end-of-message, zero otherwise
	143	*
	144	* OUTPUTS:
	145	* <-- actCount actual number of bytes written
	146	*
	147	* ERRORS:
	148	* errRefNum bad connection refnum
	149	* errState connection is not open
	150	* errAborted request aborted by Remove or Close call
	151	*/
	152	int adspWrite(sp, pb) /* (DSPPBPtr pb) */
	153	CCBPtr sp;
	154	struct adspcmd *pb;
	155	{
1c79356b A	156
	157	if (sp == 0) {
	158	pb->ioResult = errRefNum;
	159	return EINVAL; /* no stream, so drop the message */
	160	}
	161
1c79356b A	162	if (sp->state != sOpen) { /* Not allowed */
1c79356b A	163	pb->ioResult = errState;
1c79356b A	164	atalk_notify(sp->gref, ENOTCONN);
	165	gbuf_freem(pb->mp);
	166	return 0;
	167	}
	168
	169	pb->u.ioParams.actCount = 0; /* Set # of bytes so far to zero */
1c79356b A	170
	171	FillSendQueue(sp, pb); /* Copy from write param block to send queue */
	172
	173	CheckSend(sp); /* See if we should send anything */
	174	return 0;
	175	}
	176
	177	#ifdef notdef
	178	int adsp_check = 1;
	179
	180	CheckQueue(sp)
	181	CCBPtr sp;
	182	{
	183	register gbuf_t mp, tmp;
	184	unsigned char current;
	185	int current_valid = 0;
	186
	187	if (adsp_check == 0)
	188	return;
	189	if (mp = sp->sbuf_mb) {
	190	current = *mp->b_rptr;
	191	current_valid = 1;
	192	while (mp) {
	193	tmp = mp;
	194	while (tmp) {
	195	current = CheckData(tmp->b_rptr, tmp->b_wptr - tmp->b_rptr,
	196	current);
	197	tmp = tmp->b_cont;
	198	}
	199	mp = mp->b_next;
	200	}
	201	}
	202	if (mp = sp->csbuf_mb) {
	203	if (current_valid == 0)
	204	current = *mp->b_rptr;
	205	tmp = mp;
	206	while (tmp) {
	207	current = CheckData(tmp->b_rptr, tmp->b_wptr - tmp->b_rptr,
	208	current);
	209	tmp = tmp->b_cont;
	210	}
	211	}
	212	}
	213
	214
	215	int adsp_bad_block_count;
	216	char *adsp_bad_block;
	217
	218	CheckData(block, size, current)
	219	char *block;
	220	int size;
	221	u_char current;
	222	{
	223	register int anError = 0;
	224	register int i;
	225
	226	for (i = 0; i < size; i++) {
	227	if ((block[i] & 0xff) != (current & 0xff)) {
	228	if (!anError) {
	229	adsp_bad_block = block;
	230	}
	231	anError++;
	232	}
	233	current++;
234	}
235
236	if (anError) {
237	adsp_bad_block_count++;
238	}
239	return current;
240	}
241	#endif