Add rx security index enum
[openafs.git] / src / rxkad / test / stress_c.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 /* RX Authentication Stress test: client side code. */
11
12 #include <afsconfig.h>
13 #include <afs/param.h>
14
15
16 #include <afs/stds.h>
17 #include <sys/types.h>
18 #include <stdio.h>
19 #ifdef AFS_NT40_ENV
20 #include <winsock2.h>
21 #else
22 #include <netdb.h>
23 #include <netinet/in.h>
24 #endif
25 #include <afs/com_err.h>
26 #include <afs/afsutil.h>
27 #include <rx/rxkad.h>
28 #include <afs/auth.h>
29 #include "stress.h"
30 #include "stress_internal.h"
31 #ifdef AFS_PTHREAD_ENV
32 #include <pthread.h>
33 #define FT_ApproxTime() (int)time(0)
34 #endif
35
36 extern int maxSkew;
37
38 static char *whoami;
39
40 static long
41 GetServer(aname)
42      IN char *aname;
43 {
44     register struct hostent *th;
45     long addr;
46
47     th = gethostbyname(aname);
48     if (!th) {
49         fprintf(stderr, "host %s not found\n", aname);
50         return errno;
51     }
52     memcpy(&addr, th->h_addr, sizeof(addr));
53     return addr;
54 }
55
56 static long
57 GetToken(versionP, session, ticketLenP, ticket, cell)
58      OUT long *versionP;
59      OUT struct ktc_encryptionKey *session;
60      OUT int *ticketLenP;
61      OUT char *ticket;
62 {
63     struct ktc_principal sname;
64     struct ktc_token ttoken;
65     long code;
66
67     strcpy(sname.cell, cell);
68     sname.instance[0] = 0;
69     strcpy(sname.name, "afs");
70     code = ktc_GetToken(&sname, &ttoken, sizeof(ttoken), NULL);
71     if (code)
72         return code;
73
74     *versionP = ttoken.kvno;
75     *ticketLenP = ttoken.ticketLen;
76     memcpy(ticket, ttoken.ticket, ttoken.ticketLen);
77     memcpy(session, &ttoken.sessionKey, sizeof(struct ktc_encryptionKey));
78     return 0;
79 }
80
81 static long
82 GetTicket(versionP, session, ticketLenP, ticket, cell)
83      OUT long *versionP;
84      OUT struct ktc_encryptionKey *session;
85      OUT int *ticketLenP;
86      OUT char *ticket;
87 {
88     long code;
89
90     /* create random session key, using key for seed to good random */
91     des_init_random_number_generator(&serviceKey);
92     code = des_random_key(session);
93     if (code)
94         return code;
95
96     /* now create the actual ticket */
97     *ticketLenP = 0;
98     code =
99         tkt_MakeTicket(ticket, ticketLenP, &serviceKey, RXKST_CLIENT_NAME,
100                        RXKST_CLIENT_INST, cell,
101                        /*start,end */ 0, 0xffffffff, session, /*host */ 0,
102                        RXKST_SERVER_NAME, RXKST_SERVER_NAME);
103     /* parms were buffer, ticketlen, key to seal ticket with, principal name,
104      * instance and cell, start time, end time, session key to seal in ticket,
105      * inet host, server name and server instance */
106     if (code)
107         return code;
108     *versionP = serviceKeyVersion;
109     return 0;
110 }
111 struct client {
112     struct rx_connection *conn;
113     u_long sendLen;             /* parameters for call to Copious */
114     u_long recvLen;
115     u_long *fastCalls;          /* number of calls to perform */
116     u_long *slowCalls;
117     u_long *copiousCalls;
118 };
119
120 static long
121 Copious(c, buf, buflen)
122      IN struct client *c;
123      IN u_char *buf;
124      IN u_long buflen;
125 {
126     long code;
127     struct rx_call *call;
128     long i;
129     long inlen = c->sendLen;
130     long outlen = c->recvLen;
131     long d = 23;
132     long mysum;
133     long outsum;
134
135     mysum = 0;
136     for (i = 0; i < inlen; i++)
137         mysum += (d++ & 0xff);
138
139     call = rx_NewCall(c->conn);
140     code = StartRXKST_Copious(call, inlen, mysum, outlen);
141     if (code == 0) {
142         long tlen;
143         long xfer = 0;
144         long n;
145         d = 23;
146         while (xfer < inlen) {
147             tlen = inlen - xfer;
148             if (tlen > buflen)
149                 tlen = buflen;
150             for (i = 0; i < tlen; i++)
151                 buf[i] = (d++ & 0xff);
152             n = rx_Write(call, buf, tlen);
153             if (n != tlen) {
154                 if (n < 0)
155                     code = n;
156                 else
157                     code = RXKST_WRITESHORT;
158                 break;
159             }
160             xfer += tlen;
161         }
162         if (code == 0) {
163             xfer = 0;
164             mysum = 0;
165             while (xfer < outlen) {
166                 tlen = outlen - xfer;
167                 if (tlen > buflen)
168                     tlen = buflen;
169                 n = rx_Read(call, buf, tlen);
170                 if (n != tlen) {
171                     if (n < 0)
172                         code = n;
173                     else
174                         code = RXKST_READSHORT;
175                     break;
176                 }
177                 for (i = 0; i < tlen; i++)
178                     mysum += buf[i];
179                 xfer += tlen;
180             }
181         }
182     }
183     if (code == 0)
184         code = EndRXKST_Copious(call, &outsum);
185     code = rx_EndCall(call, code);
186     if (code)
187         return code;
188     if (outsum != mysum) {
189         return RXKST_BADOUTPUTSUM;
190     }
191     return 0;
192 }
193
194 static long
195 DoClient(index, rock)
196      IN u_int index;
197      IN opaque rock;
198 {
199     struct client *c = (struct client *)rock;
200     long code;
201     int i;
202     u_long n, inc_n;
203
204     n = 95678;
205     for (i = 0; i < c->fastCalls[index]; i++) {
206         code = RXKST_Fast(c->conn, n, &inc_n);
207         if (code)
208             return (code);
209         if (n + 1 != inc_n)
210             return RXKST_INCFAILED;
211         n++;
212     }
213
214     for (i = 0; i < c->slowCalls[index]; i++) {
215         u_long ntime;
216         u_long now;
217         code = RXKST_Slow(c->conn, 1, &ntime);
218         if (code)
219             return (code);
220         now = FT_ApproxTime();
221         if ((ntime < now - maxSkew) || (ntime > now + maxSkew))
222             return RXKST_TIMESKEW;
223     }
224
225     if (c->copiousCalls[index] > 0) {
226         u_long buflen = 10000;
227         u_char *buf = (u_char *) osi_Alloc(buflen);
228         for (i = 0; i < c->copiousCalls[index]; i++) {
229             code = Copious(c, buf, buflen);
230             if (code)
231                 break;
232         }
233         osi_Free(buf, buflen);
234         if (code)
235             return code;
236     }
237     return 0;
238 }
239
240 struct worker {
241     struct worker *next;
242     long exitCode;              /* is PROCESSRUNNING until exit */
243     int index;
244     opaque rock;
245     long (*proc) ();
246 };
247
248 #ifdef AFS_PTHREAD_ENV
249 static pthread_once_t workerOnce = PTHREAD_ONCE_INIT;
250 static pthread_mutex_t workerLock;
251 static pthread_cond_t workerCV;
252 void
253 WorkerInit(void)
254 {
255     pthread_mutex_init(&workerLock, NULL);
256     pthread_cond_init(&workerCV, NULL);
257 }
258 #endif
259 static struct worker *workers;
260
261 static long
262 DoWorker(w)
263      IN struct worker *w;
264 {
265     long code;
266     code = (*w->proc) (w->index, w->rock);
267 #ifdef AFS_PTHREAD_ENV
268     pthread_mutex_lock(&workerLock);
269 #endif
270     w->exitCode = code;
271 #ifdef AFS_PTHREAD_ENV
272     pthread_mutex_unlock(&workerLock);
273 #endif
274 #ifdef AFS_PTHREAD_ENV
275     pthread_cond_signal(&workerCV);
276 #else
277     LWP_NoYieldSignal(&workers);
278 #endif
279     return code;
280 }
281
282 #define MAX_CTHREADS 25
283
284 static long
285 CallSimultaneously(threads, rock, proc)
286      IN u_int threads;
287      IN opaque rock;
288      IN long (*proc) ();
289 {
290     long code;
291     int i;
292 #ifdef AFS_PTHREAD_ENV
293     pthread_once(&workerOnce, WorkerInit);
294 #endif
295
296     workers = 0;
297     for (i = 0; i < threads; i++) {
298         struct worker *w;
299 #ifdef AFS_PTHREAD_ENV
300         pthread_t pid;
301 #else
302         PROCESS pid;
303 #endif
304         assert(i < MAX_CTHREADS);
305         w = (struct worker *)osi_Alloc(sizeof(struct worker));
306         memset(w, 0, sizeof(*w));
307         w->next = workers;
308         workers = w;
309         w->index = i;
310         w->exitCode = RXKST_PROCESSRUNNING;
311         w->rock = rock;
312         w->proc = proc;
313 #ifdef AFS_PTHREAD_ENV
314         {
315             pthread_attr_t tattr;
316
317             code = pthread_attr_init(&tattr);
318             if (code) {
319                 afs_com_err(whoami, code,
320                         "can't pthread_attr_init worker process");
321                 return code;
322             }
323
324             code =
325                 pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED);
326             if (code) {
327                 afs_com_err(whoami, code,
328                         "can't pthread_attr_setdetachstate worker process");
329                 return code;
330             }
331
332             code = pthread_create(&pid, &tattr, DoWorker, (void *)w);
333         }
334 #else
335         code =
336             LWP_CreateProcess(DoWorker, 16000, LWP_NORMAL_PRIORITY,
337                               (opaque) w, "Worker Process", &pid);
338 #endif
339         if (code) {
340             afs_com_err(whoami, code, "can't create worker process");
341             return code;
342         }
343     }
344     code = 0;                   /* last non-zero code encountered */
345 #ifdef AFS_PTHREAD_ENV
346     pthread_mutex_lock(&workerLock);
347 #endif
348     while (workers) {
349         struct worker *w, *prevW, *nextW;
350         prevW = 0;
351         for (w = workers; w; w = nextW) {
352             nextW = w->next;
353             if (w->exitCode != RXKST_PROCESSRUNNING) {
354                 if (w->exitCode) {
355                     if (code == 0)
356                         code = w->exitCode;
357                 }
358                 if (prevW)
359                     prevW->next = w->next;
360                 else
361                     workers = w->next;
362                 osi_Free(w, sizeof(*w));
363                 continue;       /* don't bump prevW */
364             }
365             prevW = w;
366         }
367 #ifdef AFS_PTHREAD_ENV
368         if (workers)
369             pthread_cond_wait(&workerCV, &workerLock);
370 #else
371         if (workers)
372             LWP_WaitProcess(&workers);
373 #endif
374     }
375 #ifdef AFS_PTHREAD_ENV
376     pthread_mutex_unlock(&workerLock);
377 #endif
378     return code;
379 }
380
381 static void
382 DivideUpCalls(calls, threads, threadCalls)
383      IN u_long calls;
384      IN u_int threads;
385      IN u_long threadCalls[];
386 {
387     int i;
388     for (i = 0; i < threads; i++) {
389         threadCalls[i] = calls / (threads - i);
390         calls -= threadCalls[i];
391     }
392 }
393
394 static double
395 ftime()
396 {
397     struct timeval tv;
398     gettimeofday(&tv, 0);
399     return (double)tv.tv_sec + (double)tv.tv_usec / 1000000.0;
400 }
401
402 static long
403 RunLoadTest(parms, conn)
404      IN struct clientParms *parms;
405      IN struct rx_connection *conn;
406 {
407     long code;
408     struct client c;
409     u_long fastCalls[MAX_CTHREADS];
410     u_long slowCalls[MAX_CTHREADS];
411     u_long copiousCalls[MAX_CTHREADS];
412     double start, interval;
413
414     DivideUpCalls(parms->fastCalls, parms->threads, fastCalls);
415     DivideUpCalls(parms->slowCalls, parms->threads, slowCalls);
416     DivideUpCalls(parms->copiousCalls, parms->threads, copiousCalls);
417
418     memset(&c, 0, sizeof(c));
419     c.conn = conn;
420     c.sendLen = parms->sendLen;
421     c.recvLen = parms->recvLen;
422     c.fastCalls = fastCalls;
423     c.slowCalls = slowCalls;
424     c.copiousCalls = copiousCalls;
425
426     start = ftime();
427     code = CallSimultaneously(parms->threads, &c, DoClient);
428     if (code) {
429         afs_com_err(whoami, code, "in DoClient");
430         return code;
431     }
432     interval = ftime() - start;
433
434     if (parms->printTiming) {
435         u_long totalCalls =
436             parms->fastCalls + parms->slowCalls + parms->copiousCalls;
437         int t = (interval / totalCalls) * 1000.0 + 0.5;
438         if (totalCalls > 0) {
439             printf("For %d calls: %d msec/call\n", totalCalls, t);
440         }
441         if (parms->copiousCalls > 0) {
442             long n = parms->sendLen + parms->recvLen;
443             double kbps;
444             int b;
445             kbps = (double)(parms->copiousCalls * n) / (interval * 1000.0);
446             b = kbps + 0.5;
447 #if 0
448             I just cannot get printing of floats to work on the pmax !
449                 !!!printf("%g %d %d %d\n", (float)kbps, b);
450             printf("%g %d %d %d\n", kbps, b);
451             fprintf(stdout, "%g %d %d\n", kbps, b);
452             {
453                 char buf[100];
454                 buf[sizeof(buf) - 1] = 0;
455                 sprintf(buf, "%g %d %d\n", kbps, b);
456                 assert(buf[sizeof(buf) - 1] == 0);
457                 printf("%s", buf);
458             }
459 #endif
460             printf
461                 ("For %d copious calls, %d send + %d recv = %d bytes each: %d kbytes/sec\n",
462                  parms->copiousCalls, parms->sendLen, parms->recvLen, n, b);
463 #if 0
464             printf("%g\n", kbps);
465 #endif
466         }
467     }
468     return 0;
469 }
470
471 static long
472 RepeatLoadTest(parms, conn)
473      IN struct clientParms *parms;
474      IN struct rx_connection *conn;
475 {
476     long code;
477     long count;
478
479     if (parms->repeatInterval == 0) {
480         if (parms->repeatCount == 0)
481             parms->repeatCount = 1;
482     } else {
483         if (parms->repeatCount == 0)
484             parms->repeatCount = 0x7fffffff;
485     }
486
487     if (parms->printTiming) {
488         int types;
489         types =
490             (parms->fastCalls ? 1 : 0) + (parms->slowCalls ? 1 : 0) +
491             (parms->copiousCalls ? 1 : 0);
492         if (types > 1)
493             fprintf(stderr,
494                     "Combined timings of several types of calls may not be meaningful.\n");
495         if (types == 0)
496             /* do timings of copious calls by default */
497             parms->copiousCalls = 10;
498     }
499
500     for (count = 0; count < parms->repeatCount; count++) {
501         code = RunLoadTest(parms, conn);
502         if (code)
503             return code;
504         if (parms->repeatInterval) {
505             u_long i = parms->repeatInterval;
506             u_long now = time(0);
507             u_long next = (now + i - 1) / i * i;        /* round up to next interval */
508             while (now < next) {
509 #ifdef AFS_PTHREAD_ENV
510                 sleep(next - now);
511 #else
512                 IOMGR_Sleep(next - now);
513 #endif
514                 now = time(0);
515             }
516         }
517     }
518     return code;
519 }
520
521 /* For backward compatibility, don't try to use the CallNumber stuff unless
522  * we're compiling against the new Rx. */
523
524 #ifdef rx_GetPacketCksum
525
526 struct multiChannel {
527     struct rx_connection *conn;
528     int done;
529     long *codes;
530     int changes[RX_MAXCALLS];
531     long callNumbers[RX_MAXCALLS];
532 };
533 #define BIG_PRIME 1257056893    /* 0x4AED2A7d */
534 static u_long sequence = 0;
535
536 static long
537 FastCall(conn)
538      IN struct rx_connection *conn;
539 {
540     long code;
541     u_long n = (sequence = sequence * BIG_PRIME + BIG_PRIME);
542     u_long inc_n;
543
544     code = RXKST_Fast(conn, n, &inc_n);
545     if (code)
546         return code;
547     if (inc_n != n + 1)
548         return RXKST_INCFAILED;
549     return 0;
550 }
551
552 static long
553 UniChannelCall(index, rock)
554      IN u_int index;
555      IN opaque rock;
556 {
557     struct multiChannel *mc = (struct multiChannel *)rock;
558     long code;
559     long callNumbers[RX_MAXCALLS];
560     int unchanged;
561
562     code = 0;
563     unchanged = 1;
564     while (!mc->done && unchanged) {
565         int i;
566         code = FastCall(mc->conn);
567         if (code)
568             break;
569         code = rxi_GetCallNumberVector(mc->conn, callNumbers);
570         if (code)
571             break;
572         unchanged = 0;
573         for (i = 0; i < RX_MAXCALLS; i++) {
574             if (callNumbers[i] > mc->callNumbers[i]) {
575                 mc->callNumbers[i] = callNumbers[i];
576                 mc->changes[i]--;       /* may go negative */
577             }
578             if (mc->changes[i] > 0)
579                 unchanged++;
580         }
581     }
582     mc->codes[index] = code;
583     mc->done++;
584     return code;
585 }
586
587 static long
588 MakeMultiChannelCall(conn, each, expectedCode, codes)
589      IN struct rx_connection *conn;
590      IN int each;               /* calls to make on each channel */
591      IN long expectedCode;
592      OUT long codes[];
593 {
594     long code;
595     int i;
596     struct multiChannel mc;
597
598     memset(&mc, 0, sizeof(mc));
599     mc.conn = conn;
600     for (i = 0; i < RX_MAXCALLS; i++) {
601         codes[i] = RXKST_PROCESSRUNNING;
602         mc.changes[i] = each;
603     }
604     mc.codes = codes;
605     code = rxi_GetCallNumberVector(conn, mc.callNumbers);
606     if (code)
607         return code;
608     mc.done = 0;
609     code = CallSimultaneously(RX_MAXCALLS, &mc, UniChannelCall);
610     if (((expectedCode == RXKST_INCFAILED) || (expectedCode == -1)) && ((code == expectedCode) || (code == -3)));       /* strange cases */
611     else if (code != expectedCode) {
612         afs_com_err(whoami, code,
613                 "problem making multichannel call, expected '%s'",
614                 ((expectedCode == 0)
615                  ? "no error" : (char *)afs_error_message(expectedCode)));
616     }
617     return code;
618 }
619
620 static long
621 CheckCallFailure(conn, codes, code, msg)
622      IN struct rx_connection *conn;
623      IN long codes[];
624      IN long code;
625      IN char *msg;
626 {
627     if (code == 0) {
628         fprintf(stderr, "Failed to detect %s\n", msg);
629         return RXKST_NODUPLICATECALL;
630     } else {
631         int i;
632         int okay = 1;
633         int someZero = 0;
634         for (i = 0; i < RX_MAXCALLS; i++)
635             if (!((codes[i] == 0) || (codes[i] == code) || (codes[i] == -3)))
636                 okay = 0;
637         if (conn->error)
638             okay = 0;
639         if (!okay) {
640             fprintf(stderr, "%s produced these errors:\n", msg);
641             for (i = 0; i < RX_MAXCALLS; i++) {
642                 assert(codes[i] != RXKST_PROCESSRUNNING);
643                 if (codes[i] == 0) {
644                     someZero++;
645                     fprintf(stderr, "  %d no error\n", i);
646                 } else
647                     fprintf(stderr, "  %d %s\n", i, afs_error_message(codes[i]));
648             }
649             if (someZero) {
650                 char buf[100];
651                 sprintf(buf, "connection dead following %s", msg);
652                 code = FastCall(conn);
653                 if (code)
654                     afs_com_err(whoami, code, buf);
655             }
656         }
657     }
658     return 0;
659 }
660
661 #endif /* rx_GetPacketCksum */
662
663 static long
664 RunCallTest(parms, host, sc, si)
665      IN struct clientParms *parms;
666      IN long host;
667      IN struct rx_securityClass *sc;
668      IN long si;
669 {
670     long code;
671
672 #ifndef rx_GetPacketCksum
673
674     code = RXKST_BADARGS;
675     afs_com_err(whoami, code,
676             "Older versions of Rx don't support Get/Set callNumber Vector procedures: can't run this CallTest");
677     return code;
678
679 #else
680
681     int i, ch;
682     struct rx_connection *conn;
683     long firstCall;
684     long callNumbers[RX_MAXCALLS];
685     long codes[RX_MAXCALLS];
686     long retCode = 0;           /* ret. if nothing fatal goes wrong */
687
688     conn =
689         rx_NewConnection(host, htons(RXKST_SERVICEPORT), RXKST_SERVICEID, sc,
690                          si);
691     if (!conn)
692         return RXKST_NEWCONNFAILED;
693
694     /* First check the basic behaviour of call number handling */
695
696     code = rxi_GetCallNumberVector(conn, callNumbers);
697     if (code)
698         return code;
699     for (i = 0; i < RX_MAXCALLS; i++) {
700         if (callNumbers[i] != 0) {
701             fprintf(stderr,
702                     "Connection's initial call numbers not zero. call[%d] = %d\n",
703                     i, callNumbers[i]);
704             return RXKST_BADCALLNUMBERS;
705         }
706     }
707     code = FastCall(conn);
708     if (code)
709         return code;
710     code = rxi_GetCallNumberVector(conn, callNumbers);
711     if (code)
712         return code;
713     firstCall = callNumbers[0];
714     code = FastCall(conn);
715     if (code)
716         return code;
717     code = rxi_GetCallNumberVector(conn, callNumbers);
718     if (code)
719         return code;
720     if ((callNumbers[0] != firstCall + 1)
721         && ((firstCall == 1) || (firstCall == 2))) {
722         /* The call number after the first call should be one or, more likely,
723          * two (if the call is still DALLYing).  Between first and second call,
724          * the call number should have incremented by one. */
725         fprintf(stderr,
726                 "Connection's first channel call number not one. call[%d] = %d\n",
727                 0, callNumbers[0]);
728         return RXKST_BADCALLNUMBERS;
729     }
730     for (i = 1; i < RX_MAXCALLS; i++) {
731         if (callNumbers[i] != 0) {
732             fprintf(stderr,
733                     "Connection's other channel call numbers not zero. call[%d] = %d\n",
734                     i, callNumbers[i]);
735             return RXKST_BADCALLNUMBERS;
736         }
737     }
738     code = MakeMultiChannelCall(conn, 1, 0, codes);
739     if (code)
740         return code;
741
742     /* Now try to resend a call that's already been executed by finding a
743      * non-zero call number on a channel other than zero and decrementing it by
744      * one.  This should appear to the server as a retransmitted call.  Since
745      * this is behaving as a broken client different strange behaviors may be
746      * exhibited by different servers.  If the response packet to the original
747      * call is discarded by the time the "retransmitted" call arrives (perhaps
748      * due to high server or client load) there is no way for the server to
749      * respond at all.  Further, it seems, that under some cases the connection
750      * will be kept alive indefinitely even though the server has discarded the
751      * "retransmitted" call and is making no effort to reexecute the call.  To
752      * handle these, accept either a timeout (-1) or and INCFAILED error here,
753      * also set the connenction HardDeadTime to punt after a reasonable
754      * interval. */
755
756     /* short dead time since may we expect some trouble */
757     rx_SetConnHardDeadTime(conn, 30);
758     code = rxi_GetCallNumberVector(conn, callNumbers);
759     if (code)
760         return code;
761     for (ch = 1; ch < RX_MAXCALLS; ch++)
762         if (callNumbers[ch] > 1) {
763             callNumbers[ch]--;
764             code = rxi_SetCallNumberVector(conn, callNumbers);
765             if (code)
766                 return code;
767             break;
768         }
769     if (ch >= RX_MAXCALLS)      /* didn't find any? all DALLYing? */
770         return RXKST_BADCALLNUMBERS;
771     code = MakeMultiChannelCall(conn, 1, RXKST_INCFAILED, codes);
772     code = CheckCallFailure(conn, codes, code, "retransmitted call");
773     if (code && !retCode)
774         retCode = code;
775
776     /* Get a fresh connection, becasue if the above failed as it should the
777      * connection is dead. */
778     rx_DestroyConnection(conn);
779     conn =
780         rx_NewConnection(host, htons(RXKST_SERVICEPORT), RXKST_SERVICEID, sc,
781                          si);
782     if (!conn)
783         return RXKST_NEWCONNFAILED;
784
785     /* Similarly, but decrement call number by two which should be completely
786      * unmistakeable as a broken or malicious client. */
787
788     /* short dead time since may we expect some trouble */
789     rx_SetConnHardDeadTime(conn, 30);
790     code = MakeMultiChannelCall(conn, 2, 0, codes);
791     if (code)
792         return code;
793     code = rxi_GetCallNumberVector(conn, callNumbers);
794     if (code)
795         return code;
796     for (ch = 1; ch < RX_MAXCALLS; ch++)
797         if (callNumbers[ch] > 2) {
798             callNumbers[ch] -= 2;
799             code = rxi_SetCallNumberVector(conn, callNumbers);
800             break;
801         }
802     if (ch >= RX_MAXCALLS)      /* didn't find any? all DALLYing? */
803         return RXKST_BADCALLNUMBERS;
804     code = MakeMultiChannelCall(conn, 1, -1, codes);
805     code = CheckCallFailure(conn, codes, code, "duplicate call");
806     if (code && !retCode)
807         retCode = code;
808
809     rx_DestroyConnection(conn);
810     conn =
811         rx_NewConnection(host, htons(RXKST_SERVICEPORT), RXKST_SERVICEID, sc,
812                          si);
813     if (!conn)
814         return RXKST_NEWCONNFAILED;
815
816     /* Next, without waiting for the server to discard its state, we will check
817      * to see if the Challenge/Response protocol correctly informs the server
818      * of the client's callNumber state.  We do this by artificially increasing
819      * the call numbers of a new connection for all channels beyond zero,
820      * making a call on channel zero, then resetting the call number for the
821      * unused channels back to zero, then making calls on all channels. */
822
823     code = rxi_GetCallNumberVector(conn, callNumbers);
824     if (code)
825         return code;
826     for (i = 0; i < RX_MAXCALLS; i++) {
827         if (callNumbers[i] != 0)
828             return RXKST_BADCALLNUMBERS;
829         callNumbers[i] = 51;    /* an arbitrary value... */
830     }
831     code = rxi_SetCallNumberVector(conn, callNumbers);
832     if (code)
833         return code;
834     code = FastCall(conn);      /* use channel 0 */
835     if (code)
836         return code;
837     code = rxi_GetCallNumberVector(conn, callNumbers);
838     if (code)
839         return code;
840     if (callNumbers[0] != 52)
841         return RXKST_BADCALLNUMBERS;
842     for (i = 1; i < RX_MAXCALLS; i++) {
843         if (callNumbers[i] != 51)
844             return RXKST_BADCALLNUMBERS;
845         callNumbers[i] = 37;    /* back up a ways */
846     }
847     code = rxi_SetCallNumberVector(conn, callNumbers);
848     if (code)
849         return code;
850     /* now try calls on all channels... */
851     code = MakeMultiChannelCall(conn, 1, -1, codes);
852     code =
853         CheckCallFailure(conn, codes, code, "alternate channel call replay");
854     if (code && !retCode)
855         retCode = code;
856
857     rx_DestroyConnection(conn);
858     return retCode;
859
860 #endif /* rx_GetPacketCksum */
861
862 }
863
864 #ifdef rx_GetPacketCksum
865
866 static struct {
867     int op;
868     u_long epoch;               /* connection to attack */
869     u_long cid;
870     int client;                 /* TRUE => client side */
871     u_long newEpoch;            /* conn to direct challenges to */
872     u_long newCid;
873     u_long counts[RX_N_PACKET_TYPES];
874 } incomingOps;
875 #define IO_NOOP                 0
876 #define IO_COUNT                1
877 #define IO_REDIRECTCHALLENGE    2
878
879 static int
880 HandleIncoming(p, addr)
881      INOUT struct rx_packet *p;
882      INOUT struct sockaddr_in *addr;
883 {
884     int client;                 /* packet sent by client */
885     u_char type;                /* packet type */
886
887     if (incomingOps.op == IO_NOOP)
888         return 0;
889
890     client = ((p->header.flags & RX_CLIENT_INITIATED) != RX_CLIENT_INITIATED);
891     if ((p->header.epoch != incomingOps.epoch)
892         || ((p->header.cid ^ incomingOps.cid) & RX_CIDMASK)
893         || (client != incomingOps.client))
894         return 0;
895     type = p->header.type;
896     if ((type <= 0) || (type >= RX_N_PACKET_TYPES))
897         type = 0;
898     incomingOps.counts[type]++;
899
900     switch (incomingOps.op) {
901     case IO_NOOP:
902     case IO_COUNT:
903         break;
904
905     case IO_REDIRECTCHALLENGE:
906         if (p->header.type != RX_PACKET_TYPE_CHALLENGE)
907             break;
908         p->header.epoch = incomingOps.newEpoch;
909         p->header.cid = incomingOps.newCid;
910         /* Now set up to watch for the corresponding challenge. */
911         incomingOps.epoch = incomingOps.newEpoch;
912         incomingOps.cid = incomingOps.newCid;
913         incomingOps.op = IO_COUNT;
914         break;
915
916     default:
917         fprintf(stderr, "Unknown incoming op %d\n", incomingOps.op);
918         break;
919     }
920     return 0;
921 }
922
923 static struct {
924     int op;
925     u_long epoch;               /* connection to attack */
926     u_long cid;
927     int client;                 /* TRUE => client side */
928     u_long counts[RX_N_PACKET_TYPES];
929 } outgoingOps;
930 #define OO_NOOP         0
931 #define OO_COUNT        1
932 #define OO_ZEROCKSUM    2
933 #define OO_MUNGCKSUM    3
934
935 static int
936 HandleOutgoing(p, addr)
937      INOUT struct rx_packet *p;
938      INOUT struct sockaddr_in *addr;
939 {
940     int client;                 /* packet sent by client */
941     u_char type;                /* packet type */
942
943     if (outgoingOps.op == OO_NOOP)
944         return 0;
945
946     client = ((p->header.flags & RX_CLIENT_INITIATED) == RX_CLIENT_INITIATED);
947     if ((p->header.epoch != outgoingOps.epoch)
948         || ((p->header.cid ^ outgoingOps.cid) & RX_CIDMASK)
949         || (client != outgoingOps.client))
950         return 0;
951     type = p->header.type;
952     if ((type <= 0) || (type >= RX_N_PACKET_TYPES))
953         type = 0;
954     outgoingOps.counts[type]++;
955
956     switch (outgoingOps.op) {
957     case OO_NOOP:
958     case OO_COUNT:
959         /* counting always happens above if not noop */
960         break;
961
962     case OO_ZEROCKSUM:
963         if (p->header.type != RX_PACKET_TYPE_DATA)
964             break;
965         if (rx_GetPacketCksum(p) == 0) {
966             /* probably, a retransmitted packet */
967             fprintf(stderr, "Packet cksum already zero\n");
968             break;
969         }
970         rx_SetPacketCksum(p, 0);
971         break;
972
973     case OO_MUNGCKSUM:{
974             u_short cksum;
975             if (p->header.type != RX_PACKET_TYPE_DATA)
976                 break;
977             cksum = rx_GetPacketCksum(p);
978             if (cksum == 0) {
979                 fprintf(stderr, "Packet cksum already zero\n");
980                 break;
981             }
982             rx_SetPacketCksum(p, cksum ^ 8);
983             break;
984         }
985     default:
986         fprintf(stderr, "Unknown outgoing op %d\n", outgoingOps.op);
987         break;
988     }
989     return 0;
990 }
991
992 #ifdef AFS_PTHREAD_ENV
993 static pthread_once_t slowCallOnce = PTHREAD_ONCE_INIT;
994 static pthread_mutex_t slowCallLock;
995 static pthread_cond_t slowCallCV;
996 void
997 SlowCallInit(void)
998 {
999     pthread_mutex_init(&slowCallLock, NULL);
1000     pthread_cond_init(&slowCallCV, NULL);
1001 }
1002 #endif
1003 static long slowCallCode;
1004 static long
1005 SlowCall(conn)
1006      IN opaque conn;
1007 {
1008     u_long ntime;
1009     u_long now;
1010     long temp_rc;
1011
1012 #ifdef AFS_PTHREAD_ENV
1013     pthread_mutex_lock(&slowCallLock);
1014 #endif
1015     slowCallCode = RXKST_PROCESSRUNNING;
1016 #ifdef AFS_PTHREAD_ENV
1017     pthread_cond_signal(&slowCallCV);
1018 #else
1019     LWP_NoYieldSignal(&slowCallCode);
1020 #endif
1021     slowCallCode = RXKST_Slow(conn, 1, &ntime);
1022     if (!slowCallCode) {
1023         now = FT_ApproxTime();
1024         if ((ntime < now - maxSkew) || (ntime > now + maxSkew))
1025             slowCallCode = RXKST_TIMESKEW;
1026     }
1027     temp_rc = slowCallCode;
1028 #ifdef AFS_PTHREAD_ENV
1029     pthread_cond_signal(&slowCallCV);
1030     pthread_mutex_unlock(&slowCallLock);
1031 #else
1032     LWP_NoYieldSignal(&slowCallCode);
1033 #endif
1034     return temp_rc;
1035 }
1036
1037 #endif /* rx_GetPacketCksum */
1038
1039 static long
1040 RunHijackTest(parms, host, sc, si)
1041      IN struct clientParms *parms;
1042      IN long host;
1043      IN struct rx_securityClass *sc;
1044      IN long si;
1045 {
1046
1047 #ifndef rx_GetPacketCksum
1048
1049     code = RXKST_BADARGS;
1050     afs_com_err(whoami, code,
1051             "Older versions of Rx don't export packet tracing routines: can't run this HijackTest");
1052     return code;
1053
1054 #else
1055
1056     extern int (*rx_justReceived) ();
1057     extern int (*rx_almostSent) ();
1058
1059     long code;
1060     struct rx_connection *conn = 0;
1061     struct rx_connection *otherConn = 0;
1062 #ifdef AFS_PTHREAD_ENV
1063     pthread_t pid;
1064 #else
1065     PROCESS pid;
1066 #endif
1067     int nResp;                  /* otherConn responses seen */
1068     long tmp_rc;
1069
1070 #ifdef AFS_PTHREAD_ENV
1071     pthread_once(&slowCallOnce, SlowCallInit);
1072 #endif
1073     rx_justReceived = HandleIncoming;
1074     rx_almostSent = HandleOutgoing;
1075
1076     incomingOps.op = IO_NOOP;
1077     outgoingOps.op = OO_NOOP;
1078
1079 #define HIJACK_CONN(conn) \
1080     {   if (conn) rx_DestroyConnection (conn); \
1081         (conn) = rx_NewConnection(host, htons(RXKST_SERVICEPORT), \
1082                                 RXKST_SERVICEID, sc, si); \
1083         if (!(conn)) return RXKST_NEWCONNFAILED; \
1084         outgoingOps.client = 1; \
1085         outgoingOps.epoch = (conn)->epoch; \
1086         outgoingOps.cid = (conn)->cid; }
1087
1088     HIJACK_CONN(conn);
1089
1090     /* First try switching from no packet cksum to sending packet cksum between
1091      * calls, and see if server complains. */
1092
1093     outgoingOps.op = OO_ZEROCKSUM;
1094     code = FastCall(conn);
1095     if (code) {
1096         afs_com_err(whoami, code, "doing FastCall with ZEROCKSUM");
1097         return code;
1098     }
1099     /* The server thinks we're an old style client.  Now start sending cksums.
1100      * Server shouldn't care. */
1101     outgoingOps.op = OO_NOOP;
1102     code = FastCall(conn);
1103     if (code) {
1104         afs_com_err(whoami, code, "doing FastCall with non-ZEROCKSUM");
1105         return code;
1106     }
1107     /* The server now thinks we're a new style client, we can't go back now. */
1108     outgoingOps.op = OO_ZEROCKSUM;
1109     code = FastCall(conn);
1110     if (code == 0)
1111         code = RXKST_NOBADCKSUM;
1112     if (code != RXKADSEALEDINCON) {
1113         afs_com_err(whoami, code, "doing FastCall with ZEROCKSUM");
1114         return code;
1115     } else if (!conn->error) {
1116         code = RXKST_NOCONNERROR;
1117         afs_com_err(whoami, code, "doing FastCall with ZEROCKSUM");
1118         return code;
1119     } else
1120         code = 0;
1121
1122     HIJACK_CONN(conn);
1123
1124     /* Now try modifying packet cksum to see if server complains. */
1125
1126     outgoingOps.op = OO_MUNGCKSUM;
1127     code = FastCall(conn);
1128     if (code == 0)
1129         code = RXKST_NOBADCKSUM;
1130     if (code != RXKADSEALEDINCON) {
1131         afs_com_err(whoami, code, "doing FastCall with ZEROCKSUM");
1132         return code;
1133     } else if (!conn->error) {
1134         code = RXKST_NOCONNERROR;
1135         afs_com_err(whoami, code, "doing FastCall with ZEROCKSUM");
1136         return code;
1137     } else
1138         code = 0;
1139
1140     /* Now make two connection and direct the first challenge on one connection
1141      * to the other connection to see if it generates a response.  The
1142      * retransmitted challenge should allow the call on the first connection to
1143      * complete correctly.  Part one is to attack a new connection, then attack
1144      * it after it has made a call.  Part three, just for comparison, attacks a
1145      * otherConn while it is making a slow call (and thus has an active call).
1146      * Against this attack we have no defense so we expect a challenge in this
1147      * case, which the server will discard. */
1148
1149 #define RedirectChallenge(conn,otherConn)       \
1150     (incomingOps.epoch = (conn)->epoch,         \
1151      incomingOps.cid = (conn)->cid,             \
1152      incomingOps.client = 1,                    \
1153      incomingOps.newEpoch = (otherConn)->epoch, \
1154      incomingOps.newCid = (otherConn)->cid,     \
1155      incomingOps.op = IO_REDIRECTCHALLENGE,     \
1156      outgoingOps.epoch = (otherConn)->epoch,    \
1157      outgoingOps.cid = (otherConn)->cid,        \
1158      outgoingOps.client = 1,                    \
1159      outgoingOps.op = OO_COUNT,                 \
1160      outgoingOps.counts[RX_PACKET_TYPE_RESPONSE] = 0)
1161
1162     HIJACK_CONN(conn);
1163     HIJACK_CONN(otherConn)
1164         RedirectChallenge(conn, otherConn);
1165
1166     code = FastCall(conn);
1167     if (code)
1168         return code;
1169     assert(incomingOps.op == IO_COUNT); /* redirect code was triggered */
1170     if (outgoingOps.counts[RX_PACKET_TYPE_RESPONSE] > 0) {
1171       oracle:
1172         code = RXKST_CHALLENGEORACLE;
1173         afs_com_err(whoami, code, "misdirecting challenge");
1174         return code;
1175     }
1176     code = FastCall(otherConn); /* generate some activity here */
1177     if (code)
1178         return code;
1179     nResp = outgoingOps.counts[RX_PACKET_TYPE_RESPONSE];
1180     assert(nResp >= 1);
1181     code = FastCall(conn);
1182     if (code)
1183         return code;
1184     if (outgoingOps.counts[RX_PACKET_TYPE_RESPONSE] > nResp)
1185         goto oracle;
1186
1187     HIJACK_CONN(conn);
1188     RedirectChallenge(conn, otherConn);
1189     /* otherConn was authenticated during part one */
1190     code = FastCall(conn);
1191     if (code)
1192         return code;
1193     assert(incomingOps.op == IO_COUNT); /* redirect code was triggered */
1194     if (outgoingOps.counts[RX_PACKET_TYPE_RESPONSE] != 0)
1195         goto oracle;
1196
1197     HIJACK_CONN(conn);
1198     RedirectChallenge(conn, otherConn);
1199     /* otherConn is still authenticated */
1200     slowCallCode = RXKST_PROCESSCREATED;
1201 #ifdef AFS_PTHREAD_ENV
1202     {
1203         pthread_attr_t tattr;
1204
1205         code = pthread_attr_init(&tattr);
1206         if (code) {
1207             afs_com_err(whoami, code,
1208                     "can't pthread_attr_init slow call process");
1209             return code;
1210         }
1211
1212         code = pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED);
1213         if (code) {
1214             afs_com_err(whoami, code,
1215                     "can't pthread_attr_setdetachstate slow call process");
1216             return code;
1217         }
1218
1219         code = pthread_create(&pid, &tattr, SlowCall, (void *)otherConn);
1220     }
1221 #else
1222     code =
1223         LWP_CreateProcess(SlowCall, 16000, LWP_NORMAL_PRIORITY,
1224                           (opaque) otherConn, "Slow Call Process", &pid);
1225 #endif
1226     if (code) {
1227         afs_com_err(whoami, code, "can't create slow call process");
1228         return code;
1229     }
1230 #ifdef AFS_PTHREAD_ENV
1231     pthread_mutex_lock(&slowCallLock);
1232     while (slowCallCode == RXKST_PROCESSCREATED)
1233         pthread_cond_wait(&slowCallCV, &slowCallLock);
1234 #else
1235     while (slowCallCode == RXKST_PROCESSCREATED)
1236         LWP_WaitProcess(&slowCallCode); /* wait for process start */
1237 #endif
1238     if (slowCallCode != RXKST_PROCESSRUNNING) {
1239         tmp_rc = slowCallCode;
1240 #ifdef AFS_PTHREAD_ENV
1241         pthread_mutex_unlock(&slowCallLock);
1242 #endif
1243         return tmp_rc;          /* make sure didn't fail immediately */
1244     }
1245     assert(incomingOps.op == IO_REDIRECTCHALLENGE);
1246     code = FastCall(conn);
1247     if (code)
1248         return code;
1249     assert(incomingOps.op == IO_COUNT); /* redirect code was triggered */
1250 #ifdef AFS_PTHREAD_ENV
1251     while (slowCallCode == RXKST_PROCESSRUNNING)
1252         pthread_cond_wait(&slowCallCV, &slowCallLock);
1253     pthread_mutex_unlock(&slowCallLock);
1254 #else
1255     while (slowCallCode == RXKST_PROCESSRUNNING)
1256         LWP_WaitProcess(&slowCallCode); /* wait for process finish */
1257 #endif
1258     if (outgoingOps.counts[RX_PACKET_TYPE_RESPONSE] != 1)
1259         goto oracle;
1260
1261     rx_justReceived = 0;
1262     rx_almostSent = 0;
1263     rx_DestroyConnection(otherConn);
1264     rx_DestroyConnection(conn);
1265     return code;
1266
1267 #endif /* rx_GetPacketCksum */
1268
1269 }
1270
1271 long
1272 rxkst_StartClient(parms)
1273      IN struct clientParms *parms;
1274 {
1275     long code;
1276     long host;
1277     long scIndex;
1278     struct rx_securityClass *sc;
1279
1280     whoami = parms->whoami;     /* set this global variable */
1281
1282     host = GetServer(parms->server);
1283
1284     if (parms->authentication >= 0) {
1285         long kvno;
1286         char ticket[MAXKTCTICKETLEN];
1287         int ticketLen;
1288         struct ktc_encryptionKey Ksession;
1289
1290         if (parms->useTokens)
1291             code =
1292                 GetToken(&kvno, &Ksession, &ticketLen, ticket, parms->cell);
1293         else
1294             code =
1295                 GetTicket(&kvno, &Ksession, &ticketLen, ticket, parms->cell);
1296         if (code)
1297             return code;
1298
1299         /* next, we have ticket, kvno and session key, authenticate the conn */
1300         sc = (struct rx_securityClass *)
1301             rxkad_NewClientSecurityObject(parms->authentication, &Ksession,
1302                                           kvno, ticketLen, ticket);
1303         assert(sc);
1304         scIndex = RX_SECIDX_KAD;
1305     } else {
1306         /* unauthenticated connection */
1307         sc = rxnull_NewClientSecurityObject();
1308         assert(sc);
1309         scIndex = RX_SECIDX_NULL;
1310     }
1311
1312     code = 0;
1313     if (!code && parms->callTest) {
1314         code = RunCallTest(parms, host, sc, scIndex);
1315     }
1316     if (!code && parms->hijackTest) {
1317         code = RunHijackTest(parms, host, sc, scIndex);
1318     }
1319     if (!code
1320         && (parms->printTiming || parms->fastCalls || parms->slowCalls
1321             || parms->copiousCalls)) {
1322         struct rx_connection *conn;
1323         conn =
1324             rx_NewConnection(host, htons(RXKST_SERVICEPORT), RXKST_SERVICEID,
1325                              sc, scIndex);
1326         if (conn) {
1327             code = RepeatLoadTest(parms, conn);
1328             rx_DestroyConnection(conn);
1329         } else
1330             code = RXKST_NEWCONNFAILED;
1331     }
1332     if (!code && parms->stopServer) {
1333         struct rx_connection *conn;
1334         conn =
1335             rx_NewConnection(host, htons(RXKST_SERVICEPORT), RXKST_SERVICEID,
1336                              sc, scIndex);
1337         if (conn) {
1338             code = RXKST_Kill(conn);
1339             if (code) {
1340                 afs_com_err(whoami, code, "trying to stop server");
1341             }
1342             rx_DestroyConnection(conn);
1343         } else
1344             code = RXKST_NEWCONNFAILED;
1345     }
1346
1347     if (parms->printStats) {
1348         rx_PrintStats(stdout);
1349 #if 0
1350         /* use rxdebug style iteration here */
1351         rx_PrintPeerStats(stdout, rx_PeerOf(conn));
1352 #endif
1353     }
1354
1355     rxs_Release(sc);
1356     rx_Finalize();
1357     if (code) {
1358         afs_com_err(parms->whoami, code, "test fails");
1359         exit(13);
1360     } else {
1361         printf("Test Okay\n");
1362         if (!parms->noExit)
1363             exit(0);
1364     }
1365     return 0;
1366 }