win32-ewouldblock-20040602
[openafs.git] / src / rx / rx_packet.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 #ifdef KERNEL
12 #include "afs/param.h"
13 #else
14 #include <afs/param.h>
15 #endif
16
17 RCSID
18     ("$Header$");
19
20 #ifdef KERNEL
21 #if defined(UKERNEL)
22 #include "afs/sysincludes.h"
23 #include "afsincludes.h"
24 #include "rx/rx_kcommon.h"
25 #include "rx/rx_clock.h"
26 #include "rx/rx_queue.h"
27 #include "rx/rx_packet.h"
28 #else /* defined(UKERNEL) */
29 #ifdef RX_KERNEL_TRACE
30 #include "../rx/rx_kcommon.h"
31 #endif
32 #include "h/types.h"
33 #ifndef AFS_LINUX20_ENV
34 #include "h/systm.h"
35 #endif
36 #if defined(AFS_SGI_ENV) || defined(AFS_HPUX110_ENV)
37 #include "afs/sysincludes.h"
38 #endif
39 #if defined(AFS_OBSD_ENV)
40 #include "h/proc.h"
41 #endif
42 #include "h/socket.h"
43 #if !defined(AFS_SUN5_ENV) &&  !defined(AFS_LINUX20_ENV) && !defined(AFS_HPUX110_ENV)
44 #if     !defined(AFS_OSF_ENV) && !defined(AFS_AIX41_ENV)
45 #include "sys/mount.h"          /* it gets pulled in by something later anyway */
46 #endif
47 #include "h/mbuf.h"
48 #endif
49 #include "netinet/in.h"
50 #include "afs/afs_osi.h"
51 #include "rx_kmutex.h"
52 #include "rx/rx_clock.h"
53 #include "rx/rx_queue.h"
54 #ifdef  AFS_SUN5_ENV
55 #include <sys/sysmacros.h>
56 #endif
57 #include "rx/rx_packet.h"
58 #endif /* defined(UKERNEL) */
59 #include "rx/rx_globals.h"
60 #else /* KERNEL */
61 #include "sys/types.h"
62 #include <sys/stat.h>
63 #include <errno.h>
64 #if defined(AFS_NT40_ENV) || defined(AFS_DJGPP_ENV)
65 #ifdef AFS_NT40_ENV
66 #include <winsock2.h>
67 #ifndef EWOULDBLOCK
68 #define EWOULDBLOCK WSAEWOULDBLOCK
69 #endif
70 #else
71 #include <sys/socket.h>
72 #include <netinet/in.h>
73 #endif /* AFS_NT40_ENV */
74 #include "rx_xmit_nt.h"
75 #include <stdlib.h>
76 #else
77 #include <sys/socket.h>
78 #include <netinet/in.h>
79 #endif
80 #include "rx_clock.h"
81 #include "rx.h"
82 #include "rx_queue.h"
83 #ifdef  AFS_SUN5_ENV
84 #include <sys/sysmacros.h>
85 #endif
86 #include "rx_packet.h"
87 #include "rx_globals.h"
88 #include <lwp.h>
89 #include <assert.h>
90 #ifdef HAVE_STRING_H
91 #include <string.h>
92 #else
93 #ifdef HAVE_STRINGS_H
94 #include <strings.h>
95 #endif
96 #endif
97 #ifdef HAVE_UNISTD_H
98 #include <unistd.h>
99 #endif
100 #endif /* KERNEL */
101
102 #ifdef RX_LOCKS_DB
103 /* rxdb_fileID is used to identify the lock location, along with line#. */
104 static int rxdb_fileID = RXDB_FILE_RX_PACKET;
105 #endif /* RX_LOCKS_DB */
106 struct rx_packet *rx_mallocedP = 0;
107
108 extern char cml_version_number[];
109 extern int (*rx_almostSent) ();
110
111 static void rxi_SendDebugPacket(struct rx_packet *apacket, osi_socket asocket,
112                                 afs_int32 ahost, short aport,
113                                 afs_int32 istack);
114
115 /* some rules about packets:
116  * 1.  When a packet is allocated, the final iov_buf contains room for
117  * a security trailer, but iov_len masks that fact.  If the security
118  * package wants to add the trailer, it may do so, and then extend
119  * iov_len appropriately.  For this reason, packet's niovecs and
120  * iov_len fields should be accurate before calling PreparePacket.
121 */
122
123 /* Preconditions:
124  *        all packet buffers (iov_base) are integral multiples of 
125  *        the word size.
126  *        offset is an integral multiple of the word size.
127  */
128 afs_int32
129 rx_SlowGetInt32(struct rx_packet *packet, size_t offset)
130 {
131     unsigned int i;
132     size_t l;
133     for (l = 0, i = 1; i < packet->niovecs; i++) {
134         if (l + packet->wirevec[i].iov_len > offset) {
135             return
136                 *((afs_int32 *) ((char *)(packet->wirevec[i].iov_base) +
137                                  (offset - l)));
138         }
139         l += packet->wirevec[i].iov_len;
140     }
141
142     return 0;
143 }
144
145 /* Preconditions:
146  *        all packet buffers (iov_base) are integral multiples of the word size.
147  *        offset is an integral multiple of the word size.
148  */
149 afs_int32
150 rx_SlowPutInt32(struct rx_packet * packet, size_t offset, afs_int32 data)
151 {
152     unsigned int i;
153     size_t l;
154     for (l = 0, i = 1; i < packet->niovecs; i++) {
155         if (l + packet->wirevec[i].iov_len > offset) {
156             *((afs_int32 *) ((char *)(packet->wirevec[i].iov_base) +
157                              (offset - l))) = data;
158             return 0;
159         }
160         l += packet->wirevec[i].iov_len;
161     }
162
163     return 0;
164 }
165
166 /* Preconditions:
167  *        all packet buffers (iov_base) are integral multiples of the
168  *        word size.
169  *        offset is an integral multiple of the word size.
170  * Packet Invariants:
171  *         all buffers are contiguously arrayed in the iovec from 0..niovecs-1
172  */
173 afs_int32
174 rx_SlowReadPacket(struct rx_packet * packet, unsigned int offset, int resid,
175                   char *out)
176 {
177     unsigned int i, j, l, r;
178     for (l = 0, i = 1; i < packet->niovecs; i++) {
179         if (l + packet->wirevec[i].iov_len > offset) {
180             break;
181         }
182         l += packet->wirevec[i].iov_len;
183     }
184
185     /* i is the iovec which contains the first little bit of data in which we
186      * are interested.  l is the total length of everything prior to this iovec.
187      * j is the number of bytes we can safely copy out of this iovec.
188      */
189     r = resid;
190     while ((resid > 0) && (i < packet->niovecs)) {
191         j = MIN(resid, packet->wirevec[i].iov_len - (offset - l));
192         memcpy(out, (char *)(packet->wirevec[i].iov_base) + (offset - l), j);
193         resid -= j;
194         l += packet->wirevec[i].iov_len;
195         i++;
196     }
197
198     return (resid ? (r - resid) : r);
199 }
200
201
202 /* Preconditions:
203  *        all packet buffers (iov_base) are integral multiples of the
204  *        word size.
205  *        offset is an integral multiple of the word size.
206  */
207 afs_int32
208 rx_SlowWritePacket(struct rx_packet * packet, int offset, int resid, char *in)
209 {
210     int i, j, l, r;
211     char *b;
212
213     for (l = 0, i = 1; i < packet->niovecs; i++) {
214         if (l + packet->wirevec[i].iov_len > offset) {
215             break;
216         }
217         l += packet->wirevec[i].iov_len;
218     }
219
220     /* i is the iovec which contains the first little bit of data in which we
221      * are interested.  l is the total length of everything prior to this iovec.
222      * j is the number of bytes we can safely copy out of this iovec.
223      */
224     r = resid;
225     while ((resid > 0) && (i < RX_MAXWVECS)) {
226         if (i >= packet->niovecs)
227             if (rxi_AllocDataBuf(packet, resid, RX_PACKET_CLASS_SEND_CBUF) > 0) /* ++niovecs as a side-effect */
228                 break;
229
230         b = (char *)(packet->wirevec[i].iov_base) + (offset - l);
231         j = MIN(resid, packet->wirevec[i].iov_len - (offset - l));
232         memcpy(b, in, j);
233         resid -= j;
234         l += packet->wirevec[i].iov_len;
235         i++;
236     }
237
238     return (resid ? (r - resid) : r);
239 }
240
241 static struct rx_packet *
242 allocCBuf(int class)
243 {
244     struct rx_packet *c;
245     SPLVAR;
246
247     NETPRI;
248     MUTEX_ENTER(&rx_freePktQ_lock);
249
250 #ifdef KERNEL
251     if (rxi_OverQuota(class)) {
252         c = NULL;
253         rxi_NeedMorePackets = TRUE;
254         MUTEX_ENTER(&rx_stats_mutex);
255         switch (class) {
256         case RX_PACKET_CLASS_RECEIVE:
257             rx_stats.receivePktAllocFailures++;
258             break;
259         case RX_PACKET_CLASS_SEND:
260             rx_stats.sendPktAllocFailures++;
261             break;
262         case RX_PACKET_CLASS_SPECIAL:
263             rx_stats.specialPktAllocFailures++;
264             break;
265         case RX_PACKET_CLASS_RECV_CBUF:
266             rx_stats.receiveCbufPktAllocFailures++;
267             break;
268         case RX_PACKET_CLASS_SEND_CBUF:
269             rx_stats.sendCbufPktAllocFailures++;
270             break;
271         }
272         MUTEX_EXIT(&rx_stats_mutex);
273         goto done;
274     }
275
276     if (queue_IsEmpty(&rx_freePacketQueue)) {
277         c = NULL;
278         rxi_NeedMorePackets = TRUE;
279         goto done;
280     }
281 #else /* KERNEL */
282     if (queue_IsEmpty(&rx_freePacketQueue)) {
283         rxi_MorePacketsNoLock(rx_initSendWindow);
284     }
285 #endif /* KERNEL */
286
287     rx_nFreePackets--;
288     c = queue_First(&rx_freePacketQueue, rx_packet);
289     queue_Remove(c);
290     if (!(c->flags & RX_PKTFLAG_FREE))
291         osi_Panic("rxi_AllocPacket: packet not free\n");
292     c->flags = 0;               /* clear RX_PKTFLAG_FREE, initialize the rest */
293     c->header.flags = 0;
294
295 #ifdef KERNEL
296   done:
297 #endif
298     MUTEX_EXIT(&rx_freePktQ_lock);
299
300     USERPRI;
301     return c;
302 }
303
304 /*
305  * Free a packet currently used as a continuation buffer
306  */
307 void
308 rxi_freeCBuf(struct rx_packet *c)
309 {
310     SPLVAR;
311
312     NETPRI;
313     MUTEX_ENTER(&rx_freePktQ_lock);
314
315     rxi_FreePacketNoLock(c);
316     /* Wakeup anyone waiting for packets */
317     rxi_PacketsUnWait();
318
319     MUTEX_EXIT(&rx_freePktQ_lock);
320     USERPRI;
321 }
322
323 /* this one is kind of awful.
324  * In rxkad, the packet has been all shortened, and everything, ready for 
325  * sending.  All of a sudden, we discover we need some of that space back.
326  * This isn't terribly general, because it knows that the packets are only
327  * rounded up to the EBS (userdata + security header).
328  */
329 int
330 rxi_RoundUpPacket(struct rx_packet *p, unsigned int nb)
331 {
332     int i;
333     i = p->niovecs - 1;
334     if (p->wirevec[i].iov_base == (caddr_t) p->localdata) {
335         if (p->wirevec[i].iov_len <= RX_FIRSTBUFFERSIZE - nb) {
336             p->wirevec[i].iov_len += nb;
337             return 0;
338         }
339     } else {
340         if (p->wirevec[i].iov_len <= RX_CBUFFERSIZE - nb) {
341             p->wirevec[i].iov_len += nb;
342             return 0;
343         }
344     }
345
346     return 0;
347 }
348
349 /* get sufficient space to store nb bytes of data (or more), and hook
350  * it into the supplied packet.  Return nbytes<=0 if successful, otherwise
351  * returns the number of bytes >0 which it failed to come up with.
352  * Don't need to worry about locking on packet, since only
353  * one thread can manipulate one at a time. Locking on continution
354  * packets is handled by allocCBuf */
355 /* MTUXXX don't need to go throught the for loop if we can trust niovecs */
356 int
357 rxi_AllocDataBuf(struct rx_packet *p, int nb, int class)
358 {
359     int i;
360
361     for (i = p->niovecs; nb > 0 && i < RX_MAXWVECS; i++) {
362         register struct rx_packet *cb;
363         if ((cb = allocCBuf(class))) {
364             p->wirevec[i].iov_base = (caddr_t) cb->localdata;
365             p->wirevec[i].iov_len = RX_CBUFFERSIZE;
366             nb -= RX_CBUFFERSIZE;
367             p->length += RX_CBUFFERSIZE;
368             p->niovecs++;
369         } else
370             break;
371     }
372
373     return nb;
374 }
375
376 /* Add more packet buffers */
377 void
378 rxi_MorePackets(int apackets)
379 {
380     struct rx_packet *p, *e;
381     int getme;
382     SPLVAR;
383
384     getme = apackets * sizeof(struct rx_packet);
385     p = rx_mallocedP = (struct rx_packet *)osi_Alloc(getme);
386
387     PIN(p, getme);              /* XXXXX */
388     memset((char *)p, 0, getme);
389     NETPRI;
390     AFS_RXGLOCK();
391     MUTEX_ENTER(&rx_freePktQ_lock);
392
393     for (e = p + apackets; p < e; p++) {
394         p->wirevec[0].iov_base = (char *)(p->wirehead);
395         p->wirevec[0].iov_len = RX_HEADER_SIZE;
396         p->wirevec[1].iov_base = (char *)(p->localdata);
397         p->wirevec[1].iov_len = RX_FIRSTBUFFERSIZE;
398         p->flags |= RX_PKTFLAG_FREE;
399         p->niovecs = 2;
400
401         queue_Append(&rx_freePacketQueue, p);
402     }
403     rx_nFreePackets += apackets;
404     rxi_NeedMorePackets = FALSE;
405     rxi_PacketsUnWait();
406
407     AFS_RXGUNLOCK();
408     MUTEX_EXIT(&rx_freePktQ_lock);
409     USERPRI;
410 }
411
412 #ifndef KERNEL
413 /* Add more packet buffers */
414 void
415 rxi_MorePacketsNoLock(int apackets)
416 {
417     struct rx_packet *p, *e;
418     int getme;
419
420     /* allocate enough packets that 1/4 of the packets will be able
421      * to hold maximal amounts of data */
422     apackets += (apackets / 4)
423         * ((rx_maxJumboRecvSize - RX_FIRSTBUFFERSIZE) / RX_CBUFFERSIZE);
424     getme = apackets * sizeof(struct rx_packet);
425     p = rx_mallocedP = (struct rx_packet *)osi_Alloc(getme);
426
427     memset((char *)p, 0, getme);
428
429     for (e = p + apackets; p < e; p++) {
430         p->wirevec[0].iov_base = (char *)(p->wirehead);
431         p->wirevec[0].iov_len = RX_HEADER_SIZE;
432         p->wirevec[1].iov_base = (char *)(p->localdata);
433         p->wirevec[1].iov_len = RX_FIRSTBUFFERSIZE;
434         p->flags |= RX_PKTFLAG_FREE;
435         p->niovecs = 2;
436
437         queue_Append(&rx_freePacketQueue, p);
438     }
439     rx_nFreePackets += apackets;
440     rxi_NeedMorePackets = FALSE;
441     rxi_PacketsUnWait();
442 }
443 #endif /* !KERNEL */
444
445 void
446 rxi_FreeAllPackets(void)
447 {
448     /* must be called at proper interrupt level, etcetera */
449     /* MTUXXX need to free all Packets */
450     osi_Free(rx_mallocedP,
451              (rx_maxReceiveWindow + 2) * sizeof(struct rx_packet));
452     UNPIN(rx_mallocedP, (rx_maxReceiveWindow + 2) * sizeof(struct rx_packet));
453 }
454
455 /* Allocate more packets iff we need more continuation buffers */
456 /* In kernel, can't page in memory with interrupts disabled, so we
457  * don't use the event mechanism. */
458 void
459 rx_CheckPackets(void)
460 {
461     if (rxi_NeedMorePackets) {
462         rxi_MorePackets(rx_initSendWindow);
463     }
464 }
465
466 /* In the packet freeing routine below, the assumption is that
467    we want all of the packets to be used equally frequently, so that we
468    don't get packet buffers paging out.  It would be just as valid to
469    assume that we DO want them to page out if not many are being used.
470    In any event, we assume the former, and append the packets to the end
471    of the free list.  */
472 /* This explanation is bogus.  The free list doesn't remain in any kind of
473    useful order for afs_int32: the packets in use get pretty much randomly scattered 
474    across all the pages.  In order to permit unused {packets,bufs} to page out, they
475    must be stored so that packets which are adjacent in memory are adjacent in the 
476    free list.  An array springs rapidly to mind.
477    */
478
479 /* Actually free the packet p. */
480 void
481 rxi_FreePacketNoLock(struct rx_packet *p)
482 {
483     dpf(("Free %x\n", (int)p));
484
485     if (p->flags & RX_PKTFLAG_FREE)
486         osi_Panic("rxi_FreePacketNoLock: packet already free\n");
487     rx_nFreePackets++;
488     p->flags |= RX_PKTFLAG_FREE;
489     queue_Append(&rx_freePacketQueue, p);
490 }
491
492 int
493 rxi_FreeDataBufsNoLock(struct rx_packet *p, int first)
494 {
495     struct iovec *iov, *end;
496
497     if (first != 1)             /* MTUXXX */
498         osi_Panic("FreeDataBufs 1: first must be 1");
499     iov = &p->wirevec[1];
500     end = iov + (p->niovecs - 1);
501     if (iov->iov_base != (caddr_t) p->localdata)        /* MTUXXX */
502         osi_Panic("FreeDataBufs 2: vec 1 must be localdata");
503     for (iov++; iov < end; iov++) {
504         if (!iov->iov_base)
505             osi_Panic("FreeDataBufs 3: vecs 2-niovecs must not be NULL");
506         rxi_FreePacketNoLock(RX_CBUF_TO_PACKET(iov->iov_base, p));
507     }
508     p->length = 0;
509     p->niovecs = 0;
510
511     return 0;
512 }
513
514 int rxi_nBadIovecs = 0;
515
516 /* rxi_RestoreDataBufs 
517  *
518  * Restore the correct sizes to the iovecs. Called when reusing a packet
519  * for reading off the wire.
520  */
521 void
522 rxi_RestoreDataBufs(struct rx_packet *p)
523 {
524     int i;
525     struct iovec *iov = &p->wirevec[2];
526
527     p->wirevec[0].iov_base = (char *)(p->wirehead);
528     p->wirevec[0].iov_len = RX_HEADER_SIZE;
529     p->wirevec[1].iov_base = (char *)(p->localdata);
530     p->wirevec[1].iov_len = RX_FIRSTBUFFERSIZE;
531
532     for (i = 2, iov = &p->wirevec[2]; i < p->niovecs; i++, iov++) {
533         if (!iov->iov_base) {
534             rxi_nBadIovecs++;
535             p->niovecs = i;
536             break;
537         }
538         iov->iov_len = RX_CBUFFERSIZE;
539     }
540 }
541
542 int
543 rxi_TrimDataBufs(struct rx_packet *p, int first)
544 {
545     int length;
546     struct iovec *iov, *end;
547     SPLVAR;
548
549     if (first != 1)
550         osi_Panic("TrimDataBufs 1: first must be 1");
551
552     /* Skip over continuation buffers containing message data */
553     iov = &p->wirevec[2];
554     end = iov + (p->niovecs - 2);
555     length = p->length - p->wirevec[1].iov_len;
556     for (; iov < end && length > 0; iov++) {
557         if (!iov->iov_base)
558             osi_Panic("TrimDataBufs 3: vecs 1-niovecs must not be NULL");
559         length -= iov->iov_len;
560     }
561
562     /* iov now points to the first empty data buffer. */
563     if (iov >= end)
564         return 0;
565
566     NETPRI;
567     MUTEX_ENTER(&rx_freePktQ_lock);
568
569     for (; iov < end; iov++) {
570         if (!iov->iov_base)
571             osi_Panic("TrimDataBufs 4: vecs 2-niovecs must not be NULL");
572         rxi_FreePacketNoLock(RX_CBUF_TO_PACKET(iov->iov_base, p));
573         p->niovecs--;
574     }
575     rxi_PacketsUnWait();
576
577     MUTEX_EXIT(&rx_freePktQ_lock);
578     USERPRI;
579
580     return 0;
581 }
582
583 /* Free the packet p.  P is assumed not to be on any queue, i.e.
584  * remove it yourself first if you call this routine. */
585 void
586 rxi_FreePacket(struct rx_packet *p)
587 {
588     SPLVAR;
589
590     NETPRI;
591     MUTEX_ENTER(&rx_freePktQ_lock);
592
593     rxi_FreeDataBufsNoLock(p, 1);
594     rxi_FreePacketNoLock(p);
595     /* Wakeup anyone waiting for packets */
596     rxi_PacketsUnWait();
597
598     MUTEX_EXIT(&rx_freePktQ_lock);
599     USERPRI;
600 }
601
602
603 /* rxi_AllocPacket sets up p->length so it reflects the number of 
604  * bytes in the packet at this point, **not including** the header.
605  * The header is absolutely necessary, besides, this is the way the
606  * length field is usually used */
607 struct rx_packet *
608 rxi_AllocPacketNoLock(int class)
609 {
610     register struct rx_packet *p;
611
612 #ifdef KERNEL
613     if (rxi_OverQuota(class)) {
614         rxi_NeedMorePackets = TRUE;
615         MUTEX_ENTER(&rx_stats_mutex);
616         switch (class) {
617         case RX_PACKET_CLASS_RECEIVE:
618             rx_stats.receivePktAllocFailures++;
619             break;
620         case RX_PACKET_CLASS_SEND:
621             rx_stats.sendPktAllocFailures++;
622             break;
623         case RX_PACKET_CLASS_SPECIAL:
624             rx_stats.specialPktAllocFailures++;
625             break;
626         case RX_PACKET_CLASS_RECV_CBUF:
627             rx_stats.receiveCbufPktAllocFailures++;
628             break;
629         case RX_PACKET_CLASS_SEND_CBUF:
630             rx_stats.sendCbufPktAllocFailures++;
631             break;
632         }
633         MUTEX_EXIT(&rx_stats_mutex);
634         return (struct rx_packet *)0;
635     }
636 #endif /* KERNEL */
637
638     MUTEX_ENTER(&rx_stats_mutex);
639     rx_stats.packetRequests++;
640     MUTEX_EXIT(&rx_stats_mutex);
641
642 #ifdef KERNEL
643     if (queue_IsEmpty(&rx_freePacketQueue))
644         osi_Panic("rxi_AllocPacket error");
645 #else /* KERNEL */
646     if (queue_IsEmpty(&rx_freePacketQueue))
647         rxi_MorePacketsNoLock(rx_initSendWindow);
648 #endif /* KERNEL */
649
650     rx_nFreePackets--;
651     p = queue_First(&rx_freePacketQueue, rx_packet);
652     if (!(p->flags & RX_PKTFLAG_FREE))
653         osi_Panic("rxi_AllocPacket: packet not free\n");
654
655     dpf(("Alloc %x, class %d\n", (int)p, class));
656
657     queue_Remove(p);
658     p->flags = 0;               /* clear RX_PKTFLAG_FREE, initialize the rest */
659     p->header.flags = 0;
660
661     /* have to do this here because rx_FlushWrite fiddles with the iovs in
662      * order to truncate outbound packets.  In the near future, may need 
663      * to allocate bufs from a static pool here, and/or in AllocSendPacket
664      */
665     p->wirevec[0].iov_base = (char *)(p->wirehead);
666     p->wirevec[0].iov_len = RX_HEADER_SIZE;
667     p->wirevec[1].iov_base = (char *)(p->localdata);
668     p->wirevec[1].iov_len = RX_FIRSTBUFFERSIZE;
669     p->niovecs = 2;
670     p->length = RX_FIRSTBUFFERSIZE;
671     return p;
672 }
673
674 struct rx_packet *
675 rxi_AllocPacket(int class)
676 {
677     register struct rx_packet *p;
678
679     MUTEX_ENTER(&rx_freePktQ_lock);
680     p = rxi_AllocPacketNoLock(class);
681     MUTEX_EXIT(&rx_freePktQ_lock);
682     return p;
683 }
684
685 /* This guy comes up with as many buffers as it {takes,can get} given
686  * the MTU for this call. It also sets the packet length before
687  * returning.  caution: this is often called at NETPRI
688  * Called with call locked.
689  */
690 struct rx_packet *
691 rxi_AllocSendPacket(register struct rx_call *call, int want)
692 {
693     register struct rx_packet *p = (struct rx_packet *)0;
694     register int mud;
695     register unsigned delta;
696
697     SPLVAR;
698     mud = call->MTU - RX_HEADER_SIZE;
699     delta =
700         rx_GetSecurityHeaderSize(rx_ConnectionOf(call)) +
701         rx_GetSecurityMaxTrailerSize(rx_ConnectionOf(call));
702
703     while (!(call->error)) {
704         MUTEX_ENTER(&rx_freePktQ_lock);
705         /* if an error occurred, or we get the packet we want, we're done */
706         if ((p = rxi_AllocPacketNoLock(RX_PACKET_CLASS_SEND))) {
707             MUTEX_EXIT(&rx_freePktQ_lock);
708
709             want += delta;
710             want = MIN(want, mud);
711
712             if ((unsigned)want > p->length)
713                 (void)rxi_AllocDataBuf(p, (want - p->length),
714                                        RX_PACKET_CLASS_SEND_CBUF);
715
716             if ((unsigned)p->length > mud)
717                 p->length = mud;
718
719             if (delta >= p->length) {
720                 rxi_FreePacket(p);
721                 p = NULL;
722             } else {
723                 p->length -= delta;
724             }
725             break;
726         }
727
728         /* no error occurred, and we didn't get a packet, so we sleep.
729          * At this point, we assume that packets will be returned
730          * sooner or later, as packets are acknowledged, and so we
731          * just wait.  */
732         NETPRI;
733         call->flags |= RX_CALL_WAIT_PACKETS;
734         CALL_HOLD(call, RX_CALL_REFCOUNT_PACKET);
735         MUTEX_EXIT(&call->lock);
736         rx_waitingForPackets = 1;
737
738 #ifdef  RX_ENABLE_LOCKS
739         CV_WAIT(&rx_waitingForPackets_cv, &rx_freePktQ_lock);
740 #else
741         osi_rxSleep(&rx_waitingForPackets);
742 #endif
743         MUTEX_EXIT(&rx_freePktQ_lock);
744         MUTEX_ENTER(&call->lock);
745         CALL_RELE(call, RX_CALL_REFCOUNT_PACKET);
746         call->flags &= ~RX_CALL_WAIT_PACKETS;
747         USERPRI;
748     }
749
750     return p;
751 }
752
753 #ifndef KERNEL
754
755 /* count the number of used FDs */
756 static int
757 CountFDs(register int amax)
758 {
759     struct stat tstat;
760     register int i, code;
761     register int count;
762
763     count = 0;
764     for (i = 0; i < amax; i++) {
765         code = fstat(i, &tstat);
766         if (code == 0)
767             count++;
768     }
769     return count;
770 }
771
772 #else /* KERNEL */
773
774 #define CountFDs(amax) amax
775
776 #endif /* KERNEL */
777
778 #if !defined(KERNEL) || defined(UKERNEL)
779
780 /* This function reads a single packet from the interface into the
781  * supplied packet buffer (*p).  Return 0 if the packet is bogus.  The
782  * (host,port) of the sender are stored in the supplied variables, and
783  * the data length of the packet is stored in the packet structure.
784  * The header is decoded. */
785 int
786 rxi_ReadPacket(int socket, register struct rx_packet *p, afs_uint32 * host,
787                u_short * port)
788 {
789     struct sockaddr_in from;
790     int nbytes;
791     afs_int32 rlen;
792     register afs_int32 tlen, savelen;
793     struct msghdr msg;
794     rx_computelen(p, tlen);
795     rx_SetDataSize(p, tlen);    /* this is the size of the user data area */
796
797     tlen += RX_HEADER_SIZE;     /* now this is the size of the entire packet */
798     rlen = rx_maxJumboRecvSize; /* this is what I am advertising.  Only check
799                                  * it once in order to avoid races.  */
800     tlen = rlen - tlen;
801     if (tlen > 0) {
802         tlen = rxi_AllocDataBuf(p, tlen, RX_PACKET_CLASS_SEND_CBUF);
803         if (tlen > 0) {
804             tlen = rlen - tlen;
805         } else
806             tlen = rlen;
807     } else
808         tlen = rlen;
809
810     /* Extend the last iovec for padding, it's just to make sure that the 
811      * read doesn't return more data than we expect, and is done to get around
812      * our problems caused by the lack of a length field in the rx header.
813      * Use the extra buffer that follows the localdata in each packet
814      * structure. */
815     savelen = p->wirevec[p->niovecs - 1].iov_len;
816     p->wirevec[p->niovecs - 1].iov_len += RX_EXTRABUFFERSIZE;
817
818     memset((char *)&msg, 0, sizeof(msg));
819     msg.msg_name = (char *)&from;
820     msg.msg_namelen = sizeof(struct sockaddr_in);
821     msg.msg_iov = p->wirevec;
822     msg.msg_iovlen = p->niovecs;
823     nbytes = rxi_Recvmsg(socket, &msg, 0);
824
825     /* restore the vec to its correct state */
826     p->wirevec[p->niovecs - 1].iov_len = savelen;
827
828     p->length = (nbytes - RX_HEADER_SIZE);
829     if ((nbytes > tlen) || (p->length & 0x8000)) {      /* Bogus packet */
830         if (nbytes > 0)
831             rxi_MorePackets(rx_initSendWindow);
832         else if (nbytes < 0 && errno == EWOULDBLOCK) {
833             MUTEX_ENTER(&rx_stats_mutex);
834             rx_stats.noPacketOnRead++;
835             MUTEX_EXIT(&rx_stats_mutex);
836         }
837         else {
838             MUTEX_ENTER(&rx_stats_mutex);
839             rx_stats.bogusPacketOnRead++;
840             rx_stats.bogusHost = from.sin_addr.s_addr;
841             MUTEX_EXIT(&rx_stats_mutex);
842             dpf(("B: bogus packet from [%x,%d] nb=%d", from.sin_addr.s_addr,
843                  from.sin_port, nbytes));
844         }
845         return 0;
846     } else {
847         /* Extract packet header. */
848         rxi_DecodePacketHeader(p);
849
850         *host = from.sin_addr.s_addr;
851         *port = from.sin_port;
852         if (p->header.type > 0 && p->header.type < RX_N_PACKET_TYPES) {
853             struct rx_peer *peer;
854             MUTEX_ENTER(&rx_stats_mutex);
855             rx_stats.packetsRead[p->header.type - 1]++;
856             MUTEX_EXIT(&rx_stats_mutex);
857             /*
858              * Try to look up this peer structure.  If it doesn't exist,
859              * don't create a new one - 
860              * we don't keep count of the bytes sent/received if a peer
861              * structure doesn't already exist.
862              *
863              * The peer/connection cleanup code assumes that there is 1 peer
864              * per connection.  If we actually created a peer structure here
865              * and this packet was an rxdebug packet, the peer structure would
866              * never be cleaned up.
867              */
868             peer = rxi_FindPeer(*host, *port, 0, 0);
869             if (peer) {
870                 MUTEX_ENTER(&peer->peer_lock);
871                 hadd32(peer->bytesReceived, p->length);
872                 MUTEX_EXIT(&peer->peer_lock);
873             }
874         }
875
876         /* Free any empty packet buffers at the end of this packet */
877         rxi_TrimDataBufs(p, 1);
878
879         return 1;
880     }
881 }
882
883 #endif /* !KERNEL || UKERNEL */
884
885 /* This function splits off the first packet in a jumbo packet.
886  * As of AFS 3.5, jumbograms contain more than one fixed size
887  * packet, and the RX_JUMBO_PACKET flag is set in all but the
888  * last packet header. All packets (except the last) are padded to
889  * fall on RX_CBUFFERSIZE boundaries.
890  * HACK: We store the length of the first n-1 packets in the
891  * last two pad bytes. */
892
893 struct rx_packet *
894 rxi_SplitJumboPacket(register struct rx_packet *p, afs_int32 host, short port,
895                      int first)
896 {
897     struct rx_packet *np;
898     struct rx_jumboHeader *jp;
899     int niov, i;
900     struct iovec *iov;
901     int length;
902     afs_uint32 temp;
903
904     /* All but the last packet in each jumbogram are RX_JUMBOBUFFERSIZE
905      * bytes in length. All but the first packet are preceded by
906      * an abbreviated four byte header. The length of the last packet
907      * is calculated from the size of the jumbogram. */
908     length = RX_JUMBOBUFFERSIZE + RX_JUMBOHEADERSIZE;
909
910     if ((int)p->length < length) {
911         dpf(("rxi_SplitJumboPacket: bogus length %d\n", p->length));
912         return NULL;
913     }
914     niov = p->niovecs - 2;
915     if (niov < 1) {
916         dpf(("rxi_SplitJumboPacket: bogus niovecs %d\n", p->niovecs));
917         return NULL;
918     }
919     iov = &p->wirevec[2];
920     np = RX_CBUF_TO_PACKET(iov->iov_base, p);
921
922     /* Get a pointer to the abbreviated packet header */
923     jp = (struct rx_jumboHeader *)
924         ((char *)(p->wirevec[1].iov_base) + RX_JUMBOBUFFERSIZE);
925
926     /* Set up the iovecs for the next packet */
927     np->wirevec[0].iov_base = (char *)(&np->wirehead[0]);
928     np->wirevec[0].iov_len = sizeof(struct rx_header);
929     np->wirevec[1].iov_base = (char *)(&np->localdata[0]);
930     np->wirevec[1].iov_len = length - RX_JUMBOHEADERSIZE;
931     np->niovecs = niov + 1;
932     for (i = 2, iov++; i <= niov; i++, iov++) {
933         np->wirevec[i] = *iov;
934     }
935     np->length = p->length - length;
936     p->length = RX_JUMBOBUFFERSIZE;
937     p->niovecs = 2;
938
939     /* Convert the jumbo packet header to host byte order */
940     temp = ntohl(*(afs_uint32 *) jp);
941     jp->flags = (u_char) (temp >> 24);
942     jp->cksum = (u_short) (temp);
943
944     /* Fill in the packet header */
945     np->header = p->header;
946     np->header.serial = p->header.serial + 1;
947     np->header.seq = p->header.seq + 1;
948     np->header.flags = jp->flags;
949     np->header.spare = jp->cksum;
950
951     return np;
952 }
953
954 #ifndef KERNEL
955 /* Send a udp datagram */
956 int
957 osi_NetSend(osi_socket socket, void *addr, struct iovec *dvec, int nvecs,
958             int length, int istack)
959 {
960     struct msghdr msg;
961
962     memset(&msg, 0, sizeof(msg));
963     msg.msg_iov = dvec;
964     msg.msg_iovlen = nvecs;
965     msg.msg_name = addr;
966     msg.msg_namelen = sizeof(struct sockaddr_in);
967
968     rxi_Sendmsg(socket, &msg, 0);
969
970     return 0;
971 }
972 #elif !defined(UKERNEL)
973 /*
974  * message receipt is done in rxk_input or rx_put.
975  */
976
977 #if defined(AFS_SUN5_ENV) || defined(AFS_HPUX110_ENV)
978 /*
979  * Copy an mblock to the contiguous area pointed to by cp.
980  * MTUXXX Supposed to skip <off> bytes and copy <len> bytes,
981  * but it doesn't really.
982  * Returns the number of bytes not transferred.
983  * The message is NOT changed.
984  */
985 static int
986 cpytoc(mblk_t * mp, register int off, register int len, register char *cp)
987 {
988     register int n;
989
990     for (; mp && len > 0; mp = mp->b_cont) {
991         if (mp->b_datap->db_type != M_DATA) {
992             return -1;
993         }
994         n = MIN(len, (mp->b_wptr - mp->b_rptr));
995         memcpy(cp, (char *)mp->b_rptr, n);
996         cp += n;
997         len -= n;
998         mp->b_rptr += n;
999     }
1000     return (len);
1001 }
1002
1003 /* MTUXXX Supposed to skip <off> bytes and copy <len> bytes,
1004  * but it doesn't really.  
1005  * This sucks, anyway, do it like m_cpy.... below 
1006  */
1007 static int
1008 cpytoiovec(mblk_t * mp, int off, int len, register struct iovec *iovs,
1009            int niovs)
1010 {
1011     register int m, n, o, t, i;
1012
1013     for (i = -1, t = 0; i < niovs && mp && len > 0; mp = mp->b_cont) {
1014         if (mp->b_datap->db_type != M_DATA) {
1015             return -1;
1016         }
1017         n = MIN(len, (mp->b_wptr - mp->b_rptr));
1018         len -= n;
1019         while (n) {
1020             if (!t) {
1021                 o = 0;
1022                 i++;
1023                 t = iovs[i].iov_len;
1024             }
1025             m = MIN(n, t);
1026             memcpy(iovs[i].iov_base + o, (char *)mp->b_rptr, m);
1027             mp->b_rptr += m;
1028             o += m;
1029             t -= m;
1030             n -= m;
1031         }
1032     }
1033     return (len);
1034 }
1035
1036 #define m_cpytoc(a, b, c, d)  cpytoc(a, b, c, d)
1037 #define m_cpytoiovec(a, b, c, d, e) cpytoiovec(a, b, c, d, e)
1038 #else
1039 #if !defined(AFS_LINUX20_ENV)
1040 static int
1041 m_cpytoiovec(struct mbuf *m, int off, int len, struct iovec iovs[], int niovs)
1042 {
1043     caddr_t p1, p2;
1044     unsigned int l1, l2, i, t;
1045
1046     if (m == NULL || off < 0 || len < 0 || iovs == NULL)
1047         osi_Panic("m_cpytoiovec");      /* MTUXXX probably don't need this check */
1048
1049     while (off && m)
1050         if (m->m_len <= off) {
1051             off -= m->m_len;
1052             m = m->m_next;
1053             continue;
1054         } else
1055             break;
1056
1057     if (m == NULL)
1058         return len;
1059
1060     p1 = mtod(m, caddr_t) + off;
1061     l1 = m->m_len - off;
1062     i = 0;
1063     p2 = iovs[0].iov_base;
1064     l2 = iovs[0].iov_len;
1065
1066     while (len) {
1067         t = MIN(l1, MIN(l2, (unsigned int)len));
1068         memcpy(p2, p1, t);
1069         p1 += t;
1070         p2 += t;
1071         l1 -= t;
1072         l2 -= t;
1073         len -= t;
1074         if (!l1) {
1075             m = m->m_next;
1076             if (!m)
1077                 break;
1078             p1 = mtod(m, caddr_t);
1079             l1 = m->m_len;
1080         }
1081         if (!l2) {
1082             if (++i >= niovs)
1083                 break;
1084             p2 = iovs[i].iov_base;
1085             l2 = iovs[i].iov_len;
1086         }
1087
1088     }
1089
1090     return len;
1091 }
1092 #endif /* LINUX */
1093 #endif /* AFS_SUN5_ENV */
1094
1095 #if !defined(AFS_LINUX20_ENV)
1096 int
1097 rx_mb_to_packet(amb, free, hdr_len, data_len, phandle)
1098 #if defined(AFS_SUN5_ENV) || defined(AFS_HPUX110_ENV)
1099      mblk_t *amb;
1100 #else
1101      struct mbuf *amb;
1102 #endif
1103      void (*free) ();
1104      struct rx_packet *phandle;
1105      int hdr_len, data_len;
1106 {
1107     register int code;
1108
1109     code =
1110         m_cpytoiovec(amb, hdr_len, data_len, phandle->wirevec,
1111                      phandle->niovecs);
1112     (*free) (amb);
1113
1114     return code;
1115 }
1116 #endif /* LINUX */
1117 #endif /*KERNEL && !UKERNEL */
1118
1119
1120 /* send a response to a debug packet */
1121
1122 struct rx_packet *
1123 rxi_ReceiveDebugPacket(register struct rx_packet *ap, osi_socket asocket,
1124                        afs_int32 ahost, short aport, int istack)
1125 {
1126     struct rx_debugIn tin;
1127     afs_int32 tl;
1128     struct rx_serverQueueEntry *np, *nqe;
1129
1130     /*
1131      * Only respond to client-initiated Rx debug packets,
1132      * and clear the client flag in the response.
1133      */
1134     if (ap->header.flags & RX_CLIENT_INITIATED) {
1135         ap->header.flags = ap->header.flags & ~RX_CLIENT_INITIATED;
1136         rxi_EncodePacketHeader(ap);
1137     } else {
1138         return ap;
1139     }
1140
1141     rx_packetread(ap, 0, sizeof(struct rx_debugIn), (char *)&tin);
1142     /* all done with packet, now set length to the truth, so we can 
1143      * reuse this packet */
1144     rx_computelen(ap, ap->length);
1145
1146     tin.type = ntohl(tin.type);
1147     tin.index = ntohl(tin.index);
1148     switch (tin.type) {
1149     case RX_DEBUGI_GETSTATS:{
1150             struct rx_debugStats tstat;
1151
1152             /* get basic stats */
1153             memset((char *)&tstat, 0, sizeof(tstat));   /* make sure spares are zero */
1154             tstat.version = RX_DEBUGI_VERSION;
1155 #ifndef RX_ENABLE_LOCKS
1156             tstat.waitingForPackets = rx_waitingForPackets;
1157 #endif
1158             MUTEX_ENTER(&rx_serverPool_lock);
1159             tstat.nFreePackets = htonl(rx_nFreePackets);
1160             tstat.callsExecuted = htonl(rxi_nCalls);
1161             tstat.packetReclaims = htonl(rx_packetReclaims);
1162             tstat.usedFDs = CountFDs(64);
1163             tstat.nWaiting = htonl(rx_nWaiting);
1164             queue_Count(&rx_idleServerQueue, np, nqe, rx_serverQueueEntry,
1165                         tstat.idleThreads);
1166             MUTEX_EXIT(&rx_serverPool_lock);
1167             tstat.idleThreads = htonl(tstat.idleThreads);
1168             tl = sizeof(struct rx_debugStats) - ap->length;
1169             if (tl > 0)
1170                 tl = rxi_AllocDataBuf(ap, tl, RX_PACKET_CLASS_SEND_CBUF);
1171
1172             if (tl <= 0) {
1173                 rx_packetwrite(ap, 0, sizeof(struct rx_debugStats),
1174                                (char *)&tstat);
1175                 ap->length = sizeof(struct rx_debugStats);
1176                 rxi_SendDebugPacket(ap, asocket, ahost, aport, istack);
1177                 rx_computelen(ap, ap->length);
1178             }
1179             break;
1180         }
1181
1182     case RX_DEBUGI_GETALLCONN:
1183     case RX_DEBUGI_GETCONN:{
1184             int i, j;
1185             register struct rx_connection *tc;
1186             struct rx_call *tcall;
1187             struct rx_debugConn tconn;
1188             int all = (tin.type == RX_DEBUGI_GETALLCONN);
1189
1190
1191             tl = sizeof(struct rx_debugConn) - ap->length;
1192             if (tl > 0)
1193                 tl = rxi_AllocDataBuf(ap, tl, RX_PACKET_CLASS_SEND_CBUF);
1194             if (tl > 0)
1195                 return ap;
1196
1197             memset((char *)&tconn, 0, sizeof(tconn));   /* make sure spares are zero */
1198             /* get N'th (maybe) "interesting" connection info */
1199             for (i = 0; i < rx_hashTableSize; i++) {
1200 #if !defined(KERNEL)
1201                 /* the time complexity of the algorithm used here
1202                  * exponentially increses with the number of connections.
1203                  */
1204 #ifdef AFS_PTHREAD_ENV
1205                 pthread_yield();
1206 #else
1207                 (void)IOMGR_Poll();
1208 #endif
1209 #endif
1210                 MUTEX_ENTER(&rx_connHashTable_lock);
1211                 /* We might be slightly out of step since we are not 
1212                  * locking each call, but this is only debugging output.
1213                  */
1214                 for (tc = rx_connHashTable[i]; tc; tc = tc->next) {
1215                     if ((all || rxi_IsConnInteresting(tc))
1216                         && tin.index-- <= 0) {
1217                         tconn.host = tc->peer->host;
1218                         tconn.port = tc->peer->port;
1219                         tconn.cid = htonl(tc->cid);
1220                         tconn.epoch = htonl(tc->epoch);
1221                         tconn.serial = htonl(tc->serial);
1222                         for (j = 0; j < RX_MAXCALLS; j++) {
1223                             tconn.callNumber[j] = htonl(tc->callNumber[j]);
1224                             if ((tcall = tc->call[j])) {
1225                                 tconn.callState[j] = tcall->state;
1226                                 tconn.callMode[j] = tcall->mode;
1227                                 tconn.callFlags[j] = tcall->flags;
1228                                 if (queue_IsNotEmpty(&tcall->rq))
1229                                     tconn.callOther[j] |= RX_OTHER_IN;
1230                                 if (queue_IsNotEmpty(&tcall->tq))
1231                                     tconn.callOther[j] |= RX_OTHER_OUT;
1232                             } else
1233                                 tconn.callState[j] = RX_STATE_NOTINIT;
1234                         }
1235
1236                         tconn.natMTU = htonl(tc->peer->natMTU);
1237                         tconn.error = htonl(tc->error);
1238                         tconn.flags = tc->flags;
1239                         tconn.type = tc->type;
1240                         tconn.securityIndex = tc->securityIndex;
1241                         if (tc->securityObject) {
1242                             RXS_GetStats(tc->securityObject, tc,
1243                                          &tconn.secStats);
1244 #define DOHTONL(a) (tconn.secStats.a = htonl(tconn.secStats.a))
1245 #define DOHTONS(a) (tconn.secStats.a = htons(tconn.secStats.a))
1246                             DOHTONL(flags);
1247                             DOHTONL(expires);
1248                             DOHTONL(packetsReceived);
1249                             DOHTONL(packetsSent);
1250                             DOHTONL(bytesReceived);
1251                             DOHTONL(bytesSent);
1252                             for (i = 0;
1253                                  i <
1254                                  sizeof(tconn.secStats.spares) /
1255                                  sizeof(short); i++)
1256                                 DOHTONS(spares[i]);
1257                             for (i = 0;
1258                                  i <
1259                                  sizeof(tconn.secStats.sparel) /
1260                                  sizeof(afs_int32); i++)
1261                                 DOHTONL(sparel[i]);
1262                         }
1263
1264                         MUTEX_EXIT(&rx_connHashTable_lock);
1265                         rx_packetwrite(ap, 0, sizeof(struct rx_debugConn),
1266                                        (char *)&tconn);
1267                         tl = ap->length;
1268                         ap->length = sizeof(struct rx_debugConn);
1269                         rxi_SendDebugPacket(ap, asocket, ahost, aport,
1270                                             istack);
1271                         ap->length = tl;
1272                         return ap;
1273                     }
1274                 }
1275                 MUTEX_EXIT(&rx_connHashTable_lock);
1276             }
1277             /* if we make it here, there are no interesting packets */
1278             tconn.cid = htonl(0xffffffff);      /* means end */
1279             rx_packetwrite(ap, 0, sizeof(struct rx_debugConn),
1280                            (char *)&tconn);
1281             tl = ap->length;
1282             ap->length = sizeof(struct rx_debugConn);
1283             rxi_SendDebugPacket(ap, asocket, ahost, aport, istack);
1284             ap->length = tl;
1285             break;
1286         }
1287
1288         /*
1289          * Pass back all the peer structures we have available
1290          */
1291
1292     case RX_DEBUGI_GETPEER:{
1293             int i;
1294             register struct rx_peer *tp;
1295             struct rx_debugPeer tpeer;
1296
1297
1298             tl = sizeof(struct rx_debugPeer) - ap->length;
1299             if (tl > 0)
1300                 tl = rxi_AllocDataBuf(ap, tl, RX_PACKET_CLASS_SEND_CBUF);
1301             if (tl > 0)
1302                 return ap;
1303
1304             memset((char *)&tpeer, 0, sizeof(tpeer));
1305             for (i = 0; i < rx_hashTableSize; i++) {
1306 #if !defined(KERNEL)
1307                 /* the time complexity of the algorithm used here
1308                  * exponentially increses with the number of peers.
1309                  *
1310                  * Yielding after processing each hash table entry
1311                  * and dropping rx_peerHashTable_lock.
1312                  * also increases the risk that we will miss a new
1313                  * entry - but we are willing to live with this
1314                  * limitation since this is meant for debugging only
1315                  */
1316 #ifdef AFS_PTHREAD_ENV
1317                 pthread_yield();
1318 #else
1319                 (void)IOMGR_Poll();
1320 #endif
1321 #endif
1322                 MUTEX_ENTER(&rx_peerHashTable_lock);
1323                 for (tp = rx_peerHashTable[i]; tp; tp = tp->next) {
1324                     if (tin.index-- <= 0) {
1325                         tpeer.host = tp->host;
1326                         tpeer.port = tp->port;
1327                         tpeer.ifMTU = htons(tp->ifMTU);
1328                         tpeer.idleWhen = htonl(tp->idleWhen);
1329                         tpeer.refCount = htons(tp->refCount);
1330                         tpeer.burstSize = tp->burstSize;
1331                         tpeer.burst = tp->burst;
1332                         tpeer.burstWait.sec = htonl(tp->burstWait.sec);
1333                         tpeer.burstWait.usec = htonl(tp->burstWait.usec);
1334                         tpeer.rtt = htonl(tp->rtt);
1335                         tpeer.rtt_dev = htonl(tp->rtt_dev);
1336                         tpeer.timeout.sec = htonl(tp->timeout.sec);
1337                         tpeer.timeout.usec = htonl(tp->timeout.usec);
1338                         tpeer.nSent = htonl(tp->nSent);
1339                         tpeer.reSends = htonl(tp->reSends);
1340                         tpeer.inPacketSkew = htonl(tp->inPacketSkew);
1341                         tpeer.outPacketSkew = htonl(tp->outPacketSkew);
1342                         tpeer.rateFlag = htonl(tp->rateFlag);
1343                         tpeer.natMTU = htons(tp->natMTU);
1344                         tpeer.maxMTU = htons(tp->maxMTU);
1345                         tpeer.maxDgramPackets = htons(tp->maxDgramPackets);
1346                         tpeer.ifDgramPackets = htons(tp->ifDgramPackets);
1347                         tpeer.MTU = htons(tp->MTU);
1348                         tpeer.cwind = htons(tp->cwind);
1349                         tpeer.nDgramPackets = htons(tp->nDgramPackets);
1350                         tpeer.congestSeq = htons(tp->congestSeq);
1351                         tpeer.bytesSent.high = htonl(tp->bytesSent.high);
1352                         tpeer.bytesSent.low = htonl(tp->bytesSent.low);
1353                         tpeer.bytesReceived.high =
1354                             htonl(tp->bytesReceived.high);
1355                         tpeer.bytesReceived.low =
1356                             htonl(tp->bytesReceived.low);
1357
1358                         MUTEX_EXIT(&rx_peerHashTable_lock);
1359                         rx_packetwrite(ap, 0, sizeof(struct rx_debugPeer),
1360                                        (char *)&tpeer);
1361                         tl = ap->length;
1362                         ap->length = sizeof(struct rx_debugPeer);
1363                         rxi_SendDebugPacket(ap, asocket, ahost, aport,
1364                                             istack);
1365                         ap->length = tl;
1366                         return ap;
1367                     }
1368                 }
1369                 MUTEX_EXIT(&rx_peerHashTable_lock);
1370             }
1371             /* if we make it here, there are no interesting packets */
1372             tpeer.host = htonl(0xffffffff);     /* means end */
1373             rx_packetwrite(ap, 0, sizeof(struct rx_debugPeer),
1374                            (char *)&tpeer);
1375             tl = ap->length;
1376             ap->length = sizeof(struct rx_debugPeer);
1377             rxi_SendDebugPacket(ap, asocket, ahost, aport, istack);
1378             ap->length = tl;
1379             break;
1380         }
1381
1382     case RX_DEBUGI_RXSTATS:{
1383             int i;
1384             afs_int32 *s;
1385
1386             tl = sizeof(rx_stats) - ap->length;
1387             if (tl > 0)
1388                 tl = rxi_AllocDataBuf(ap, tl, RX_PACKET_CLASS_SEND_CBUF);
1389             if (tl > 0)
1390                 return ap;
1391
1392             /* Since its all int32s convert to network order with a loop. */
1393             MUTEX_ENTER(&rx_stats_mutex);
1394             s = (afs_int32 *) & rx_stats;
1395             for (i = 0; i < sizeof(rx_stats) / sizeof(afs_int32); i++, s++)
1396                 rx_PutInt32(ap, i * sizeof(afs_int32), htonl(*s));
1397
1398             tl = ap->length;
1399             ap->length = sizeof(rx_stats);
1400             MUTEX_EXIT(&rx_stats_mutex);
1401             rxi_SendDebugPacket(ap, asocket, ahost, aport, istack);
1402             ap->length = tl;
1403             break;
1404         }
1405
1406     default:
1407         /* error response packet */
1408         tin.type = htonl(RX_DEBUGI_BADTYPE);
1409         tin.index = tin.type;
1410         rx_packetwrite(ap, 0, sizeof(struct rx_debugIn), (char *)&tin);
1411         tl = ap->length;
1412         ap->length = sizeof(struct rx_debugIn);
1413         rxi_SendDebugPacket(ap, asocket, ahost, aport, istack);
1414         ap->length = tl;
1415         break;
1416     }
1417     return ap;
1418 }
1419
1420 struct rx_packet *
1421 rxi_ReceiveVersionPacket(register struct rx_packet *ap, osi_socket asocket,
1422                          afs_int32 ahost, short aport, int istack)
1423 {
1424     afs_int32 tl;
1425
1426     /*
1427      * Only respond to client-initiated version requests, and
1428      * clear that flag in the response.
1429      */
1430     if (ap->header.flags & RX_CLIENT_INITIATED) {
1431         char buf[66];
1432
1433         ap->header.flags = ap->header.flags & ~RX_CLIENT_INITIATED;
1434         rxi_EncodePacketHeader(ap);
1435         memset(buf, 0, sizeof(buf));
1436         strncpy(buf, cml_version_number + 4, sizeof(buf) - 1);
1437         rx_packetwrite(ap, 0, 65, buf);
1438         tl = ap->length;
1439         ap->length = 65;
1440         rxi_SendDebugPacket(ap, asocket, ahost, aport, istack);
1441         ap->length = tl;
1442     }
1443
1444     return ap;
1445 }
1446
1447
1448 /* send a debug packet back to the sender */
1449 static void
1450 rxi_SendDebugPacket(struct rx_packet *apacket, osi_socket asocket,
1451                     afs_int32 ahost, short aport, afs_int32 istack)
1452 {
1453     struct sockaddr_in taddr;
1454     int i;
1455     int nbytes;
1456     int saven = 0;
1457     size_t savelen = 0;
1458 #ifdef KERNEL
1459     int waslocked = ISAFS_GLOCK();
1460 #endif
1461
1462     taddr.sin_family = AF_INET;
1463     taddr.sin_port = aport;
1464     taddr.sin_addr.s_addr = ahost;
1465 #ifdef STRUCT_SOCKADDR_HAS_SA_LEN
1466     taddr.sin_len = sizeof(struct sockaddr_in);
1467 #endif
1468
1469     /* We need to trim the niovecs. */
1470     nbytes = apacket->length;
1471     for (i = 1; i < apacket->niovecs; i++) {
1472         if (nbytes <= apacket->wirevec[i].iov_len) {
1473             savelen = apacket->wirevec[i].iov_len;
1474             saven = apacket->niovecs;
1475             apacket->wirevec[i].iov_len = nbytes;
1476             apacket->niovecs = i + 1;   /* so condition fails because i == niovecs */
1477         } else
1478             nbytes -= apacket->wirevec[i].iov_len;
1479     }
1480     AFS_RXGUNLOCK();
1481 #ifdef KERNEL
1482 #ifdef RX_KERNEL_TRACE
1483     if (ICL_SETACTIVE(afs_iclSetp)) {
1484         if (!waslocked)
1485             AFS_GLOCK();
1486         afs_Trace1(afs_iclSetp, CM_TRACE_TIMESTAMP, ICL_TYPE_STRING,
1487                    "before osi_NetSend()");
1488         AFS_GUNLOCK();
1489     } else
1490 #else
1491     if (waslocked)
1492         AFS_GUNLOCK();
1493 #endif
1494 #endif
1495     /* debug packets are not reliably delivered, hence the cast below. */
1496     (void)osi_NetSend(asocket, &taddr, apacket->wirevec, apacket->niovecs,
1497                       apacket->length + RX_HEADER_SIZE, istack);
1498 #ifdef KERNEL
1499 #ifdef RX_KERNEL_TRACE
1500     if (ICL_SETACTIVE(afs_iclSetp)) {
1501         AFS_GLOCK();
1502         afs_Trace1(afs_iclSetp, CM_TRACE_TIMESTAMP, ICL_TYPE_STRING,
1503                    "after osi_NetSend()");
1504         if (!waslocked)
1505             AFS_GUNLOCK();
1506     } else
1507 #else
1508     if (waslocked)
1509         AFS_GLOCK();
1510 #endif
1511 #endif
1512     AFS_RXGLOCK();
1513     if (saven) {                /* means we truncated the packet above. */
1514         apacket->wirevec[i - 1].iov_len = savelen;
1515         apacket->niovecs = saven;
1516     }
1517
1518 }
1519
1520 /* Send the packet to appropriate destination for the specified
1521  * call.  The header is first encoded and placed in the packet.
1522  */
1523 void
1524 rxi_SendPacket(struct rx_call *call, struct rx_connection *conn,
1525                struct rx_packet *p, int istack)
1526 {
1527 #if defined(KERNEL)
1528     int waslocked;
1529 #endif
1530     int code;
1531     struct sockaddr_in addr;
1532     register struct rx_peer *peer = conn->peer;
1533     osi_socket socket;
1534 #ifdef RXDEBUG
1535     char deliveryType = 'S';
1536 #endif
1537     /* The address we're sending the packet to */
1538     memset(&addr, 0, sizeof(addr));
1539     addr.sin_family = AF_INET;
1540     addr.sin_port = peer->port;
1541     addr.sin_addr.s_addr = peer->host;
1542
1543     /* This stuff should be revamped, I think, so that most, if not
1544      * all, of the header stuff is always added here.  We could
1545      * probably do away with the encode/decode routines. XXXXX */
1546
1547     /* Stamp each packet with a unique serial number.  The serial
1548      * number is maintained on a connection basis because some types
1549      * of security may be based on the serial number of the packet,
1550      * and security is handled on a per authenticated-connection
1551      * basis. */
1552     /* Pre-increment, to guarantee no zero serial number; a zero
1553      * serial number means the packet was never sent. */
1554     MUTEX_ENTER(&conn->conn_data_lock);
1555     p->header.serial = ++conn->serial;
1556     MUTEX_EXIT(&conn->conn_data_lock);
1557     /* This is so we can adjust retransmit time-outs better in the face of 
1558      * rapidly changing round-trip times.  RTO estimation is not a la Karn.
1559      */
1560     if (p->firstSerial == 0) {
1561         p->firstSerial = p->header.serial;
1562     }
1563 #ifdef RXDEBUG
1564     /* If an output tracer function is defined, call it with the packet and
1565      * network address.  Note this function may modify its arguments. */
1566     if (rx_almostSent) {
1567         int drop = (*rx_almostSent) (p, &addr);
1568         /* drop packet if return value is non-zero? */
1569         if (drop)
1570             deliveryType = 'D'; /* Drop the packet */
1571     }
1572 #endif
1573
1574     /* Get network byte order header */
1575     rxi_EncodePacketHeader(p);  /* XXX in the event of rexmit, etc, don't need to 
1576                                  * touch ALL the fields */
1577
1578     /* Send the packet out on the same socket that related packets are being
1579      * received on */
1580     socket =
1581         (conn->type ==
1582          RX_CLIENT_CONNECTION ? rx_socket : conn->service->socket);
1583
1584 #ifdef RXDEBUG
1585     /* Possibly drop this packet,  for testing purposes */
1586     if ((deliveryType == 'D')
1587         || ((rx_intentionallyDroppedPacketsPer100 > 0)
1588             && (random() % 100 < rx_intentionallyDroppedPacketsPer100))) {
1589         deliveryType = 'D';     /* Drop the packet */
1590     } else {
1591         deliveryType = 'S';     /* Send the packet */
1592 #endif /* RXDEBUG */
1593
1594         /* Loop until the packet is sent.  We'd prefer just to use a
1595          * blocking socket, but unfortunately the interface doesn't
1596          * allow us to have the socket block in send mode, and not
1597          * block in receive mode */
1598         AFS_RXGUNLOCK();
1599 #ifdef KERNEL
1600         waslocked = ISAFS_GLOCK();
1601 #ifdef RX_KERNEL_TRACE
1602         if (ICL_SETACTIVE(afs_iclSetp)) {
1603             if (!waslocked)
1604                 AFS_GLOCK();
1605             afs_Trace1(afs_iclSetp, CM_TRACE_TIMESTAMP, ICL_TYPE_STRING,
1606                        "before osi_NetSend()");
1607             AFS_GUNLOCK();
1608         } else
1609 #else
1610         if (waslocked)
1611             AFS_GUNLOCK();
1612 #endif
1613 #endif
1614         if ((code =
1615              osi_NetSend(socket, &addr, p->wirevec, p->niovecs,
1616                          p->length + RX_HEADER_SIZE, istack)) != 0) {
1617             /* send failed, so let's hurry up the resend, eh? */
1618             MUTEX_ENTER(&rx_stats_mutex);
1619             rx_stats.netSendFailures++;
1620             MUTEX_EXIT(&rx_stats_mutex);
1621             p->retryTime = p->timeSent; /* resend it very soon */
1622             clock_Addmsec(&(p->retryTime),
1623                           10 + (((afs_uint32) p->backoff) << 8));
1624
1625 #if defined(KERNEL) && defined(AFS_LINUX20_ENV)
1626             /* Linux is nice -- it can tell us right away that we cannot
1627              * reach this recipient by returning an ENETUNREACH error
1628              * code.  So, when this happens let's "down" the host NOW so
1629              * we don't sit around waiting for this host to timeout later.
1630              */
1631             if (call && code == -ENETUNREACH)
1632                 call->lastReceiveTime = 0;
1633 #endif
1634         }
1635 #ifdef KERNEL
1636 #ifdef RX_KERNEL_TRACE
1637         if (ICL_SETACTIVE(afs_iclSetp)) {
1638             AFS_GLOCK();
1639             afs_Trace1(afs_iclSetp, CM_TRACE_TIMESTAMP, ICL_TYPE_STRING,
1640                        "after osi_NetSend()");
1641             if (!waslocked)
1642                 AFS_GUNLOCK();
1643         } else
1644 #else
1645         if (waslocked)
1646             AFS_GLOCK();
1647 #endif
1648 #endif
1649         AFS_RXGLOCK();
1650 #ifdef RXDEBUG
1651     }
1652     dpf(("%c %d %s: %x.%u.%u.%u.%u.%u.%u flags %d, packet %x resend %d.%0.3d len %d", deliveryType, p->header.serial, rx_packetTypes[p->header.type - 1], peer->host, peer->port, p->header.serial, p->header.epoch, p->header.cid, p->header.callNumber, p->header.seq, p->header.flags, (int)p, p->retryTime.sec, p->retryTime.usec / 1000, p->length));
1653 #endif
1654     MUTEX_ENTER(&rx_stats_mutex);
1655     rx_stats.packetsSent[p->header.type - 1]++;
1656     MUTEX_EXIT(&rx_stats_mutex);
1657     MUTEX_ENTER(&peer->peer_lock);
1658     hadd32(peer->bytesSent, p->length);
1659     MUTEX_EXIT(&peer->peer_lock);
1660 }
1661
1662 /* Send a list of packets to appropriate destination for the specified
1663  * connection.  The headers are first encoded and placed in the packets.
1664  */
1665 void
1666 rxi_SendPacketList(struct rx_call *call, struct rx_connection *conn,
1667                    struct rx_packet **list, int len, int istack)
1668 {
1669 #if     defined(AFS_SUN5_ENV) && defined(KERNEL)
1670     int waslocked;
1671 #endif
1672     struct sockaddr_in addr;
1673     register struct rx_peer *peer = conn->peer;
1674     osi_socket socket;
1675     struct rx_packet *p = NULL;
1676     struct iovec wirevec[RX_MAXIOVECS];
1677     int i, length, code;
1678     afs_uint32 serial;
1679     afs_uint32 temp;
1680     struct rx_jumboHeader *jp;
1681 #ifdef RXDEBUG
1682     char deliveryType = 'S';
1683 #endif
1684     /* The address we're sending the packet to */
1685     addr.sin_family = AF_INET;
1686     addr.sin_port = peer->port;
1687     addr.sin_addr.s_addr = peer->host;
1688
1689     if (len + 1 > RX_MAXIOVECS) {
1690         osi_Panic("rxi_SendPacketList, len > RX_MAXIOVECS\n");
1691     }
1692
1693     /*
1694      * Stamp the packets in this jumbogram with consecutive serial numbers
1695      */
1696     MUTEX_ENTER(&conn->conn_data_lock);
1697     serial = conn->serial;
1698     conn->serial += len;
1699     MUTEX_EXIT(&conn->conn_data_lock);
1700
1701
1702     /* This stuff should be revamped, I think, so that most, if not
1703      * all, of the header stuff is always added here.  We could
1704      * probably do away with the encode/decode routines. XXXXX */
1705
1706     jp = NULL;
1707     length = RX_HEADER_SIZE;
1708     wirevec[0].iov_base = (char *)(&list[0]->wirehead[0]);
1709     wirevec[0].iov_len = RX_HEADER_SIZE;
1710     for (i = 0; i < len; i++) {
1711         p = list[i];
1712
1713         /* The whole 3.5 jumbogram scheme relies on packets fitting
1714          * in a single packet buffer. */
1715         if (p->niovecs > 2) {
1716             osi_Panic("rxi_SendPacketList, niovecs > 2\n");
1717         }
1718
1719         /* Set the RX_JUMBO_PACKET flags in all but the last packets
1720          * in this chunk.  */
1721         if (i < len - 1) {
1722             if (p->length != RX_JUMBOBUFFERSIZE) {
1723                 osi_Panic("rxi_SendPacketList, length != jumbo size\n");
1724             }
1725             p->header.flags |= RX_JUMBO_PACKET;
1726             length += RX_JUMBOBUFFERSIZE + RX_JUMBOHEADERSIZE;
1727             wirevec[i + 1].iov_len = RX_JUMBOBUFFERSIZE + RX_JUMBOHEADERSIZE;
1728         } else {
1729             wirevec[i + 1].iov_len = p->length;
1730             length += p->length;
1731         }
1732         wirevec[i + 1].iov_base = (char *)(&p->localdata[0]);
1733         if (jp != NULL) {
1734             /* Convert jumbo packet header to network byte order */
1735             temp = (afs_uint32) (p->header.flags) << 24;
1736             temp |= (afs_uint32) (p->header.spare);
1737             *(afs_uint32 *) jp = htonl(temp);
1738         }
1739         jp = (struct rx_jumboHeader *)
1740             ((char *)(&p->localdata[0]) + RX_JUMBOBUFFERSIZE);
1741
1742         /* Stamp each packet with a unique serial number.  The serial
1743          * number is maintained on a connection basis because some types
1744          * of security may be based on the serial number of the packet,
1745          * and security is handled on a per authenticated-connection
1746          * basis. */
1747         /* Pre-increment, to guarantee no zero serial number; a zero
1748          * serial number means the packet was never sent. */
1749         p->header.serial = ++serial;
1750         /* This is so we can adjust retransmit time-outs better in the face of 
1751          * rapidly changing round-trip times.  RTO estimation is not a la Karn.
1752          */
1753         if (p->firstSerial == 0) {
1754             p->firstSerial = p->header.serial;
1755         }
1756 #ifdef RXDEBUG
1757         /* If an output tracer function is defined, call it with the packet and
1758          * network address.  Note this function may modify its arguments. */
1759         if (rx_almostSent) {
1760             int drop = (*rx_almostSent) (p, &addr);
1761             /* drop packet if return value is non-zero? */
1762             if (drop)
1763                 deliveryType = 'D';     /* Drop the packet */
1764         }
1765 #endif
1766
1767         /* Get network byte order header */
1768         rxi_EncodePacketHeader(p);      /* XXX in the event of rexmit, etc, don't need to 
1769                                          * touch ALL the fields */
1770     }
1771
1772     /* Send the packet out on the same socket that related packets are being
1773      * received on */
1774     socket =
1775         (conn->type ==
1776          RX_CLIENT_CONNECTION ? rx_socket : conn->service->socket);
1777
1778 #ifdef RXDEBUG
1779     /* Possibly drop this packet,  for testing purposes */
1780     if ((deliveryType == 'D')
1781         || ((rx_intentionallyDroppedPacketsPer100 > 0)
1782             && (random() % 100 < rx_intentionallyDroppedPacketsPer100))) {
1783         deliveryType = 'D';     /* Drop the packet */
1784     } else {
1785         deliveryType = 'S';     /* Send the packet */
1786 #endif /* RXDEBUG */
1787
1788         /* Loop until the packet is sent.  We'd prefer just to use a
1789          * blocking socket, but unfortunately the interface doesn't
1790          * allow us to have the socket block in send mode, and not
1791          * block in receive mode */
1792         AFS_RXGUNLOCK();
1793 #if     defined(AFS_SUN5_ENV) && defined(KERNEL)
1794         waslocked = ISAFS_GLOCK();
1795         if (!istack && waslocked)
1796             AFS_GUNLOCK();
1797 #endif
1798         if ((code =
1799              osi_NetSend(socket, &addr, &wirevec[0], len + 1, length,
1800                          istack)) != 0) {
1801             /* send failed, so let's hurry up the resend, eh? */
1802             MUTEX_ENTER(&rx_stats_mutex);
1803             rx_stats.netSendFailures++;
1804             MUTEX_EXIT(&rx_stats_mutex);
1805             for (i = 0; i < len; i++) {
1806                 p = list[i];
1807                 p->retryTime = p->timeSent;     /* resend it very soon */
1808                 clock_Addmsec(&(p->retryTime),
1809                               10 + (((afs_uint32) p->backoff) << 8));
1810             }
1811 #if defined(KERNEL) && defined(AFS_LINUX20_ENV)
1812             /* Linux is nice -- it can tell us right away that we cannot
1813              * reach this recipient by returning an ENETUNREACH error
1814              * code.  So, when this happens let's "down" the host NOW so
1815              * we don't sit around waiting for this host to timeout later.
1816              */
1817             if (call && code == -ENETUNREACH)
1818                 call->lastReceiveTime = 0;
1819 #endif
1820         }
1821 #if     defined(AFS_SUN5_ENV) && defined(KERNEL)
1822         if (!istack && waslocked)
1823             AFS_GLOCK();
1824 #endif
1825         AFS_RXGLOCK();
1826 #ifdef RXDEBUG
1827     }
1828
1829     assert(p != NULL);
1830
1831     dpf(("%c %d %s: %x.%u.%u.%u.%u.%u.%u flags %d, packet %x resend %d.%0.3d len %d", 
1832            deliveryType, p->header.serial, rx_packetTypes[p->header.type - 1], 
1833            peer->host, peer->port, p->header.serial, p->header.epoch, 
1834            p->header.cid, p->header.callNumber, p->header.seq, p->header.flags,
1835            (int)p, p->retryTime.sec, p->retryTime.usec / 1000, p->length));
1836
1837 #endif
1838     MUTEX_ENTER(&rx_stats_mutex);
1839     rx_stats.packetsSent[p->header.type - 1]++;
1840     MUTEX_EXIT(&rx_stats_mutex);
1841     MUTEX_ENTER(&peer->peer_lock);
1842
1843     hadd32(peer->bytesSent, p->length);
1844     MUTEX_EXIT(&peer->peer_lock);
1845 }
1846
1847
1848 /* Send a "special" packet to the peer connection.  If call is
1849  * specified, then the packet is directed to a specific call channel
1850  * associated with the connection, otherwise it is directed to the
1851  * connection only. Uses optionalPacket if it is supplied, rather than
1852  * allocating a new packet buffer.  Nbytes is the length of the data
1853  * portion of the packet.  If data is non-null, nbytes of data are
1854  * copied into the packet.  Type is the type of the packet, as defined
1855  * in rx.h.  Bug: there's a lot of duplication between this and other
1856  * routines.  This needs to be cleaned up. */
1857 struct rx_packet *
1858 rxi_SendSpecial(register struct rx_call *call,
1859                 register struct rx_connection *conn,
1860                 struct rx_packet *optionalPacket, int type, char *data,
1861                 int nbytes, int istack)
1862 {
1863     /* Some of the following stuff should be common code for all
1864      * packet sends (it's repeated elsewhere) */
1865     register struct rx_packet *p;
1866     unsigned int i = 0;
1867     int savelen = 0, saven = 0;
1868     int channel, callNumber;
1869     if (call) {
1870         channel = call->channel;
1871         callNumber = *call->callNumber;
1872         /* BUSY packets refer to the next call on this connection */
1873         if (type == RX_PACKET_TYPE_BUSY) {
1874             callNumber++;
1875         }
1876     } else {
1877         channel = 0;
1878         callNumber = 0;
1879     }
1880     p = optionalPacket;
1881     if (!p) {
1882         p = rxi_AllocPacket(RX_PACKET_CLASS_SPECIAL);
1883         if (!p)
1884             osi_Panic("rxi_SendSpecial failure");
1885     }
1886
1887     if (nbytes != -1)
1888         p->length = nbytes;
1889     else
1890         nbytes = p->length;
1891     p->header.serviceId = conn->serviceId;
1892     p->header.securityIndex = conn->securityIndex;
1893     p->header.cid = (conn->cid | channel);
1894     p->header.callNumber = callNumber;
1895     p->header.seq = 0;
1896     p->header.epoch = conn->epoch;
1897     p->header.type = type;
1898     p->header.flags = 0;
1899     if (conn->type == RX_CLIENT_CONNECTION)
1900         p->header.flags |= RX_CLIENT_INITIATED;
1901     if (data)
1902         rx_packetwrite(p, 0, nbytes, data);
1903
1904     for (i = 1; i < p->niovecs; i++) {
1905         if (nbytes <= p->wirevec[i].iov_len) {
1906             savelen = p->wirevec[i].iov_len;
1907             saven = p->niovecs;
1908             p->wirevec[i].iov_len = nbytes;
1909             p->niovecs = i + 1; /* so condition fails because i == niovecs */
1910         } else
1911             nbytes -= p->wirevec[i].iov_len;
1912     }
1913
1914     if (call)
1915         rxi_Send(call, p, istack);
1916     else
1917         rxi_SendPacket((struct rx_call *)0, conn, p, istack);
1918     if (saven) {                /* means we truncated the packet above.  We probably don't  */
1919         /* really need to do this, but it seems safer this way, given that  */
1920         /* sneaky optionalPacket... */
1921         p->wirevec[i - 1].iov_len = savelen;
1922         p->niovecs = saven;
1923     }
1924     if (!optionalPacket)
1925         rxi_FreePacket(p);
1926     return optionalPacket;
1927 }
1928
1929
1930 /* Encode the packet's header (from the struct header in the packet to
1931  * the net byte order representation in the wire representation of the
1932  * packet, which is what is actually sent out on the wire) */
1933 void
1934 rxi_EncodePacketHeader(register struct rx_packet *p)
1935 {
1936     register afs_uint32 *buf = (afs_uint32 *) (p->wirevec[0].iov_base); /* MTUXXX */
1937
1938     memset((char *)buf, 0, RX_HEADER_SIZE);
1939     *buf++ = htonl(p->header.epoch);
1940     *buf++ = htonl(p->header.cid);
1941     *buf++ = htonl(p->header.callNumber);
1942     *buf++ = htonl(p->header.seq);
1943     *buf++ = htonl(p->header.serial);
1944     *buf++ = htonl((((afs_uint32) p->header.type) << 24)
1945                    | (((afs_uint32) p->header.flags) << 16)
1946                    | (p->header.userStatus << 8) | p->header.securityIndex);
1947     /* Note: top 16 bits of this next word were reserved */
1948     *buf++ = htonl((p->header.spare << 16) | (p->header.serviceId & 0xffff));
1949 }
1950
1951 /* Decode the packet's header (from net byte order to a struct header) */
1952 void
1953 rxi_DecodePacketHeader(register struct rx_packet *p)
1954 {
1955     register afs_uint32 *buf = (afs_uint32 *) (p->wirevec[0].iov_base); /* MTUXXX */
1956     afs_uint32 temp;
1957
1958     p->header.epoch = ntohl(*buf);
1959     buf++;
1960     p->header.cid = ntohl(*buf);
1961     buf++;
1962     p->header.callNumber = ntohl(*buf);
1963     buf++;
1964     p->header.seq = ntohl(*buf);
1965     buf++;
1966     p->header.serial = ntohl(*buf);
1967     buf++;
1968
1969     temp = ntohl(*buf);
1970     buf++;
1971
1972     /* C will truncate byte fields to bytes for me */
1973     p->header.type = temp >> 24;
1974     p->header.flags = temp >> 16;
1975     p->header.userStatus = temp >> 8;
1976     p->header.securityIndex = temp >> 0;
1977
1978     temp = ntohl(*buf);
1979     buf++;
1980
1981     p->header.serviceId = (temp & 0xffff);
1982     p->header.spare = temp >> 16;
1983     /* Note: top 16 bits of this last word are the security checksum */
1984 }
1985
1986 void
1987 rxi_PrepareSendPacket(register struct rx_call *call,
1988                       register struct rx_packet *p, register int last)
1989 {
1990     register struct rx_connection *conn = call->conn;
1991     int i, j;
1992     ssize_t len;                /* len must be a signed type; it can go negative */
1993
1994     p->flags &= ~RX_PKTFLAG_ACKED;
1995     p->header.cid = (conn->cid | call->channel);
1996     p->header.serviceId = conn->serviceId;
1997     p->header.securityIndex = conn->securityIndex;
1998     p->header.callNumber = *call->callNumber;
1999     p->header.seq = call->tnext++;
2000     p->header.epoch = conn->epoch;
2001     p->header.type = RX_PACKET_TYPE_DATA;
2002     p->header.flags = 0;
2003     p->header.spare = 0;
2004     if (conn->type == RX_CLIENT_CONNECTION)
2005         p->header.flags |= RX_CLIENT_INITIATED;
2006
2007     if (last)
2008         p->header.flags |= RX_LAST_PACKET;
2009
2010     clock_Zero(&p->retryTime);  /* Never yet transmitted */
2011     clock_Zero(&p->firstSent);  /* Never yet transmitted */
2012     p->header.serial = 0;       /* Another way of saying never transmitted... */
2013     p->backoff = 0;
2014
2015     /* Now that we're sure this is the last data on the call, make sure
2016      * that the "length" and the sum of the iov_lens matches. */
2017     len = p->length + call->conn->securityHeaderSize;
2018
2019     for (i = 1; i < p->niovecs && len > 0; i++) {
2020         len -= p->wirevec[i].iov_len;
2021     }
2022     if (len > 0) {
2023         osi_Panic("PrepareSendPacket 1\n");     /* MTUXXX */
2024     } else {
2025         /* Free any extra elements in the wirevec */
2026         for (j = MAX(2, i); j < p->niovecs; j++) {
2027             rxi_freeCBuf(RX_CBUF_TO_PACKET(p->wirevec[j].iov_base, p));
2028         }
2029         p->niovecs = i;
2030         p->wirevec[i - 1].iov_len += len;
2031     }
2032     RXS_PreparePacket(conn->securityObject, call, p);
2033 }
2034
2035 /* Given an interface MTU size, calculate an adjusted MTU size that
2036  * will make efficient use of the RX buffers when the peer is sending
2037  * either AFS 3.4a jumbograms or AFS 3.5 jumbograms.  */
2038 int
2039 rxi_AdjustIfMTU(int mtu)
2040 {
2041     int adjMTU;
2042     int frags;
2043
2044     adjMTU = RX_HEADER_SIZE + RX_JUMBOBUFFERSIZE + RX_JUMBOHEADERSIZE;
2045     if (mtu <= adjMTU) {
2046         return mtu;
2047     }
2048     mtu -= adjMTU;
2049     if (mtu <= 0) {
2050         return adjMTU;
2051     }
2052     frags = mtu / (RX_JUMBOBUFFERSIZE + RX_JUMBOHEADERSIZE);
2053     return (adjMTU + (frags * (RX_JUMBOBUFFERSIZE + RX_JUMBOHEADERSIZE)));
2054 }
2055
2056 /* Given an interface MTU size, and the peer's advertised max receive
2057  * size, calculate an adjisted maxMTU size that makes efficient use
2058  * of our packet buffers when we are sending AFS 3.4a jumbograms. */
2059 int
2060 rxi_AdjustMaxMTU(int mtu, int peerMaxMTU)
2061 {
2062     int maxMTU = mtu * rxi_nSendFrags;
2063     maxMTU = MIN(maxMTU, peerMaxMTU);
2064     return rxi_AdjustIfMTU(maxMTU);
2065 }
2066
2067 /* Given a packet size, figure out how many datagram packet will fit.
2068  * The first buffer always contains RX_HEADER_SIZE+RX_JUMBOBUFFERSIZE+
2069  * RX_JUMBOHEADERSIZE, the middle buffers contain RX_JUMBOBUFFERSIZE+
2070  * RX_JUMBOHEADERSIZE, and the last buffer contains RX_JUMBOBUFFERSIZE */
2071 int
2072 rxi_AdjustDgramPackets(int frags, int mtu)
2073 {
2074     int maxMTU;
2075     if (mtu + IPv6_FRAG_HDR_SIZE < RX_JUMBOBUFFERSIZE + RX_HEADER_SIZE) {
2076         return 1;
2077     }
2078     maxMTU = (frags * (mtu + UDP_HDR_SIZE)) - UDP_HDR_SIZE;
2079     maxMTU = MIN(maxMTU, RX_MAX_PACKET_SIZE);
2080     /* subtract the size of the first and last packets */
2081     maxMTU -= RX_HEADER_SIZE + (2 * RX_JUMBOBUFFERSIZE) + RX_JUMBOHEADERSIZE;
2082     if (maxMTU < 0) {
2083         return 1;
2084     }
2085     return (2 + (maxMTU / (RX_JUMBOBUFFERSIZE + RX_JUMBOHEADERSIZE)));
2086 }