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