ptserver: Tidy header includes
[openafs.git] / src / ptserver / ptclient.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 #include <afs/stds.h>
13
14 #include <roken.h>
15
16 #ifdef AFS_NT40_ENV
17 #include <WINNT/afsevent.h>
18 #endif
19
20 #include <rx/xdr.h>
21 #include <rx/rx.h>
22 #include <afs/com_err.h>
23 #include <afs/cellconfig.h>
24 #include <afs/afsutil.h>
25
26 #include "ptclient.h"
27 #include "ptuser.h"
28 #include "pterror.h"
29 #include "display.h"
30
31 afs_int32 security = 0;
32 char confdir[AFSDIR_PATH_MAX];
33
34 char *whoami;
35
36 #ifndef AFS_PTHREAD_ENV
37 extern struct ubik_client *pruclient;
38 static void skip(char **);
39 static void PrintHelp(void);
40 #endif
41
42 static int ignoreExist = 0;
43 static char line[256];
44 static char *lineProgress;
45
46 #define WHITESPACE " \t\n"
47
48 #ifndef AFS_PTHREAD_ENV
49 int
50 osi_audit()
51 {
52 /* OK, this REALLY sucks bigtime, but I can't tell who is calling
53  * afsconf_CheckAuth easily, and only *SERVERS* should be calling osi_audit
54  * anyway.  It's gonna give somebody fits to debug, I know, I know.
55  */
56     return 0;
57 }
58 #endif /* !AFS_PTHREAD_ENV */
59
60 int
61 GetToken(char *format, afs_int32 *l)
62 {
63     int c;
64
65     *l = 0;
66     if (lineProgress == 0)
67         lineProgress = line;
68     c = sscanf(lineProgress, format, l);
69     if (c != 1)
70         return -1;
71     /* skip the white space */
72     lineProgress += strspn(lineProgress, WHITESPACE);
73     /* skip to end of token */
74     lineProgress = strpbrk(lineProgress, WHITESPACE);
75     return 0;
76 }
77
78 #define GetInt32(l) GetToken ("%d", l)
79 #define GetXInt32(l) GetToken ("%x", l)
80
81 int
82 GetString(char *s, int slen)
83 {
84     char *beg;
85     int l;
86     int code;
87
88     if (lineProgress == 0)
89         lineProgress = line;
90     /* skip the white space */
91     lineProgress += strspn(lineProgress, WHITESPACE);
92
93     /* check for quoted string and find end */
94     beg = lineProgress;
95     if (*beg == '"') {
96         l = strcspn(++beg, "\"");
97         if (l == strlen(beg))
98             return -1;          /* unbalanced quotes */
99         lineProgress = beg + l + 1;
100     } else {
101         l = strcspn(beg, WHITESPACE);
102         lineProgress += l;
103     }
104     if (l >= slen) {            /* don't return too much */
105         code = -1;
106         l = slen - 1;
107     } else
108         code = 0;
109
110     strncpy(s, beg, l);
111     s[l] = 0;                   /* null termination */
112     return code;
113 }
114
115 int
116 CodeOk(afs_int32 code)
117 {
118     if (!ignoreExist)
119         return code;
120     return code && (code != PREXIST) && (code != PRIDEXIST);
121 }
122
123 int
124 PrintEntry(afs_int32 ea, struct prentry *e, int indent)
125 {
126     /* handle screwed up versions of DumpEntry */
127     if (e->flags & PRCONT) {
128         afs_int32 id;
129
130         memcpy(&id, e->name, sizeof(id));
131         if ((id != PRBADID) && ((id > (1 << 24)) || (id < -(1 << 24)))) {
132             /* assume server incorrectly swapped these bytes... */
133             int i = 0;
134             while (i < sizeof(e->name)) {
135                 char temp;
136                 temp = e->name[i];
137                 e->name[i] = e->name[i + 3];
138                 e->name[i + 3] = temp;
139                 temp = e->name[i + 1];
140                 e->name[i + 1] = e->name[i + 2];
141                 e->name[i + 2] = temp;
142                 i += 4;
143             }
144         }
145     }
146     return pr_PrintEntry(stdout, /*host order */ 1, ea, e, indent);
147 }
148
149 #ifndef AFS_PTHREAD_ENV
150
151 /* main program */
152
153 #include "AFS_component_version_number.c"
154
155 int
156 main(int argc, char **argv)
157 {
158     afs_int32 code;
159     char op[8];
160     char name[PR_MAXNAMELEN];
161     afs_int32 id, oid = ANONYMOUSID, gid;
162     afs_int32 pos;
163     unsigned int i;
164     int n;
165     struct prentry entry;
166     prlist alist;
167     idlist lid;
168     namelist lnames;
169     struct hostent *hostinfo;
170     struct in_addr *hostaddr;
171     afs_int32 *ptr;
172     char *foo;
173     afs_int32 over;
174     char *cell;
175
176 #ifdef  AFS_AIX32_ENV
177     /*
178      * The following signal action for AIX is necessary so that in case of a
179      * crash (i.e. core is generated) we can include the user's data section
180      * in the core dump. Unfortunately, by default, only a partial core is
181      * generated which, in many cases, isn't too useful.
182      */
183     struct sigaction nsa;
184
185     sigemptyset(&nsa.sa_mask);
186     nsa.sa_handler = SIG_DFL;
187     nsa.sa_flags = SA_FULLDUMP;
188     sigaction(SIGSEGV, &nsa, NULL);
189 #endif
190     whoami = argv[0];
191
192     initialize_PT_error_table();
193
194     strcpy(confdir, AFSDIR_CLIENT_ETC_DIRPATH);
195     cell = 0;
196     n = 1;
197     while (n < argc) {
198         int arglen = strlen(argv[n]);
199         char arg[256];
200         lcstring(arg, argv[n], sizeof(arg));
201 #define IsArg(a) (strncmp (arg,a, arglen) == 0)
202         if (IsArg("-testconfdir"))
203             strncpy(confdir, argv[++n], sizeof(confdir));
204         else if (IsArg("client"))
205             strncpy(confdir, AFSDIR_CLIENT_ETC_DIRPATH, sizeof(confdir));
206         else if (IsArg("server"))
207             strncpy(confdir, AFSDIR_SERVER_ETC_DIRPATH, sizeof(confdir));
208         else if (IsArg("0") || IsArg("1") || IsArg("2"))
209             security = atoi(argv[n]);
210         else if (IsArg("-ignoreexist"))
211             ignoreExist++;
212         else if (IsArg("-cell"))
213             cell = argv[++n];
214         else {
215             printf
216                 ("Usage is: 'prclient [-testconfdir <dir> | server | client] [0 | 1 | 2] [-ignoreExist] [-cell <cellname>]\n");
217             exit(1);
218         }
219         n++;
220     }
221
222     printf("Using CellServDB file in %s\n", confdir);
223     if (security == 0)
224         printf("Making unauthenticated connection to prserver\n");
225
226     code = pr_Initialize(security, confdir, cell);
227     if (code) {
228         afs_com_err(whoami, code, "Couldn't initialize protection library");
229         exit(1);
230     }
231
232     while (1) {
233         char *s;
234
235         printf("pr> ");
236         s = fgets(line, sizeof(line), stdin);
237         if (s == NULL)
238             break;
239         lineProgress = 0;
240
241         code = GetString(op, sizeof(op));
242         if (code) {
243             afs_com_err(whoami, PRBADARG,
244                     "error reading opcode in line '%s', got '%.*s'", line,
245                     sizeof(op), op);
246             exit(1);
247         }
248         if (strlen(op) == 0)
249             continue;           /* no input */
250
251         if (!strcmp(op, "cr")) {
252             if (GetString(name, sizeof(name)) || GetInt32(&id)
253                 || GetInt32(&oid))
254                 code = PRBADARG;
255             /* use ubik_Call to do the work, finding an up server and handling
256              * the job of finding a sync site, if need be */
257             else
258                 code = ubik_PR_INewEntry(pruclient, 0, name, id, oid);
259             if (CodeOk(code))
260                 afs_com_err(whoami, code, "on %s %s %d %d", op, name, id, oid);
261         } else if (!strcmp(op, "sf")) {
262             afs_int32 mask, access, gq, uq;
263             if (GetInt32(&id) || GetXInt32(&mask) || GetXInt32(&access)
264                 || GetInt32(&gq) || GetInt32(&uq))
265                 code = PRBADARG;
266             else
267                 code =
268                     ubik_PR_SetFieldsEntry(pruclient, 0, id, mask,
269                               access, gq, uq, 0, 0);
270             if (CodeOk(code))
271                 afs_com_err(whoami, code, "on %s %d %x %x %d %d", op, id, mask,
272                         access, gq, uq);
273         } else if (!strcmp(op, "ce")) {
274             char newname[PR_MAXNAMELEN];
275             afs_int32 newid;
276             if (GetInt32(&id) || GetString(newname, sizeof(newname))
277                 || GetInt32(&oid) || GetInt32(&newid))
278                 code = PRBADARG;
279             else
280                 code =
281                     ubik_PR_ChangeEntry(pruclient, 0, id, newname, oid,
282                               newid);
283             if (CodeOk(code))
284                 afs_com_err(whoami, code, "on %s %d %s %d %d", op, id, newname,
285                         oid, newid);
286         } else if (!strcmp(op, "wh")) {
287             /* scanf("%d",&id); */
288             if (GetInt32(&id))
289                 code = PRBADARG;
290             else
291                 code = ubik_PR_WhereIsIt(pruclient, 0, id, &pos);
292             if (CodeOk(code))
293                 printf("%s\n", pr_ErrorMsg(code));
294             else
295                 printf("location %d\n", pos);
296         } else if (!strcmp(op, "du")) {
297             memset(&entry, 0, sizeof(entry));
298             /* scanf("%d",&pos); */
299             if (GetInt32(&pos))
300                 code = PRBADARG;
301             else
302                 code = ubik_PR_DumpEntry(pruclient, 0, pos, (struct prdebugentry *)&entry);
303             if (CodeOk(code))
304                 printf("%s\n", pr_ErrorMsg(code));
305             if (code == PRSUCCESS) {
306                 PrintEntry(pos, &entry, /*indent */ 0);
307 #if 0
308                 printf("The contents of the entry for %d are:\n", entry.id);
309                 printf("flags %d next %d\n", entry.flags, entry.next);
310                 printf("Groups (or members) \n");
311                 for (i = 0; i < PRSIZE; i++)
312                     printf("%d\n", entry.entries[i]);
313                 printf("nextID %d nextname %d name %s\n", entry.nextID,
314                        entry.nextName, entry.name);
315                 printf("owner %d creator %d\n", entry.owner, entry.creator);
316 #endif
317             }
318         } else if (!strcmp(op, "add") || !strcmp(op, "au")) {
319             /* scanf("%d %d",&id,&gid); */
320             if (GetInt32(&id) || GetInt32(&gid))
321                 code = PRBADARG;
322             else
323                 code = ubik_PR_AddToGroup(pruclient, 0, id, gid);
324             if (CodeOk(code))
325                 afs_com_err(whoami, code, "on %s %d %d", op, id, gid);
326         } else if (!strcmp(op, "iton")) {
327             lid.idlist_val = (afs_int32 *) malloc(20 * sizeof(afs_int32));
328             ptr = lid.idlist_val;
329             lid.idlist_len = 0;
330             foo = line;
331             skip(&foo);
332             while ((lid.idlist_len < 20) && (sscanf(foo, "%d", ptr) != EOF)) {
333                 lid.idlist_len++;
334                 skip(&foo);
335                 ptr++;
336             }
337             if (*foo) {
338                 fprintf(stderr, "too many values specified; max is %d\n", 20);
339             }
340             lnames.namelist_val = 0;
341             lnames.namelist_len = 0;
342             code = ubik_PR_IDToName(pruclient, 0, &lid, &lnames);
343             if (CodeOk(code))
344                 printf("%s\n", pr_ErrorMsg(code));
345             if (code == PRSUCCESS) {
346                 for (i = 0; i < lnames.namelist_len; i++) {
347                     printf("id %d name %s\n", lid.idlist_val[i],
348                            lnames.namelist_val[i]);
349                 }
350                 free(lnames.namelist_val);
351             }
352             free(lid.idlist_val);
353             lid.idlist_val = 0;
354             lid.idlist_len = 0;
355         } else if (!strcmp(op, "ntoi")) {
356             lnames.namelist_val =
357                 (prname *) malloc(PR_MAXLIST * PR_MAXNAMELEN);
358             lnames.namelist_len = 0;
359             foo = line;
360             skip(&foo);
361             for (i = 0; ((lnames.namelist_len < PR_MAXLIST)
362                          && (sscanf(foo, "%s", lnames.namelist_val[i]) !=
363                              EOF)); i++) {
364                 lnames.namelist_len++;
365                 skip(&foo);
366             }
367             if (*foo) {
368                 fprintf(stderr, "too many values specified; max is %d\n",
369                         PR_MAXLIST);
370             }
371             lid.idlist_val = 0;
372             lid.idlist_len = 0;
373             code = ubik_PR_NameToID(pruclient, 0, &lnames, &lid);
374             if (CodeOk(code))
375                 printf("%s\n", pr_ErrorMsg(code));
376             if (code == PRSUCCESS) {
377                 for (i = 0; i < lid.idlist_len; i++)
378                     printf("name %s id %d\n", lnames.namelist_val[i],
379                            lid.idlist_val[i]);
380                 free(lid.idlist_val);
381             }
382             free(lnames.namelist_val);
383             lnames.namelist_val = 0;
384             lnames.namelist_len = 0;
385         } else if (!strcmp(op, "del")) {
386             /* scanf("%d",&id); */
387             if (GetInt32(&id))
388                 code = PRBADARG;
389             else
390                 code = ubik_PR_Delete(pruclient, 0, id);
391             if (CodeOk(code))
392                 printf("%s\n", pr_ErrorMsg(code));
393         } else if (!strcmp(op, "dg")) {
394             /* scanf("%d",&id); */
395             if (GetInt32(&id))
396                 code = PRBADARG;
397             else
398                 code = ubik_PR_Delete(pruclient, 0, id);
399             if (CodeOk(code))
400                 printf("%s\n", pr_ErrorMsg(code));
401         } else if (!strcmp(op, "rm")) {
402             /* scanf("%d %d",&id,&gid); */
403             if (GetInt32(&id) || GetInt32(&gid))
404                 code = PRBADARG;
405             else
406                 code = ubik_PR_RemoveFromGroup(pruclient, 0, id, gid);
407             if (CodeOk(code))
408                 printf("%s\n", pr_ErrorMsg(code));
409         }
410 #if defined(SUPERGROUPS)
411         else if (!strcmp(op, "lsg")) {
412             alist.prlist_len = 0;
413             alist.prlist_val = 0;
414             /* scanf("%d",&id); */
415             if (GetInt32(&id))
416                 code = PRBADARG;
417             else
418                 code =
419                     ubik_PR_ListSuperGroups(pruclient, 0, id, &alist,
420                               &over);
421             if (CodeOk(code))
422                 printf("%s\n", pr_ErrorMsg(code));
423             if (code == PRSUCCESS) {
424                 ptr = alist.prlist_val;
425                 if (over) {
426                     printf("Number of groups greater than PR_MAXGROUPS!\n");
427                     printf("Excess of %d.\n", over);
428                 }
429                 for (i = 0; i < alist.prlist_len; i++, ptr++)
430                     printf("%d\n", *ptr);
431                 free(alist.prlist_val);
432                 alist.prlist_len = 0;
433                 alist.prlist_val = 0;
434             }
435         }
436 #endif /* SUPERGROUPS */
437         else if (!strcmp(op, "l")) {
438             alist.prlist_len = 0;
439             alist.prlist_val = 0;
440             /* scanf("%d",&id); */
441             if (GetInt32(&id))
442                 code = PRBADARG;
443             else
444                 code = ubik_PR_GetCPS(pruclient, 0, id, &alist, &over);
445             if (CodeOk(code))
446                 printf("%s\n", pr_ErrorMsg(code));
447             if (code == PRSUCCESS) {
448                 ptr = alist.prlist_val;
449                 if (over) {
450                     printf("Number of groups greater than PR_MAXGROUPS!\n");
451                     printf("Excess of %d.\n", over);
452                 }
453                 for (i = 0; i < alist.prlist_len; i++, ptr++)
454                     printf("%d\n", *ptr);
455                 free(alist.prlist_val);
456                 alist.prlist_len = 0;
457                 alist.prlist_val = 0;
458             }
459         } else if (!strcmp(op, "lh")) {
460             alist.prlist_len = 0;
461             alist.prlist_val = 0;
462             /* scanf("%d",&id); */
463             if (GetString(name, sizeof(name)))
464                 code = PRBADARG;
465             else if (!(hostinfo = gethostbyname(name)))
466                 code = PRBADARG;
467             else {
468                 hostaddr = (struct in_addr *)hostinfo->h_addr_list[0];
469                 id = ntohl(hostaddr->s_addr);
470                 code =
471                     ubik_PR_GetHostCPS(pruclient, 0, id, &alist, &over);
472             }
473             if (CodeOk(code))
474                 printf("%s\n", pr_ErrorMsg(code));
475             if (code == PRSUCCESS) {
476                 ptr = alist.prlist_val;
477                 if (over) {
478                     printf("Number of groups greater than PR_MAXGROUPS!\n");
479                     printf("Excess of %d.\n", over);
480                 }
481                 for (i = 0; i < alist.prlist_len; i++, ptr++)
482                     printf("%d\n", *ptr);
483                 free(alist.prlist_val);
484                 alist.prlist_len = 0;
485                 alist.prlist_val = 0;
486             }
487         }
488 #if defined(SUPERGROUPS)
489         else if (!strcmp(op, "m")) {
490             alist.prlist_len = 0;
491             alist.prlist_val = 0;
492             /* scanf("%d",&id); */
493             if (GetInt32(&id))
494                 code = PRBADARG;
495             else
496                 code =
497                     ubik_PR_ListElements(pruclient, 0, id, &alist,
498                               &over);
499             if (CodeOk(code))
500                 printf("%s\n", pr_ErrorMsg(code));
501             if (code == PRSUCCESS) {
502                 ptr = alist.prlist_val;
503                 if (over) {
504                     printf("Number of groups greater than PR_MAXGROUPS!\n");
505                     printf("Excess of %d.\n", over);
506                 }
507                 for (i = 0; i < alist.prlist_len; i++, ptr++)
508                     printf("%d\n", *ptr);
509                 free(alist.prlist_val);
510                 alist.prlist_len = 0;
511                 alist.prlist_val = 0;
512             }
513         }
514 #endif /* SUPERGROUPS */
515         else if (!strcmp(op, "nu")) {
516             /* scanf("%s",name); */
517             if (GetString(name, sizeof(name)))
518                 code = PRBADARG;
519             else
520                 code = pr_CreateUser(name, &id);
521             if (CodeOk(code))
522                 printf("%s\n", pr_ErrorMsg(code));
523             if (code == PRSUCCESS)
524                 printf("Id is %d.\n", id);
525         } else if (!strcmp(op, "ng")) {
526             /* scanf("%s",name); */
527             if (GetString(name, sizeof(name)))
528                 code = PRBADARG;
529             else
530                 code = ubik_PR_NewEntry(pruclient, 0, name, 1, oid, &id);
531             if (CodeOk(code))
532                 printf("%s\n", pr_ErrorMsg(code));
533             if (code == PRSUCCESS)
534                 printf("Id is %d.\n", id);
535         } else if (!strcmp(op, "lm")) {
536             code = ubik_PR_ListMax(pruclient, 0, &id, &gid);
537             if (CodeOk(code))
538                 printf("%s\n", pr_ErrorMsg(code));
539             if (code == PRSUCCESS)
540                 printf("Max user id is %d, max (really min) group is %d.\n",
541                        id, gid);
542         } else if (!strcmp(op, "smu")) {
543             /* scanf("%d",&id); */
544             if (GetInt32(&id))
545                 code = PRBADARG;
546             else
547                 code = ubik_PR_SetMax(pruclient, 0, id, 0);
548             if (CodeOk(code))
549                 printf("%s\n", pr_ErrorMsg(code));
550         } else if (!strcmp(op, "smg")) {
551             /* scanf("%d",&id); */
552             if (GetInt32(&id))
553                 code = PRBADARG;
554             else
555                 code = ubik_PR_SetMax(pruclient, 0, id, 1);
556             if (CodeOk(code))
557                 printf("%s\n", pr_ErrorMsg(code));
558         } else if (!strcmp(op, "sin")) {
559             /* scanf("%d",&id); */
560             if (GetInt32(&id))
561                 code = PRBADARG;
562             else
563                 code = pr_SIdToName(id, name);
564             if (CodeOk(code))
565                 printf("%s\n", pr_ErrorMsg(code));
566             if (code == PRSUCCESS)
567                 printf("id %d name %s\n", id, name);
568         } else if (!strcmp(op, "sni")) {
569             /* scanf("%s",name); */
570             if (GetString(name, sizeof(name)))
571                 code = PRBADARG;
572             else
573                 code = pr_SNameToId(name, &id);
574             if (CodeOk(code))
575                 printf("%s\n", pr_ErrorMsg(code));
576             if (code == PRSUCCESS)
577                 printf("name %s id %d\n", name, id);
578         } else if (!strcmp(op, "fih")) {
579             char tname[128];
580             struct PrUpdateEntry uentry;
581             memset(&uentry, 0, sizeof(uentry));
582             /* scanf("%s",name); */
583             if (GetString(name, sizeof(name))) {
584                 code = PRBADARG;
585                 continue;
586             }
587             code = pr_SNameToId(name, &id);
588             if (CodeOk(code)) {
589                 printf("%s\n", pr_ErrorMsg(code));
590                 continue;
591             }
592             code = pr_SIdToName(id, tname);
593             if (code == PRSUCCESS) {
594                 printf
595                     ("Warning: Id hash for %s (id %d) seems correct at the db; rehashing it anyway\n",
596                      name, id);
597 /*              continue;*/
598             }
599             uentry.Mask = PRUPDATE_IDHASH;
600             code = ubik_PR_UpdateEntry(pruclient, 0, 0, name, &uentry);
601             if (code) {
602                 printf("Failed to update entry %s (err=%d)\n", name, code);
603                 continue;
604             }
605         } else if (!strcmp(op, "fnh")) {
606             int tid;
607             struct PrUpdateEntry uentry;
608             memset(&uentry, 0, sizeof(uentry));
609             /* scanf("%d", &id); */
610             if (GetInt32(&id)) {
611                 code = PRBADARG;
612                 continue;
613             }
614             code = pr_SIdToName(id, name);
615             if (CodeOk(code)) {
616                 printf("%s\n", pr_ErrorMsg(code));
617                 continue;
618             }
619             code = pr_SNameToId(name, &tid);
620             if (code == PRSUCCESS) {
621                 printf
622                     ("Name hash for %d (name is %s) seems correct at the db; rehashing it anyway\n",
623                      id, name);
624 /*              continue;*/
625             }
626             uentry.Mask = PRUPDATE_NAMEHASH;
627             code =
628                 ubik_PR_UpdateEntry(pruclient, 0, id, "_foo_", &uentry);
629             if (code) {
630                 printf("Failed to update entry with id %d (err=%d)\n", id,
631                        code);
632                 continue;
633             }
634         }
635 #if defined(SUPERGROUPS)
636         else if (!strcmp(op, "fih")) {
637             char tname[128];
638             struct PrUpdateEntry uentry;
639             memset(&uentry, 0, sizeof(uentry));
640             /* scanf("%s",name); */
641             if (GetString(name, sizeof(name))) {
642                 code = PRBADARG;
643                 continue;
644             }
645             code = pr_SNameToId(name, &id);
646             if (CodeOk(code)) {
647                 printf("%s\n", pr_ErrorMsg(code));
648                 continue;
649             }
650             code = pr_SIdToName(id, tname);
651             if (code == PRSUCCESS) {
652                 printf
653                     ("Warning: Id hash for %s (id %d) seems correct at the db; rehashing it anyway\n",
654                      name, id);
655 /*              continue;*/
656             }
657             uentry.Mask = PRUPDATE_IDHASH;
658             code = ubik_PR_UpdateEntry(pruclient, 0, 0, name, &uentry);
659             if (code) {
660                 printf("Failed to update entry %s (err=%d)\n", name, code);
661                 continue;
662             }
663         } else if (!strcmp(op, "fnh")) {
664             int tid;
665             struct PrUpdateEntry uentry;
666             memset(&uentry, 0, sizeof(uentry));
667             /* scanf("%d", &id); */
668             if (GetInt32(&id)) {
669                 code = PRBADARG;
670                 continue;
671             }
672             code = pr_SIdToName(id, name);
673             if (CodeOk(code)) {
674                 printf("%s\n", pr_ErrorMsg(code));
675                 continue;
676             }
677             code = pr_SNameToId(name, &tid);
678             if (code == PRSUCCESS) {
679                 printf
680                     ("Name hash for %d (name is %s) seems correct at the db; rehashing it anyway\n",
681                      id, name);
682 /*              continue;*/
683             }
684             uentry.Mask = PRUPDATE_NAMEHASH;
685             code =
686                 ubik_PR_UpdateEntry(pruclient, 0, id, "_foo_", &uentry);
687             if (code) {
688                 printf("Failed to update entry with id %d (err=%d)\n", id,
689                        code);
690                 continue;
691             }
692         }
693 #endif /* SUPERGROUPS */
694         else if (!strcmp(op, "?"))
695             PrintHelp();
696         else if (!strcmp(op, "q"))
697             exit(0);
698         else
699             printf("Unknown op: '%s'! ? for help\n", op);
700     }
701 }
702
703
704 static void
705 PrintHelp(void)
706 {
707     printf("cr name id owner - create entry with name and id.\n");
708     printf("wh id  - what is the offset into database for id?\n");
709     printf("du offset - dump the contents of the entry at offset.\n");
710     printf("add uid gid - add user uid to group gid.\n");
711     printf("iton id* - translate the list of id's to names.\n");
712     printf("ntoi name* - translate the list of names to ids.\n");
713     printf("del id - delete the entry for id.\n");
714     printf("dg gid - delete the entry for group gid.\n");
715     printf("rm id gid - remove user id from group gid.\n");
716     printf("l id - get the CPS for id.\n");
717     printf("lh host - get the host CPS for host.\n");
718 #if defined(SUPERGROUPS)
719     printf("lsg id - get the supergroups for id.\n");
720     printf("m id - list elements for id.\n");
721 #endif
722     printf("nu name - create new user with name - returns an id.\n");
723     printf("ng name - create new group with name - returns an id.\n");
724     printf("lm  - list max user id and max (really min) group id.\n");
725     printf("smu - set max user id.\n");
726     printf("smg - set max group id.\n");
727     printf("sin id - single iton.\n");
728     printf("sni name - single ntoi.\n");
729     printf("fih name - fix id hash for <name>.\n");
730     printf("fnh id - fix name hash for <id>.\n");
731     printf("q - quit.\n?- this message.\n");
732 }
733
734 static void
735 skip(char **s)
736 {
737     while (**s != ' ' && **s != '\0')
738         (*s)++;
739     while (**s == ' ')
740         (*s)++;
741 }
742 #endif /* !AFS_PTHREAD_ENV */