volser: Avoid calling osi_audit before audit init
[openafs.git] / src / ptserver / ptprocs.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 /*
11  *                      (3) function addToGroup
12  *
13  *                          1. Eliminate the code that tests for adding groups
14  *                             to groups. This is an error in normal AFS.
15  *                          2. If adding a group to a group call AddToSGEntry
16  *                             to add the id of the group it's a member of.
17  *
18  *                      (4) function Delete
19  *
20  *                          1. Print a messsage if an error is returned from
21  *                             FindByID() and PTDEBUG is defined.
22  *                          2. If removing a group from a group call
23  *                             RemoveFromSGEntry to remove the id of the
24  *                             group it's a member of.
25  *                          3. Remove supergroup continuation records.
26  *
27  *                      (5) function RemoveFromGroup
28  *
29  *                          1. Eliminate the code that tests for adding groups
30  *                             to groups. This is an error in normal AFS.
31  *                          2. If removing a group from a group call
32  *                             RemoveFromSGEntry to remove the id of the
33  *                             group it's a member of.
34  *
35  *                      (6) Add new functions PR_ListSuperGroups and
36  *                          listSuperGroups.
37  *
38  *                      (7) function isAMemberOf
39  *
40  *                          1. Allow groups to be members of groups.
41  *
42  *                      Transarc does not currently use opcodes past 520, but
43  *                      they *could* decide at any time to use more opcodes.
44  *                      If they did, then one part of our local mods,
45  *                      ListSupergroups, would break.  I've therefore
46  *                      renumbered it to 530, and put logic in to enable the
47  *                      old opcode to work (for now).
48  */
49
50 #include <afsconfig.h>
51 #include <afs/param.h>
52 #include <afs/stds.h>
53
54 #include <roken.h>
55 #include <afs/opr.h>
56
57 #include <ctype.h>
58
59 #include <lock.h>
60 #include <afs/afsutil.h>
61 #include <ubik.h>
62 #include <rx/xdr.h>
63 #include <rx/rx.h>
64 #include <rx/rxkad.h>
65 #include <rx/rx_identity.h>
66 #include <afs/auth.h>
67 #include <afs/cellconfig.h>
68
69 #include "ptserver.h"
70 #include "pterror.h"
71 #include "ptprototypes.h"
72 #include "afs/audit.h"
73
74 extern int restricted;
75 extern int restrict_anonymous;
76 extern struct ubik_dbase *dbase;
77 extern int pr_noAuth;
78 extern int prp_group_default;
79 extern int prp_user_default;
80 extern struct afsconf_dir *prdir;
81
82 static afs_int32 iNewEntry(struct rx_call *call, char aname[], afs_int32 aid,
83                            afs_int32 oid, afs_int32 *cid);
84 static afs_int32 newEntry(struct rx_call *call, char aname[], afs_int32 flag,
85                           afs_int32 oid, afs_int32 *aid, afs_int32 *cid);
86 static afs_int32 whereIsIt(struct rx_call *call, afs_int32 aid, afs_int32 *apos,
87                            afs_int32 *cid);
88 static afs_int32 dumpEntry(struct rx_call *call, afs_int32 apos,
89                            struct prdebugentry *aentry, afs_int32 *cid);
90 static afs_int32 addToGroup(struct rx_call *call, afs_int32 aid, afs_int32 gid,
91                             afs_int32 *cid);
92 static afs_int32 nameToID(struct rx_call *call, namelist *aname, idlist *aid);
93 static afs_int32 idToName(struct rx_call *call, idlist *aid, namelist *aname, afs_int32 *cid);
94 static afs_int32 Delete(struct rx_call *call, afs_int32 aid, afs_int32 *cid);
95 static afs_int32 UpdateEntry(struct rx_call *call, afs_int32 aid, char *name,
96                              struct PrUpdateEntry *uentry, afs_int32 *cid);
97 static afs_int32 removeFromGroup(struct rx_call *call, afs_int32 aid,
98                                  afs_int32 gid, afs_int32 *cid);
99 static afs_int32 getCPS(struct rx_call *call, afs_int32 aid, prlist *alist,
100                         afs_int32 *over, afs_int32 *cid);
101 static afs_int32 getCPS2(struct rx_call *call, afs_int32 aid, afs_uint32 ahost,
102                          prlist *alist, afs_int32 *over, afs_int32 *cid);
103 static afs_int32 getHostCPS(struct rx_call *call, afs_uint32 ahost,
104                             prlist *alist, afs_int32 *over, afs_int32 *cid);
105 static afs_int32 listMax(struct rx_call *call, afs_int32 *uid, afs_int32 *gid, afs_int32 *cid);
106 static afs_int32 setMax(struct rx_call *call, afs_int32 aid, afs_int32 gflag,
107                         afs_int32 *cid);
108 static afs_int32 listEntry(struct rx_call *call, afs_int32 aid,
109                            struct prcheckentry *aentry, afs_int32 *cid);
110 static afs_int32 listEntries(struct rx_call *call, afs_int32 flag,
111                              afs_int32 startindex, prentries *bulkentries,
112                              afs_int32 *nextstartindex, afs_int32 *cid);
113 static afs_int32 put_prentries(struct prentry *tentry, prentries *bulkentries);
114 static afs_int32 changeEntry(struct rx_call *call, afs_int32 aid, char *name,
115                              afs_int32 oid, afs_int32 newid, afs_int32 *cid);
116 static afs_int32 setFieldsEntry(struct rx_call *call, afs_int32 id,
117                                 afs_int32 mask, afs_int32 flags,
118                                 afs_int32 ngroups, afs_int32 nusers,
119                                 afs_int32 spare1, afs_int32 spare2,
120                                 afs_int32 *cid);
121 static afs_int32 listElements(struct rx_call *call, afs_int32 aid,
122                               prlist *alist, afs_int32 *over, afs_int32 *cid);
123 #if defined(SUPERGROUPS)
124 static afs_int32 listSuperGroups(struct rx_call *call, afs_int32 aid,
125                                  prlist *alist, afs_int32 *over,
126                                  afs_int32 *cid);
127 #endif
128 static afs_int32 listOwned(struct rx_call *call, afs_int32 aid, prlist *alist,
129                            afs_int32 *lastP, afs_int32 *cid);
130 static afs_int32 isAMemberOf(struct rx_call *call, afs_int32 uid, afs_int32 gid,
131                              afs_int32 *flag, afs_int32 *cid);
132 static afs_int32 addWildCards(struct ubik_trans *tt, prlist *alist,
133                               afs_uint32 host);
134 static afs_int32 WhoIsThisWithName(struct rx_call *acall,
135                                    struct ubik_trans *at, afs_int32 *aid,
136                                    char *aname);
137
138 /* when we abort, the ubik cachedVersion will be reset, so we'll read in the
139  * header on the next call.
140  * Abort the transaction and return the code.
141  */
142 #define ABORT_WITH(tt,code) return(ubik_AbortTrans(tt),code)
143
144 static int
145 CreateOK(struct ubik_trans *ut, afs_int32 cid, afs_int32 oid, afs_int32 flag,
146          int admin)
147 {
148     if (restricted && !admin)
149         return 0;
150
151     if (flag & PRFOREIGN) {
152         /* Foreign users are recognized by the '@' sign and
153          * not by the PRFOREIGN flag.
154          */
155         return 0;
156     } else if (flag & PRGRP) {
157         /* Allow anonymous group creation only if owner specified
158          * and running noAuth.
159          */
160         if (cid == ANONYMOUSID) {
161             if ((oid == 0) || !pr_noAuth)
162                 return 0;
163         }
164     } else {                    /* creating a user */
165         if (oid == ANONYMOUSID)
166             return 0;
167         if (!admin && !pr_noAuth)
168             return 0;
169     }
170     return 1;                   /* OK! */
171 }
172
173 afs_int32
174 WhoIsThis(struct rx_call *acall, struct ubik_trans *at, afs_int32 *aid)
175 {
176     int code = WhoIsThisWithName(acall, at, aid, NULL);
177     if (code == 2 && *aid == ANONYMOUSID)
178         return PRNOENT;
179     return code;
180 }
181
182 static int
183 WritePreamble(struct ubik_trans **tt)
184 {
185     int code;
186
187     code = Initdb();
188     if (code)
189         return code;
190
191     code = ubik_BeginTrans(dbase, UBIK_WRITETRANS, tt);
192     if (code)
193         return code;
194
195     code = ubik_SetLock(*tt, 1, 1, LOCKWRITE);
196     if (code)
197         goto out;
198
199     code = read_DbHeader(*tt);
200
201 out:
202     if (code)
203         ubik_AbortTrans(*tt);
204
205     return code;
206 }
207
208 static int
209 ReadPreamble(struct ubik_trans **tt)
210 {
211     int code;
212
213     code = Initdb();
214     if (code)
215         return code;
216
217     code = ubik_BeginTransReadAny(dbase, UBIK_READTRANS, tt);
218     if (code)
219         return code;
220
221     code = ubik_SetLock(*tt, 1, 1, LOCKREAD);
222     if (code)
223         goto out;
224
225     code = read_DbHeader(*tt);
226
227 out:
228     if (code)
229         ubik_AbortTrans(*tt);
230
231     return code;
232 }
233
234 afs_int32
235 SPR_INewEntry(struct rx_call *call, char aname[], afs_int32 aid, afs_int32 oid)
236 {
237     afs_int32 code;
238     afs_int32 cid = ANONYMOUSID;
239
240     code = iNewEntry(call, aname, aid, oid, &cid);
241     osi_auditU(call, PTS_INewEntEvent, code, AUD_ID, aid, AUD_STR, aname,
242                AUD_ID, oid, AUD_END);
243     ViceLog(5, ("PTS_INewEntry: code %d cid %d aid %d aname %s oid %d\n", code, cid, aid, aname, oid));
244     return code;
245 }
246
247 static afs_int32
248 iNewEntry(struct rx_call *call, char aname[], afs_int32 aid, afs_int32 oid,
249           afs_int32 *cid)
250 {
251     /* used primarily for conversion - not intended to be used as usual means
252      * of entering people into the database. */
253     struct ubik_trans *tt;
254     afs_int32 code;
255     afs_int32 gflag = 0;
256     int admin;
257
258     stolower(aname);
259
260     code = WritePreamble(&tt);
261     if (code)
262         return code;
263
264     code = WhoIsThis(call, tt, cid);
265     if (code)
266         ABORT_WITH(tt, PRPERM);
267     admin = IsAMemberOf(tt, *cid, SYSADMINID);
268
269     /* first verify the id is good */
270     if (aid == 0)
271         ABORT_WITH(tt, PRPERM);
272     if (aid < 0) {
273         gflag |= PRGRP;
274         /* only sysadmin can reuse a group id */
275         if (!admin && !pr_noAuth && (aid != ntohl(cheader.maxGroup) - 1))
276             ABORT_WITH(tt, PRPERM);
277     }
278     if (FindByID(tt, aid))
279         ABORT_WITH(tt, PRIDEXIST);
280
281     /* check a few other things */
282     if (!CreateOK(tt, *cid, oid, gflag, admin))
283         ABORT_WITH(tt, PRPERM);
284
285     code = CreateEntry(tt, aname, &aid, 1, gflag, oid, *cid);
286     if (code != PRSUCCESS)
287         ABORT_WITH(tt, code);
288
289     /* finally, commit transaction */
290     code = ubik_EndTrans(tt);
291     if (code)
292         return code;
293     return PRSUCCESS;
294 }
295
296
297 afs_int32
298 SPR_NewEntry(struct rx_call *call, char aname[], afs_int32 flag, afs_int32 oid,
299              afs_int32 *aid)
300 {
301     afs_int32 code;
302     afs_int32 cid = ANONYMOUSID;
303
304     code = newEntry(call, aname, flag, oid, aid, &cid);
305     osi_auditU(call, PTS_NewEntEvent, code, AUD_ID, *aid, AUD_STR, aname,
306                AUD_ID, oid, AUD_END);
307     ViceLog(5, ("PTS_NewEntry: code %d cid %d aid %d aname %s oid %d\n", code, cid, *aid, aname, oid));
308     return code;
309 }
310
311 static afs_int32
312 newEntry(struct rx_call *call, char aname[], afs_int32 flag, afs_int32 oid,
313          afs_int32 *aid, afs_int32 *cid)
314 {
315     afs_int32 code;
316     struct ubik_trans *tt;
317     int admin;
318     int foreign = 0;
319     char cname[PR_MAXNAMELEN];
320     stolower(aname);
321
322     code = WritePreamble(&tt);
323     if (code)
324         return code;
325
326     /* this is for cross-cell self registration. It is not added in the
327      * SPR_INewEntry because we want self-registration to only do
328      * automatic id assignment.
329      */
330     code = WhoIsThisWithName(call, tt, cid, cname);
331     if (code && code != 2)
332         ABORT_WITH(tt, PRPERM);
333     admin = IsAMemberOf(tt, *cid, SYSADMINID);
334     if (code == 2 /* foreign cell request */) {
335         foreign = 1;
336
337         if (!restricted && (strcmp(aname, cname) == 0)) {
338             /* can't autoregister while providing an owner id */
339             if (oid != 0)
340                 ABORT_WITH(tt, PRPERM);
341
342             admin = 1;
343             oid = SYSADMINID;
344         }
345     }
346     if (!CreateOK(tt, *cid, oid, flag, admin))
347         ABORT_WITH(tt, PRPERM);
348
349     code = CreateEntry(tt, aname, aid, 0, flag, oid, *cid);
350     /*
351      * If this was an autoregistration then be sure to audit log
352      * the proper id as the creator.
353      */
354     if (foreign && code == 0 && *aid > 0)
355         *cid = *aid;
356     if (code != PRSUCCESS)
357         ABORT_WITH(tt, code);
358
359     code = ubik_EndTrans(tt);
360     if (code)
361         return code;
362     return PRSUCCESS;
363 }
364
365
366
367 afs_int32
368 SPR_WhereIsIt(struct rx_call *call, afs_int32 aid, afs_int32 *apos)
369 {
370     afs_int32 code;
371     afs_int32 cid = ANONYMOUSID;
372
373     code = whereIsIt(call, aid, apos, &cid);
374     osi_auditU(call, PTS_WheIsItEvent, code, AUD_ID, aid, AUD_LONG, *apos,
375                AUD_END);
376     ViceLog(125, ("PTS_WhereIsIt: code %d cid %d aid %d apos %d\n", code, cid, aid, *apos));
377     return code;
378 }
379
380 static afs_int32
381 whereIsIt(struct rx_call *call, afs_int32 aid, afs_int32 *apos, afs_int32 *cid)
382 {
383     afs_int32 code;
384     struct ubik_trans *tt;
385     afs_int32 temp;
386
387     code = ReadPreamble(&tt);
388     if (code)
389         return code;
390
391     code = WhoIsThis(call, tt, cid);
392     if (code)
393         ABORT_WITH(tt, PRPERM);
394     if (!pr_noAuth && restrict_anonymous && *cid == ANONYMOUSID)
395         ABORT_WITH(tt, PRPERM);
396
397     temp = FindByID(tt, aid);
398     if (!temp)
399         ABORT_WITH(tt, PRNOENT);
400     *apos = temp;
401     code = ubik_EndTrans(tt);
402     if (code)
403         return code;
404     return PRSUCCESS;
405 }
406
407
408 afs_int32
409 SPR_DumpEntry(struct rx_call *call, afs_int32 apos,
410               struct prdebugentry *aentry)
411 {
412     afs_int32 code;
413     afs_int32 cid = ANONYMOUSID;
414
415     code = dumpEntry(call, apos, aentry, &cid);
416     osi_auditU(call, PTS_DmpEntEvent, code, AUD_LONG, apos, AUD_END);
417     ViceLog(125, ("PTS_DumpEntry: code %d cid %d apos %d\n", code, cid, apos));
418     return code;
419 }
420
421 static afs_int32
422 dumpEntry(struct rx_call *call, afs_int32 apos, struct prdebugentry *aentry,
423           afs_int32 *cid)
424 {
425     afs_int32 code;
426     struct ubik_trans *tt;
427
428     code = ReadPreamble(&tt);
429     if (code)
430         return code;
431
432     code = WhoIsThis(call, tt, cid);
433     if (code)
434         ABORT_WITH(tt, PRPERM);
435     code = pr_ReadEntry(tt, 0, apos, (struct prentry *)aentry);
436     if (code)
437         ABORT_WITH(tt, code);
438
439     if (!AccessOK(tt, *cid, 0, PRP_STATUS_MEM, 0))
440         ABORT_WITH(tt, PRPERM);
441
442     code = ubik_EndTrans(tt);
443     if (code)
444         return code;
445     return PRSUCCESS;
446 }
447
448 afs_int32
449 SPR_AddToGroup(struct rx_call *call, afs_int32 aid, afs_int32 gid)
450 {
451     afs_int32 code;
452     afs_int32 cid = ANONYMOUSID;
453
454     code = addToGroup(call, aid, gid, &cid);
455     osi_auditU(call, PTS_AdToGrpEvent, code, AUD_ID, gid, AUD_ID, aid,
456                AUD_END);
457     ViceLog(5, ("PTS_AddToGroup: code %d cid %d gid %d aid %d\n", code, cid, gid, aid));
458     return code;
459 }
460
461 static afs_int32
462 addToGroup(struct rx_call *call, afs_int32 aid, afs_int32 gid, afs_int32 *cid)
463 {
464     afs_int32 code;
465     struct ubik_trans *tt;
466     afs_int32 tempu;
467     afs_int32 tempg;
468     struct prentry tentry;
469     struct prentry uentry;
470
471     if (gid == ANYUSERID || gid == AUTHUSERID)
472         return PRPERM;
473     if (aid == ANONYMOUSID)
474         return PRPERM;
475
476     code = WritePreamble(&tt);
477     if (code)
478         return code;
479
480     code = WhoIsThis(call, tt, cid);
481     if (code)
482         ABORT_WITH(tt, PRPERM);
483     tempu = FindByID(tt, aid);
484     if (!tempu)
485         ABORT_WITH(tt, PRNOENT);
486     memset(&uentry, 0, sizeof(uentry));
487     code = pr_ReadEntry(tt, 0, tempu, &uentry);
488     if (code != 0)
489         ABORT_WITH(tt, code);
490
491 #if !defined(SUPERGROUPS)
492     /* we don't allow groups as members of groups at present */
493     if (uentry.flags & PRGRP)
494         ABORT_WITH(tt, PRNOTUSER);
495 #endif
496
497     tempg = FindByID(tt, gid);
498     if (!tempg)
499         ABORT_WITH(tt, PRNOENT);
500     code = pr_ReadEntry(tt, 0, tempg, &tentry);
501     if (code != 0)
502         ABORT_WITH(tt, code);
503     /* make sure that this is a group */
504     if (!(tentry.flags & PRGRP))
505         ABORT_WITH(tt, PRNOTGROUP);
506     if (!AccessOK(tt, *cid, &tentry, PRP_ADD_MEM, PRP_ADD_ANY))
507         ABORT_WITH(tt, PRPERM);
508
509     code = AddToEntry(tt, &tentry, tempg, aid);
510     if (code != PRSUCCESS)
511         ABORT_WITH(tt, code);
512
513 #if defined(SUPERGROUPS)
514     if (uentry.flags & PRGRP)
515         code = AddToSGEntry(tt, &uentry, tempu, gid);   /* mod group to be in sg */
516     else
517 #endif
518         /* now, modify the user's entry as well */
519         code = AddToEntry(tt, &uentry, tempu, gid);
520     if (code != PRSUCCESS)
521         ABORT_WITH(tt, code);
522     code = ubik_EndTrans(tt);
523     if (code)
524         return code;
525     return PRSUCCESS;
526 }
527
528 afs_int32
529 SPR_NameToID(struct rx_call *call, namelist *aname, idlist *aid)
530 {
531     afs_int32 code;
532
533     code = nameToID(call, aname, aid);
534     osi_auditU(call, PTS_NmToIdEvent, code, AUD_END);
535     ViceLog(125, ("PTS_NameToID: code %d\n", code));
536     return code;
537 }
538
539 static afs_int32
540 nameToID(struct rx_call *call, namelist *aname, idlist *aid)
541 {
542     afs_int32 code;
543     struct ubik_trans *tt;
544     afs_int32 i;
545     int size;
546     int count = 0;
547
548     /* Initialize return struct */
549     aid->idlist_len = 0;
550     aid->idlist_val = NULL;
551
552     size = aname->namelist_len;
553     if (size == 0)
554         return 0;
555     if (size < 0)
556         return PRTOOMANY;
557
558     aid->idlist_val = malloc(size * sizeof(afs_int32));
559     if (!aid->idlist_val)
560         return PRNOMEM;
561
562     code = ReadPreamble(&tt);
563     if (code)
564         return code;
565
566     for (i = 0; i < aname->namelist_len; i++) {
567         char vname[256];
568         char *nameinst, *cell;
569         afs_int32 islocal = 1;
570
571         strncpy(vname, aname->namelist_val[i], sizeof(vname));
572         vname[sizeof(vname)-1] ='\0';
573
574         nameinst = vname;
575         cell = strchr(vname, '@');
576         if (cell) {
577             *cell = '\0';
578             cell++;
579         }
580
581         if (cell && *cell) {
582             code = afsconf_IsLocalRealmMatch(prdir, &islocal, nameinst, NULL, cell);
583             ViceLog(125,
584                     ("PTS_NameToID: afsconf_IsLocalRealmMatch(); code=%d, nameinst=%s, cell=%s\n",
585                      code, nameinst, cell));
586         }
587         if (islocal)
588             code = NameToID(tt, nameinst, &aid->idlist_val[i]);
589         else
590             code = NameToID(tt, aname->namelist_val[i], &aid->idlist_val[i]);
591
592         if (code != PRSUCCESS)
593             aid->idlist_val[i] = ANONYMOUSID;
594         osi_audit(PTS_NmToIdEvent, code, AUD_STR,
595                    aname->namelist_val[i], AUD_ID, aid->idlist_val[i],
596                    AUD_END);
597         ViceLog(125, ("PTS_NameToID: code %d aname %s aid %d\n", code,
598                       aname->namelist_val[i], aid->idlist_val[i]));
599         if (count++ > 50) {
600 #ifndef AFS_PTHREAD_ENV
601             IOMGR_Poll();
602 #endif
603             count = 0;
604         }
605     }
606     aid->idlist_len = aname->namelist_len;
607
608     code = ubik_EndTrans(tt);
609     if (code)
610         return code;
611     return PRSUCCESS;
612 }
613
614 /*
615  * SPR_IDToName
616  * Given an array of ids, find the name for each of them.
617  * The array of ids and names is unlimited.
618  */
619 afs_int32
620 SPR_IDToName(struct rx_call *call, idlist *aid, namelist *aname)
621 {
622     afs_int32 code;
623     afs_int32 cid = ANONYMOUSID;
624
625     code = idToName(call, aid, aname, &cid);
626     osi_auditU(call, PTS_IdToNmEvent, code, AUD_END);
627     ViceLog(125, ("PTS_IDToName: code %d\n", code));
628     return code;
629 }
630
631 static afs_int32
632 idToName(struct rx_call *call, idlist *aid, namelist *aname, afs_int32 *cid)
633 {
634     afs_int32 code;
635     struct ubik_trans *tt;
636     afs_int32 i;
637     int size;
638     int count = 0;
639
640     /* leave this first for rpc stub */
641     size = aid->idlist_len;
642     if (size == 0)
643         return 0;
644     if (size < 0 || size > INT_MAX / PR_MAXNAMELEN)
645         return PRTOOMANY;
646     aname->namelist_val = calloc(size, PR_MAXNAMELEN);
647     aname->namelist_len = 0;
648     if (aname->namelist_val == 0)
649         return PRNOMEM;
650     if (aid->idlist_len == 0)
651         return 0;
652     if (size == 0)
653         return PRTOOMANY;       /* rxgen will probably handle this */
654
655     code = ReadPreamble(&tt);
656     if (code)
657         return code;
658
659     code = WhoIsThis(call, tt, cid);
660     if (code)
661         ABORT_WITH(tt, PRPERM);
662     if (!pr_noAuth && restrict_anonymous && *cid == ANONYMOUSID)
663         ABORT_WITH(tt, PRPERM);
664
665     for (i = 0; i < aid->idlist_len; i++) {
666         code = IDToName(tt, aid->idlist_val[i], aname->namelist_val[i]);
667         if (code != PRSUCCESS)
668             sprintf(aname->namelist_val[i], "%d", aid->idlist_val[i]);
669         osi_audit(PTS_IdToNmEvent, code, AUD_ID, aid->idlist_val[i],
670                   AUD_STR, aname->namelist_val[i], AUD_END);
671         ViceLog(125, ("PTS_idToName: code %d aid %d aname %s\n", code,
672                       aid->idlist_val[i], aname->namelist_val[i]));
673         if (count++ > 50) {
674 #ifndef AFS_PTHREAD_ENV
675             IOMGR_Poll();
676 #endif
677             count = 0;
678         }
679     }
680     aname->namelist_len = aid->idlist_len;
681
682     code = ubik_EndTrans(tt);
683     if (code)
684         return code;
685     return PRSUCCESS;
686 }
687
688 afs_int32
689 SPR_Delete(struct rx_call *call, afs_int32 aid)
690 {
691     afs_int32 code;
692     afs_int32 cid = ANONYMOUSID;
693
694     code = Delete(call, aid, &cid);
695     osi_auditU(call, PTS_DelEvent, code, AUD_ID, aid, AUD_END);
696     ViceLog(5, ("PTS_Delete: code %d cid %d aid %d\n", code, cid, aid));
697     return code;
698 }
699
700 static afs_int32
701 Delete(struct rx_call *call, afs_int32 aid, afs_int32 *cid)
702 {
703     afs_int32 code;
704     struct ubik_trans *tt;
705     struct prentry tentry;
706     afs_int32 loc, nptr;
707     int count;
708
709     if (aid == SYSADMINID || aid == ANYUSERID || aid == AUTHUSERID
710         || aid == ANONYMOUSID)
711         return PRPERM;
712
713     code = WritePreamble(&tt);
714     if (code)
715         return code;
716
717     code = WhoIsThis(call, tt, cid);
718     if (code)
719         ABORT_WITH(tt, PRPERM);
720
721     /* Read in entry to be deleted */
722     loc = FindByID(tt, aid);
723     if (loc == 0)
724         ABORT_WITH(tt, PRNOENT);
725     code = pr_ReadEntry(tt, 0, loc, &tentry);
726     if (code)
727         ABORT_WITH(tt, PRDBFAIL);
728
729     /* Do some access checking */
730     if (tentry.owner != *cid && !IsAMemberOf(tt, *cid, SYSADMINID)
731         && !IsAMemberOf(tt, *cid, tentry.owner) && !pr_noAuth)
732         ABORT_WITH(tt, PRPERM);
733
734     if (restricted && !IsAMemberOf(tt, *cid, SYSADMINID)) {
735         ABORT_WITH(tt, PRPERM);
736     }
737
738     /* Delete each continuation block as a separate transaction so that no one
739      * transaction become to large to complete. */
740     nptr = tentry.next;
741     while (nptr != 0) {
742         struct contentry centry;
743         int i;
744
745         code = pr_ReadCoEntry(tt, 0, nptr, &centry);
746         if (code != 0)
747             ABORT_WITH(tt, PRDBFAIL);
748         for (i = 0; i < COSIZE; i++) {
749             if (centry.entries[i] == PRBADID)
750                 continue;
751             if (centry.entries[i] == 0)
752                 break;
753 #if defined(SUPERGROUPS)
754             if (aid < 0 && centry.entries[i] < 0)       /* Supergroup */
755                 code = RemoveFromSGEntry(tt, aid, centry.entries[i]);
756             else
757 #endif
758                 code = RemoveFromEntry(tt, aid, centry.entries[i]);
759             if (code)
760                 ABORT_WITH(tt, code);
761             tentry.count--;     /* maintain count */
762 #ifndef AFS_PTHREAD_ENV
763             if ((i & 3) == 0)
764                 IOMGR_Poll();
765 #endif
766         }
767         tentry.next = centry.next;      /* thread out this block */
768         code = FreeBlock(tt, nptr);     /* free continuation block */
769         if (code)
770             ABORT_WITH(tt, code);
771         code = pr_WriteEntry(tt, 0, loc, &tentry);      /* update main entry */
772         if (code)
773             ABORT_WITH(tt, code);
774
775         /* end this trans and start a new one */
776         code = ubik_EndTrans(tt);
777         if (code)
778             return code;
779 #ifndef AFS_PTHREAD_ENV
780         IOMGR_Poll();           /* just to keep the connection alive */
781 #endif
782         code = ubik_BeginTrans(dbase, UBIK_WRITETRANS, &tt);
783         if (code)
784             return code;
785         code = ubik_SetLock(tt, 1, 1, LOCKWRITE);
786         if (code)
787             ABORT_WITH(tt, code);
788
789         /* re-read entry to get consistent uptodate info */
790         loc = FindByID(tt, aid);
791         if (loc == 0)
792             ABORT_WITH(tt, PRNOENT);
793         code = pr_ReadEntry(tt, 0, loc, &tentry);
794         if (code)
795             ABORT_WITH(tt, PRDBFAIL);
796
797         nptr = tentry.next;
798     }
799
800 #if defined(SUPERGROUPS)
801     /* Delete each continuation block as a separate transaction
802      * so that no one transaction become too large to complete. */
803     {
804         struct prentryg *tentryg = (struct prentryg *)&tentry;
805         nptr = tentryg->nextsg;
806         while (nptr != 0) {
807             struct contentry centry;
808             int i;
809
810             code = pr_ReadCoEntry(tt, 0, nptr, &centry);
811             if (code != 0)
812                 ABORT_WITH(tt, PRDBFAIL);
813             for (i = 0; i < COSIZE; i++) {
814                 if (centry.entries[i] == PRBADID)
815                     continue;
816                 if (centry.entries[i] == 0)
817                     break;
818                 code = RemoveFromEntry(tt, aid, centry.entries[i]);
819                 if (code)
820                     ABORT_WITH(tt, code);
821                 tentryg->countsg--;     /* maintain count */
822 #ifndef AFS_PTHREAD_ENV
823                 if ((i & 3) == 0)
824                     IOMGR_Poll();
825 #endif
826             }
827             tentryg->nextsg = centry.next;      /* thread out this block */
828             code = FreeBlock(tt, nptr); /* free continuation block */
829             if (code)
830                 ABORT_WITH(tt, code);
831             code = pr_WriteEntry(tt, 0, loc, &tentry);  /* update main entry */
832             if (code)
833                 ABORT_WITH(tt, code);
834
835             /* end this trans and start a new one */
836             code = ubik_EndTrans(tt);
837             if (code)
838                 return code;
839 #ifndef AFS_PTHREAD_ENV
840             IOMGR_Poll();       /* just to keep the connection alive */
841 #endif
842
843             code = ubik_BeginTrans(dbase, UBIK_WRITETRANS, &tt);
844             if (code)
845                 return code;
846             code = ubik_SetLock(tt, 1, 1, LOCKWRITE);
847             if (code)
848                 ABORT_WITH(tt, code);
849
850             /* re-read entry to get consistent uptodate info */
851             loc = FindByID(tt, aid);
852             if (loc == 0)
853                 ABORT_WITH(tt, PRNOENT);
854             code = pr_ReadEntry(tt, 0, loc, &tentry);
855             if (code)
856                 ABORT_WITH(tt, PRDBFAIL);
857
858             nptr = tentryg->nextsg;
859         }
860     }
861
862 #endif /* SUPERGROUPS */
863
864     /* Then move the owned chain, except possibly ourself to the orphan list.
865      * Because this list can be very long and so exceed the size of a ubik
866      * transaction, we start a new transaction every 50 entries. */
867     count = 0;
868     nptr = tentry.owned;
869     while (nptr != 0) {
870         struct prentry nentry;
871
872         code = pr_ReadEntry(tt, 0, nptr, &nentry);
873         if (code)
874             ABORT_WITH(tt, PRDBFAIL);
875         nptr = tentry.owned = nentry.nextOwned; /* thread out */
876
877         if (nentry.id != tentry.id) {   /* don't add us to orphan chain! */
878             code = AddToOrphan(tt, nentry.id);
879             if (code)
880                 ABORT_WITH(tt, code);
881             count++;
882 #ifndef AFS_PTHREAD_ENV
883             if ((count & 3) == 0)
884                 IOMGR_Poll();
885 #endif
886         }
887         if (count < 50)
888             continue;
889         code = pr_WriteEntry(tt, 0, loc, &tentry);      /* update main entry */
890         if (code)
891             ABORT_WITH(tt, code);
892
893         /* end this trans and start a new one */
894         code = ubik_EndTrans(tt);
895         if (code)
896             return code;
897 #ifndef AFS_PTHREAD_ENV
898         IOMGR_Poll();           /* just to keep the connection alive */
899 #endif
900         code = ubik_BeginTrans(dbase, UBIK_WRITETRANS, &tt);
901         if (code)
902             return code;
903         code = ubik_SetLock(tt, 1, 1, LOCKWRITE);
904         if (code)
905             ABORT_WITH(tt, code);
906
907         /* re-read entry to get consistent uptodate info */
908         loc = FindByID(tt, aid);
909         if (loc == 0)
910             ABORT_WITH(tt, PRNOENT);
911         code = pr_ReadEntry(tt, 0, loc, &tentry);
912         if (code)
913             ABORT_WITH(tt, PRDBFAIL);
914
915         nptr = tentry.owned;
916     }
917
918     /* now do what's left of the deletion stuff */
919     code = DeleteEntry(tt, &tentry, loc);
920     if (code != PRSUCCESS)
921         ABORT_WITH(tt, code);
922
923     code = ubik_EndTrans(tt);
924     if (code)
925         return code;
926     return PRSUCCESS;
927 }
928
929 afs_int32
930 SPR_UpdateEntry(struct rx_call *call, afs_int32 aid, char *name,
931                 struct PrUpdateEntry *uentry)
932 {
933     afs_int32 code;
934     afs_int32 cid = ANONYMOUSID;
935
936     code = UpdateEntry(call, aid, name, uentry, &cid);
937     osi_auditU(call, PTS_UpdEntEvent, code, AUD_ID, aid, AUD_STR, name, AUD_END);
938     ViceLog(5, ("PTS_UpdateEntry: code %d cid %d aid %d name %s\n", code, cid, aid, name));
939     return code;
940 }
941
942 afs_int32
943 UpdateEntry(struct rx_call *call, afs_int32 aid, char *name,
944             struct PrUpdateEntry *uentry, afs_int32 *cid)
945 {
946     afs_int32 code;
947     struct ubik_trans *tt;
948     struct prentry tentry;
949     afs_int32 loc;
950     int id = 0;
951
952     if (aid) {
953         id = aid;
954         if (aid == SYSADMINID || aid == ANYUSERID || aid == AUTHUSERID
955             || aid == ANONYMOUSID)
956             return PRPERM;
957     }
958
959     code = WritePreamble(&tt);
960     if (code)
961         return code;
962
963     code = WhoIsThis(call, tt, cid);
964     if (code)
965         ABORT_WITH(tt, PRPERM);
966     code = IsAMemberOf(tt, *cid, SYSADMINID);
967     if (!code && !pr_noAuth)
968         ABORT_WITH(tt, PRPERM);
969
970     /* Read in entry to be deleted */
971     if (id) {
972         loc = FindByID(tt, aid);
973     } else {
974         loc = FindByName(tt, name, &tentry);
975     }
976     if (loc == 0)
977         ABORT_WITH(tt, PRNOENT);
978     code = pr_ReadEntry(tt, 0, loc, &tentry);
979     if (code)
980         ABORT_WITH(tt, PRDBFAIL);
981
982     if (uentry->Mask & PRUPDATE_NAMEHASH) {
983         int tloc;
984         code = RemoveFromNameHash(tt, tentry.name, &tloc);
985         if (code != PRSUCCESS)
986             ABORT_WITH(tt, PRDBFAIL);
987         code = AddToNameHash(tt, tentry.name, loc);
988         if (code)
989             ABORT_WITH(tt, code);
990     }
991
992     if (uentry->Mask & PRUPDATE_IDHASH) {
993         int tloc;
994         if (!id)
995             id = tentry.id;
996         code = RemoveFromIDHash(tt, id, &tloc);
997         if (code != PRSUCCESS)
998             ABORT_WITH(tt, PRDBFAIL);
999         code = AddToIDHash(tt, id, loc);
1000         if (code)
1001             ABORT_WITH(tt, code);
1002     }
1003
1004     code = ubik_EndTrans(tt);
1005     if (code)
1006         return code;
1007     return PRSUCCESS;
1008 }
1009
1010 afs_int32
1011 SPR_RemoveFromGroup(struct rx_call *call, afs_int32 aid, afs_int32 gid)
1012 {
1013     afs_int32 code;
1014     afs_int32 cid = ANONYMOUSID;
1015
1016     code = removeFromGroup(call, aid, gid, &cid);
1017     osi_auditU(call, PTS_RmFmGrpEvent, code, AUD_ID, gid, AUD_ID, aid,
1018                AUD_END);
1019     ViceLog(5, ("PTS_RemoveFromGroup: code %d cid %d gid %d aid %d\n", code, cid, gid, aid));
1020     return code;
1021 }
1022
1023 static afs_int32
1024 removeFromGroup(struct rx_call *call, afs_int32 aid, afs_int32 gid,
1025                 afs_int32 *cid)
1026 {
1027     afs_int32 code;
1028     struct ubik_trans *tt;
1029     afs_int32 tempu;
1030     afs_int32 tempg;
1031     struct prentry uentry;
1032     struct prentry gentry;
1033
1034     code = WritePreamble(&tt);
1035     if (code)
1036         return code;
1037
1038     code = WhoIsThis(call, tt, cid);
1039     if (code)
1040         ABORT_WITH(tt, PRPERM);
1041     tempu = FindByID(tt, aid);
1042     if (!tempu)
1043         ABORT_WITH(tt, PRNOENT);
1044     tempg = FindByID(tt, gid);
1045     if (!tempg)
1046         ABORT_WITH(tt, PRNOENT);
1047     memset(&uentry, 0, sizeof(uentry));
1048     memset(&gentry, 0, sizeof(gentry));
1049     code = pr_ReadEntry(tt, 0, tempu, &uentry);
1050     if (code != 0)
1051         ABORT_WITH(tt, code);
1052     code = pr_ReadEntry(tt, 0, tempg, &gentry);
1053     if (code != 0)
1054         ABORT_WITH(tt, code);
1055     if (!(gentry.flags & PRGRP))
1056         ABORT_WITH(tt, PRNOTGROUP);
1057 #if !defined(SUPERGROUPS)
1058     if (uentry.flags & PRGRP)
1059         ABORT_WITH(tt, PRNOTUSER);
1060 #endif
1061     if (!AccessOK(tt, *cid, &gentry, PRP_REMOVE_MEM, 0))
1062         ABORT_WITH(tt, PRPERM);
1063     code = RemoveFromEntry(tt, aid, gid);
1064     if (code != PRSUCCESS)
1065         ABORT_WITH(tt, code);
1066 #if defined(SUPERGROUPS)
1067     if (!(uentry.flags & PRGRP))
1068 #endif
1069         code = RemoveFromEntry(tt, gid, aid);
1070 #if defined(SUPERGROUPS)
1071     else
1072         code = RemoveFromSGEntry(tt, gid, aid);
1073 #endif
1074     if (code != PRSUCCESS)
1075         ABORT_WITH(tt, code);
1076
1077     code = ubik_EndTrans(tt);
1078     if (code)
1079         return code;
1080     return PRSUCCESS;
1081 }
1082
1083
1084 afs_int32
1085 SPR_GetCPS(struct rx_call *call, afs_int32 aid, prlist *alist, afs_int32 *over)
1086 {
1087     afs_int32 code;
1088     afs_int32 cid = ANONYMOUSID;
1089
1090     code = getCPS(call, aid, alist, over, &cid);
1091     osi_auditU(call, PTS_GetCPSEvent, code, AUD_ID, aid, AUD_END);
1092     ViceLog(125, ("PTS_GetCPS: code %d cid %d aid %d\n", code, cid, aid));
1093     return code;
1094 }
1095
1096 static afs_int32
1097 getCPS(struct rx_call *call, afs_int32 aid, prlist *alist, afs_int32 *over,
1098        afs_int32 *cid)
1099 {
1100     afs_int32 code;
1101     struct ubik_trans *tt;
1102     afs_int32 temp;
1103     struct prentry tentry;
1104
1105     *over = 0;
1106     alist->prlist_len = 0;
1107     alist->prlist_val = NULL;
1108
1109     code = ReadPreamble(&tt);
1110     if (code)
1111         return code;
1112
1113     code = WhoIsThis(call, tt, cid);
1114     if (code)
1115         ABORT_WITH(tt, PRPERM);
1116     if (!pr_noAuth && restrict_anonymous && *cid == ANONYMOUSID)
1117         ABORT_WITH(tt, PRPERM);
1118
1119     temp = FindByID(tt, aid);
1120     if (!temp)
1121         ABORT_WITH(tt, PRNOENT);
1122     code = pr_ReadEntry(tt, 0, temp, &tentry);
1123     if (code)
1124         ABORT_WITH(tt, code);
1125
1126     if (!AccessOK(tt, *cid, &tentry, PRP_MEMBER_MEM, PRP_MEMBER_ANY))
1127         ABORT_WITH(tt, PRPERM);
1128
1129     code = GetList(tt, &tentry, alist, 1);
1130     if (code != PRSUCCESS)
1131         ABORT_WITH(tt, code);
1132
1133     code = ubik_EndTrans(tt);
1134     return code;
1135 }
1136
1137
1138 int
1139 inCPS(prlist CPS, afs_int32 id)
1140 {
1141     int i;
1142
1143     for (i = (CPS.prlist_len - 1); i >= 0; i--) {
1144         if (CPS.prlist_val[i] == id)
1145             return (1);
1146     }
1147     return (0);
1148 }
1149
1150
1151 afs_int32
1152 SPR_GetCPS2(struct rx_call *call, afs_int32 aid, afs_int32 ahost,
1153             prlist *alist, afs_int32 *over)
1154 {
1155     afs_int32 code;
1156     afs_int32 cid = ANONYMOUSID;
1157
1158     code = getCPS2(call, aid, ahost, alist, over, &cid);
1159     osi_auditU(call, PTS_GetCPS2Event, code, AUD_ID, aid, AUD_HOST, htonl(ahost),
1160                AUD_END);
1161     ViceLog(125, ("PTS_GetCPS2: code %d cid %d aid %d ahost %d\n", code, cid, aid, ahost));
1162     return code;
1163 }
1164
1165 static afs_int32
1166 getCPS2(struct rx_call *call, afs_int32 aid, afs_uint32 ahost, prlist *alist,
1167         afs_int32 *over, afs_int32 *cid)
1168 {
1169     afs_int32 code;
1170     struct ubik_trans *tt;
1171     afs_int32 temp;
1172     struct prentry tentry;
1173     struct prentry host_tentry;
1174     afs_int32 hostid;
1175     int host_list = 0;
1176     struct in_addr iaddr;
1177     char hoststr[16];
1178
1179     *over = 0;
1180     iaddr.s_addr = ntohl(ahost);
1181     alist->prlist_len = 0;
1182     alist->prlist_val = NULL;
1183
1184     code = ReadPreamble(&tt);
1185     if (code)
1186         return code;
1187
1188     if (aid != PRBADID) {
1189         temp = FindByID(tt, aid);
1190         if (!temp)
1191             ABORT_WITH(tt, PRNOENT);
1192         code = pr_ReadEntry(tt, 0, temp, &tentry);
1193         if (code)
1194             ABORT_WITH(tt, code);
1195
1196         /* afs does authenticate now */
1197         code = WhoIsThis(call, tt, cid);
1198         if (code
1199             || !AccessOK(tt, *cid, &tentry, PRP_MEMBER_MEM, PRP_MEMBER_ANY))
1200             ABORT_WITH(tt, PRPERM);
1201     }
1202     code = NameToID(tt, afs_inet_ntoa_r(iaddr.s_addr, hoststr), &hostid);
1203     if (code == PRSUCCESS && hostid != 0) {
1204         temp = FindByID(tt, hostid);
1205         if (temp) {
1206             code = pr_ReadEntry(tt, 0, temp, &host_tentry);
1207             if (code == PRSUCCESS)
1208                 host_list = 1;
1209             else
1210                 fprintf(stderr, "pr_ReadEntry returned %d\n", code);
1211         } else
1212             fprintf(stderr, "FindByID Failed -- Not found\n");
1213     }
1214     if (host_list)
1215         code = GetList2(tt, &tentry, &host_tentry, alist, 1);
1216     else
1217         code = GetList(tt, &tentry, alist, 1);
1218     if (!code)
1219         code = addWildCards(tt, alist, ntohl(ahost));
1220     if (code != PRSUCCESS)
1221         ABORT_WITH(tt, code);
1222
1223     code = ubik_EndTrans(tt);
1224     return code;
1225 }
1226
1227
1228 afs_int32
1229 SPR_GetHostCPS(struct rx_call *call, afs_int32 ahost, prlist *alist,
1230                afs_int32 *over)
1231 {
1232     afs_int32 code;
1233     afs_int32 cid = ANONYMOUSID;
1234
1235     code = getHostCPS(call, ahost, alist, over, &cid);
1236     osi_auditU(call, PTS_GetHCPSEvent, code, AUD_HOST, htonl(ahost), AUD_END);
1237     ViceLog(125, ("PTS_GetHostCPS: code %d ahost %u (0x%x)\n", code, ahost, ahost));
1238     return code;
1239 }
1240
1241 afs_int32
1242 getHostCPS(struct rx_call *call, afs_uint32 ahost, prlist *alist,
1243            afs_int32 *over, afs_int32 *cid)
1244 {
1245     afs_int32 code, temp;
1246     struct ubik_trans *tt;
1247     struct prentry host_tentry;
1248     afs_int32 hostid;
1249     struct in_addr iaddr;
1250     char hoststr[16];
1251
1252     *over = 0;
1253     iaddr.s_addr = ntohl(ahost);
1254     alist->prlist_len = 0;
1255     alist->prlist_val = NULL;
1256
1257     code = ReadPreamble(&tt);
1258     if (code)
1259         return code;
1260
1261     code = WhoIsThis(call, tt, cid);
1262     if (code)
1263         ABORT_WITH(tt, PRPERM);
1264     if (!pr_noAuth && restrict_anonymous && *cid == ANONYMOUSID)
1265         ABORT_WITH(tt, PRPERM);
1266
1267     code = NameToID(tt, afs_inet_ntoa_r(iaddr.s_addr, hoststr), &hostid);
1268     if (code == PRSUCCESS && hostid != 0) {
1269         temp = FindByID(tt, hostid);
1270         if (temp) {
1271             code = pr_ReadEntry(tt, 0, temp, &host_tentry);
1272             if (code == PRSUCCESS) {
1273                 code = GetList(tt, &host_tentry, alist, 0);
1274                 if (code)
1275                     goto bad;
1276             } else
1277                 fprintf(stderr, "pr_ReadEntry returned %d\n", code);
1278         } else
1279             fprintf(stderr, "FindByID Failed -- Not found\n");
1280     }
1281     code = addWildCards(tt, alist, ntohl(ahost));
1282   bad:
1283     if (code != PRSUCCESS)
1284         ABORT_WITH(tt, code);
1285
1286     code = ubik_EndTrans(tt);
1287     return code;
1288 }
1289
1290
1291 afs_int32
1292 SPR_ListMax(struct rx_call *call, afs_int32 *uid, afs_int32 *gid)
1293 {
1294     afs_int32 code;
1295     afs_int32 cid = ANONYMOUSID;
1296
1297     code = listMax(call, uid, gid, &cid);
1298     osi_auditU(call, PTS_LstMaxEvent, code, AUD_END);
1299     ViceLog(125, ("PTS_ListMax: code %d\n", code));
1300     return code;
1301 }
1302
1303 afs_int32
1304 listMax(struct rx_call *call, afs_int32 *uid, afs_int32 *gid, afs_int32 *cid)
1305 {
1306     afs_int32 code;
1307     struct ubik_trans *tt;
1308
1309     code = ReadPreamble(&tt);
1310     if (code)
1311         return code;
1312
1313     code = WhoIsThis(call, tt, cid);
1314     if (code)
1315         ABORT_WITH(tt, PRPERM);
1316     if (!pr_noAuth && restrict_anonymous && *cid == ANONYMOUSID)
1317         ABORT_WITH(tt, PRPERM);
1318
1319     code = GetMax(tt, uid, gid);
1320     if (code != PRSUCCESS)
1321         ABORT_WITH(tt, code);
1322
1323     code = ubik_EndTrans(tt);
1324     if (code)
1325         return code;
1326     return PRSUCCESS;
1327 }
1328
1329 afs_int32
1330 SPR_SetMax(struct rx_call *call, afs_int32 aid, afs_int32 gflag)
1331 {
1332     afs_int32 code;
1333     afs_int32 cid = ANONYMOUSID;
1334
1335     code = setMax(call, aid, gflag, &cid);
1336     osi_auditU(call, PTS_SetMaxEvent, code, AUD_ID, aid, AUD_LONG, gflag,
1337                AUD_END);
1338     ViceLog(125, ("PTS_SetMax: code %d cid %d aid %d gflag %d\n", code, cid, aid, gflag));
1339     return code;
1340 }
1341
1342 static afs_int32
1343 setMax(struct rx_call *call, afs_int32 aid, afs_int32 gflag, afs_int32 *cid)
1344 {
1345     afs_int32 code;
1346     struct ubik_trans *tt;
1347
1348     code = WritePreamble(&tt);
1349     if (code)
1350         return code;
1351
1352     code = WhoIsThis(call, tt, cid);
1353     if (code)
1354         ABORT_WITH(tt, PRPERM);
1355     if (!AccessOK(tt, *cid, 0, 0, 0))
1356         ABORT_WITH(tt, PRPERM);
1357     if (((gflag & PRGRP) && (aid > 0)) || (!(gflag & PRGRP) && (aid < 0)))
1358         ABORT_WITH(tt, PRBADARG);
1359
1360     code = SetMax(tt, aid, gflag);
1361     if (code != PRSUCCESS)
1362         ABORT_WITH(tt, code);
1363
1364     code = ubik_EndTrans(tt);
1365     if (code)
1366         return code;
1367     return PRSUCCESS;
1368 }
1369
1370 afs_int32
1371 SPR_ListEntry(struct rx_call *call, afs_int32 aid, struct prcheckentry *aentry)
1372 {
1373     afs_int32 code;
1374     afs_int32 cid = ANONYMOUSID;
1375
1376     code = listEntry(call, aid, aentry, &cid);
1377     osi_auditU(call, PTS_LstEntEvent, code, AUD_ID, aid, AUD_END);
1378     ViceLog(125, ("PTS_ListEntry: code %d cid %d aid %d\n", code, cid, aid));
1379     return code;
1380 }
1381
1382 static afs_int32
1383 listEntry(struct rx_call *call, afs_int32 aid, struct prcheckentry *aentry,
1384           afs_int32 *cid)
1385 {
1386     afs_int32 code;
1387     struct ubik_trans *tt;
1388     afs_int32 temp;
1389     struct prentry tentry;
1390
1391     code = ReadPreamble(&tt);
1392     if (code)
1393         return code;
1394
1395     code = WhoIsThis(call, tt, cid);
1396     if (code)
1397         ABORT_WITH(tt, PRPERM);
1398     if (!pr_noAuth && restrict_anonymous && *cid == ANONYMOUSID)
1399         ABORT_WITH(tt, PRPERM);
1400     temp = FindByID(tt, aid);
1401     if (!temp)
1402         ABORT_WITH(tt, PRNOENT);
1403     code = pr_ReadEntry(tt, 0, temp, &tentry);
1404     if (code != 0)
1405         ABORT_WITH(tt, code);
1406     if (!AccessOK(tt, *cid, &tentry, PRP_STATUS_MEM, PRP_STATUS_ANY))
1407         ABORT_WITH(tt, PRPERM);
1408
1409     aentry->flags = tentry.flags >> PRIVATE_SHIFT;
1410     if (aentry->flags == 0) {
1411         if (tentry.flags & PRGRP)
1412             aentry->flags = prp_group_default >> PRIVATE_SHIFT;
1413         else
1414             aentry->flags = prp_user_default >> PRIVATE_SHIFT;
1415     }
1416     aentry->owner = tentry.owner;
1417     aentry->id = tentry.id;
1418     strncpy(aentry->name, tentry.name, PR_MAXNAMELEN);
1419     aentry->creator = tentry.creator;
1420     aentry->ngroups = tentry.ngroups;
1421     aentry->nusers = tentry.nusers;
1422     aentry->count = tentry.count;
1423     memset(aentry->reserved, 0, sizeof(aentry->reserved));
1424     code = ubik_EndTrans(tt);
1425     if (code)
1426         return code;
1427     return PRSUCCESS;
1428 }
1429
1430 afs_int32
1431 SPR_ListEntries(struct rx_call *call, afs_int32 flag, afs_int32 startindex,
1432                 prentries *bulkentries, afs_int32 *nextstartindex)
1433 {
1434     afs_int32 code;
1435     afs_int32 cid = ANONYMOUSID;
1436
1437     code = listEntries(call, flag, startindex, bulkentries, nextstartindex, &cid);
1438     osi_auditU(call, PTS_LstEntsEvent, code, AUD_LONG, flag, AUD_END);
1439     ViceLog(125, ("PTS_ListEntries: code %d cid %d flag %d\n", code, cid, flag));
1440     return code;
1441 }
1442
1443 static afs_int32
1444 listEntries(struct rx_call *call, afs_int32 flag, afs_int32 startindex,
1445             prentries *bulkentries, afs_int32 *nextstartindex, afs_int32 *cid)
1446 {
1447     afs_int32 code;
1448     struct ubik_trans *tt;
1449     afs_int32 i, eof, pos, maxentries, f;
1450     struct prentry tentry;
1451     afs_int32 pollcount = 0;
1452
1453     *nextstartindex = -1;
1454     bulkentries->prentries_val = 0;
1455     bulkentries->prentries_len = 0;
1456
1457     code = ReadPreamble(&tt);
1458     if (code)
1459         return code;
1460
1461     /* Make sure we are an authenticated caller and that we are on the
1462      * SYSADMIN list.
1463      */
1464     code = WhoIsThis(call, tt, cid);
1465     if (code)
1466         ABORT_WITH(tt, PRPERM);
1467     code = IsAMemberOf(tt, *cid, SYSADMINID);
1468     if (!code && !pr_noAuth)
1469         ABORT_WITH(tt, PRPERM);
1470
1471     eof = ntohl(cheader.eofPtr) - sizeof(cheader);
1472     maxentries = eof / sizeof(struct prentry);
1473     for (i = startindex; i < maxentries; i++) {
1474         pos = i * sizeof(struct prentry) + sizeof(cheader);
1475         code = pr_ReadEntry(tt, 0, pos, &tentry);
1476         if (code)
1477             goto done;
1478
1479         if (++pollcount > 50) {
1480 #ifndef AFS_PTHREAD_ENV
1481             IOMGR_Poll();
1482 #endif
1483             pollcount = 0;
1484         }
1485
1486         f = (tentry.flags & PRTYPE);
1487         if (((flag & PRUSERS) && (f == 0)) ||   /* User  entry */
1488             ((flag & PRGROUPS) && (f & PRGRP))) {       /* Group entry */
1489             code = put_prentries(&tentry, bulkentries);
1490             if (code == -1)
1491                 break;          /* Filled return array */
1492             if (code)
1493                 goto done;
1494         }
1495     }
1496     code = 0;
1497     if (i < maxentries)
1498         *nextstartindex = i;
1499
1500   done:
1501     if (code) {
1502         if (bulkentries->prentries_val)
1503             free(bulkentries->prentries_val);
1504         bulkentries->prentries_val = 0;
1505         bulkentries->prentries_len = 0;
1506         ABORT_WITH(tt, code);
1507     } else {
1508         code = ubik_EndTrans(tt);
1509     }
1510     if (code)
1511         return code;
1512     return PRSUCCESS;
1513 }
1514
1515 #define PR_MAXENTRIES 500
1516 static afs_int32
1517 put_prentries(struct prentry *tentry, prentries *bulkentries)
1518 {
1519     struct prlistentries *entry;
1520
1521     if (bulkentries->prentries_val == 0) {
1522         bulkentries->prentries_len = 0;
1523         bulkentries->prentries_val = malloc(PR_MAXENTRIES *
1524                                             sizeof(struct prlistentries));
1525         if (!bulkentries->prentries_val) {
1526             return (PRNOMEM);
1527         }
1528     }
1529
1530     if (bulkentries->prentries_len >= PR_MAXENTRIES) {
1531         return (-1);
1532     }
1533
1534     entry = bulkentries->prentries_val;
1535     entry += bulkentries->prentries_len;
1536
1537     memset(entry, 0, sizeof(*entry));
1538     entry->flags = tentry->flags >> PRIVATE_SHIFT;
1539     if (entry->flags == 0) {
1540         entry->flags =
1541             ((tentry->
1542               flags & PRGRP) ? prp_group_default : prp_user_default) >>
1543             PRIVATE_SHIFT;
1544     }
1545     entry->owner = tentry->owner;
1546     entry->id = tentry->id;
1547     entry->creator = tentry->creator;
1548     entry->ngroups = tentry->ngroups;
1549     entry->nusers = tentry->nusers;
1550     entry->count = tentry->count;
1551     strncpy(entry->name, tentry->name, PR_MAXNAMELEN);
1552     bulkentries->prentries_len++;
1553     return 0;
1554 }
1555
1556 afs_int32
1557 SPR_ChangeEntry(struct rx_call *call, afs_int32 aid, char *name, afs_int32 oid,
1558                 afs_int32 newid)
1559 {
1560     afs_int32 code;
1561     afs_int32 cid = ANONYMOUSID;
1562
1563     code = changeEntry(call, aid, name, oid, newid, &cid);
1564     osi_auditU(call, PTS_ChgEntEvent, code, AUD_ID, aid, AUD_STR, name,
1565                AUD_LONG, oid, AUD_LONG, newid, AUD_END);
1566     ViceLog(5, ("PTS_ChangeEntry: code %d cid %d aid %d name %s oid %d newid %d\n", code, cid, aid, name, oid, newid));
1567     return code;
1568 }
1569
1570 static afs_int32
1571 changeEntry(struct rx_call *call, afs_int32 aid, char *name, afs_int32 oid,
1572             afs_int32 newid, afs_int32 *cid)
1573 {
1574     afs_int32 code;
1575     struct ubik_trans *tt;
1576     afs_int32 pos;
1577
1578     if (!name)
1579         return PRPERM;
1580     stolower(name);
1581
1582     if (aid == ANYUSERID || aid == AUTHUSERID || aid == ANONYMOUSID
1583         || aid == SYSADMINID)
1584         return PRPERM;
1585
1586     code = WritePreamble(&tt);
1587     if (code)
1588         return code;
1589
1590     code = WhoIsThis(call, tt, cid);
1591     if (code)
1592         ABORT_WITH(tt, PRPERM);
1593     pos = FindByID(tt, aid);
1594     if (!pos)
1595         ABORT_WITH(tt, PRNOENT);
1596     /* protection check in changeentry */
1597     code = ChangeEntry(tt, aid, *cid, name, oid, newid);
1598     if (code != PRSUCCESS)
1599         ABORT_WITH(tt, code);
1600
1601     code = ubik_EndTrans(tt);
1602     return code;
1603 }
1604
1605 afs_int32
1606 SPR_SetFieldsEntry(struct rx_call *call,
1607                    afs_int32 id,
1608                    afs_int32 mask, /* specify which fields to update */
1609                    afs_int32 flags, afs_int32 ngroups, afs_int32 nusers,
1610                    afs_int32 spare1, afs_int32 spare2)
1611 {
1612     afs_int32 code;
1613     afs_int32 cid = ANONYMOUSID;
1614
1615     code =
1616         setFieldsEntry(call, id, mask, flags, ngroups, nusers, spare1,
1617                        spare2, &cid);
1618     osi_auditU(call, PTS_SetFldEntEvent, code, AUD_ID, id, AUD_END);
1619     ViceLog(5, ("PTS_SetFieldsEntry: code %d cid %d id %d\n", code, cid, id));
1620     return code;
1621 }
1622
1623 static afs_int32
1624 setFieldsEntry(struct rx_call *call,
1625                afs_int32 id,
1626                afs_int32 mask, /* specify which fields to update */
1627                afs_int32 flags, afs_int32 ngroups, afs_int32 nusers,
1628                afs_int32 spare1, afs_int32 spare2, afs_int32 *cid)
1629 {
1630     afs_int32 code;
1631     struct ubik_trans *tt;
1632     afs_int32 pos;
1633     struct prentry tentry;
1634     afs_int32 tflags;
1635
1636     if (mask == 0)
1637         return 0;               /* no-op */
1638
1639     if (id == ANYUSERID || id == AUTHUSERID || id == ANONYMOUSID)
1640         return PRPERM;
1641
1642     code = WritePreamble(&tt);
1643     if (code)
1644         return code;
1645
1646     code = WhoIsThis(call, tt, cid);
1647     if (code)
1648         ABORT_WITH(tt, PRPERM);
1649     pos = FindByID(tt, id);
1650     if (!pos)
1651         ABORT_WITH(tt, PRNOENT);
1652     code = pr_ReadEntry(tt, 0, pos, &tentry);
1653     if (code)
1654         ABORT_WITH(tt, code);
1655     tflags = tentry.flags;
1656
1657     if (mask & (PR_SF_NGROUPS | PR_SF_NUSERS)) {
1658         if (!AccessOK(tt, *cid, 0, 0, 0))
1659             ABORT_WITH(tt, PRPERM);
1660         if ((tflags & PRQUOTA) == 0) {  /* default if only setting one */
1661             tentry.ngroups = tentry.nusers = 20;
1662         }
1663     } else {
1664         if (!AccessOK(tt, *cid, &tentry, 0, 0))
1665             ABORT_WITH(tt, PRPERM);
1666     }
1667
1668     if (mask & 0xffff) {        /* if setting flag bits */
1669         afs_int32 flagsMask = mask & 0xffff;
1670         tflags &= ~(flagsMask << PRIVATE_SHIFT);
1671         tflags |= (flags & flagsMask) << PRIVATE_SHIFT;
1672         tflags |= PRACCESS;
1673     }
1674
1675     if (mask & PR_SF_NGROUPS) { /* setting group limit */
1676         if (ngroups < 0)
1677             ABORT_WITH(tt, PRBADARG);
1678         tentry.ngroups = ngroups;
1679         tflags |= PRQUOTA;
1680     }
1681
1682     if (mask & PR_SF_NUSERS) {  /* setting foreign user limit */
1683         if (nusers < 0)
1684             ABORT_WITH(tt, PRBADARG);
1685         tentry.nusers = nusers;
1686         tflags |= PRQUOTA;
1687     }
1688     tentry.flags = tflags;
1689
1690     code = pr_WriteEntry(tt, 0, pos, &tentry);
1691     if (code)
1692         ABORT_WITH(tt, code);
1693
1694     code = ubik_EndTrans(tt);
1695     return code;
1696 }
1697
1698 afs_int32
1699 SPR_ListElements(struct rx_call *call, afs_int32 aid, prlist *alist,
1700                  afs_int32 *over)
1701 {
1702     afs_int32 code;
1703     afs_int32 cid = ANONYMOUSID;
1704
1705     code = listElements(call, aid, alist, over, &cid);
1706     osi_auditU(call, PTS_LstEleEvent, code, AUD_ID, aid, AUD_END);
1707     ViceLog(125, ("PTS_ListElements: code %d cid %d aid %d\n", code, cid, aid));
1708     return code;
1709 }
1710
1711 static afs_int32
1712 listElements(struct rx_call *call, afs_int32 aid, prlist *alist,
1713              afs_int32 *over, afs_int32 *cid)
1714 {
1715     afs_int32 code;
1716     struct ubik_trans *tt;
1717     afs_int32 temp;
1718     struct prentry tentry;
1719
1720     *over = 0;
1721     alist->prlist_len = 0;
1722     alist->prlist_val = NULL;
1723
1724     code = ReadPreamble(&tt);
1725     if (code)
1726         return code;
1727
1728     code = WhoIsThis(call, tt, cid);
1729     if (code)
1730         ABORT_WITH(tt, PRPERM);
1731
1732     temp = FindByID(tt, aid);
1733     if (!temp)
1734         ABORT_WITH(tt, PRNOENT);
1735     code = pr_ReadEntry(tt, 0, temp, &tentry);
1736     if (code)
1737         ABORT_WITH(tt, code);
1738     if (!AccessOK(tt, *cid, &tentry, PRP_MEMBER_MEM, PRP_MEMBER_ANY))
1739         ABORT_WITH(tt, PRPERM);
1740
1741     code = GetList(tt, &tentry, alist, 0);
1742     if (code != PRSUCCESS)
1743         ABORT_WITH(tt, code);
1744
1745     code = ubik_EndTrans(tt);
1746     return code;
1747 }
1748
1749
1750 afs_int32
1751 SPR_ListSuperGroups(struct rx_call *call, afs_int32 aid, prlist *alist,
1752                     afs_int32 *over)
1753 {
1754 #if defined(SUPERGROUPS)
1755     afs_int32 code;
1756     afs_int32 cid = ANONYMOUSID;
1757
1758     code = listSuperGroups(call, aid, alist, over, &cid);
1759     osi_auditU(call, PTS_LstSGrps, code, AUD_ID, aid, AUD_END);
1760     ViceLog(125, ("PTS_ListSuperGroups: code %d cid %d aid %d\n", code, cid, aid));
1761     return code;
1762 #else
1763     return RXGEN_OPCODE;
1764 #endif
1765 }
1766
1767 #if defined(SUPERGROUPS)
1768 static afs_int32
1769 listSuperGroups(struct rx_call *call, afs_int32 aid, prlist *alist,
1770                 afs_int32 *over, afs_int32 *cid)
1771 {
1772     afs_int32 code;
1773     struct ubik_trans *tt;
1774     afs_int32 temp;
1775     struct prentry tentry;
1776
1777     alist->prlist_len = 0;
1778     alist->prlist_val = (afs_int32 *) 0;
1779
1780     code = ReadPreamble(&tt);
1781     if (code)
1782         return code;
1783
1784     code = WhoIsThis(call, tt, cid);
1785     if (code)
1786         ABORT_WITH(tt, PRPERM);
1787     if (!pr_noAuth && restrict_anonymous && *cid == ANONYMOUSID)
1788         ABORT_WITH(tt, PRPERM);
1789
1790     temp = FindByID(tt, aid);
1791     if (!temp)
1792         ABORT_WITH(tt, PRNOENT);
1793     code = pr_ReadEntry(tt, 0, temp, &tentry);
1794     if (code)
1795         ABORT_WITH(tt, code);
1796     if (!AccessOK(tt, *cid, &tentry, PRP_MEMBER_MEM, PRP_MEMBER_ANY))
1797         ABORT_WITH(tt, PRPERM);
1798
1799     code = GetSGList(tt, &tentry, alist);
1800     *over = 0;
1801     if (code == PRTOOMANY)
1802         *over = 1;
1803     else if (code != PRSUCCESS)
1804         ABORT_WITH(tt, code);
1805
1806     code = ubik_EndTrans(tt);
1807
1808     return code;
1809 }
1810
1811 #endif /* SUPERGROUPS */
1812
1813 /*
1814  * SPR_ListOwned
1815  * List the entries owned by this id.  If the id is zero,
1816  * return the orphans list. This will return up to PR_MAXGROUPS
1817  * at a time with the lastP available to get the rest. The
1818  * maximum value is enforced in GetOwnedChain().
1819  */
1820 afs_int32
1821 SPR_ListOwned(struct rx_call *call, afs_int32 aid, prlist *alist,
1822               afs_int32 *lastP)
1823 {
1824     afs_int32 code;
1825     afs_int32 cid = ANONYMOUSID;
1826
1827     code = listOwned(call, aid, alist, lastP, &cid);
1828     osi_auditU(call, PTS_LstOwnEvent, code, AUD_ID, aid, AUD_END);
1829     ViceLog(125, ("PTS_ListOwned: code %d cid %d aid %d\n", code, cid, aid));
1830     return code;
1831 }
1832
1833 afs_int32
1834 listOwned(struct rx_call *call, afs_int32 aid, prlist *alist, afs_int32 *lastP,
1835           afs_int32 *cid)
1836 {
1837     afs_int32 code;
1838     struct ubik_trans *tt;
1839     struct prentry tentry;
1840     afs_int32 head = 0;
1841     afs_int32 start;
1842
1843     alist->prlist_len = 0;
1844     alist->prlist_val = NULL;
1845
1846     if (!lastP)
1847         return PRBADARG;
1848     start = *lastP;
1849     *lastP = 0;
1850
1851     code = ReadPreamble(&tt);
1852     if (code)
1853         return code;
1854
1855     code = WhoIsThis(call, tt, cid);
1856     if (code)
1857         ABORT_WITH(tt, PRPERM);
1858
1859     if (start) {
1860         code = pr_ReadEntry(tt, 0, start, &tentry);
1861         if (!code && (tentry.owner == aid))
1862             head = start;       /* pick up where we left off */
1863     }
1864
1865     if (!head) {
1866         if (aid) {
1867             afs_int32 loc = FindByID(tt, aid);
1868             if (loc == 0)
1869                 ABORT_WITH(tt, PRNOENT);
1870             code = pr_ReadEntry(tt, 0, loc, &tentry);
1871             if (code)
1872                 ABORT_WITH(tt, code);
1873
1874             if (!AccessOK(tt, *cid, &tentry, -1, PRP_OWNED_ANY))
1875                 ABORT_WITH(tt, PRPERM);
1876             head = tentry.owned;
1877         } else {
1878             if (!AccessOK(tt, *cid, 0, 0, 0))
1879                 ABORT_WITH(tt, PRPERM);
1880             head = ntohl(cheader.orphan);
1881         }
1882     }
1883
1884     code = GetOwnedChain(tt, &head, alist);
1885     if (code) {
1886         if (code == PRTOOMANY)
1887             *lastP = head;
1888         else
1889             ABORT_WITH(tt, code);
1890     }
1891
1892     code = ubik_EndTrans(tt);
1893     return code;
1894 }
1895
1896 afs_int32
1897 SPR_IsAMemberOf(struct rx_call *call, afs_int32 uid, afs_int32 gid,
1898                 afs_int32 *flag)
1899 {
1900     afs_int32 code;
1901     afs_int32 cid = ANONYMOUSID;
1902
1903     code = isAMemberOf(call, uid, gid, flag, &cid);
1904     osi_auditU(call, PTS_IsMemOfEvent, code, AUD_LONG, uid, AUD_LONG, gid,
1905                AUD_END);
1906     ViceLog(125, ("PTS_IsAMemberOf: code %d cid %d uid %d gid %d\n", code, cid, uid, gid));
1907     return code;
1908 }
1909
1910 static afs_int32
1911 isAMemberOf(struct rx_call *call, afs_int32 uid, afs_int32 gid, afs_int32 *flag,
1912             afs_int32 *cid)
1913 {
1914     afs_int32 code;
1915     struct ubik_trans *tt;
1916
1917     code = ReadPreamble(&tt);
1918     if (code)
1919         return code;
1920
1921     {
1922         afs_int32 uloc = FindByID(tt, uid);
1923         afs_int32 gloc = FindByID(tt, gid);
1924         struct prentry uentry, gentry;
1925
1926         if (!uloc || !gloc)
1927             ABORT_WITH(tt, PRNOENT);
1928         code = WhoIsThis(call, tt, cid);
1929         if (code)
1930             ABORT_WITH(tt, PRPERM);
1931         code = pr_ReadEntry(tt, 0, uloc, &uentry);
1932         if (code)
1933             ABORT_WITH(tt, code);
1934         code = pr_ReadEntry(tt, 0, gloc, &gentry);
1935         if (code)
1936             ABORT_WITH(tt, code);
1937 #if !defined(SUPERGROUPS)
1938         if ((uentry.flags & PRGRP) || !(gentry.flags & PRGRP))
1939             ABORT_WITH(tt, PRBADARG);
1940 #else
1941         if (!(gentry.flags & PRGRP))
1942             ABORT_WITH(tt, PRBADARG);
1943 #endif
1944         if (!AccessOK(tt, *cid, &uentry, 0, PRP_MEMBER_ANY)
1945             && !AccessOK(tt, *cid, &gentry, PRP_MEMBER_MEM, PRP_MEMBER_ANY))
1946             ABORT_WITH(tt, PRPERM);
1947     }
1948
1949     *flag = IsAMemberOf(tt, uid, gid);
1950     code = ubik_EndTrans(tt);
1951     return code;
1952 }
1953
1954 static afs_int32
1955 addWildCards(struct ubik_trans *tt, prlist *alist, afs_uint32 host)
1956 {
1957     afs_int32 temp;
1958     struct prentry tentry;
1959     prlist wlist;
1960     unsigned wild = htonl(0xffffff00);
1961     struct in_addr iaddr;
1962     afs_int32 hostid;
1963     int size = 0, i, code;
1964     int added = 0;
1965     char hoststr[16];
1966
1967     while ((host = (host & wild))) {
1968         wild = htonl(ntohl(wild) << 8);
1969         iaddr.s_addr = host;
1970         code = NameToID(tt, afs_inet_ntoa_r(iaddr.s_addr, hoststr), &hostid);
1971         if (code == PRSUCCESS && hostid != 0) {
1972             temp = FindByID(tt, hostid);
1973             if (temp) {
1974                 code = pr_ReadEntry(tt, 0, temp, &tentry);
1975                 if (code != PRSUCCESS)
1976                     continue;
1977             } else
1978                 continue;
1979         } else
1980             continue;
1981         wlist.prlist_len = 0;
1982         wlist.prlist_val = NULL;
1983
1984         code = GetList(tt, &tentry, &wlist, 0);
1985         if (code)
1986             return code;
1987         added += wlist.prlist_len;
1988         for (i = 0; i < wlist.prlist_len; i++) {
1989             if (!inCPS(*alist, wlist.prlist_val[i]))
1990                 if ((code = AddToPRList(alist, &size, wlist.prlist_val[i]))) {
1991                     free(wlist.prlist_val);
1992                     return (code);
1993                 }
1994         }
1995         if (wlist.prlist_val)
1996             free(wlist.prlist_val);
1997     }
1998     if (added)
1999         qsort(alist->prlist_val, alist->prlist_len, sizeof(afs_int32), IDCmp);
2000     return 0;
2001 }
2002
2003 static afs_int32
2004 WhoIsThisWithName(struct rx_call *acall, struct ubik_trans *at, afs_int32 *aid,
2005                   char *aname)
2006 {
2007     afs_int32 islocal = 1;
2008     /* aid is set to the identity of the caller, if known, else ANONYMOUSID */
2009     /* returns -1 and sets aid to ANONYMOUSID on any failure */
2010     struct rx_connection *tconn;
2011     afs_int32 code;
2012     char tcell[MAXKTCREALMLEN];
2013     char name[MAXKTCNAMELEN];
2014     char inst[MAXKTCNAMELEN];
2015     int ilen;
2016     char vname[256];
2017
2018     *aid = ANONYMOUSID;
2019     tconn = rx_ConnectionOf(acall);
2020     code = rx_SecurityClassOf(tconn);
2021     if (code == RX_SECIDX_NULL)
2022         return 0;
2023     else if (code == RX_SECIDX_VAB) {
2024         goto done;              /* no longer supported */
2025     } else if (code == RX_SECIDX_KAD) {
2026         if ((code = rxkad_GetServerInfo(rx_ConnectionOf(acall), NULL, NULL,
2027                                         name, inst, tcell, NULL)))
2028             goto done;
2029
2030         if (tcell[0]) {
2031             code = afsconf_IsLocalRealmMatch(prdir, &islocal, name, inst, tcell);
2032             if (code)
2033                 goto done;
2034         }
2035         strncpy(vname, name, sizeof(vname));
2036         if ((ilen = strlen(inst))) {
2037             if (strlen(vname) + 1 + ilen >= sizeof(vname))
2038                 goto done;
2039             strcat(vname, ".");
2040             strcat(vname, inst);
2041         }
2042         if (!islocal) {
2043             if (strlen(vname) + strlen(tcell) + 1  >= sizeof(vname))
2044                 goto done;
2045             strcat(vname, "@");
2046             strcat(vname, tcell);
2047             lcstring(vname, vname, sizeof(vname));
2048             NameToID(at, vname, aid);
2049             if (aname)
2050                 strcpy(aname, vname);
2051             return 2;
2052         }
2053
2054         if (strcmp(AUTH_SUPERUSER, vname) == 0)
2055             *aid = SYSADMINID;  /* special case for the fileserver */
2056         else {
2057             lcstring(vname, vname, sizeof(vname));
2058             code = NameToID(at, vname, aid);
2059         }
2060
2061     } else {
2062         /* If we reached here, we don't understand the security class of the
2063          * given call. But if the calling user is RX_ID_SUPERUSER, we can check
2064          * that without even needing to understand the security class. Remember
2065          * to only check for RX_ID_SUPERUSER specifically; we do not use
2066          * SYSADMINID for other admins. */
2067         int is_super;
2068         struct rx_identity *id = NULL;
2069         is_super = afsconf_SuperIdentity(prdir, acall, &id);
2070         if (is_super && id->kind == RX_ID_SUPERUSER) {
2071             *aid = SYSADMINID;
2072             code = 0;
2073         } else {
2074             code = -1;
2075         }
2076         if (id != NULL) {
2077             rx_identity_free(&id);
2078         }
2079     }
2080   done:
2081     if (code && !pr_noAuth)
2082         return -1;
2083     return 0;
2084 }