Windows: Redirector Dir Enumeration Bug
[openafs.git] / src / rx / rx_rdwr.c
1  /*
2   * Copyright 2000, International Business Machines Corporation and others.
3   * All Rights Reserved.
4   *
5   * This software has been released under the terms of the IBM Public
6   * License.  For details, see the LICENSE file in the top-level source
7   * directory or online at http://www.openafs.org/dl/license10.html
8   */
9
10 #include <afsconfig.h>
11 #include <afs/param.h>
12
13 #ifdef KERNEL
14 # ifndef UKERNEL
15 #  ifdef RX_KERNEL_TRACE
16 #   include "rx_kcommon.h"
17 #  endif
18 #  if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
19 #   include "afs/sysincludes.h"
20 #  else
21 #   include "h/types.h"
22 #   include "h/time.h"
23 #   include "h/stat.h"
24 #   if defined(AFS_AIX_ENV) || defined(AFS_AUX_ENV) || defined(AFS_SUN5_ENV)
25 #    include "h/systm.h"
26 #   endif
27 #   ifdef       AFS_OSF_ENV
28 #    include <net/net_globals.h>
29 #   endif /* AFS_OSF_ENV */
30 #   ifdef AFS_LINUX20_ENV
31 #    include "h/socket.h"
32 #   endif
33 #   include "netinet/in.h"
34 #   if defined(AFS_SGI_ENV)
35 #    include "afs/sysincludes.h"
36 #   endif
37 #  endif
38 #  include "afs/afs_args.h"
39 #  if   (defined(AFS_AUX_ENV) || defined(AFS_AIX_ENV))
40 #   include "h/systm.h"
41 #  endif
42 # else /* !UKERNEL */
43 #  include "afs/sysincludes.h"
44 # endif /* !UKERNEL */
45
46 # ifdef RXDEBUG
47 #  undef RXDEBUG                        /* turn off debugging */
48 # endif /* RXDEBUG */
49
50 # include "afs/afs_osi.h"
51 # include "rx_kmutex.h"
52 # include "rx/rx_kernel.h"
53 # include "afs/lock.h"
54 #else /* KERNEL */
55 # include <roken.h>
56 #endif /* KERNEL */
57
58 #include "rx.h"
59 #include "rx_clock.h"
60 #include "rx_queue.h"
61 #include "rx_globals.h"
62
63 #include "rx_conn.h"
64 #include "rx_call.h"
65 #include "rx_packet.h"
66
67 #ifdef RX_LOCKS_DB
68 /* rxdb_fileID is used to identify the lock location, along with line#. */
69 static int rxdb_fileID = RXDB_FILE_RX_RDWR;
70 #endif /* RX_LOCKS_DB */
71 /* rxi_ReadProc -- internal version.
72  *
73  * LOCKS USED -- called at netpri
74  */
75 int
76 rxi_ReadProc(struct rx_call *call, char *buf,
77              int nbytes)
78 {
79     struct rx_packet *cp = call->currentPacket;
80     struct rx_packet *rp;
81     int requestCount;
82     unsigned int t;
83
84 /* XXXX took out clock_NewTime from here.  Was it needed? */
85     requestCount = nbytes;
86
87     /* Free any packets from the last call to ReadvProc/WritevProc */
88     if (queue_IsNotEmpty(&call->iovq)) {
89 #ifdef RXDEBUG_PACKET
90         call->iovqc -=
91 #endif /* RXDEBUG_PACKET */
92             rxi_FreePackets(0, &call->iovq);
93     }
94
95     do {
96         if (call->nLeft == 0) {
97             /* Get next packet */
98             MUTEX_ENTER(&call->lock);
99             for (;;) {
100                 if (call->error || (call->mode != RX_MODE_RECEIVING)) {
101                     if (call->error) {
102                         call->mode = RX_MODE_ERROR;
103                         MUTEX_EXIT(&call->lock);
104                         return 0;
105                     }
106                     if (call->mode == RX_MODE_SENDING) {
107                         MUTEX_EXIT(&call->lock);
108                         rxi_FlushWrite(call);
109                         MUTEX_ENTER(&call->lock);
110                         continue;
111                     }
112                 }
113                 if (queue_IsNotEmpty(&call->rq)) {
114                     /* Check that next packet available is next in sequence */
115                     rp = queue_First(&call->rq, rx_packet);
116                     if (rp->header.seq == call->rnext) {
117                         afs_int32 error;
118                         struct rx_connection *conn = call->conn;
119                         queue_Remove(rp);
120 #ifdef RX_TRACK_PACKETS
121                         rp->flags &= ~RX_PKTFLAG_RQ;
122 #endif
123 #ifdef RXDEBUG_PACKET
124                         call->rqc--;
125 #endif /* RXDEBUG_PACKET */
126
127                         /* RXS_CheckPacket called to undo RXS_PreparePacket's
128                          * work.  It may reduce the length of the packet by up
129                          * to conn->maxTrailerSize, to reflect the length of the
130                          * data + the header. */
131                         if ((error =
132                              RXS_CheckPacket(conn->securityObject, call,
133                                              rp))) {
134                             /* Used to merely shut down the call, but now we
135                              * shut down the whole connection since this may
136                              * indicate an attempt to hijack it */
137
138                             MUTEX_EXIT(&call->lock);
139                             rxi_ConnectionError(conn, error);
140                             MUTEX_ENTER(&conn->conn_data_lock);
141                             rp = rxi_SendConnectionAbort(conn, rp, 0, 0);
142                             MUTEX_EXIT(&conn->conn_data_lock);
143                             rxi_FreePacket(rp);
144
145                             return 0;
146                         }
147                         call->rnext++;
148                         cp = call->currentPacket = rp;
149 #ifdef RX_TRACK_PACKETS
150                         call->currentPacket->flags |= RX_PKTFLAG_CP;
151 #endif
152                         call->curvec = 1;       /* 0th vec is always header */
153                         /* begin at the beginning [ more or less ], continue
154                          * on until the end, then stop. */
155                         call->curpos =
156                             (char *)cp->wirevec[1].iov_base +
157                             call->conn->securityHeaderSize;
158                         call->curlen =
159                             cp->wirevec[1].iov_len -
160                             call->conn->securityHeaderSize;
161
162                         /* Notice that this code works correctly if the data
163                          * size is 0 (which it may be--no reply arguments from
164                          * server, for example).  This relies heavily on the
165                          * fact that the code below immediately frees the packet
166                          * (no yields, etc.).  If it didn't, this would be a
167                          * problem because a value of zero for call->nLeft
168                          * normally means that there is no read packet */
169                         call->nLeft = cp->length;
170                         hadd32(call->bytesRcvd, cp->length);
171
172                         /* Send a hard ack for every rxi_HardAckRate+1 packets
173                          * consumed. Otherwise schedule an event to send
174                          * the hard ack later on.
175                          */
176                         call->nHardAcks++;
177                         if (!(call->flags & RX_CALL_RECEIVE_DONE)) {
178                             if (call->nHardAcks > (u_short) rxi_HardAckRate) {
179                                 rxevent_Cancel(&call->delayedAckEvent, call,
180                                                RX_CALL_REFCOUNT_DELAY);
181                                 rxi_SendAck(call, 0, 0, RX_ACK_DELAY, 0);
182                             } else {
183                                 /* Delay to consolidate ack packets */
184                                 rxi_PostDelayedAckEvent(call,
185                                                         &rx_hardAckDelay);
186                             }
187                         }
188                         break;
189                     }
190                 }
191
192                 /*
193                  * If we reach this point either we have no packets in the
194                  * receive queue or the next packet in the queue is not the
195                  * one we are looking for.  There is nothing else for us to
196                  * do but wait for another packet to arrive.
197                  */
198
199                 /* Are there ever going to be any more packets? */
200                 if (call->flags & RX_CALL_RECEIVE_DONE) {
201                     MUTEX_EXIT(&call->lock);
202                     return requestCount - nbytes;
203                 }
204                 /* Wait for in-sequence packet */
205                 call->flags |= RX_CALL_READER_WAIT;
206                 clock_NewTime();
207                 call->startWait = clock_Sec();
208                 while (call->flags & RX_CALL_READER_WAIT) {
209 #ifdef  RX_ENABLE_LOCKS
210                     CV_WAIT(&call->cv_rq, &call->lock);
211 #else
212                     osi_rxSleep(&call->rq);
213 #endif
214                 }
215                 cp = call->currentPacket;
216
217                 call->startWait = 0;
218 #ifdef RX_ENABLE_LOCKS
219                 if (call->error) {
220                     MUTEX_EXIT(&call->lock);
221                     return 0;
222                 }
223 #endif /* RX_ENABLE_LOCKS */
224             }
225             MUTEX_EXIT(&call->lock);
226         } else
227             /* osi_Assert(cp); */
228             /* MTUXXX  this should be replaced by some error-recovery code before shipping */
229             /* yes, the following block is allowed to be the ELSE clause (or not) */
230             /* It's possible for call->nLeft to be smaller than any particular
231              * iov_len.  Usually, recvmsg doesn't change the iov_len, since it
232              * reflects the size of the buffer.  We have to keep track of the
233              * number of bytes read in the length field of the packet struct.  On
234              * the final portion of a received packet, it's almost certain that
235              * call->nLeft will be smaller than the final buffer. */
236             while (nbytes && cp) {
237                 t = MIN((int)call->curlen, nbytes);
238                 t = MIN(t, (int)call->nLeft);
239                 memcpy(buf, call->curpos, t);
240                 buf += t;
241                 nbytes -= t;
242                 call->curpos += t;
243                 call->curlen -= t;
244                 call->nLeft -= t;
245
246                 if (!call->nLeft) {
247                     /* out of packet.  Get another one. */
248 #ifdef RX_TRACK_PACKETS
249                     call->currentPacket->flags &= ~RX_PKTFLAG_CP;
250 #endif
251                     rxi_FreePacket(cp);
252                     cp = call->currentPacket = (struct rx_packet *)0;
253                 } else if (!call->curlen) {
254                     /* need to get another struct iov */
255                     if (++call->curvec >= cp->niovecs) {
256                         /* current packet is exhausted, get ready for another */
257                         /* don't worry about curvec and stuff, they get set somewhere else */
258 #ifdef RX_TRACK_PACKETS
259                         call->currentPacket->flags &= ~RX_PKTFLAG_CP;
260 #endif
261                         rxi_FreePacket(cp);
262                         cp = call->currentPacket = (struct rx_packet *)0;
263                         call->nLeft = 0;
264                     } else {
265                         call->curpos =
266                             (char *)cp->wirevec[call->curvec].iov_base;
267                         call->curlen = cp->wirevec[call->curvec].iov_len;
268                     }
269                 }
270             }
271         if (!nbytes) {
272             /* user buffer is full, return */
273             return requestCount;
274         }
275
276     } while (nbytes);
277
278     return requestCount;
279 }
280
281 int
282 rx_ReadProc(struct rx_call *call, char *buf, int nbytes)
283 {
284     int bytes;
285     int tcurlen;
286     int tnLeft;
287     char *tcurpos;
288     SPLVAR;
289
290     /* Free any packets from the last call to ReadvProc/WritevProc */
291     if (!queue_IsEmpty(&call->iovq)) {
292 #ifdef RXDEBUG_PACKET
293         call->iovqc -=
294 #endif /* RXDEBUG_PACKET */
295             rxi_FreePackets(0, &call->iovq);
296     }
297
298     /*
299      * Most common case, all of the data is in the current iovec.
300      * We are relying on nLeft being zero unless the call is in receive mode.
301      */
302     tcurlen = call->curlen;
303     tnLeft = call->nLeft;
304     if (!call->error && tcurlen > nbytes && tnLeft > nbytes) {
305         tcurpos = call->curpos;
306         memcpy(buf, tcurpos, nbytes);
307
308         call->curpos = tcurpos + nbytes;
309         call->curlen = tcurlen - nbytes;
310         call->nLeft = tnLeft - nbytes;
311
312         if (!call->nLeft && call->currentPacket != NULL) {
313             /* out of packet.  Get another one. */
314             rxi_FreePacket(call->currentPacket);
315             call->currentPacket = (struct rx_packet *)0;
316         }
317         return nbytes;
318     }
319
320     NETPRI;
321     bytes = rxi_ReadProc(call, buf, nbytes);
322     USERPRI;
323     return bytes;
324 }
325
326 /* Optimization for unmarshalling 32 bit integers */
327 int
328 rx_ReadProc32(struct rx_call *call, afs_int32 * value)
329 {
330     int bytes;
331     int tcurlen;
332     int tnLeft;
333     char *tcurpos;
334     SPLVAR;
335
336     /* Free any packets from the last call to ReadvProc/WritevProc */
337     if (!queue_IsEmpty(&call->iovq)) {
338 #ifdef RXDEBUG_PACKET
339         call->iovqc -=
340 #endif /* RXDEBUG_PACKET */
341             rxi_FreePackets(0, &call->iovq);
342     }
343
344     /*
345      * Most common case, all of the data is in the current iovec.
346      * We are relying on nLeft being zero unless the call is in receive mode.
347      */
348     tcurlen = call->curlen;
349     tnLeft = call->nLeft;
350     if (!call->error && tcurlen >= sizeof(afs_int32)
351         && tnLeft >= sizeof(afs_int32)) {
352         tcurpos = call->curpos;
353
354         memcpy((char *)value, tcurpos, sizeof(afs_int32));
355
356         call->curpos = tcurpos + sizeof(afs_int32);
357         call->curlen = (u_short)(tcurlen - sizeof(afs_int32));
358         call->nLeft = (u_short)(tnLeft - sizeof(afs_int32));
359         if (!call->nLeft && call->currentPacket != NULL) {
360             /* out of packet.  Get another one. */
361             rxi_FreePacket(call->currentPacket);
362             call->currentPacket = (struct rx_packet *)0;
363         }
364         return sizeof(afs_int32);
365     }
366
367     NETPRI;
368     bytes = rxi_ReadProc(call, (char *)value, sizeof(afs_int32));
369     USERPRI;
370
371     return bytes;
372 }
373
374 /* rxi_FillReadVec
375  *
376  * Uses packets in the receive queue to fill in as much of the
377  * current iovec as possible. Does not block if it runs out
378  * of packets to complete the iovec. Return true if an ack packet
379  * was sent, otherwise return false */
380 int
381 rxi_FillReadVec(struct rx_call *call, afs_uint32 serial)
382 {
383     int didConsume = 0;
384     int didHardAck = 0;
385     unsigned int t;
386     struct rx_packet *rp;
387     struct rx_packet *curp;
388     struct iovec *call_iov;
389     struct iovec *cur_iov = NULL;
390
391     curp = call->currentPacket;
392     if (curp) {
393         cur_iov = &curp->wirevec[call->curvec];
394     }
395     call_iov = &call->iov[call->iovNext];
396
397     while (!call->error && call->iovNBytes && call->iovNext < call->iovMax) {
398         if (call->nLeft == 0) {
399             /* Get next packet */
400             if (queue_IsNotEmpty(&call->rq)) {
401                 /* Check that next packet available is next in sequence */
402                 rp = queue_First(&call->rq, rx_packet);
403                 if (rp->header.seq == call->rnext) {
404                     afs_int32 error;
405                     struct rx_connection *conn = call->conn;
406                     queue_Remove(rp);
407 #ifdef RX_TRACK_PACKETS
408                     rp->flags &= ~RX_PKTFLAG_RQ;
409 #endif
410 #ifdef RXDEBUG_PACKET
411                     call->rqc--;
412 #endif /* RXDEBUG_PACKET */
413
414                     /* RXS_CheckPacket called to undo RXS_PreparePacket's
415                      * work.  It may reduce the length of the packet by up
416                      * to conn->maxTrailerSize, to reflect the length of the
417                      * data + the header. */
418                     if ((error =
419                          RXS_CheckPacket(conn->securityObject, call, rp))) {
420                         /* Used to merely shut down the call, but now we
421                          * shut down the whole connection since this may
422                          * indicate an attempt to hijack it */
423
424                         MUTEX_EXIT(&call->lock);
425                         rxi_ConnectionError(conn, error);
426                         MUTEX_ENTER(&conn->conn_data_lock);
427                         rp = rxi_SendConnectionAbort(conn, rp, 0, 0);
428                         MUTEX_EXIT(&conn->conn_data_lock);
429                         rxi_FreePacket(rp);
430                         MUTEX_ENTER(&call->lock);
431
432                         return 1;
433                     }
434                     call->rnext++;
435                     curp = call->currentPacket = rp;
436 #ifdef RX_TRACK_PACKETS
437                     call->currentPacket->flags |= RX_PKTFLAG_CP;
438 #endif
439                     call->curvec = 1;   /* 0th vec is always header */
440                     cur_iov = &curp->wirevec[1];
441                     /* begin at the beginning [ more or less ], continue
442                      * on until the end, then stop. */
443                     call->curpos =
444                         (char *)curp->wirevec[1].iov_base +
445                         call->conn->securityHeaderSize;
446                     call->curlen =
447                         curp->wirevec[1].iov_len -
448                         call->conn->securityHeaderSize;
449
450                     /* Notice that this code works correctly if the data
451                      * size is 0 (which it may be--no reply arguments from
452                      * server, for example).  This relies heavily on the
453                      * fact that the code below immediately frees the packet
454                      * (no yields, etc.).  If it didn't, this would be a
455                      * problem because a value of zero for call->nLeft
456                      * normally means that there is no read packet */
457                     call->nLeft = curp->length;
458                     hadd32(call->bytesRcvd, curp->length);
459
460                     /* Send a hard ack for every rxi_HardAckRate+1 packets
461                      * consumed. Otherwise schedule an event to send
462                      * the hard ack later on.
463                      */
464                     call->nHardAcks++;
465                     didConsume = 1;
466                     continue;
467                 }
468             }
469             break;
470         }
471
472         /* It's possible for call->nLeft to be smaller than any particular
473          * iov_len.  Usually, recvmsg doesn't change the iov_len, since it
474          * reflects the size of the buffer.  We have to keep track of the
475          * number of bytes read in the length field of the packet struct.  On
476          * the final portion of a received packet, it's almost certain that
477          * call->nLeft will be smaller than the final buffer. */
478         while (call->iovNBytes && call->iovNext < call->iovMax && curp) {
479
480             t = MIN((int)call->curlen, call->iovNBytes);
481             t = MIN(t, (int)call->nLeft);
482             call_iov->iov_base = call->curpos;
483             call_iov->iov_len = t;
484             call_iov++;
485             call->iovNext++;
486             call->iovNBytes -= t;
487             call->curpos += t;
488             call->curlen -= t;
489             call->nLeft -= t;
490
491             if (!call->nLeft) {
492                 /* out of packet.  Get another one. */
493 #ifdef RX_TRACK_PACKETS
494                 curp->flags &= ~RX_PKTFLAG_CP;
495                 curp->flags |= RX_PKTFLAG_IOVQ;
496 #endif
497                 queue_Append(&call->iovq, curp);
498 #ifdef RXDEBUG_PACKET
499                 call->iovqc++;
500 #endif /* RXDEBUG_PACKET */
501                 curp = call->currentPacket = (struct rx_packet *)0;
502             } else if (!call->curlen) {
503                 /* need to get another struct iov */
504                 if (++call->curvec >= curp->niovecs) {
505                     /* current packet is exhausted, get ready for another */
506                     /* don't worry about curvec and stuff, they get set somewhere else */
507 #ifdef RX_TRACK_PACKETS
508                     curp->flags &= ~RX_PKTFLAG_CP;
509                     curp->flags |= RX_PKTFLAG_IOVQ;
510 #endif
511                     queue_Append(&call->iovq, curp);
512 #ifdef RXDEBUG_PACKET
513                     call->iovqc++;
514 #endif /* RXDEBUG_PACKET */
515                     curp = call->currentPacket = (struct rx_packet *)0;
516                     call->nLeft = 0;
517                 } else {
518                     cur_iov++;
519                     call->curpos = (char *)cur_iov->iov_base;
520                     call->curlen = cur_iov->iov_len;
521                 }
522             }
523         }
524     }
525
526     /* If we consumed any packets then check whether we need to
527      * send a hard ack. */
528     if (didConsume && (!(call->flags & RX_CALL_RECEIVE_DONE))) {
529         if (call->nHardAcks > (u_short) rxi_HardAckRate) {
530             rxevent_Cancel(&call->delayedAckEvent, call,
531                            RX_CALL_REFCOUNT_DELAY);
532             rxi_SendAck(call, 0, serial, RX_ACK_DELAY, 0);
533             didHardAck = 1;
534         } else {
535             /* Delay to consolidate ack packets */
536             rxi_PostDelayedAckEvent(call, &rx_hardAckDelay);
537         }
538     }
539     return didHardAck;
540 }
541
542
543 /* rxi_ReadvProc -- internal version.
544  *
545  * Fills in an iovec with pointers to the packet buffers. All packets
546  * except the last packet (new current packet) are moved to the iovq
547  * while the application is processing the data.
548  *
549  * LOCKS USED -- called at netpri.
550  */
551 int
552 rxi_ReadvProc(struct rx_call *call, struct iovec *iov, int *nio, int maxio,
553               int nbytes)
554 {
555     int bytes;
556
557     /* Free any packets from the last call to ReadvProc/WritevProc */
558     if (queue_IsNotEmpty(&call->iovq)) {
559 #ifdef RXDEBUG_PACKET
560         call->iovqc -=
561 #endif /* RXDEBUG_PACKET */
562             rxi_FreePackets(0, &call->iovq);
563     }
564
565     if (call->mode == RX_MODE_SENDING) {
566         rxi_FlushWrite(call);
567     }
568
569     MUTEX_ENTER(&call->lock);
570     if (call->error)
571         goto error;
572
573     /* Get whatever data is currently available in the receive queue.
574      * If rxi_FillReadVec sends an ack packet then it is possible
575      * that we will receive more data while we drop the call lock
576      * to send the packet. Set the RX_CALL_IOVEC_WAIT flag
577      * here to avoid a race with the receive thread if we send
578      * hard acks in rxi_FillReadVec. */
579     call->flags |= RX_CALL_IOVEC_WAIT;
580     call->iovNBytes = nbytes;
581     call->iovMax = maxio;
582     call->iovNext = 0;
583     call->iov = iov;
584     rxi_FillReadVec(call, 0);
585
586     /* if we need more data then sleep until the receive thread has
587      * filled in the rest. */
588     if (!call->error && call->iovNBytes && call->iovNext < call->iovMax
589         && !(call->flags & RX_CALL_RECEIVE_DONE)) {
590         call->flags |= RX_CALL_READER_WAIT;
591         clock_NewTime();
592         call->startWait = clock_Sec();
593         while (call->flags & RX_CALL_READER_WAIT) {
594 #ifdef  RX_ENABLE_LOCKS
595             CV_WAIT(&call->cv_rq, &call->lock);
596 #else
597             osi_rxSleep(&call->rq);
598 #endif
599         }
600         call->startWait = 0;
601     }
602     call->flags &= ~RX_CALL_IOVEC_WAIT;
603
604     if (call->error)
605         goto error;
606
607     call->iov = NULL;
608     *nio = call->iovNext;
609     bytes = nbytes - call->iovNBytes;
610     MUTEX_EXIT(&call->lock);
611     return bytes;
612
613   error:
614     MUTEX_EXIT(&call->lock);
615     call->mode = RX_MODE_ERROR;
616     return 0;
617 }
618
619 int
620 rx_ReadvProc(struct rx_call *call, struct iovec *iov, int *nio, int maxio,
621              int nbytes)
622 {
623     int bytes;
624     SPLVAR;
625
626     NETPRI;
627     bytes = rxi_ReadvProc(call, iov, nio, maxio, nbytes);
628     USERPRI;
629     return bytes;
630 }
631
632 /* rxi_WriteProc -- internal version.
633  *
634  * LOCKS USED -- called at netpri
635  */
636
637 int
638 rxi_WriteProc(struct rx_call *call, char *buf,
639               int nbytes)
640 {
641     struct rx_connection *conn = call->conn;
642     struct rx_packet *cp = call->currentPacket;
643     unsigned int t;
644     int requestCount = nbytes;
645
646     /* Free any packets from the last call to ReadvProc/WritevProc */
647     if (queue_IsNotEmpty(&call->iovq)) {
648 #ifdef RXDEBUG_PACKET
649         call->iovqc -=
650 #endif /* RXDEBUG_PACKET */
651             rxi_FreePackets(0, &call->iovq);
652     }
653
654     if (call->mode != RX_MODE_SENDING) {
655         if ((conn->type == RX_SERVER_CONNECTION)
656             && (call->mode == RX_MODE_RECEIVING)) {
657             call->mode = RX_MODE_SENDING;
658             if (cp) {
659 #ifdef RX_TRACK_PACKETS
660                 cp->flags &= ~RX_PKTFLAG_CP;
661 #endif
662                 rxi_FreePacket(cp);
663                 cp = call->currentPacket = (struct rx_packet *)0;
664                 call->nLeft = 0;
665                 call->nFree = 0;
666             }
667         } else {
668             return 0;
669         }
670     }
671
672     /* Loop condition is checked at end, so that a write of 0 bytes
673      * will force a packet to be created--specially for the case where
674      * there are 0 bytes on the stream, but we must send a packet
675      * anyway. */
676     do {
677         if (call->nFree == 0) {
678             MUTEX_ENTER(&call->lock);
679             cp = call->currentPacket;
680             if (call->error)
681                 call->mode = RX_MODE_ERROR;
682             if (!call->error && cp) {
683                 /* Clear the current packet now so that if
684                  * we are forced to wait and drop the lock
685                  * the packet we are planning on using
686                  * cannot be freed.
687                  */
688 #ifdef RX_TRACK_PACKETS
689                 cp->flags &= ~RX_PKTFLAG_CP;
690 #endif
691                 call->currentPacket = (struct rx_packet *)0;
692                 clock_NewTime();        /* Bogus:  need new time package */
693                 /* The 0, below, specifies that it is not the last packet:
694                  * there will be others. PrepareSendPacket may
695                  * alter the packet length by up to
696                  * conn->securityMaxTrailerSize */
697                 hadd32(call->bytesSent, cp->length);
698                 rxi_PrepareSendPacket(call, cp, 0);
699 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
700                 /* PrepareSendPacket drops the call lock */
701                 rxi_WaitforTQBusy(call);
702 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
703 #ifdef RX_TRACK_PACKETS
704                 cp->flags |= RX_PKTFLAG_TQ;
705 #endif
706                 queue_Append(&call->tq, cp);
707 #ifdef RXDEBUG_PACKET
708                 call->tqc++;
709 #endif /* RXDEBUG_PACKET */
710                 cp = (struct rx_packet *)0;
711                 /* If the call is in recovery, let it exhaust its current
712                  * retransmit queue before forcing it to send new packets
713                  */
714                 if (!(call->flags & (RX_CALL_FAST_RECOVER))) {
715                     rxi_Start(call, 0);
716                 }
717             } else if (cp) {
718 #ifdef RX_TRACK_PACKETS
719                 cp->flags &= ~RX_PKTFLAG_CP;
720 #endif
721                 rxi_FreePacket(cp);
722                 cp = call->currentPacket = (struct rx_packet *)0;
723             }
724             /* Wait for transmit window to open up */
725             while (!call->error
726                    && call->tnext + 1 > call->tfirst + (2 * call->twind)) {
727                 clock_NewTime();
728                 call->startWait = clock_Sec();
729
730 #ifdef  RX_ENABLE_LOCKS
731                 CV_WAIT(&call->cv_twind, &call->lock);
732 #else
733                 call->flags |= RX_CALL_WAIT_WINDOW_ALLOC;
734                 osi_rxSleep(&call->twind);
735 #endif
736
737                 call->startWait = 0;
738 #ifdef RX_ENABLE_LOCKS
739                 if (call->error) {
740                     call->mode = RX_MODE_ERROR;
741                     MUTEX_EXIT(&call->lock);
742                     return 0;
743                 }
744 #endif /* RX_ENABLE_LOCKS */
745             }
746             if ((cp = rxi_AllocSendPacket(call, nbytes))) {
747 #ifdef RX_TRACK_PACKETS
748                 cp->flags |= RX_PKTFLAG_CP;
749 #endif
750                 call->currentPacket = cp;
751                 call->nFree = cp->length;
752                 call->curvec = 1;       /* 0th vec is always header */
753                 /* begin at the beginning [ more or less ], continue
754                  * on until the end, then stop. */
755                 call->curpos =
756                     (char *)cp->wirevec[1].iov_base +
757                     call->conn->securityHeaderSize;
758                 call->curlen =
759                     cp->wirevec[1].iov_len - call->conn->securityHeaderSize;
760             }
761             if (call->error) {
762                 call->mode = RX_MODE_ERROR;
763                 if (cp) {
764 #ifdef RX_TRACK_PACKETS
765                     cp->flags &= ~RX_PKTFLAG_CP;
766 #endif
767                     rxi_FreePacket(cp);
768                     call->currentPacket = NULL;
769                 }
770                 MUTEX_EXIT(&call->lock);
771                 return 0;
772             }
773             MUTEX_EXIT(&call->lock);
774         }
775
776         if (cp && (int)call->nFree < nbytes) {
777             /* Try to extend the current buffer */
778             int len, mud;
779             len = cp->length;
780             mud = rx_MaxUserDataSize(call);
781             if (mud > len) {
782                 int want;
783                 want = MIN(nbytes - (int)call->nFree, mud - len);
784                 rxi_AllocDataBuf(cp, want, RX_PACKET_CLASS_SEND_CBUF);
785                 if (cp->length > (unsigned)mud)
786                     cp->length = mud;
787                 call->nFree += (cp->length - len);
788             }
789         }
790
791         /* If the remaining bytes fit in the buffer, then store them
792          * and return.  Don't ship a buffer that's full immediately to
793          * the peer--we don't know if it's the last buffer yet */
794
795         if (!cp) {
796             call->nFree = 0;
797         }
798
799         while (nbytes && call->nFree) {
800
801             t = MIN((int)call->curlen, nbytes);
802             t = MIN((int)call->nFree, t);
803             memcpy(call->curpos, buf, t);
804             buf += t;
805             nbytes -= t;
806             call->curpos += t;
807             call->curlen -= (u_short)t;
808             call->nFree -= (u_short)t;
809
810             if (!call->curlen) {
811                 /* need to get another struct iov */
812                 if (++call->curvec >= cp->niovecs) {
813                     /* current packet is full, extend or send it */
814                     call->nFree = 0;
815                 } else {
816                     call->curpos = (char *)cp->wirevec[call->curvec].iov_base;
817                     call->curlen = cp->wirevec[call->curvec].iov_len;
818                 }
819             }
820         }                       /* while bytes to send and room to send them */
821
822         /* might be out of space now */
823         if (!nbytes) {
824             return requestCount;
825         } else;                 /* more data to send, so get another packet and keep going */
826     } while (nbytes);
827
828     return requestCount - nbytes;
829 }
830
831 int
832 rx_WriteProc(struct rx_call *call, char *buf, int nbytes)
833 {
834     int bytes;
835     int tcurlen;
836     int tnFree;
837     char *tcurpos;
838     SPLVAR;
839
840     /* Free any packets from the last call to ReadvProc/WritevProc */
841     if (queue_IsNotEmpty(&call->iovq)) {
842 #ifdef RXDEBUG_PACKET
843         call->iovqc -=
844 #endif /* RXDEBUG_PACKET */
845             rxi_FreePackets(0, &call->iovq);
846     }
847
848     /*
849      * Most common case: all of the data fits in the current iovec.
850      * We are relying on nFree being zero unless the call is in send mode.
851      */
852     tcurlen = (int)call->curlen;
853     tnFree = (int)call->nFree;
854     if (!call->error && tcurlen >= nbytes && tnFree >= nbytes) {
855         tcurpos = call->curpos;
856
857         memcpy(tcurpos, buf, nbytes);
858         call->curpos = tcurpos + nbytes;
859         call->curlen = (u_short)(tcurlen - nbytes);
860         call->nFree = (u_short)(tnFree - nbytes);
861         return nbytes;
862     }
863
864     NETPRI;
865     bytes = rxi_WriteProc(call, buf, nbytes);
866     USERPRI;
867     return bytes;
868 }
869
870 /* Optimization for marshalling 32 bit arguments */
871 int
872 rx_WriteProc32(struct rx_call *call, afs_int32 * value)
873 {
874     int bytes;
875     int tcurlen;
876     int tnFree;
877     char *tcurpos;
878     SPLVAR;
879
880     if (queue_IsNotEmpty(&call->iovq)) {
881 #ifdef RXDEBUG_PACKET
882         call->iovqc -=
883 #endif /* RXDEBUG_PACKET */
884             rxi_FreePackets(0, &call->iovq);
885     }
886
887     /*
888      * Most common case: all of the data fits in the current iovec.
889      * We are relying on nFree being zero unless the call is in send mode.
890      */
891     tcurlen = call->curlen;
892     tnFree = call->nFree;
893     if (!call->error && tcurlen >= sizeof(afs_int32)
894         && tnFree >= sizeof(afs_int32)) {
895         tcurpos = call->curpos;
896
897         if (!((size_t)tcurpos & (sizeof(afs_int32) - 1))) {
898             *((afs_int32 *) (tcurpos)) = *value;
899         } else {
900             memcpy(tcurpos, (char *)value, sizeof(afs_int32));
901         }
902         call->curpos = tcurpos + sizeof(afs_int32);
903         call->curlen = (u_short)(tcurlen - sizeof(afs_int32));
904         call->nFree = (u_short)(tnFree - sizeof(afs_int32));
905         return sizeof(afs_int32);
906     }
907
908     NETPRI;
909     bytes = rxi_WriteProc(call, (char *)value, sizeof(afs_int32));
910     USERPRI;
911     return bytes;
912 }
913
914 /* rxi_WritevAlloc -- internal version.
915  *
916  * Fill in an iovec to point to data in packet buffers. The application
917  * calls rxi_WritevProc when the buffers are full.
918  *
919  * LOCKS USED -- called at netpri.
920  */
921
922 static int
923 rxi_WritevAlloc(struct rx_call *call, struct iovec *iov, int *nio, int maxio,
924                 int nbytes)
925 {
926     struct rx_connection *conn = call->conn;
927     struct rx_packet *cp = call->currentPacket;
928     int requestCount;
929     int nextio;
930     /* Temporary values, real work is done in rxi_WritevProc */
931     int tnFree;
932     unsigned int tcurvec;
933     char *tcurpos;
934     int tcurlen;
935
936     requestCount = nbytes;
937     nextio = 0;
938
939     /* Free any packets from the last call to ReadvProc/WritevProc */
940     if (queue_IsNotEmpty(&call->iovq)) {
941 #ifdef RXDEBUG_PACKET
942         call->iovqc -=
943 #endif /* RXDEBUG_PACKET */
944             rxi_FreePackets(0, &call->iovq);
945     }
946
947     if (call->mode != RX_MODE_SENDING) {
948         if ((conn->type == RX_SERVER_CONNECTION)
949             && (call->mode == RX_MODE_RECEIVING)) {
950             call->mode = RX_MODE_SENDING;
951             if (cp) {
952 #ifdef RX_TRACK_PACKETS
953                 cp->flags &= ~RX_PKTFLAG_CP;
954 #endif
955                 rxi_FreePacket(cp);
956                 cp = call->currentPacket = (struct rx_packet *)0;
957                 call->nLeft = 0;
958                 call->nFree = 0;
959             }
960         } else {
961             return 0;
962         }
963     }
964
965     /* Set up the iovec to point to data in packet buffers. */
966     tnFree = call->nFree;
967     tcurvec = call->curvec;
968     tcurpos = call->curpos;
969     tcurlen = call->curlen;
970     do {
971         int t;
972
973         if (tnFree == 0) {
974             /* current packet is full, allocate a new one */
975             MUTEX_ENTER(&call->lock);
976             cp = rxi_AllocSendPacket(call, nbytes);
977             MUTEX_EXIT(&call->lock);
978             if (cp == NULL) {
979                 /* out of space, return what we have */
980                 *nio = nextio;
981                 return requestCount - nbytes;
982             }
983 #ifdef RX_TRACK_PACKETS
984             cp->flags |= RX_PKTFLAG_IOVQ;
985 #endif
986             queue_Append(&call->iovq, cp);
987 #ifdef RXDEBUG_PACKET
988             call->iovqc++;
989 #endif /* RXDEBUG_PACKET */
990             tnFree = cp->length;
991             tcurvec = 1;
992             tcurpos =
993                 (char *)cp->wirevec[1].iov_base +
994                 call->conn->securityHeaderSize;
995             tcurlen = cp->wirevec[1].iov_len - call->conn->securityHeaderSize;
996         }
997
998         if (tnFree < nbytes) {
999             /* try to extend the current packet */
1000             int len, mud;
1001             len = cp->length;
1002             mud = rx_MaxUserDataSize(call);
1003             if (mud > len) {
1004                 int want;
1005                 want = MIN(nbytes - tnFree, mud - len);
1006                 rxi_AllocDataBuf(cp, want, RX_PACKET_CLASS_SEND_CBUF);
1007                 if (cp->length > (unsigned)mud)
1008                     cp->length = mud;
1009                 tnFree += (cp->length - len);
1010                 if (cp == call->currentPacket) {
1011                     call->nFree += (cp->length - len);
1012                 }
1013             }
1014         }
1015
1016         /* fill in the next entry in the iovec */
1017         t = MIN(tcurlen, nbytes);
1018         t = MIN(tnFree, t);
1019         iov[nextio].iov_base = tcurpos;
1020         iov[nextio].iov_len = t;
1021         nbytes -= t;
1022         tcurpos += t;
1023         tcurlen -= t;
1024         tnFree -= t;
1025         nextio++;
1026
1027         if (!tcurlen) {
1028             /* need to get another struct iov */
1029             if (++tcurvec >= cp->niovecs) {
1030                 /* current packet is full, extend it or move on to next packet */
1031                 tnFree = 0;
1032             } else {
1033                 tcurpos = (char *)cp->wirevec[tcurvec].iov_base;
1034                 tcurlen = cp->wirevec[tcurvec].iov_len;
1035             }
1036         }
1037     } while (nbytes && nextio < maxio);
1038     *nio = nextio;
1039     return requestCount - nbytes;
1040 }
1041
1042 int
1043 rx_WritevAlloc(struct rx_call *call, struct iovec *iov, int *nio, int maxio,
1044                int nbytes)
1045 {
1046     int bytes;
1047     SPLVAR;
1048
1049     NETPRI;
1050     bytes = rxi_WritevAlloc(call, iov, nio, maxio, nbytes);
1051     USERPRI;
1052     return bytes;
1053 }
1054
1055 /* rxi_WritevProc -- internal version.
1056  *
1057  * Send buffers allocated in rxi_WritevAlloc.
1058  *
1059  * LOCKS USED -- called at netpri.
1060  */
1061 int
1062 rxi_WritevProc(struct rx_call *call, struct iovec *iov, int nio, int nbytes)
1063 {
1064     struct rx_packet *cp = NULL;
1065 #ifdef RX_TRACK_PACKETS
1066     struct rx_packet *p, *np;
1067 #endif
1068     int nextio;
1069     int requestCount;
1070     struct rx_queue tmpq;
1071 #ifdef RXDEBUG_PACKET
1072     u_short tmpqc;
1073 #endif
1074
1075     requestCount = nbytes;
1076     nextio = 0;
1077
1078     MUTEX_ENTER(&call->lock);
1079     if (call->error) {
1080         call->mode = RX_MODE_ERROR;
1081     } else if (call->mode != RX_MODE_SENDING) {
1082         call->error = RX_PROTOCOL_ERROR;
1083     }
1084 #ifdef AFS_GLOBAL_RXLOCK_KERNEL
1085     rxi_WaitforTQBusy(call);
1086 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
1087     cp = call->currentPacket;
1088
1089     if (call->error) {
1090         call->mode = RX_MODE_ERROR;
1091         MUTEX_EXIT(&call->lock);
1092         if (cp) {
1093 #ifdef RX_TRACK_PACKETS
1094             cp->flags &= ~RX_PKTFLAG_CP;
1095             cp->flags |= RX_PKTFLAG_IOVQ;
1096 #endif
1097             queue_Prepend(&call->iovq, cp);
1098 #ifdef RXDEBUG_PACKET
1099             call->iovqc++;
1100 #endif /* RXDEBUG_PACKET */
1101             call->currentPacket = (struct rx_packet *)0;
1102         }
1103 #ifdef RXDEBUG_PACKET
1104         call->iovqc -=
1105 #endif /* RXDEBUG_PACKET */
1106             rxi_FreePackets(0, &call->iovq);
1107         return 0;
1108     }
1109
1110     /* Loop through the I/O vector adjusting packet pointers.
1111      * Place full packets back onto the iovq once they are ready
1112      * to send. Set RX_PROTOCOL_ERROR if any problems are found in
1113      * the iovec. We put the loop condition at the end to ensure that
1114      * a zero length write will push a short packet. */
1115     nextio = 0;
1116     queue_Init(&tmpq);
1117 #ifdef RXDEBUG_PACKET
1118     tmpqc = 0;
1119 #endif /* RXDEBUG_PACKET */
1120     do {
1121         if (call->nFree == 0 && cp) {
1122             clock_NewTime();    /* Bogus:  need new time package */
1123             /* The 0, below, specifies that it is not the last packet:
1124              * there will be others. PrepareSendPacket may
1125              * alter the packet length by up to
1126              * conn->securityMaxTrailerSize */
1127             hadd32(call->bytesSent, cp->length);
1128             rxi_PrepareSendPacket(call, cp, 0);
1129 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
1130             /* PrepareSendPacket drops the call lock */
1131             rxi_WaitforTQBusy(call);
1132 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
1133             queue_Append(&tmpq, cp);
1134 #ifdef RXDEBUG_PACKET
1135             tmpqc++;
1136 #endif /* RXDEBUG_PACKET */
1137             cp = call->currentPacket = (struct rx_packet *)0;
1138
1139             /* The head of the iovq is now the current packet */
1140             if (nbytes) {
1141                 if (queue_IsEmpty(&call->iovq)) {
1142                     MUTEX_EXIT(&call->lock);
1143                     call->error = RX_PROTOCOL_ERROR;
1144 #ifdef RXDEBUG_PACKET
1145                     tmpqc -=
1146 #endif /* RXDEBUG_PACKET */
1147                         rxi_FreePackets(0, &tmpq);
1148                     return 0;
1149                 }
1150                 cp = queue_First(&call->iovq, rx_packet);
1151                 queue_Remove(cp);
1152 #ifdef RX_TRACK_PACKETS
1153                 cp->flags &= ~RX_PKTFLAG_IOVQ;
1154 #endif
1155 #ifdef RXDEBUG_PACKET
1156                 call->iovqc--;
1157 #endif /* RXDEBUG_PACKET */
1158 #ifdef RX_TRACK_PACKETS
1159                 cp->flags |= RX_PKTFLAG_CP;
1160 #endif
1161                 call->currentPacket = cp;
1162                 call->nFree = cp->length;
1163                 call->curvec = 1;
1164                 call->curpos =
1165                     (char *)cp->wirevec[1].iov_base +
1166                     call->conn->securityHeaderSize;
1167                 call->curlen =
1168                     cp->wirevec[1].iov_len - call->conn->securityHeaderSize;
1169             }
1170         }
1171
1172         if (nbytes) {
1173             /* The next iovec should point to the current position */
1174             if (iov[nextio].iov_base != call->curpos
1175                 || iov[nextio].iov_len > (int)call->curlen) {
1176                 call->error = RX_PROTOCOL_ERROR;
1177                 MUTEX_EXIT(&call->lock);
1178                 if (cp) {
1179 #ifdef RX_TRACK_PACKETS
1180                     cp->flags &= ~RX_PKTFLAG_CP;
1181 #endif
1182                     queue_Prepend(&tmpq, cp);
1183 #ifdef RXDEBUG_PACKET
1184                     tmpqc++;
1185 #endif /* RXDEBUG_PACKET */
1186                     cp = call->currentPacket = (struct rx_packet *)0;
1187                 }
1188 #ifdef RXDEBUG_PACKET
1189                 tmpqc -=
1190 #endif /* RXDEBUG_PACKET */
1191                     rxi_FreePackets(0, &tmpq);
1192                 return 0;
1193             }
1194             nbytes -= iov[nextio].iov_len;
1195             call->curpos += iov[nextio].iov_len;
1196             call->curlen -= iov[nextio].iov_len;
1197             call->nFree -= iov[nextio].iov_len;
1198             nextio++;
1199             if (call->curlen == 0) {
1200                 if (++call->curvec > cp->niovecs) {
1201                     call->nFree = 0;
1202                 } else {
1203                     call->curpos = (char *)cp->wirevec[call->curvec].iov_base;
1204                     call->curlen = cp->wirevec[call->curvec].iov_len;
1205                 }
1206             }
1207         }
1208     } while (nbytes && nextio < nio);
1209
1210     /* Move the packets from the temporary queue onto the transmit queue.
1211      * We may end up with more than call->twind packets on the queue. */
1212
1213 #ifdef RX_TRACK_PACKETS
1214     for (queue_Scan(&tmpq, p, np, rx_packet))
1215     {
1216         p->flags |= RX_PKTFLAG_TQ;
1217     }
1218 #endif
1219
1220     if (call->error)
1221         call->mode = RX_MODE_ERROR;
1222
1223     queue_SpliceAppend(&call->tq, &tmpq);
1224
1225     /* If the call is in recovery, let it exhaust its current retransmit
1226      * queue before forcing it to send new packets
1227      */
1228     if (!(call->flags & RX_CALL_FAST_RECOVER)) {
1229         rxi_Start(call, 0);
1230     }
1231
1232     /* Wait for the length of the transmit queue to fall below call->twind */
1233     while (!call->error && call->tnext + 1 > call->tfirst + (2 * call->twind)) {
1234         clock_NewTime();
1235         call->startWait = clock_Sec();
1236 #ifdef  RX_ENABLE_LOCKS
1237         CV_WAIT(&call->cv_twind, &call->lock);
1238 #else
1239         call->flags |= RX_CALL_WAIT_WINDOW_ALLOC;
1240         osi_rxSleep(&call->twind);
1241 #endif
1242         call->startWait = 0;
1243     }
1244
1245     /* cp is no longer valid since we may have given up the lock */
1246     cp = call->currentPacket;
1247
1248     if (call->error) {
1249         call->mode = RX_MODE_ERROR;
1250         call->currentPacket = NULL;
1251         MUTEX_EXIT(&call->lock);
1252         if (cp) {
1253 #ifdef RX_TRACK_PACKETS
1254             cp->flags &= ~RX_PKTFLAG_CP;
1255 #endif
1256             rxi_FreePacket(cp);
1257         }
1258         return 0;
1259     }
1260     MUTEX_EXIT(&call->lock);
1261
1262     return requestCount - nbytes;
1263 }
1264
1265 int
1266 rx_WritevProc(struct rx_call *call, struct iovec *iov, int nio, int nbytes)
1267 {
1268     int bytes;
1269     SPLVAR;
1270
1271     NETPRI;
1272     bytes = rxi_WritevProc(call, iov, nio, nbytes);
1273     USERPRI;
1274     return bytes;
1275 }
1276
1277 /* Flush any buffered data to the stream, switch to read mode
1278  * (clients) or to EOF mode (servers)
1279  *
1280  * LOCKS HELD: called at netpri.
1281  */
1282 void
1283 rxi_FlushWrite(struct rx_call *call)
1284 {
1285     struct rx_packet *cp = NULL;
1286
1287     /* Free any packets from the last call to ReadvProc/WritevProc */
1288     if (queue_IsNotEmpty(&call->iovq)) {
1289 #ifdef RXDEBUG_PACKET
1290         call->iovqc -=
1291 #endif /* RXDEBUG_PACKET */
1292             rxi_FreePackets(0, &call->iovq);
1293     }
1294
1295     if (call->mode == RX_MODE_SENDING) {
1296
1297         call->mode =
1298             (call->conn->type ==
1299              RX_CLIENT_CONNECTION ? RX_MODE_RECEIVING : RX_MODE_EOF);
1300
1301 #ifdef RX_KERNEL_TRACE
1302         {
1303             int glockOwner = ISAFS_GLOCK();
1304             if (!glockOwner)
1305                 AFS_GLOCK();
1306             afs_Trace3(afs_iclSetp, CM_TRACE_WASHERE, ICL_TYPE_STRING,
1307                        __FILE__, ICL_TYPE_INT32, __LINE__, ICL_TYPE_POINTER,
1308                        call);
1309             if (!glockOwner)
1310                 AFS_GUNLOCK();
1311         }
1312 #endif
1313
1314         MUTEX_ENTER(&call->lock);
1315         if (call->error)
1316             call->mode = RX_MODE_ERROR;
1317
1318         cp = call->currentPacket;
1319
1320         if (cp) {
1321             /* cp->length is only supposed to be the user's data */
1322             /* cp->length was already set to (then-current)
1323              * MaxUserDataSize or less. */
1324 #ifdef RX_TRACK_PACKETS
1325             cp->flags &= ~RX_PKTFLAG_CP;
1326 #endif
1327             cp->length -= call->nFree;
1328             call->currentPacket = (struct rx_packet *)0;
1329             call->nFree = 0;
1330         } else {
1331             cp = rxi_AllocSendPacket(call, 0);
1332             if (!cp) {
1333                 /* Mode can no longer be MODE_SENDING */
1334                 return;
1335             }
1336             cp->length = 0;
1337             cp->niovecs = 2;    /* header + space for rxkad stuff */
1338             call->nFree = 0;
1339         }
1340
1341         /* The 1 specifies that this is the last packet */
1342         hadd32(call->bytesSent, cp->length);
1343         rxi_PrepareSendPacket(call, cp, 1);
1344 #ifdef  AFS_GLOBAL_RXLOCK_KERNEL
1345         /* PrepareSendPacket drops the call lock */
1346         rxi_WaitforTQBusy(call);
1347 #endif /* AFS_GLOBAL_RXLOCK_KERNEL */
1348 #ifdef RX_TRACK_PACKETS
1349         cp->flags |= RX_PKTFLAG_TQ;
1350 #endif
1351         queue_Append(&call->tq, cp);
1352 #ifdef RXDEBUG_PACKET
1353         call->tqc++;
1354 #endif /* RXDEBUG_PACKET */
1355
1356         /* If the call is in recovery, let it exhaust its current retransmit
1357          * queue before forcing it to send new packets
1358          */
1359         if (!(call->flags & RX_CALL_FAST_RECOVER)) {
1360             rxi_Start(call, 0);
1361         }
1362         MUTEX_EXIT(&call->lock);
1363     }
1364 }
1365
1366 /* Flush any buffered data to the stream, switch to read mode
1367  * (clients) or to EOF mode (servers) */
1368 void
1369 rx_FlushWrite(struct rx_call *call)
1370 {
1371     SPLVAR;
1372     NETPRI;
1373     rxi_FlushWrite(call);
1374     USERPRI;
1375 }