f2b1341e028006b1a8514f90bffa12291d146d41
[openafs.git] / src / ptserver / ptuser.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 #include <afs/opr.h>
16
17 #include <rx/rx.h>
18 #include <rx/xdr.h>
19 #include <afs/auth.h>
20 #include <afs/cellconfig.h>
21 #include <afs/afsutil.h>
22 #include <afs/com_err.h>
23
24 #include "ptclient.h"
25 #include "ptuser.h"
26 #include "pterror.h"
27
28 struct ubik_client *pruclient = 0;
29 static afs_int32 lastLevel;     /* security level pruclient, if any */
30
31 static char *whoami = "libprot";
32
33
34 #define ID_HASH_SIZE 1024
35 #define ID_STACK_SIZE 1024
36
37 /**
38  * Hash table chain of user and group ids.
39  */
40 struct idchain {
41     struct idchain *next;
42     afs_int32 id;
43 };
44
45 /**
46  * Hash table of user and group ids.
47  */
48 struct idhash {
49     afs_uint32 userEntries;         /**< number of user id entries hashed */
50     afs_uint32 groupEntries;        /**< number of group id entries hashed */
51     struct idchain *hash[ID_HASH_SIZE];
52 };
53
54 /**
55  * Allocate a new id hash table.
56  */
57 static afs_int32
58 AllocateIdHash(struct idhash **aidhash)
59 {
60     struct idhash *idhash;
61
62     idhash = calloc(1, sizeof(struct idhash));
63     if (!idhash) {
64        return ENOMEM;
65     }
66     *aidhash = idhash;
67     return 0;
68 }
69
70 /**
71  * Free the id hash.
72  */
73 static void
74 FreeIdHash(struct idhash *idhash)
75 {
76     int index;
77     struct idchain *chain;
78     struct idchain *next;
79
80     for (index = 0; index < ID_HASH_SIZE; index++) {
81        for (chain = idhash->hash[index]; chain; chain = next) {
82            next = chain->next;
83            free(chain);
84        }
85     }
86     free(idhash);
87 }
88
89 /**
90  * Indicate if group/user id is already hashed, and
91  * if not insert it.
92  *
93  * @returns whether id is present
94  *   @retval >0 id is already present in the hash
95  *   @retval 0  id was not found and was inserted into the hash
96  *   @retval <0 error encountered
97  */
98 static afs_int32
99 FindId(struct idhash *idhash, afs_int32 id)
100 {
101     afs_int32 index;
102     struct idchain *chain;
103     struct idchain *newChain;
104
105     index = abs(id) % ID_HASH_SIZE;
106     for (chain = idhash->hash[index]; chain; chain = chain->next) {
107         if (chain->id == id) {
108             return 1;
109         }
110     }
111
112     /* Insert this id but return not found. */
113     newChain = malloc(sizeof(struct idchain));
114     if (!newChain) {
115         return ENOMEM;
116     } else {
117         newChain->id = id;
118         newChain->next = idhash->hash[index];
119         idhash->hash[index] = newChain;
120         if (id < 0) {
121             idhash->groupEntries++;
122         } else {
123             idhash->userEntries++;
124         }
125     }
126     return 0;
127 }
128
129 /**
130  * Create an idlist from the ids in the hash.
131  */
132 static afs_int32
133 CreateIdList(struct idhash *idhash, idlist * alist, afs_int32 select)
134 {
135     struct idchain *chain;
136     afs_int32 entries = 0;
137     int index;
138     int i;
139
140     if (select & PRGROUPS) {
141         entries += idhash->groupEntries;
142     }
143     if (select & PRUSERS) {
144         entries += idhash->userEntries;
145     }
146     if (entries == 0) {
147         alist->idlist_len = 0;
148         alist->idlist_val = NULL;
149         return 0;
150     }
151
152     alist->idlist_len = entries;
153     alist->idlist_val = malloc(sizeof(afs_int32) * entries);
154     if (!alist->idlist_val) {
155         return ENOMEM;
156     }
157
158     for (i = 0, index = 0; index < ID_HASH_SIZE; index++) {
159         for (chain = idhash->hash[index]; chain; chain = chain->next) {
160             if (chain->id < 0) {
161                 if (select & PRGROUPS) {
162                     alist->idlist_val[i++] = chain->id;
163                 }
164             } else {
165                 if (select & PRUSERS) {
166                     alist->idlist_val[i++] = chain->id;
167                 }
168             }
169         }
170     }
171     return 0;
172 }
173
174 afs_int32
175 pr_Initialize(IN afs_int32 secLevel, IN const char *confDir, IN char *cell)
176 {
177     afs_int32 code;
178     struct rx_connection *serverconns[MAXSERVERS];
179     struct rx_securityClass *sc = NULL;
180     static struct afsconf_dir *tdir = NULL;     /* only do this once */
181     static char tconfDir[100] = "";
182     static char tcell[64] = "";
183     afs_int32 scIndex;
184     afs_int32 secFlags;
185     static struct afsconf_cell info;
186     afs_int32 i;
187     char cellstr[64];
188     afs_int32 gottdir = 0;
189     afs_int32 refresh = 0;
190
191     initialize_PT_error_table();
192     initialize_RXK_error_table();
193     initialize_ACFG_error_table();
194     initialize_KTC_error_table();
195
196     if (!cell) {
197         if (!tdir)
198             tdir = afsconf_Open(confDir);
199         if (!tdir) {
200             if (confDir && strcmp(confDir, ""))
201                 fprintf(stderr,
202                         "%s: Could not open configuration directory: %s.\n",
203                         whoami, confDir);
204             else
205                 fprintf(stderr,
206                         "%s: No configuration directory specified.\n",
207                         whoami);
208             return -1;
209         }
210         gottdir = 1;
211
212         code = afsconf_GetLocalCell(tdir, cellstr, sizeof(cellstr));
213         if (code) {
214             fprintf(stderr,
215                      "libprot: Could not get local cell. [%d]\n", code);
216             return code;
217         }
218         cell = cellstr;
219     }
220
221     if (tdir == NULL || strcmp(confDir, tconfDir) || strcmp(cell, tcell)) {
222         /*
223          * force re-evaluation.  we either don't have an afsconf_dir,
224          * the directory has changed or the cell has changed.
225          */
226         if (tdir && !gottdir) {
227             afsconf_Close(tdir);
228             tdir = NULL;
229         }
230         pruclient = NULL;
231         refresh = 1;
232     }
233
234     if (refresh) {
235         strncpy(tconfDir, confDir, sizeof(tconfDir));
236         strncpy(tcell, cell, sizeof(tcell));
237
238         if (!gottdir)
239             tdir = afsconf_Open(confDir);
240         if (!tdir) {
241             if (confDir && strcmp(confDir, ""))
242                 fprintf(stderr,
243                         "libprot: Could not open configuration directory: %s.\n",
244                         confDir);
245             else
246                 fprintf(stderr,
247                         "libprot: No configuration directory specified.\n");
248             return -1;
249         }
250
251         code = afsconf_GetCellInfo(tdir, cell, "afsprot", &info);
252         if (code) {
253             fprintf(stderr, "libprot: Could not locate cell %s in %s\n",
254                     cell, tdir->cellservDB);
255             return code;
256         }
257     }
258
259     /* If we already have a client and it is at the security level we
260      * want, don't get a new one. Unless the security level is 2 in
261      * which case we will get one (and re-read the key file).
262      */
263     if (pruclient && (lastLevel == secLevel) && (secLevel != 2)) {
264         return 0;
265     }
266
267     code = rx_Init(0);
268     if (code) {
269         fprintf(stderr, "libprot:  Could not initialize rx.\n");
270         return code;
271     }
272
273     /* Most callers use secLevel==1, however, the fileserver uses secLevel==2
274      * to force use of the KeyFile.  secLevel == 0 implies -noauth was
275      * specified. */
276     if (secLevel == 2) {
277         /* If secLevel is two assume we're on a file server and use
278          * ClientAuthSecure if possible. */
279         code = afsconf_ClientAuthSecure(tdir, &sc, &scIndex);
280         if (code)
281             afs_com_err(whoami, code, "(calling client secure)\n");
282     } else if (secLevel > 0) {
283         secFlags = 0;
284         if (secLevel > 1)
285             secFlags |= AFSCONF_SECOPTS_ALWAYSENCRYPT;
286
287         code = afsconf_ClientAuthToken(&info, secFlags, &sc, &scIndex, NULL);
288         if (code) {
289             afs_com_err(whoami, code, "(getting token)");
290             if (secLevel > 1)
291                 return code;
292         }
293     }
294
295     if (sc == NULL) {
296         sc = rxnull_NewClientSecurityObject();
297         scIndex = RX_SECIDX_NULL;
298     }
299
300     if ((scIndex == RX_SECIDX_NULL) && (secLevel != 0))
301         fprintf(stderr,
302                 "%s: Could not get afs tokens, running unauthenticated\n",
303                 whoami);
304
305     memset(serverconns, 0, sizeof(serverconns));        /* terminate list!!! */
306     for (i = 0; i < info.numServers; i++)
307         serverconns[i] =
308             rx_NewConnection(info.hostAddr[i].sin_addr.s_addr,
309                              info.hostAddr[i].sin_port, PRSRV, sc,
310                              scIndex);
311
312     code = ubik_ClientInit(serverconns, &pruclient);
313     if (code) {
314         afs_com_err(whoami, code, "ubik client init failed.");
315         return code;
316     }
317     lastLevel = scIndex;
318
319     code = rxs_Release(sc);
320     return code;
321 }
322
323 int
324 pr_End(void)
325 {
326     int code = 0;
327
328     if (pruclient) {
329         code = ubik_ClientDestroy(pruclient);
330         pruclient = 0;
331     }
332     return code;
333 }
334
335 /*
336  * Make sure that arg is a proper C string that fits in a prname.
337  * If strnlen(arg, PR_MAXNAMELEN) == PR_MAXNAMELEN, then arg either
338  * doesn't have a terminating NUL or is too long, and we can't tell
339  * which one in the current API.  This code has always assumed that
340  * the names presented to it are valid C strings, but for robustness
341  * we can't depend on the server side guaranteeing that.  Unfortunately,
342  * the wire protocol uses a vector[PR_MAXNAMELEN] of char, so XDR will
343  * not automatically fix up strings generated by the server.
344  *
345  * The inequality is just belt-and-suspenders and should be impossible.
346  */
347 static_inline int check_length(prname arg)
348 {
349     if (strnlen(arg, PR_MAXNAMELEN) >= PR_MAXNAMELEN)
350         return PRNAMETOOLONG;
351     return 0;
352 }
353
354 int
355 pr_CreateUser(prname name, afs_int32 *id)
356 {
357     afs_int32 code;
358
359     code = check_length(name);
360     if (code)
361         return code;
362     stolower(name);
363     if (*id) {
364         code = ubik_PR_INewEntry(pruclient, 0, name, *id, 0);
365     } else {
366         code = ubik_PR_NewEntry(pruclient, 0, name, 0, 0, id);
367     }
368     return code;
369 }
370
371 int
372 pr_CreateGroup(prname name, prname owner, afs_int32 *id)
373 {
374     afs_int32 code;
375     afs_int32 oid = 0;
376     afs_int32 flags = 0;
377
378     code = check_length(name);
379     if (code)
380         return code;
381     /* pr_SNameToId will check owner's length. */
382     stolower(name);
383     if (owner) {
384         code = pr_SNameToId(owner, &oid);
385         if (code)
386             return code;
387         if (oid == ANONYMOUSID)
388             return PRNOENT;
389     }
390     flags |= PRGRP;
391     if (*id) {
392         code = ubik_PR_INewEntry(pruclient, 0, name, *id, oid);
393     } else {
394         code = ubik_PR_NewEntry(pruclient, 0, name, flags, oid, id);
395     }
396     return code;
397 }
398
399 int
400 pr_Delete(prname name)
401 {
402     afs_int32 code;
403     afs_int32 id;
404
405     /* pr_SNameToId both checks the length of name and lowercases it. */
406     code = pr_SNameToId(name, &id);
407     if (code)
408         return code;
409     if (id == ANONYMOUSID)
410         return PRNOENT;
411     code = ubik_PR_Delete(pruclient, 0, id);
412     return code;
413 }
414
415 int
416 pr_DeleteByID(afs_int32 id)
417 {
418     afs_int32 code;
419
420     code = ubik_PR_Delete(pruclient, 0, id);
421     return code;
422 }
423
424 int
425 pr_AddToGroup(prname user, prname group)
426 {
427     afs_int32 code;
428     namelist lnames;
429     idlist lids;
430
431     code = check_length(user);
432     if (code)
433         return code;
434     code = check_length(group);
435     if (code)
436         return code;
437     lnames.namelist_len = 2;
438     lnames.namelist_val = malloc(2 * PR_MAXNAMELEN);
439     strncpy(lnames.namelist_val[0], user, PR_MAXNAMELEN);
440     strncpy(lnames.namelist_val[1], group, PR_MAXNAMELEN);
441     lids.idlist_val = 0;
442     lids.idlist_len = 0;
443     code = pr_NameToId(&lnames, &lids);
444     if (code)
445         goto done;
446     /* if here, still could be missing an entry */
447     if (lids.idlist_len != 2) {
448         code = PRINTERNAL;
449         goto done;
450     }
451     if (lids.idlist_val[0] == ANONYMOUSID
452         || lids.idlist_val[1] == ANONYMOUSID) {
453         code = PRNOENT;
454         goto done;
455     }
456     code =
457         ubik_PR_AddToGroup(pruclient, 0, lids.idlist_val[0],
458                   lids.idlist_val[1]);
459   done:
460     if (lnames.namelist_val)
461         free(lnames.namelist_val);
462
463     xdr_free((xdrproc_t) xdr_idlist, &lids);
464     return code;
465 }
466
467 int
468 pr_RemoveUserFromGroup(prname user, prname group)
469 {
470     afs_int32 code;
471     namelist lnames;
472     idlist lids;
473
474     code = check_length(user);
475     if (code)
476         return code;
477     code = check_length(group);
478     if (code)
479         return code;
480     lnames.namelist_len = 2;
481     lnames.namelist_val = malloc(2 * PR_MAXNAMELEN);
482     strncpy(lnames.namelist_val[0], user, PR_MAXNAMELEN);
483     strncpy(lnames.namelist_val[1], group, PR_MAXNAMELEN);
484     lids.idlist_val = 0;
485     lids.idlist_len = 0;
486     code = pr_NameToId(&lnames, &lids);
487     if (code)
488         goto done;
489
490     if (lids.idlist_len != 2) {
491         code = PRINTERNAL;
492         goto done;
493     }
494     if (lids.idlist_val[0] == ANONYMOUSID
495         || lids.idlist_val[1] == ANONYMOUSID) {
496         code = PRNOENT;
497         goto done;
498     }
499     code =
500         ubik_PR_RemoveFromGroup(pruclient, 0, lids.idlist_val[0],
501                   lids.idlist_val[1]);
502   done:
503     if (lnames.namelist_val)
504         free(lnames.namelist_val);
505
506     xdr_free((xdrproc_t) xdr_idlist, &lids);
507
508     return code;
509 }
510
511 int
512 pr_NameToId(namelist *names, idlist *ids)
513 {
514     afs_int32 code;
515     afs_int32 i;
516
517     for (i = 0; i < names->namelist_len; i++) {
518         code = check_length(names->namelist_val[i]);
519         if (code)
520             return code;
521         stolower(names->namelist_val[i]);
522     }
523     code = ubik_PR_NameToID(pruclient, 0, names, ids);
524     return code;
525 }
526
527 int
528 pr_SNameToId(prname name, afs_int32 *id)
529 {
530     namelist lnames;
531     idlist lids;
532     afs_int32 code;
533
534     code = check_length(name);
535     if (code)
536         return code;
537     lids.idlist_len = 0;
538     lids.idlist_val = 0;
539     lnames.namelist_len = 1;
540     lnames.namelist_val = malloc(PR_MAXNAMELEN);
541     stolower(name);
542     strncpy(lnames.namelist_val[0], name, PR_MAXNAMELEN);
543     code = ubik_PR_NameToID(pruclient, 0, &lnames, &lids);
544     if (lids.idlist_val) {
545         *id = *lids.idlist_val;
546         xdr_free((xdrproc_t) xdr_idlist, &lids);
547     } else if (code == 0) {
548         code = PRINTERNAL;
549     }
550     if (lnames.namelist_val)
551         free(lnames.namelist_val);
552     return code;
553 }
554
555 /*
556  * Like ubik_PR_IDToName, but enforces that the output prnames are
557  * interpretable as C strings (i.e., NUL-terminated).
558  */
559 int
560 string_PR_IDToName(struct ubik_client *client, afs_int32 flags,
561                    idlist *ids, namelist *names)
562 {
563     afs_int32 code;
564     int i;
565
566     code = ubik_PR_IDToName(client, flags, ids, names);
567     if (code)
568         return code;
569     for (i = 0; i < names->namelist_len; i++) {
570         code = check_length(names->namelist_val[i]);
571         if (code)
572             return code;
573     }
574     return code;
575 }
576
577
578 int
579 pr_IdToName(idlist *ids, namelist *names)
580 {
581     return string_PR_IDToName(pruclient, 0, ids, names);
582 }
583
584 int
585 pr_SIdToName(afs_int32 id, prname name)
586 {
587     namelist lnames;
588     idlist lids;
589     afs_int32 code;
590
591     lids.idlist_len = 1;
592     lids.idlist_val = malloc(sizeof(afs_int32));
593     *lids.idlist_val = id;
594     lnames.namelist_len = 0;
595     lnames.namelist_val = 0;
596     code = pr_IdToName(&lids, &lnames);
597     if (lnames.namelist_val)
598         strncpy(name, lnames.namelist_val[0], PR_MAXNAMELEN);
599     else if (code == 0)
600         code = PRINTERNAL;
601
602     if (lids.idlist_val)
603         free(lids.idlist_val);
604
605     xdr_free((xdrproc_t) xdr_namelist, &lnames);
606
607     return code;
608 }
609
610 int
611 pr_GetCPS(afs_int32 id, prlist *CPS)
612 {
613     afs_int32 code;
614     afs_int32 over;
615
616     over = 0;
617     code = ubik_PR_GetCPS(pruclient, 0, id, CPS, &over);
618     if (code != PRSUCCESS)
619         return code;
620     if (over) {
621         /* do something about this, probably make a new call */
622         /* don't forget there's a hard limit in the interface */
623         fprintf(stderr, "membership list for id %d exceeds display limit\n",
624                 id);
625     }
626     return 0;
627 }
628
629 int
630 pr_GetCPS2(afs_int32 id, afs_uint32 host, prlist *CPS)
631 {
632     afs_int32 code;
633     afs_int32 over;
634
635     over = 0;
636     code = ubik_PR_GetCPS2(pruclient, 0, id, host, CPS, &over);
637     if (code != PRSUCCESS)
638         return code;
639     if (over) {
640         /* do something about this, probably make a new call */
641         /* don't forget there's a hard limit in the interface */
642         fprintf(stderr, "membership list for id %d exceeds display limit\n",
643                 id);
644     }
645     return 0;
646 }
647
648 int
649 pr_GetHostCPS(afs_uint32 host, prlist *CPS)
650 {
651     afs_int32 code;
652     afs_int32 over;
653
654     over = 0;
655     code = ubik_PR_GetHostCPS(pruclient, 0, host, CPS, &over);
656     if (code != PRSUCCESS)
657         return code;
658     if (over) {
659         /* do something about this, probably make a new call */
660         /* don't forget there's a hard limit in the interface */
661         fprintf(stderr,
662                 "membership list for host id %d exceeds display limit\n",
663                 host);
664     }
665     return 0;
666 }
667
668 int
669 pr_ListMembers(prname group, namelist *lnames)
670 {
671     afs_int32 code;
672     afs_int32 gid;
673     int i;
674
675     memset(lnames, 0, sizeof(namelist));
676
677     /* pr_SNameToId checks the length of group. */
678     code = pr_SNameToId(group, &gid);
679     if (code)
680         return code;
681     if (gid == ANONYMOUSID)
682         return PRNOENT;
683     code = pr_IDListMembers(gid, lnames);
684     if (code)
685         return code;
686     for (i = 0; i < lnames->namelist_len; i++) {
687         code = check_length(lnames->namelist_val[i]);
688         if (code)
689             return code;
690     }
691     return code;
692 }
693
694 int
695 pr_ListOwned(afs_int32 oid, namelist *lnames, afs_int32 *moreP)
696 {
697     afs_int32 code;
698     prlist alist;
699     idlist *lids;
700
701     alist.prlist_len = 0;
702     alist.prlist_val = 0;
703     code = ubik_PR_ListOwned(pruclient, 0, oid, &alist, moreP);
704     if (code)
705         return code;
706     if (*moreP == 1) {
707         /* Remain backwards compatible when moreP was a T/F bit */
708         fprintf(stderr, "membership list for id %d exceeds display limit\n",
709                 oid);
710         *moreP = 0;
711     }
712     lids = (idlist *) &alist;
713     code = pr_IdToName(lids, lnames);
714
715     xdr_free((xdrproc_t) xdr_prlist, &alist);
716
717     if (code)
718         return code;
719
720     return PRSUCCESS;
721 }
722
723 int
724 pr_IDListMembers(afs_int32 gid, namelist *lnames)
725 {
726     afs_int32 code;
727     prlist alist;
728     idlist *lids;
729     afs_int32 over;
730
731     alist.prlist_len = 0;
732     alist.prlist_val = 0;
733     code = ubik_PR_ListElements(pruclient, 0, gid, &alist, &over);
734     if (code)
735         return code;
736     if (over) {
737         fprintf(stderr, "membership list for id %d exceeds display limit\n",
738                 gid);
739     }
740     lids = (idlist *) &alist;
741     code = pr_IdToName(lids, lnames);
742
743     xdr_free((xdrproc_t) xdr_prlist, &alist);
744
745     if (code)
746         return code;
747     return PRSUCCESS;
748 }
749
750 int
751 pr_IDListExpandedMembers(afs_int32 aid, namelist * lnames)
752 {
753     afs_int32 code;
754     afs_int32 gid;
755     idlist lids;
756     prlist alist;
757     afs_int32 over;
758     struct idhash *members = NULL;
759     afs_int32 *stack = NULL;
760     afs_int32 maxstack = ID_STACK_SIZE;
761     int n = 0;                  /* number of ids stacked */
762     int i;
763     int firstpass = 1;
764
765     code = AllocateIdHash(&members);
766     if (code) {
767         return code;
768     }
769     stack = malloc(sizeof(afs_int32) * maxstack);
770     if (!stack) {
771         code = ENOMEM;
772         goto done;
773     }
774
775     stack[n++] = aid;
776     while (n) {
777         gid = stack[--n];       /* pop next group id */
778         alist.prlist_len = 0;
779         alist.prlist_val = NULL;
780         if (firstpass || aid < 0) {
781             firstpass = 0;
782             code = ubik_PR_ListElements(pruclient, 0, gid, &alist, &over);
783         } else {
784             code = ubik_PR_ListSuperGroups(pruclient, 0, gid, &alist, &over);
785             if (code == RXGEN_OPCODE) {
786                 alist.prlist_len = 0;
787                 alist.prlist_val = NULL;
788                 code = 0; /* server does not support supergroups. */
789             }
790         }
791         if (code)
792             goto done;
793         if (over) {
794             fprintf(stderr,
795                     "membership list for id %d exceeds display limit\n", gid);
796         }
797         for (i = 0; i < alist.prlist_len; i++) {
798             afs_int32 found;
799             afs_int32 id;
800
801             id = alist.prlist_val[i];
802             found = FindId(members, id);
803             if (found < 0) {
804                 code = found;
805                 xdr_free((xdrproc_t) xdr_prlist, &alist);
806                 goto done;
807             }
808             if (found == 0 && id < 0) {
809                 if (n == maxstack) {    /* need more stack space */
810                     afs_int32 *tmp;
811                     maxstack += n;
812                     tmp = realloc(stack, maxstack * sizeof(afs_int32));
813                     if (!tmp) {
814                         code = ENOMEM;
815                         xdr_free((xdrproc_t) xdr_prlist, &alist);
816                         goto done;
817                     }
818                     stack = tmp;
819                 }
820                 stack[n++] = id;        /* push group id */
821             }
822         }
823         xdr_free((xdrproc_t) xdr_prlist, &alist);
824     }
825
826     code = CreateIdList(members, &lids, (aid < 0 ? PRUSERS : PRGROUPS));
827     if (code) {
828         goto done;
829     } else if (lids.idlist_len == 0) {
830         /* Avoid the RPC when there's nothing to look up. */
831         lnames->namelist_len = 0;
832         lnames->namelist_val = NULL;
833         goto done;
834     }
835     code = pr_IdToName(&lids, lnames);
836     free(lids.idlist_val);
837
838   done:
839     if (stack)
840         free(stack);
841     if (members)
842         FreeIdHash(members);
843     return code;
844 }
845
846 int
847 pr_ListEntry(afs_int32 id, struct prcheckentry *aentry)
848 {
849     afs_int32 code;
850
851     code = ubik_PR_ListEntry(pruclient, 0, id, aentry);
852     if (code)
853         return code;
854     return check_length(aentry->name);
855 }
856
857 afs_int32
858 pr_ListEntries(int flag, afs_int32 startindex, afs_int32 *nentries, struct prlistentries **entries, afs_int32 *nextstartindex)
859 {
860     afs_int32 code;
861     int i;
862     prentries bulkentries;
863
864     *nentries = 0;
865     *entries = NULL;
866     *nextstartindex = -1;
867     bulkentries.prentries_val = 0;
868     bulkentries.prentries_len = 0;
869
870     code =
871         ubik_PR_ListEntries(pruclient, 0, flag, startindex,
872                   &bulkentries, nextstartindex);
873     if (code)
874         return code;
875     for (i = 0; i < bulkentries.prentries_len; i++) {
876         /* XXX should we try to return all the other entries? */
877         code = check_length(bulkentries.prentries_val[i].name);
878         if (code)
879             goto out;
880     }
881
882 out:
883     if (code != 0) {
884         xdr_free((xdrproc_t)xdr_prentries, &bulkentries);
885     } else {
886         *nentries = bulkentries.prentries_len;
887         *entries = bulkentries.prentries_val;
888     }
889     return code;
890 }
891
892 int
893 pr_CheckEntryByName(prname name, afs_int32 *id, prname owner, prname creator)
894 {
895     /* struct prcheckentry returns other things, which aren't useful to show at this time. */
896     afs_int32 code;
897     struct prcheckentry aentry;
898
899     /* pr_SNameToId will check name's length. */
900     code = pr_SNameToId(name, id);
901     if (code)
902         return code;
903     if (*id == ANONYMOUSID)
904         return PRNOENT;
905     code = ubik_PR_ListEntry(pruclient, 0, *id, &aentry);
906     if (code)
907         return code;
908     /* this should be done in one RPC, but I'm lazy. */
909     code = pr_SIdToName(aentry.owner, owner);
910     if (code)
911         return code;
912     code = pr_SIdToName(aentry.creator, creator);
913     if (code)
914         return code;
915     return PRSUCCESS;
916 }
917
918 int
919 pr_CheckEntryById(prname name, afs_int32 id, prname owner, prname creator)
920 {
921     /* struct prcheckentry returns other things, which aren't useful to show at this time. */
922     afs_int32 code;
923     struct prcheckentry aentry;
924
925     /* XXX ListEntry RPC gives us the name back so should avoid extra RPC */
926     code = pr_SIdToName(id, name);
927     if (code)
928         return code;
929     if (id == ANONYMOUSID)
930         return PRNOENT;
931     code = ubik_PR_ListEntry(pruclient, 0, id, &aentry);
932     if (code)
933         return code;
934     /* this should be done in one RPC, but I'm lazy. */
935     code = pr_SIdToName(aentry.owner, owner);
936     if (code)
937         return code;
938     code = pr_SIdToName(aentry.creator, creator);
939     if (code)
940         return code;
941     return PRSUCCESS;
942 }
943
944 int
945 pr_ChangeEntry(prname oldname, prname newname, afs_int32 *newid, prname newowner)
946 {
947     afs_int32 code;
948     afs_int32 id;
949     afs_int32 oid = 0;
950
951     /* pr_SNameToId takes care of length checks for us. */
952     code = pr_SNameToId(oldname, &id);
953     if (code)
954         return code;
955     if (id == ANONYMOUSID)
956         return PRNOENT;
957     if (newowner && *newowner) {
958         code = pr_SNameToId(newowner, &oid);
959         if (code)
960             return code;
961         if (oid == ANONYMOUSID)
962             return PRNOENT;
963     }
964     if (newid)
965         code = ubik_PR_ChangeEntry(pruclient, 0, id, newname, oid, *newid);
966     else
967         code = ubik_PR_ChangeEntry(pruclient, 0, id, newname, oid, 0);
968     return code;
969 }
970
971 int
972 pr_IsAMemberOf(prname uname, prname gname, afs_int32 *flag)
973 {
974     afs_int32 code;
975     namelist lnames;
976     idlist lids;
977
978     code = check_length(uname);
979     if (code)
980         return code;
981     code = check_length(gname);
982     if (code)
983         return code;
984     stolower(uname);
985     stolower(gname);
986     lnames.namelist_len = 2;
987     lnames.namelist_val = malloc(2 * PR_MAXNAMELEN);
988     strncpy(lnames.namelist_val[0], uname, PR_MAXNAMELEN);
989     strncpy(lnames.namelist_val[1], gname, PR_MAXNAMELEN);
990     lids.idlist_val = 0;
991     lids.idlist_len = 0;
992     code = pr_NameToId(&lnames, &lids);
993     if (code) {
994         if (lnames.namelist_val)
995             free(lnames.namelist_val);
996         xdr_free((xdrproc_t) xdr_idlist, &lids);
997         return code;
998     }
999     if (lids.idlist_len != 2) {
1000         free(lnames.namelist_val);
1001         xdr_free((xdrproc_t) xdr_idlist, &lids);
1002         return PRINTERNAL;
1003     }
1004     code =
1005         ubik_PR_IsAMemberOf(pruclient, 0, lids.idlist_val[0],
1006                   lids.idlist_val[1], flag);
1007     if (lnames.namelist_val)
1008         free(lnames.namelist_val);
1009     xdr_free((xdrproc_t) xdr_idlist, &lids);
1010     return code;
1011 }
1012
1013 int
1014 pr_ListMaxUserId(afs_int32 *mid)
1015 {
1016     afs_int32 code;
1017     afs_int32 gid;
1018     code = ubik_PR_ListMax(pruclient, 0, mid, &gid);
1019     return code;
1020 }
1021
1022 int
1023 pr_SetMaxUserId(afs_int32 mid)
1024 {
1025     afs_int32 code;
1026     afs_int32 flag = 0;
1027     code = ubik_PR_SetMax(pruclient, 0, mid, flag);
1028     return code;
1029 }
1030
1031 int
1032 pr_ListMaxGroupId(afs_int32 *mid)
1033 {
1034     afs_int32 code;
1035     afs_int32 id;
1036     code = ubik_PR_ListMax(pruclient, 0, &id, mid);
1037     return code;
1038 }
1039
1040 int
1041 pr_SetMaxGroupId(afs_int32 mid)
1042 {
1043     afs_int32 code;
1044     afs_int32 flag = 0;
1045
1046     flag |= PRGRP;
1047     code = ubik_PR_SetMax(pruclient, 0, mid, flag);
1048     return code;
1049 }
1050
1051 afs_int32
1052 pr_SetFieldsEntry(afs_int32 id, afs_int32 mask, afs_int32 flags, afs_int32 ngroups, afs_int32 nusers)
1053 {
1054     afs_int32 code;
1055
1056     code =
1057         ubik_PR_SetFieldsEntry(pruclient, 0, id, mask, flags, ngroups,
1058                   nusers, 0, 0);
1059     return code;
1060 }
1061
1062 int
1063 pr_ListSuperGroups(afs_int32 gid, namelist * lnames)
1064 {
1065     afs_int32 code;
1066     prlist alist;
1067     idlist *lids;
1068     afs_int32 over;
1069
1070     alist.prlist_len = 0;
1071     alist.prlist_val = 0;
1072     code = ubik_PR_ListSuperGroups(pruclient, 0, gid, &alist, &over);
1073     if (code)
1074         return code;
1075     if (over) {
1076         fprintf(stderr, "supergroup list for id %d exceeds display limit\n",
1077                 gid);
1078     }
1079     lids = (idlist *) & alist;
1080     code = pr_IdToName(lids, lnames);
1081
1082     xdr_free((xdrproc_t) xdr_prlist, &alist);
1083     return code;
1084 }