pts: Fix stringop-overflow warnings
[openafs.git] / src / ptserver / testpt.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  *
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #include <afsconfig.h>
11 #include <afs/param.h>
12
13 #include <roken.h>
14 #include <afs/opr.h>
15
16 #include <ctype.h>
17 #include <math.h>
18
19 #ifdef AFS_NT40_ENV
20 #include <WINNT/afsevent.h>
21 #endif
22
23 #include <rx/rx.h>
24 #include <rx/xdr.h>
25 #include <afs/rxgen_consts.h>
26 #include <afs/cmd.h>
27 #include <afs/auth.h>
28 #include <afs/cellconfig.h>
29 #include <afs/afsutil.h>
30 #include <afs/com_err.h>
31
32 #include "ptclient.h"
33 #include "pterror.h"
34 #include "ptuser.h"
35 #include "ptprototypes.h"
36
37 static char *whoami = "testpr";
38 static struct afsconf_dir *conf;        /* cell info, set by MyBeforeProc */
39 static char conf_dir[100];
40 static char lcell[MAXCELLCHARS];
41
42 int
43 ListUsedIds(struct cmd_syndesc *as, void *arock)
44 {
45     afs_int32 code;
46     namelist lnames;
47     idlist lids;
48     int i, j;
49     int group = 0;              /* check groups */
50     int unused = 0;             /* print unused */
51     int number = 100;           /* check 100 ids */
52     afs_int32 startId = 1;
53     afs_int32 maxId;
54     int range;
55
56     if (as->parms[0].items)
57         startId = atoi(as->parms[0].items->data);
58     if (as->parms[1].items)
59         number = atoi(as->parms[1].items->data);
60     if (as->parms[2].items)
61         unused = 1;
62
63     code = pr_Initialize(1, conf_dir, NULL);
64     if (code) {
65         afs_com_err(whoami, code, "initializing pruser");
66         exit(1);
67     }
68     if (startId < 0) {
69         group = 1;
70         code = pr_ListMaxGroupId(&maxId);
71         if (code) {
72           bad_max:
73             afs_com_err(whoami, code, "getting maximum id");
74             exit(2);
75         }
76         if (startId < maxId) {
77             fprintf(stderr, "Max group id is only %d.\n", maxId);
78             exit(3);
79         }
80     } else {
81         code = pr_ListMaxUserId(&maxId);
82         if (code)
83             goto bad_max;
84         if (startId > maxId) {
85             fprintf(stderr, "Max user id is only %d.\n", maxId);
86             exit(3);
87         }
88     }
89     range = abs(startId - maxId);
90     range++;                    /* number that can be printed */
91     if (range < number) {
92         fprintf(stderr, "Only %d ids to be checked.\n", range);
93         number = range;
94     }
95
96     printf("Checking for %d %sused ids starting at %d.\n", number,
97            (unused ? "un" : ""), startId);
98 #define NUM 100
99     lids.idlist_val = malloc(sizeof(afs_int32) * NUM);
100     lnames.namelist_len = 0;
101     lnames.namelist_val = 0;
102     while (number) {
103         if (number < NUM)
104             i = number;
105         else
106             i = NUM;
107         for (j = 0; j < i; j++) {
108             lids.idlist_val[j] = startId;
109             if (group)
110                 startId--;
111             else
112                 startId++;
113         }
114         lids.idlist_len = i;
115         code = pr_IdToName(&lids, &lnames);
116         if (code) {
117             afs_com_err(whoami, code, "converting id to name");
118             exit(2);
119         }
120         for (j = 0; j < lnames.namelist_len; j++) {
121             if (lids.idlist_val[j] == atoi(lnames.namelist_val[j])) {
122                 if (unused)
123                     printf("%s is free\n", lnames.namelist_val[j]);
124             } else {
125                 if (!unused)
126                     printf("%s is id %d\n", lnames.namelist_val[j],
127                            lids.idlist_val[j]);
128             }
129         }
130         number -= i;
131     }
132     if (lids.idlist_val)
133         free(lids.idlist_val);
134     if (lnames.namelist_val)
135         free(lnames.namelist_val);
136     return 0;
137 }
138
139 /* TestManyMembers - called with a number N.  Try creating N users and N groups
140  * and put all the users on one of the groups and one of the users on all the
141  * groups.  Also put many users on many groups.
142  *
143  * To keep track of this create an NxN matrix of membership and fill it in with
144  * a function that looks like a quarter of a circle.  That makes the first
145  * group contain every user and the first user be a member of every group. */
146
147 int verbose;
148 char callerName[PR_MAXNAMELEN];
149 afs_int32 callerId;
150 afs_int32 lastGroup;            /* id of last group created */
151 afs_int32 ownerUser;            /* first created user */
152 char ownerUserName[PR_MAXNAMELEN];      /*  " " " name */
153 int steepDropOff;               /* precentage decreate in GroupLimit */
154 char *createPrefix;             /* prefix for naming users&groups */
155 extern struct ubik_client *pruclient;   /* initialized by pr_Initialize */
156
157 /* These variables form the state if this test */
158 int number;                     /* max number of members */
159 char *population;               /* matrix of memberships */
160 afs_int32 *users;               /* ids of users */
161 afs_int32 *groups;              /* ids of groups */
162 afs_int32 *groupOwners;         /* ids of owners of groups */
163
164 /* statistics */
165 int nUsers, nGroups, nAdds, nRems, nUDels, nGDels;
166
167 int
168 IdCmp(const void *a, const void *b)
169 {
170     if (*(afs_int32 *)a > *(afs_int32 *)b) {
171         return 1;
172     } else if (*(afs_int32 *)a == *(afs_int32 *)b) {
173         return 0;
174     } else /* (*a < *b) */ {
175         return -1;
176     }
177 }
178
179 static int
180 sqr(int n)
181 {
182     return n * n;
183 }
184
185 static int
186 GetGroupLimit(int N, int x)
187 {
188     int y;
189
190     if ((x >= N) || (x < 0)) {
191         printf("GetGroupLimit: input value out of range %d (%d)\n", x, N);
192         exit(10);
193     }
194     if (steepDropOff) {         /* Use exponential decrease */
195         int i;
196         y = N;
197         for (i = 0; i < x; i++) {
198             y = (y * steepDropOff) / 100;       /* parameter is a percentage */
199             if (y == 0) {
200                 y = 1;          /* with a floor of 1 */
201                 break;
202             }
203         }
204     } else {                    /* Use a circle's third quadrant */
205         y = sqr(N - 1) - sqr(N - 1 - x);
206         y = (int)(sqrt((double)y) + 0.5);       /* round off */
207         y = N - y;
208     }
209     if ((y > N) || (y < 1)) {
210         printf("filling value out of range: %d (%d) => %d\n", x, N, y);
211         exit(11);
212     }
213     return y;
214 }
215
216 void
217 CreateUser(int u)
218 {
219     afs_int32 code;
220     prname name;
221     afs_int32 id;
222
223     sprintf(name, "%s%d", createPrefix, u);
224     id = 0;
225     code = pr_CreateUser(name, &id);
226     if (code) {
227         if (code == PREXIST) {
228             code = pr_Delete(name);
229             if (code == 0) {
230                 nUDels++;
231                 code = pr_CreateUser(name, &id);
232                 if (code == 0) {
233                     if (verbose)
234                         printf("RE-");
235                     goto done;
236                 }
237             }
238         }
239         afs_com_err(whoami, code, "couldn't create %s", name);
240         exit(12);
241     }
242   done:
243     if (verbose)
244         printf("Creating user %s (%di)\n", name, id);
245     users[u] = id;
246     nUsers++;
247
248     if (ownerUser == 0) {
249         ownerUser = id;
250         strcpy(ownerUserName, name);
251     }
252 }
253
254 void
255 CreateGroup(int g)
256 {
257     afs_int32 code;
258     char name[PR_MAXNAMELEN + 1];
259     afs_int32 id = 0;
260     afs_int32 owner = 0;
261     char *ownerName = NULL;
262     int ownerType;              /* type of ownership */
263     static char *lastGroupPrefix;       /* prefix used for type==2 */
264
265     /* At least 50 groups should be owned by another group to test long owner
266      * chains during deletion.  Also let's create some long owners of owners
267      * lists.  */
268     ownerType = random() % 3;
269
270     if (!ownerUser)
271         ownerType = 0;
272     if (!lastGroup)
273         ownerType = 0;
274     switch (ownerType) {
275     case 0:
276         owner = callerId;
277         ownerName = callerName;
278         break;
279     case 1:
280         owner = ownerUser;
281         ownerName = ownerUserName;
282         break;
283     case 2:
284         owner = lastGroup;
285         ownerName = lastGroupPrefix;
286         break;
287     }
288
289     code = snprintf(name, sizeof(name), "%s:%s%d", ownerName, createPrefix, g);
290     if (code >= sizeof(name)) {
291         fprintf(stderr, "%s: generated group name is too long: %s:%s%d\n",
292                 whoami, ownerName, createPrefix, g);
293         exit(13);
294     }
295     code = ubik_PR_NewEntry(pruclient, 0, name, PRGRP, owner, &id);
296     if (code) {
297         if (code == PREXIST) {
298             code = pr_Delete(name);
299             if (code == 0) {
300                 nGDels++;
301                 code =
302                     ubik_PR_NewEntry(pruclient, 0, name, PRGRP, owner,
303                               &id);
304                 if (code == 0) {
305                     if (verbose)
306                         printf("RE-");
307                     goto done;
308                 }
309             }
310         }
311         afs_com_err(whoami, code, "couldn't create %s w/ owner=%d", name, owner);
312         exit(13);
313     }
314   done:
315     if (verbose)
316         printf("Creating group %s (%di)\n", name, id);
317     groups[g] = id;
318     groupOwners[g] = owner;
319     nGroups++;
320     if (!lastGroup || (ownerType == 2)) {
321         lastGroup = id;
322         lastGroupPrefix = ownerName;
323     }
324 }
325
326 int
327 DeleteRandomId(afs_int32 *list)
328 {
329     afs_int32 code;
330     afs_int32 id;
331     int j, k;
332     int m;
333
334     k = random();               /* random starting point */
335     for (j = 0; j < number; j++) {      /* find an undeleted id */
336         m = (k + j) % number;
337         if ((id = list[m])) {
338             code = ubik_PR_Delete(pruclient, 0, id);
339             if (code) {
340                 afs_com_err(whoami, code, "Couldn't delete %di", id);
341                 exit(22);
342             }
343             list[m] = 0;
344             if (list == users)
345                 nUDels++;
346             else
347                 nGDels++;
348             return 0;
349         }
350     }
351     return -1;                  /* none left */
352 }
353
354 void
355 AddUser(int u, int g)
356 {
357     afs_int32 code;
358     afs_int32 ui, gi;
359
360     if (users[u] == 0)          /* create if necessary */
361         CreateUser(u);
362     if (groups[g] == 0)         /* create group if necessary */
363         CreateGroup(g);
364     ui = users[u];
365     gi = groups[g];
366     code = ubik_PR_AddToGroup(pruclient, 0, ui, gi);
367     if (code) {
368         afs_com_err(whoami, code, "couldn't add %d to %d", ui, gi);
369         exit(14);
370     }
371     if (verbose)
372         printf("Adding user (%di) to group (%di)\n", ui, gi);
373     population[u * number + g]++;
374     nAdds++;
375 }
376
377 void
378 RemUser(int u, int g)
379 {
380     afs_int32 code;
381     afs_int32 ui, gi;
382
383     ui = users[u];
384     gi = groups[g];
385     code = ubik_PR_RemoveFromGroup(pruclient, 0, ui, gi);
386     if (code) {
387         afs_com_err(whoami, code, "couldn't remove %d from %d", ui, gi);
388         exit(14);
389     }
390     if (verbose)
391         printf("Removing user (%di) from group (%di)\n", ui, gi);
392     population[u * number + g]--;
393     nRems++;
394 }
395
396 int
397 TestManyMembers(struct cmd_syndesc *as, void *arock)
398 {
399     char *filled;               /* users filled up */
400     char *cleaned;              /* users cleaned up */
401
402     int nFilled, nCleaned;
403     int u, g, i, j, n;
404     int seed;                   /* random number generator seed */
405
406     afs_int32 *glist;           /* membership list */
407
408     afs_int32 code;
409
410     code = pr_Initialize(1, conf_dir, NULL);
411     if (code) {
412         afs_com_err(whoami, code, "initializing pruser");
413         exit(1);
414     }
415     /* get name of person running command */
416     {
417         struct ktc_principal afs, user;
418         struct ktc_token token;
419
420         strcpy(afs.name, "afs");
421         strcpy(afs.instance, "");
422         code = afsconf_GetLocalCell(conf, afs.cell, sizeof(afs.cell));
423         if (code)
424             exit(2);
425         code = ktc_GetToken(&afs, &token, sizeof(token), &user);
426         if (code) {
427             afs_com_err(whoami, code, "getting afs tokens");
428             exit(3);
429         }
430         if (strlen(user.instance) > 0) {
431             fprintf(stderr, "can't handle non-null instance %s.%s\n",
432                     user.name, user.cell);
433             exit(4);
434         }
435         if (strncmp(user.name, "AFS ID ", 7) == 0) {
436             callerId = atoi(user.name + 7);
437             code = pr_SIdToName(callerId, callerName);
438             if (code) {
439                 afs_com_err(whoami, code, "call get name for id %d", callerId);
440                 exit(6);
441             }
442         } else {
443             strcpy(callerName, user.name);
444             code = pr_SNameToId(callerName, &callerId);
445             if ((code == 0) && (callerId == ANONYMOUSID))
446                 code = PRNOENT;
447         }
448         if (code) {
449             afs_com_err(whoami, code, "can't find caller %s", callerName);
450             exit(6);
451         } else
452             printf("Assuming caller is %s (%di)\n", callerName, callerId);
453     }
454
455     /* Parse arguments */
456     if (as->parms[0].items)
457         number = atoi(as->parms[0].items->data);
458     if (as->parms[1].items) {
459         steepDropOff = atoi(as->parms[1].items->data);
460         if ((steepDropOff < 0) || (steepDropOff > 100)) {
461             fprintf(stderr,
462                     "Illegal value for dropoff: %d, must be between 0 and 100, inclusive.\n",
463                     steepDropOff);
464             exit(7);
465         }
466     } else
467         steepDropOff = 0;       /* use quadratic dropoff */
468     if (as->parms[2].items)
469         createPrefix = as->parms[2].items->data;
470     else
471         createPrefix = "u";
472     if (as->parms[3].items)
473         verbose = 1;
474     else
475         verbose = 0;
476     if (as->parms[4].items)
477         seed = atoi(as->parms[4].items->data);
478     else
479         seed = 1;
480
481     srandom(seed);
482
483     users = calloc(number, sizeof(afs_int32));
484     groups = calloc(number, sizeof(afs_int32));
485     filled = calloc(number, sizeof(char));
486     cleaned = calloc(number, sizeof(char));
487     population = calloc(sqr(number), sizeof(char));
488
489     nFilled = 0;
490     nCleaned = 0;
491
492     ownerUser = lastGroup = 0;
493     groupOwners = malloc(number * sizeof(afs_int32));
494     nUsers = nGroups = nAdds = nRems = nUDels = nGDels = 0;
495
496     while ((nFilled < number) || (nCleaned < number)) {
497         /* pick a user at random, using  */
498         u = random() % number;
499         if (!filled[u]) {
500             n = GetGroupLimit(number, u);       /* get group limit for that user */
501             g = random() % (n + 1);     /* pick a random group */
502             if (g == n) {       /* in a few cases create any user */
503                 n = number;     /* in the whole range */
504                 g = random() % n;
505             }
506             for (i = 0; i < n; i++) {   /* rotate until unused one found */
507                 j = (g + i) % n;
508                 if (!population[u * number + j]) {
509                     /* add this user/group membership */
510                     AddUser(u, j);
511                     goto added;
512                 }
513             }
514             filled[u]++;
515             nFilled++;
516           added:;
517         }
518         if (!cleaned[u]) {
519             int base;
520             if (filled[u]) {    /* only clean above GroupLimit */
521                 base = GetGroupLimit(number, u);
522                 n = number - base;
523                 if (n == 0)
524                     goto iscleaned;
525                 g = random() % n;
526             } else {
527                 base = 0;
528                 n = number;     /* pick a group from the whole range */
529                 g = random() % 2 * n;   /* at random for removal */
530                 if (g >= n)
531                     goto remed; /* but half the time do nothing */
532             }
533             for (i = 0; i < n; i++) {   /* rotate until used one found */
534                 j = (g + i) % n + base;
535                 if (population[u * number + j]) {
536                     /* remove this user/group membership */
537                     RemUser(u, j);
538                     goto remed;
539                 }
540             }
541             if (filled[u]) {    /* track finished ones */
542               iscleaned:
543                 cleaned[u]++;
544                 nCleaned++;
545             }
546           remed:;
547         }
548     }
549
550     /* check the membership list of all users for correctness */
551     printf("Starting check of memberships\n");
552     glist = malloc(number * sizeof(afs_int32));
553     for (u = 0; u < number; u++) {
554         afs_int32 ui = users[u];
555         if (ui) {
556             int i;
557             int ng;             /* number groups */
558             int over;
559             int (*proc)(struct ubik_client *, afs_int32, afs_int32, prlist *,
560                         afs_int32 *);
561             prlist alist;
562
563             alist.prlist_len = 0;
564             alist.prlist_val = 0;
565             if (random() & 4) {
566                 proc = ubik_PR_ListElements;
567             } else {
568                 proc = ubik_PR_GetCPS;
569             }
570             code = (*proc)(pruclient, 0, ui, &alist, &over);
571             if (code) {
572                 afs_com_err(whoami, code,
573                         "getting membership list of (%di) using %s", ui,
574                         (proc == ubik_PR_ListElements?"ListElements":"GetCPS"));
575                 exit(24);
576             }
577             if (over) {
578                 fprintf(stderr, "membership list for id %di too long\n", ui);
579             }
580             ng = 0;
581             for (i = 0; i < number; i++)
582                 if (population[u * number + i])
583                     glist[ng++] = groups[i];
584             qsort(glist, ng, sizeof(afs_int32), IdCmp);
585             if (ng != (alist.prlist_len - ((proc == ubik_PR_GetCPS) ? 3 : 0))) {
586                 fprintf(stderr,
587                         "Membership list for %di of unexpected length: was %d but expected %d\n",
588                         ui, alist.prlist_len, ng);
589                 exit(20);
590             }
591             /* all the extra entries for the CPS should be at the end. */
592             code = 0;
593             for (i = 0; i < ng; i++)
594                 if (alist.prlist_val[i] != glist[i]) {
595                     fprintf(stderr,
596                             "membership for %di not correct: was %di but expected %di\n",
597                             ui, alist.prlist_val[i], glist[i]);
598                     code++;
599                 }
600             if (code)
601                 exit(21);
602             if (proc == ubik_PR_GetCPS) {
603                 if ((alist.prlist_val[i /* =ng */ ] != AUTHUSERID) ||
604                     (alist.prlist_val[++i] != ANYUSERID)
605                     || (alist.prlist_val[++i] != ui)) {
606                     fprintf(stderr, "CPS doesn't have extra entries\n");
607                     exit(27);
608                 }
609             }
610             if (alist.prlist_val)
611                 free(alist.prlist_val);
612
613             /* User 0 is a member of all groups all of which should also be on
614              * the owner list of the caller or the ownerUser, although there
615              * may also be others.  Check this. */
616             if (u == 0) {
617                 prlist callerList;
618                 prlist ownerList;
619                 prlist lastGroupList;
620                 int i, j, k, l;
621
622                 if (ng != number) {
623                     fprintf(stderr, "User 0 not a member of all groups\n");
624                     exit(26);
625                 }
626 #define GETOWNED(xlist,xid) \
627   (xlist).prlist_val = 0; (xlist).prlist_len = 0; \
628   code = ubik_PR_ListOwned(pruclient, 0, (xid), &(xlist), &over); \
629   if (code) { \
630       afs_com_err (whoami, code, "getting owner list of (%di)", (xid)); \
631       exit (23); } \
632   if (over) \
633       { fprintf (stderr, "membership of id %di too long\n", (xid)); }
634
635                 GETOWNED(callerList, callerId);
636                 GETOWNED(ownerList, ownerUser);
637
638                 /* look for every entry in glist, in all the owner lists */
639                 for (i = j = k = l = 0; i < number; i++) {
640                     while ((j < callerList.prlist_len)
641                            && (callerList.prlist_val[j] < glist[i]))
642                         j++;
643                     while ((k < ownerList.prlist_len)
644                            && (ownerList.prlist_val[k] < glist[i]))
645                         k++;
646 #define PRLISTCMP(l,i) \
647   (((l).prlist_len == 0) || (glist[i] != (l).prlist_val[(i)]))
648                     if (PRLISTCMP(callerList, j) && PRLISTCMP(ownerList, k)) {
649                         for (l = 0; l < number; l++) {
650                             if (groups[l] == glist[i]) {
651                                 if ((groupOwners[l] != callerId)
652                                     && (groupOwners[l] != ownerUser)) {
653                                     GETOWNED(lastGroupList, groupOwners[l]);
654                                     if ((lastGroupList.prlist_len != 1)
655                                         || (lastGroupList.prlist_val[0] !=
656                                             glist[i])) {
657                                         fprintf(stderr,
658                                                 "Group (%di) not on any owner list\n",
659                                                 glist[i]);
660                                         exit(25);
661                                     }
662                                 }
663                                 goto foundLast;
664                             }
665                         }
666                         fprintf(stderr, "unexpected group %di\n", glist[i]);
667                       foundLast:;
668                     }
669                 }
670                 if (callerList.prlist_val)
671                     free(callerList.prlist_val);
672                 if (ownerList.prlist_val)
673                     free(ownerList.prlist_val);
674                 if (lastGroupList.prlist_val)
675                     free(lastGroupList.prlist_val);
676             }
677         }
678     }
679
680     /* cleanup by deleting all the users and groups */
681     printf("Starting deletion of users and groups\n");
682     for (i = 0; i < number; i++) {
683         DeleteRandomId(users);
684         DeleteRandomId(groups);
685     }
686
687     printf
688         ("Created/deleted %d/%d users and %d/%d groups; added %d and removed %d.\n",
689          nUsers, nUDels, nGroups, nGDels, nAdds, nRems);
690     return 0;
691 }
692
693 /* from ka_ConvertBytes included here to avoid circularity */
694 /* Converts a byte string to ascii.  Return the number of unconverted bytes. */
695
696 static int
697 ka_ConvertBytes(char *ascii,            /* output buffer */
698                 int alen,               /* buffer length */
699                 char bs[],              /* byte string */
700                 int bl)                 /* number of bytes */
701 {
702     int i;
703     unsigned char c;
704
705     alen--;                     /* make room for termination */
706     for (i = 0; i < bl; i++) {
707         c = bs[i];
708         if (alen <= 0)
709             return bl - i;
710         if (isalnum(c) || ispunct(c))
711             (*ascii++ = c), alen--;
712         else {
713             if (alen <= 3)
714                 return bl - i;
715             *ascii++ = '\\';
716             *ascii++ = (c >> 6) + '0';
717             *ascii++ = (c >> 3 & 7) + '0';
718             *ascii++ = (c & 7) + '0';
719             alen -= 4;
720         }
721     }
722     *ascii = 0;                 /* terminate string */
723     return 0;
724 }
725
726 /* This runs various tests on the server.  It creates, then deletes, a bunch of
727  * users and groups, so it would be safest to run it on a test database.
728  *
729  * These are the things I check for:
730  *   User names longer than PR_MAXNAMELEN - strlen(cellname).
731  *   Group names longer than PR_MAXNAMELEN.
732  *   User names containing all legal 8-bit ascii characters.  This excludes
733  *     only ':', '@', and '\n'.
734  *   Group names as above, but at least one colon is required, and the owner
735  *     must be correct.
736  */
737
738 int
739 TestPrServ(struct cmd_syndesc *as, void *arock)
740 {
741     afs_int32 id;
742     char name[PR_MAXNAMELEN + 1];
743     char creator[PR_MAXNAMELEN];        /* our name */
744     struct prcheckentry ent;
745     afs_int32 code;
746     int i, j;
747     int maxLen = PR_MAXNAMELEN - 1 - strlen(lcell) - 1;
748
749     code = pr_Initialize(1, conf_dir, NULL);
750     if (code) {
751         afs_com_err(whoami, code, "initializing pruser");
752         exit(1);
753     }
754
755     for (i = 0; i < maxLen; i++)
756         name[i] = 'a';
757     name[i] = 'a';              /* too long a name... */
758     name[i + 1] = 0;
759     id = 0;
760     code = pr_CreateUser(name, &id);
761     if ((code != RXGEN_CC_MARSHAL) && (code != PRBADNAM)) {
762         afs_com_err(whoami, code, "succeeded creating %s", name);
763         exit(2);
764     }
765     name[i] = 0;
766     id = 0;
767     code = pr_CreateUser(name, &id);
768     if (code == PREXIST) {
769         fprintf(stderr, "group already exists, skipping\n");
770         pr_SNameToId(name, &id);
771     } else if (code) {
772         afs_com_err(whoami, code, "failed creating %s", name);
773         exit(3);
774     }
775     if ((code = pr_ListEntry(id, &ent))
776         || (code = pr_SIdToName(ent.creator, creator))) {
777         afs_com_err(whoami, code, "getting creator's name");
778         exit(5);
779     }
780     code = pr_DeleteByID(id);
781     if (code) {
782         afs_com_err(whoami, code, "deleting %s", name);
783         exit(6);
784     }
785     /* now make sure the illegal chars are detected */
786     {
787         char *illegalChars;
788         for (illegalChars = "@:\n"; *illegalChars; illegalChars++) {
789             name[10] = *illegalChars;
790             id = 0;
791             code = pr_CreateUser(name, &id);
792             if (code != PRBADNAM) {
793                 afs_com_err(whoami, code, "succeeded creating %s", name);
794                 exit(8);
795             }
796         }
797     }
798
799     for (i = 1; i <= 255;) {    /* for all 8-bit ascii... */
800         j = 0;                  /* build a new name */
801         while ((j < maxLen) && (i <= 255)) {
802             if (!((i == ':') || (i == '@') || (i == '\n')))
803                 name[j++] = i;
804             i++;
805         }
806         name[j] = 0;            /* terminate string */
807         id = 0;
808         code = pr_CreateUser(name, &id);
809         if (code == PREXIST) {
810             fprintf(stderr, "user already exists, skipping\n");
811             pr_SNameToId(name, &id);
812         } else if (code) {
813             char ascii[BUFSIZ];
814             ka_ConvertBytes(ascii, sizeof(ascii), name, strlen(name));
815             afs_com_err(whoami, code, "failed creating %s", ascii);
816             exit(4);
817         }
818         code = pr_DeleteByID(id);
819         if (code) {
820             afs_com_err(whoami, code, "deleting %s", name);
821             exit(7);
822         }
823     }
824
825     /* now check group names */
826     strcpy(name, creator);
827     strcat(name, ":abcdefghijklmnopqrstuvwxyz");
828     name[0] = 1;                /* bash the owner name */
829     id = 0;
830     code = pr_CreateGroup(name, creator, &id);
831     if (code != PRNOENT) {      /* owner doesn't exist */
832         afs_com_err(whoami, code, "succeeded creating %s", name);
833         exit(9);
834     }
835     name[0] = creator[0];       /* fix owner */
836     /* Make sure the illegal chars are detected */
837     {
838         char *illegalChars;
839         for (illegalChars = ":@\n"; *illegalChars; illegalChars++) {
840             name[strlen(creator) + 10] = *illegalChars;
841             id = 0;
842             code = pr_CreateGroup(name, creator, &id);
843             if (code != PRBADNAM) {
844                 afs_com_err(whoami, code, "succeeded creating %s", name);
845                 exit(10);
846             }
847         }
848     }
849     for (i = 1; i <= 255;) {    /* for all 8-bit ascii... */
850         j = strlen(creator) + 1;        /* build a new name */
851         while ((j < PR_MAXNAMELEN - 1) && (i <= 255)) {
852             if (!((i == ':') || (i == '@') || (i == '\n')))
853                 name[j++] = i;
854             i++;
855         }
856         name[j] = 0;            /* terminate string */
857         id = 0;
858         code = pr_CreateGroup(name, creator, &id);
859         if (code == PREXIST) {
860             fprintf(stderr, "group already exists, skipping\n");
861             pr_SNameToId(name, &id);
862         } else if (code) {
863             char ascii[BUFSIZ];
864             ka_ConvertBytes(ascii, sizeof(ascii), name, strlen(name));
865             afs_com_err(whoami, code, "failed creating %s", ascii);
866             exit(4);
867         }
868         code = pr_DeleteByID(id);
869         if (code) {
870             afs_com_err(whoami, code, "deleting %s", name);
871             exit(7);
872         }
873     }
874
875     printf("All OK\n");
876     return 0;
877 }
878
879 static char tmp_conf_dir[128] = "";
880 static char tmp_conf_file[128] = "";
881 static char tmp_cell_file[128] = "";
882 static char tmp_noauth_file[128] = "";
883
884 static int
885 MyAfterProc(struct cmd_syndesc *as, void *arock)
886 {
887     if (strlen(tmp_conf_file))
888         unlink(tmp_conf_file);
889     if (strlen(tmp_cell_file))
890         unlink(tmp_cell_file);
891     if (strlen(tmp_noauth_file))
892         unlink(tmp_noauth_file);
893     if (strlen(tmp_conf_dir))
894         rmdir(tmp_conf_dir);
895     return 0;
896 }
897
898 static int
899 MyBeforeProc(struct cmd_syndesc *as, void *arock)
900 {
901     afs_int32 code;
902     int i;
903     char *cdir = 0;
904     int noAuth = 0;
905     struct cmd_item *serverList = 0;
906     struct afsconf_dir *local_conf = 0; /* so we can default stuff nicely */
907     struct afsconf_cell cellinfo;
908
909     if (as->parms[12].items) {  /* if conf dir specified */
910         cdir = as->parms[12].items->data;
911         if (as->parms[13].items || as->parms[14].items || as->parms[15].items) {
912             printf("Can't specify conf dir and other cell parameters\n");
913             return AFSCONF_SYNTAX;
914         }
915     }
916
917     /* if we need to default cell name or cell servers, get local conf info */
918
919     if (!(local_conf = afsconf_Open(AFSDIR_CLIENT_ETC_DIRPATH))
920         && !(local_conf = afsconf_Open(AFSDIR_SERVER_ETC_DIRPATH))) {
921         printf("** Can't local configuration!\n");
922         return AFSCONF_NOCELL;
923     }
924
925     if (as->parms[13].items) {  /* if cell name specified */
926         lcstring(lcell, as->parms[13].items->data, sizeof(lcell));
927         code = afsconf_GetCellInfo(local_conf, lcell, 0, &cellinfo);
928         if (code == 0)
929             strncpy(lcell, cellinfo.name, sizeof(lcell));
930     } else {
931         code = afsconf_GetLocalCell(local_conf, lcell, sizeof(lcell));
932         if (code)
933             return code;
934     }
935
936     if (as->parms[14].items) {  /* noauth flag */
937         noAuth = 1;
938     }
939
940     if (as->parms[15].items) {  /* servers list */
941         serverList = as->parms[15].items;
942         for (i = 0; serverList; i++, serverList = serverList->next) {
943             struct hostent *th;
944             if (i >= MAXHOSTSPERCELL)
945                 return AFSCONF_FULL;
946             strncpy(cellinfo.hostName[i], serverList->data, MAXHOSTCHARS);
947             th = gethostbyname(cellinfo.hostName[i]);
948             if (!th)
949                 return UBADHOST;
950             memcpy(&cellinfo.hostAddr[i].sin_addr, th->h_addr,
951                    sizeof(afs_int32));
952             cellinfo.hostAddr[i].sin_family = AF_INET;
953             cellinfo.hostAddr[i].sin_port = 0;
954 #ifdef STRUCT_SOCKADDR_HAS_SA_LEN
955             cellinfo.hostAddr[i].sin_len = sizeof(struct sockaddr_in);
956 #endif
957         }
958         cellinfo.numServers = i;
959         strcpy(cellinfo.name, lcell);
960     } else {
961         code = afsconf_GetCellInfo(local_conf, lcell, 0, &cellinfo);
962         if (code)
963             return code;
964     }
965
966     if (local_conf)
967         afsconf_Close(local_conf);
968
969     if (cdir == 0) {
970         FILE *f;
971
972         sprintf(tmp_conf_dir, "%s/afsconf.%lu", gettmpdir(),
973                 (unsigned long)getpid());
974         code = mkdir(tmp_conf_dir, 0777);
975         if ((code < 0) && (errno != EEXIST)) {
976             afs_com_err(whoami, errno, "can't create temporary afsconf dir: %s",
977                     tmp_conf_dir);
978             return errno;
979         }
980
981         strcompose(tmp_conf_file, 128, tmp_conf_dir, "/",
982                    AFSDIR_CELLSERVDB_FILE, (char *)NULL);
983         f = fopen(tmp_conf_file, "w");
984         if (f == 0) {
985           cantcreate:
986             afs_com_err(whoami, errno, "can't create conf file %s",
987                     tmp_conf_file);
988             return errno;
989         }
990         fprintf(f, ">%s\n", lcell);
991         for (i = 0; i < cellinfo.numServers; i++) {
992             unsigned char *tp =
993                 (unsigned char *)&cellinfo.hostAddr[i].sin_addr;
994             fprintf(f, "%d.%d.%d.%d\t#%s\n", tp[0], tp[1], tp[2], tp[3],
995                     cellinfo.hostName[i]);
996         }
997         if (fclose(f) == EOF) {
998           cantclose:
999             afs_com_err(whoami, errno, "can't write to conf file %s",
1000                     tmp_conf_file);
1001             return errno;
1002         }
1003
1004         strcompose(tmp_cell_file, 128, tmp_conf_dir, "/",
1005                    AFSDIR_THISCELL_FILE, (char *)NULL);
1006         f = fopen(tmp_cell_file, "w");
1007         if (f == 0)
1008             goto cantcreate;
1009         fprintf(f, "%s", lcell);
1010         if (fclose(f) == EOF)
1011             goto cantclose;
1012
1013         strcompose(tmp_noauth_file, 128, tmp_conf_dir, "/",
1014                    AFSDIR_NOAUTH_FILE, (char *)NULL);
1015         if (noAuth) {
1016             code = creat(tmp_noauth_file, 0777);
1017             if (code && (errno != EEXIST))
1018                 return errno;
1019         } else {                /* make sure file doesn't exist */
1020             code = unlink(tmp_noauth_file);
1021             if (code && (errno != ENOENT))
1022                 return errno;
1023         }
1024     }
1025
1026     strncpy(conf_dir, tmp_conf_dir, sizeof(conf_dir));
1027     conf = afsconf_Open(conf_dir);
1028     if (conf == 0)
1029         return AFSCONF_NOTFOUND;
1030     return 0;
1031 }
1032
1033 static void
1034 add_std_args(struct cmd_syndesc *ts)
1035 {
1036     cmd_Seek(ts, 12);
1037     cmd_AddParm(ts, "-confdir", CMD_SINGLE, CMD_OPTIONAL,
1038                 "AFS Conf dir pathname");
1039     cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_OPTIONAL, "Cell name");
1040     cmd_AddParm(ts, "-noauth", CMD_FLAG, CMD_OPTIONAL, "Don't authenticate");
1041     cmd_AddParm(ts, "-servers", CMD_LIST, CMD_OPTIONAL, "Server config");
1042 }
1043
1044 int
1045 osi_audit(void)
1046 {
1047 /* OK, this REALLY sucks bigtime, but I can't tell who is calling
1048  * afsconf_CheckAuth easily, and only *SERVERS* should be calling osi_audit
1049  * anyway.  It's gonna give somebody fits to debug, I know, I know.
1050  */
1051     return 0;
1052 }
1053
1054 #include "AFS_component_version_number.c"
1055
1056 int
1057 main(int argc, char *argv[])
1058 {
1059     afs_int32 code;
1060     struct cmd_syndesc *ts;     /* ptr to parsed command line syntax */
1061
1062     whoami = argv[0];
1063     initialize_CMD_error_table();
1064     initialize_ACFG_error_table();
1065     initialize_KTC_error_table();
1066     initialize_U_error_table();
1067     initialize_PT_error_table();
1068     initialize_RXK_error_table();
1069
1070 #ifdef AFS_NT40_ENV
1071     /* initialize winsock */
1072     if (afs_winsockInit() < 0) {
1073         fprintf(stderr, "%s: couldn't initialize winsock. \n", whoami);
1074         exit(1);
1075     }
1076 #endif
1077
1078     cmd_SetBeforeProc(MyBeforeProc, NULL);
1079     cmd_SetAfterProc(MyAfterProc, NULL);
1080
1081     ts = cmd_CreateSyntax("usedIds", ListUsedIds, NULL, 0,
1082                           "Find used (or unused) user (or group) ids");
1083     cmd_AddParm(ts, "-startId", CMD_SINGLE, CMD_OPTIONAL,
1084                 "id to start checking");
1085     cmd_AddParm(ts, "-number", CMD_SINGLE, CMD_OPTIONAL,
1086                 "number of ids to check");
1087     cmd_AddParm(ts, "-unused", CMD_FLAG, CMD_OPTIONAL, "print unused ids");
1088     add_std_args(ts);
1089
1090     ts = cmd_CreateSyntax("initcmd", TestPrServ, NULL, 0, "test the prserver");
1091     add_std_args(ts);
1092
1093     ts = cmd_CreateSyntax("testmanymembers", TestManyMembers, NULL, 0,
1094                           "test creating users and groups w/ many members");
1095     cmd_AddParm(ts, "-number", CMD_SINGLE, 0,
1096                 "number of users/groups to create");
1097     cmd_AddParm(ts, "-dropoff", CMD_SINGLE, CMD_OPTIONAL,
1098                 "precentage for exponential dropoff");
1099     cmd_AddParm(ts, "-prefix", CMD_SINGLE, CMD_OPTIONAL, "naming prefix");
1100     cmd_AddParm(ts, "-long", CMD_FLAG, CMD_OPTIONAL, "show progress");
1101     cmd_AddParm(ts, "-seed", CMD_SINGLE, CMD_OPTIONAL, "random number seed");
1102     add_std_args(ts);
1103     cmd_CreateAlias(ts, "mm");
1104
1105
1106     code = cmd_Dispatch(argc, argv);
1107     if (code)
1108         afs_com_err(whoami, code, "calling cmd_Dispatch");
1109     exit(code);
1110 }