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