bsd/netat/adsp_Write.c

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