Remove warnings from supergroups code on x86
[openafs.git] / src / ptserver / ptutils.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  *                      (5) Add functions to process supergroups:
12  *                          ChangeIDEntry(), RemoveFromSGEntry(),
13  *                          AddToSGEntry(), GetListSG2().
14  *                      (6) Add code to existing functions to process
15  *                          supergroups.
16  *      2/1/98 jjm      Add mdw's changes for bit mapping for supergroups
17  *
18  *      09/26/02 kwc    Move depthsg definition here from ptserver.c since
19  *                      pt_util needs it defined also, and this file is
20  *                      common between the two programs.
21  */
22
23 #include <afsconfig.h>
24 #include <afs/param.h>
25
26
27 #include <afs/stds.h>
28 #include <sys/types.h>
29 #include <stdio.h>
30 #ifdef AFS_NT40_ENV
31 #include <winsock2.h>
32 #else
33 #include <netinet/in.h>
34 #endif
35 #include <string.h>
36 #include <lock.h>
37 #include <ubik.h>
38 #include <rx/xdr.h>
39 #include <afs/com_err.h>
40 #include <afs/cellconfig.h>
41 #include "ptserver.h"
42 #include "pterror.h"
43 #include "ptprototypes.h"
44 #include <stdlib.h>
45
46 /* Foreign cells are represented by the group system:authuser@cell*/
47 #define AUTHUSER_GROUP "system:authuser"
48
49 extern int restricted;
50 extern struct ubik_dbase *dbase;
51 extern struct afsconf_dir *prdir;
52 extern int pr_noAuth;
53
54 static int inRange(struct prentry *cellEntry, afs_int32 aid);
55 static afs_int32 allocNextId(struct ubik_trans *, struct prentry *);
56 static int AddAuthGroup(struct prentry *tentry, prlist *alist, afs_int32 *size);
57
58 static char *whoami = "ptserver";
59
60 int prp_user_default = PRP_USER_DEFAULT;
61 int prp_group_default = PRP_GROUP_DEFAULT;
62
63 #if defined(SUPERGROUPS)
64
65 #include "map.h"
66
67 afs_int32 depthsg = 5;          /* Maximum iterations used during IsAMemberOF */
68 afs_int32 GetListSG2(struct ubik_trans *at, afs_int32 gid, prlist * alist,
69                      afs_int32 * sizeP, afs_int32 depth);
70
71 struct map *sg_flagged;
72 struct map *sg_found;
73
74 #define NIL_MAP ((struct map *) 0)
75
76 /* pt_mywrite hooks into the logic that writes ubik records to disk
77  *  at a very low level.  It invalidates mappings in sg_flagged/sg_found.
78  *  By hoooking in at this level, we ensure that a ubik file reload
79  *  invalidates our incore cache.
80  *
81  * We assert records, cheaders and everything else are 0 mod 64.
82  *  So, we can always see the first 64 bytes of any record written.
83  *  The stuff we're interested in (flags, id) are in the first 8 bytes.
84  *  so we can always tell if we're writing a group record.
85  */
86
87 int (*pt_save_dbase_write)(struct ubik_dbase *, afs_int32, void *, afs_int32,
88                            afs_int32);
89
90 int
91 pt_mywrite(struct ubik_dbase *tdb, afs_int32 fno, void *bp, afs_int32 pos, afs_int32 count)
92 {
93     afs_uint32 headersize = ntohl(cheader.headerSize);
94
95     if (fno == 0 && pos + count > headersize) {
96         afs_int32 p, l, c, o;
97         char *cp;
98         p = pos - headersize;
99         cp = bp;
100         l = count;
101         if (p < 0) {
102             l += p;
103             p = 0;
104         }
105         while (l > 0) {
106             o = p % ENTRYSIZE;
107             c = ENTRYSIZE - o;
108             if (c > l)
109                 c = l;
110 #define xPT(p,x) ((((struct prentry *)(p))->flags & htonl(PRTYPE)) == htonl(x))
111 #if DEBUG_SG_MAP
112             if (o)
113                 fprintf(stderr, "Writing %d bytes of entry @ %#lx(+%d)\n", c,
114                         p - o, o);
115             else if (c == ENTRYSIZE)
116                 fprintf(stderr,
117                         "Writing %d bytes of entry @ %#lx (%d<%s>,%d)\n",
118                         c, p, ntohl(((struct prentry *)cp)->flags),
119                         xPT(cp,PRUSER) ? "user" : xPT(cp,PRFREE) ? "free" :
120                         xPT(cp,PRGRP) ? "group" : xPT(cp,PRCONT) ? "cont" :
121                         xPT(cp,PRCELL) ? "cell" : xPT(cp,PRFOREIGN) ? "foreign" :
122                         xPT(cp,PRINST) ? "sub/super instance" : "?",
123                         ntohl(((struct prentry *)cp)->id));
124             else if (c >= 8)
125                 fprintf(stderr,
126                         "Writing first %d bytes of entry @ %#lx (%d<%s>,%d)\n",
127                         c, p, ntohl(((struct prentry *)cp)->flags),
128                         xPT(cp,PRUSER) ? "user" : xPT(cp,PRFREE) ? "free" :
129                         xPT(cp,PRGRP) ? "group" : xPT(cp,PRCONT) ? "cont" :
130                         xPT(cp,PRCELL) ? "cell" : xPT(cp,PRFOREIGN) ? "foreign" :
131                         xPT(cp,PRINST) ? "sub/super instance" : "?",
132                         ntohl(((struct prentry *)cp)->id));
133             else
134                 fprintf(stderr, "Writing %d bytes of entry @ %#lx\n", c, p);
135 #endif
136             if (!o && c >= 8 && xPT(cp,PRGRP)) {
137 #if DEBUG_SG_MAP
138                 if (in_map(sg_found, -ntohl(((struct prentry *)cp)->id)))
139                     fprintf(stderr, "Unfound: Removing group %d\n",
140                             ntohl(((struct prentry *)cp)->id));
141                 if (in_map(sg_flagged, -ntohl(((struct prentry *)cp)->id)))
142                     fprintf(stderr, "Unflag: Removing group %d\n",
143                             ntohl(((struct prentry *)cp)->id));
144 #endif
145                 sg_found =
146                     bic_map(sg_found,
147                         add_map(NIL_MAP, -ntohl(((struct prentry *)cp)->id)));
148                 sg_flagged =
149                     bic_map(sg_flagged,
150                         add_map(NIL_MAP, -ntohl(((struct prentry *)cp)->id)));
151             }
152             cp += c;
153             p += c;
154             l -= c;
155 #undef xPT
156         }
157     }
158     return (*pt_save_dbase_write) (tdb, fno, bp, pos, count);
159 }
160
161 /*
162  * this function attaches pt_mywrite.  It's called once,
163  *  just after ubik_ServerInit.
164  */
165
166 void 
167 pt_hook_write(void)
168 {
169     extern struct ubik_dbase *ubik_dbase;
170     if (ubik_dbase->write != pt_mywrite) {
171         pt_save_dbase_write = ubik_dbase->write;
172         ubik_dbase->write = pt_mywrite;
173     }
174 }
175
176 #endif /* SUPERGROUPS */
177
178 /* CorrectUserName - Check to make sure a user name is OK.  It must not include
179  *   either a colon (or it would look like a group) or an atsign (or it would
180  *   look like a foreign user).  The length is checked as well to make sure
181  *   that the user name, an atsign, and the local cell name will fit in
182  *   PR_MAXNAMELEN.  This is so this user can fit in another cells database as
183  *   a foreign user with our cell name tacked on.  This is a predicate, so it
184  *   return one if name is OK and zero if name is bogus. */
185
186 static int
187 CorrectUserName(char *name)
188 {
189     extern int pr_realmNameLen;
190
191     /* We accept foreign names, so we will deal with '@' later */
192     if (strchr(name, ':') || strchr(name, '\n'))
193         return 0;
194     if (strlen(name) >= PR_MAXNAMELEN - pr_realmNameLen - 1)
195         return 0;
196     return 1;
197 }
198
199 /* CorrectGroupName - Like the above but handles more complicated cases caused
200  * by including the ownership in the name.  The interface works by calculating
201  * the correct name based on a given name and owner.  This allows easy use by
202  * rename, which then compares the correct name with the requested new name. */
203
204 static afs_int32
205 CorrectGroupName(struct ubik_trans *ut, char aname[PR_MAXNAMELEN],      /* name for group */
206                  afs_int32 cid,         /* caller id */
207                  afs_int32 oid,         /* owner of group */
208                  char cname[PR_MAXNAMELEN])     /* correct name for group */
209 {
210     afs_int32 code;
211     int admin;
212     char *prefix;               /* ptr to group owner part */
213     char *suffix;               /* ptr to group name part */
214     char name[PR_MAXNAMELEN];   /* correct name for group */
215     struct prentry tentry;
216
217     if (strlen(aname) >= PR_MAXNAMELEN)
218         return PRBADNAM;
219     admin = pr_noAuth || IsAMemberOf(ut, cid, SYSADMINID);
220
221     if (oid == 0)
222         oid = cid;
223
224     /* Determine the correct prefix for the name. */
225     if (oid == SYSADMINID)
226         prefix = "system";
227     else {
228         afs_int32 loc = FindByID(ut, oid);
229         if (loc == 0) {
230             /* let admin create groups owned by non-existent ids (probably
231              * setting a group to own itself).  Check that they look like
232              * groups (with a colon) or otherwise are good user names. */
233             if (admin) {
234                 strcpy(cname, aname);
235                 goto done;
236             }
237             return PRNOENT;
238         }
239         code = pr_Read(ut, 0, loc, &tentry, sizeof(tentry));
240         if (code)
241             return code;
242         if (ntohl(tentry.flags) & PRGRP) {
243             if ((tentry.count == 0) && !admin)
244                 return PRGROUPEMPTY;
245             /* terminate prefix at colon if there is one */
246             if ((prefix = strchr(tentry.name, ':')))
247                 *prefix = 0;
248         }
249         prefix = tentry.name;
250     }
251     /* only sysadmin allow to use 'system:' prefix */
252     if ((strcmp(prefix, "system") == 0) && !admin)
253         return PRPERM;
254
255     strcpy(name, aname);        /* in case aname & cname are same */
256     suffix = strchr(name, ':');
257     if (suffix == 0) {
258         /* sysadmin can make groups w/o ':', but they must still look like
259          * legal user names. */
260         if (!admin)
261             return PRBADNAM;
262         strcpy(cname, name);
263     } else {
264         if (strlen(prefix) + strlen(suffix) >= PR_MAXNAMELEN)
265             return PRBADNAM;
266         strcpy(cname, prefix);
267         strcat(cname, suffix);
268     }
269   done:
270     /* check for legal name with either group rules or user rules */
271     if ((suffix = strchr(cname, ':'))) {
272         /* check for confusing characters */
273         if (strchr(cname, '\n') ||      /* restrict so recreate can work */
274             strchr(suffix + 1, ':'))    /* avoid multiple colons */
275             return PRBADNAM;
276     } else {
277         if (!CorrectUserName(cname))
278             return PRBADNAM;
279     }
280     return 0;
281 }
282
283 int
284 AccessOK(struct ubik_trans *ut, afs_int32 cid,          /* caller id */
285          struct prentry *tentry,        /* object being accessed */
286          int mem,                       /* check membership in aid, if group */
287          int any)                       /* if set return true */
288 {
289     afs_int32 flags;
290     afs_int32 oid;
291     afs_int32 aid;
292
293     if (pr_noAuth)
294         return 1;
295     if (cid == SYSADMINID)
296         return 1;               /* special case fileserver */
297     if (restricted && ((mem == PRP_ADD_MEM) || (mem == PRP_REMOVE_MEM)) && (any == 0))
298         return 0;
299     if (tentry) {
300         flags = tentry->flags;
301         oid = tentry->owner;
302         aid = tentry->id;
303     } else {
304         flags = oid = aid = 0;
305     }
306     if (!(flags & PRACCESS)) {  /* provide default access */
307         if (flags & PRGRP)
308             flags |= prp_group_default;
309         else
310             flags |= prp_user_default;
311     }
312
313     if (flags & any)
314         return 1;
315     if (oid) {
316         if ((cid == oid) || IsAMemberOf(ut, cid, oid))
317             return 1;
318     }
319     if (aid > 0) {              /* checking on a user */
320         if (aid == cid)
321             return 1;
322     } else if (aid < 0) {       /* checking on group */
323         if ((flags & mem) && IsAMemberOf(ut, cid, aid))
324             return 1;
325     }
326     /* Allow members of SYSVIEWERID to get membership and status only */
327     if (((mem == PRP_STATUS_MEM) || (mem == PRP_MEMBER_MEM)
328          || (any == PRP_OWNED_ANY)) && (IsAMemberOf(ut, cid, SYSVIEWERID)))
329         return 1;
330     if (IsAMemberOf(ut, cid, SYSADMINID))
331         return 1;
332     return 0;                   /* no access */
333 }
334
335 afs_int32
336 CreateEntry(struct ubik_trans *at, char aname[PR_MAXNAMELEN], afs_int32 *aid, afs_int32 idflag, afs_int32 flag, afs_int32 oid, afs_int32 creator)
337 {
338     /* get and init a new entry */
339     afs_int32 code;
340     afs_int32 newEntry;
341     struct prentry tentry, tent;
342     char *atsign;
343
344     memset(&tentry, 0, sizeof(tentry));
345
346     if ((oid == 0) || (oid == ANONYMOUSID))
347         oid = creator;
348
349     if (flag & PRGRP) {
350         code = CorrectGroupName(at, aname, creator, oid, tentry.name);
351         if (code)
352             return code;
353         if (strcmp(aname, tentry.name) != 0)
354             return PRBADNAM;
355     } else {                    /* non-group must not have colon */
356         if (!CorrectUserName(aname))
357             return PRBADNAM;
358         strcpy(tentry.name, aname);
359     }
360
361     if (FindByName(at, aname, &tent))
362         return PREXIST;
363
364     newEntry = AllocBlock(at);
365     if (!newEntry)
366         return PRDBFAIL;
367 #ifdef PR_REMEMBER_TIMES
368     tentry.createTime = time(0);
369 #endif
370
371     if (flag & PRGRP) {
372         tentry.flags = PRGRP;
373         tentry.owner = oid;
374     } else if (flag == 0) {
375         tentry.flags = 0;
376         tentry.owner = SYSADMINID;
377     } else {
378         return PRBADARG;
379     }
380
381     atsign = strchr(aname, '@');
382     if (!atsign) {
383         /* A normal user or group. Pick an id for it */
384         if (idflag)
385             tentry.id = *aid;
386         else {
387             code = AllocID(at, flag, &tentry.id);
388             if (code != PRSUCCESS)
389                 return code;
390         }
391     } else if (flag & PRGRP) {
392         /* A foreign group. Its format must be AUTHUSER_GROUP@cellname
393          * Then pick an id for the group.
394          */
395         int badFormat;
396
397         *atsign = '\0';
398         badFormat = strcmp(AUTHUSER_GROUP, aname);
399         *atsign = '@';
400         if (badFormat)
401             return PRBADNAM;
402
403         if (idflag)
404             tentry.id = *aid;
405         else {
406             code = AllocID(at, flag, &tentry.id);
407             if (code != PRSUCCESS)
408                 return code;
409         }
410     } else {
411         /* A foreign user: <name>@<cell>. The foreign user is added to
412          * its representing group. It is 
413          */
414         char *cellGroup;
415         afs_int32 pos, n;
416         struct prentry centry;
417
418         /* To create the user <name>@<cell> the group AUTHUSER_GROUP@<cell>
419          * must exist.
420          */
421         cellGroup =
422             (char *)malloc(strlen(AUTHUSER_GROUP) + strlen(atsign) + 1);
423         strcpy(cellGroup, AUTHUSER_GROUP);
424         strcat(cellGroup, atsign);
425         pos = FindByName(at, cellGroup, &centry);
426         free(cellGroup);
427         if (!pos)
428             return PRBADNAM;
429         code = pr_Read(at, 0, pos, &centry, sizeof(centry));
430         if (code)
431             return code;
432
433         /* cellid is the id of the group representing the cell */
434         tentry.cellid = ntohl(centry.id);
435
436         if (idflag) {
437             /* Check if id is good */
438             if (!inRange(&centry, *aid))
439                 return PRBADARG;
440             tentry.id = *aid;
441         } else {
442             /* Allocate an ID special for this foreign user. It is based 
443              * on the representing group's id and nusers count.
444              */
445             tentry.id = allocNextId(at, &centry);
446             if (!tentry.id)
447                 return PRNOIDS;
448         }
449
450         /* The foreign user will be added to the representing foreign
451          * group. The group can hold up to 30 entries.
452          */
453         if (!(ntohl(centry.flags) & PRQUOTA)) {
454             centry.flags = htonl(ntohl(centry.flags) | PRQUOTA);
455             centry.ngroups = htonl(30);
456         }
457         n = ntohl(centry.ngroups);
458         if ((n <= 0) && !pr_noAuth)
459             return PRNOMORE;
460         centry.ngroups = htonl(n - 1);
461
462         /* write updated entry for group */
463         code = pr_Write(at, 0, pos, &centry, sizeof(centry));
464
465         /* Now add the new user entry to the database */
466         tentry.creator = creator;
467         *aid = tentry.id;
468         code = pr_WriteEntry(at, 0, newEntry, &tentry);
469         if (code)
470             return PRDBFAIL;
471         code = AddToIDHash(at, *aid, newEntry);
472         if (code != PRSUCCESS)
473             return code;
474         code = AddToNameHash(at, aname, newEntry);
475         if (code != PRSUCCESS)
476             return code;
477         if (inc_header_word(at, foreigncount, 1))
478             return PRDBFAIL;
479
480         /* Now add the entry to the authuser group for this cell.
481          * We will reread the entries for the user and the group
482          * instead of modifying them before writing them in the
483          * previous steps. Although not very efficient, much simpler
484          */
485         pos = FindByID(at, tentry.cellid);
486         if (!pos)
487             return PRBADNAM;
488         code = pr_ReadEntry(at, 0, pos, &centry);
489         if (code)
490             return code;
491         code = AddToEntry(at, &centry, pos, *aid);
492         if (code)
493             return code;
494         /* and now the user entry */
495         pos = FindByID(at, *aid);
496         if (!pos)
497             return PRBADNAM;
498         code = pr_ReadEntry(at, 0, pos, &tentry);
499         if (code)
500             return code;
501         code = AddToEntry(at, &tentry, pos, tentry.cellid);
502         if (code)
503             return code;
504
505         return PRSUCCESS;
506     }
507
508     /* Remember the largest group id or largest user id */
509     if (flag & PRGRP) {
510         /* group ids are negative */
511         if (tentry.id < (afs_int32) ntohl(cheader.maxGroup)) {
512             code = set_header_word(at, maxGroup, htonl(tentry.id));
513             if (code)
514                 return PRDBFAIL;
515         }
516     } else {
517         if (tentry.id > (afs_int32) ntohl(cheader.maxID)) {
518             code = set_header_word(at, maxID, htonl(tentry.id));
519             if (code)
520                 return PRDBFAIL;
521         }
522     }
523
524     /* Charge the creator for this group */
525     if (flag & PRGRP) {
526         afs_int32 loc = FindByID(at, creator);
527         struct prentry centry;
528         int admin;
529
530         if (loc) {              /* this should only fail during initialization */
531             code = pr_Read(at, 0, loc, &centry, sizeof(centry));
532             if (code)
533                 return code;
534
535             /* If quota is uninitialized, do it */
536             if (!(ntohl(centry.flags) & PRQUOTA)) {
537                 centry.flags = htonl(ntohl(centry.flags) | PRQUOTA);
538                 centry.ngroups = centry.nusers = htonl(20);
539             }
540
541             /* Admins don't get charged for creating a group.
542              * If in noAuth mode, you get changed for it but you 
543              * are still allowed to create as many groups as you want.
544              */
545             admin = ((creator == SYSADMINID)
546                      || IsAMemberOf(at, creator, SYSADMINID));
547             if (!admin) {
548                 if (ntohl(centry.ngroups) <= 0) {
549                     if (!pr_noAuth)
550                         return PRNOMORE;
551                 } else {
552                     centry.ngroups = htonl(ntohl(centry.ngroups) - 1);
553                 }
554             }
555
556             code = pr_Write(at, 0, loc, &centry, sizeof(centry));
557             if (code)
558                 return code;
559         }                       /* if (loc) */
560     } else {
561         /* Initialize the quota for the user. Groups don't have their
562          * quota initialized.
563          */
564         tentry.flags |= PRQUOTA;
565         tentry.ngroups = tentry.nusers = 20;
566     }
567
568     tentry.creator = creator;
569     *aid = tentry.id;
570     code = pr_WriteEntry(at, 0, newEntry, &tentry);
571     if (code)
572         return PRDBFAIL;
573     code = AddToIDHash(at, *aid, newEntry);
574     if (code != PRSUCCESS)
575         return code;
576     code = AddToNameHash(at, aname, newEntry);
577     if (code != PRSUCCESS)
578         return code;
579     if (tentry.flags & PRGRP) {
580         code = AddToOwnerChain(at, tentry.id, oid);
581         if (code)
582             return code;
583     }
584     if (tentry.flags & PRGRP) {
585         if (inc_header_word(at, groupcount, 1))
586             return PRDBFAIL;
587     } else if (tentry.flags & PRINST) {
588         if (inc_header_word(at, instcount, 1))
589             return PRDBFAIL;
590     } else {
591         if (inc_header_word(at, usercount, 1))
592             return PRDBFAIL;
593     }
594     return PRSUCCESS;
595 }
596
597
598 /* RemoveFromEntry - remove aid from bid's entries list, freeing a continuation
599  * entry if appropriate */
600
601 afs_int32
602 RemoveFromEntry(struct ubik_trans *at, afs_int32 aid, afs_int32 bid)
603 {
604     afs_int32 code;
605     struct prentry tentry;
606     struct contentry centry;
607     struct contentry hentry;
608     afs_int32 temp;
609     afs_int32 i, j;
610     afs_int32 nptr;
611     afs_int32 hloc;
612
613     if (aid == bid)
614         return PRINCONSISTENT;
615     memset(&hentry, 0, sizeof(hentry));
616     temp = FindByID(at, bid);
617     if (temp == 0)
618         return PRNOENT;
619     code = pr_ReadEntry(at, 0, temp, &tentry);
620     if (code != 0)
621         return code;
622 #ifdef PR_REMEMBER_TIMES
623     tentry.removeTime = time(0);
624 #endif
625     for (i = 0; i < PRSIZE; i++) {
626         if (tentry.entries[i] == aid) {
627             tentry.entries[i] = PRBADID;
628             tentry.count--;
629             code = pr_WriteEntry(at, 0, temp, &tentry);
630             if (code != 0)
631                 return code;
632             return PRSUCCESS;
633         }
634         if (tentry.entries[i] == 0)     /* found end of list */
635             return PRNOENT;
636     }
637     hloc = 0;
638     nptr = tentry.next;
639     while (nptr != 0) {
640         code = pr_ReadCoEntry(at, 0, nptr, &centry);
641         if (code != 0)
642             return code;
643         if ((centry.id != bid) || !(centry.flags & PRCONT))
644             return PRDBBAD;
645         for (i = 0; i < COSIZE; i++) {
646             if (centry.entries[i] == aid) {
647                 centry.entries[i] = PRBADID;
648                 for (j = 0; j < COSIZE; j++)
649                     if (centry.entries[j] != PRBADID
650                         && centry.entries[j] != 0)
651                         break;
652                 if (j == COSIZE) {      /* can free this block */
653                     if (hloc == 0) {
654                         tentry.next = centry.next;
655                     } else {
656                         hentry.next = centry.next;
657                         code = pr_WriteCoEntry(at, 0, hloc, &hentry);
658                         if (code != 0)
659                             return code;
660                     }
661                     code = FreeBlock(at, nptr);
662                     if (code)
663                         return code;
664                 } else {        /* can't free it yet */
665                     code = pr_WriteCoEntry(at, 0, nptr, &centry);
666                     if (code != 0)
667                         return code;
668                 }
669                 tentry.count--;
670                 code = pr_WriteEntry(at, 0, temp, &tentry);
671                 if (code)
672                     return PRDBFAIL;
673                 return 0;
674             }
675             if (centry.entries[i] == 0)
676                 return PRNOENT;
677         }                       /* for all coentry slots */
678         hloc = nptr;
679         nptr = centry.next;
680         memcpy(&hentry, &centry, sizeof(centry));
681     }                           /* while there are coentries */
682     return PRNOENT;
683 }
684
685 #if defined(SUPERGROUPS)
686 /* ChangeIDEntry - remove aid from bid's entries list, freeing a continuation
687  * entry if appropriate */
688
689 afs_int32
690 ChangeIDEntry(register struct ubik_trans *at, register afs_int32 aid, afs_int32 newid, register afs_int32 bid)
691 {
692     register afs_int32 code;
693     struct prentry tentry;
694     struct contentry centry;
695     afs_int32 temp;
696     afs_int32 i, j;
697     afs_int32 nptr;
698
699     if (aid == bid)
700         return PRINCONSISTENT;
701     temp = FindByID(at, bid);
702     if (temp == 0) {
703         return PRNOENT;
704     }
705     code = pr_ReadEntry(at, 0, temp, &tentry);
706     if (code != 0)
707         return code;
708     for (i = 0; i < PRSIZE; i++) {
709         if (tentry.entries[i] == aid) {
710             tentry.entries[i] = newid;
711             code = pr_WriteEntry(at, 0, temp, &tentry);
712             if (code != 0)
713                 return code;
714             return PRSUCCESS;
715         }
716         if (tentry.entries[i] == 0) {   /* found end of list */
717             return PRNOENT;
718         }
719     }
720
721     nptr = tentry.next;
722     while (nptr) {
723         code = pr_ReadCoEntry(at, 0, nptr, &centry);
724         if (code != 0)
725             return code;
726         if ((centry.id != bid) || !(centry.flags & PRCONT)) {
727             fprintf(stderr,
728                     "ChangeIDEntry: bad database bid=%d centry.id=%d .flags=%d\n",
729                     bid, centry.id, centry.flags);
730             return PRDBBAD;
731         }
732         for (i = 0; i < COSIZE; i++) {
733             if (centry.entries[i] == aid) {
734                 centry.entries[i] = newid;
735                 for (j = 0; j < COSIZE; j++)
736                     if (centry.entries[j] != PRBADID
737                         && centry.entries[j] != 0)
738                         break;
739                 code = pr_WriteCoEntry(at, 0, nptr, &centry);
740                 if (code != 0)
741                     return code;
742                 return 0;
743             }
744             if (centry.entries[i] == 0) {
745                 return PRNOENT;
746             }
747         }                       /* for all coentry slots */
748         nptr = centry.next;
749     }                           /* while there are coentries */
750     return PRNOENT;
751 }
752
753 /*  #ifdef SUPERGROUPS */
754 /* RemoveFromSGEntry - remove aid from bid's supergroups list, freeing a
755  * continuation entry if appropriate */
756
757 afs_int32
758 RemoveFromSGEntry(register struct ubik_trans *at, register afs_int32 aid, register afs_int32 bid)
759 {
760     register afs_int32 code;
761     struct prentry tentry;
762     struct prentryg *tentryg;
763     struct contentry centry;
764     struct contentry hentry;
765     afs_int32 temp;
766     afs_int32 i, j;
767     afs_int32 nptr;
768     afs_int32 hloc;
769
770     if (aid == bid)
771         return PRINCONSISTENT;
772     memset(&hentry, 0, sizeof(hentry));
773     temp = FindByID(at, bid);
774     if (temp == 0) {
775         return PRNOENT;
776     }
777     code = pr_ReadEntry(at, 0, temp, &tentry);
778     if (code != 0)
779         return code;
780 #ifdef PR_REMEMBER_TIMES
781     tentry.removeTime = time(NULL);
782 #endif
783     tentryg = (struct prentryg *)&tentry;
784     for (i = 0; i < SGSIZE; i++) {
785         if (tentryg->supergroup[i] == aid) {
786             tentryg->supergroup[i] = PRBADID;
787             tentryg->countsg--;
788             code = pr_WriteEntry(at, 0, temp, &tentry);
789             if (code != 0)
790                 return code;
791             return PRSUCCESS;
792         }
793         if (tentryg->supergroup[i] == 0) {      /* found end of list */
794             return PRNOENT;
795         }
796     }
797     hloc = 0;
798     nptr = tentryg->nextsg;
799     while (nptr) {
800         code = pr_ReadCoEntry(at, 0, nptr, &centry);
801         if (code != 0)
802             return code;
803         if ((centry.id != bid) || !(centry.flags & PRCONT)) {
804             fprintf(stderr,
805                     "ChangeIDEntry: bad database bid=%d centry.id=%d .flags=%d\n",
806                     bid, centry.id, centry.flags);
807             return PRDBBAD;
808         }
809         for (i = 0; i < COSIZE; i++) {
810             if (centry.entries[i] == aid) {
811                 centry.entries[i] = PRBADID;
812                 for (j = 0; j < COSIZE; j++)
813                     if (centry.entries[j] != PRBADID
814                         && centry.entries[j] != 0)
815                         break;
816                 if (j == COSIZE) {      /* can free this block */
817                     if (hloc == 0) {
818                         tentryg->nextsg = centry.next;
819                     } else {
820                         hentry.next = centry.next;
821                         code = pr_WriteCoEntry(at, 0, hloc, &hentry);
822                         if (code != 0)
823                             return code;
824                     }
825                     code = FreeBlock(at, nptr);
826                     if (code)
827                         return code;
828                 } else {        /* can't free it yet */
829                     code = pr_WriteCoEntry(at, 0, nptr, &centry);
830                     if (code != 0)
831                         return code;
832                 }
833                 tentryg->countsg--;
834                 code = pr_WriteEntry(at, 0, temp, &tentry);
835                 if (code)
836                     return PRDBFAIL;
837                 return 0;
838             }
839             if (centry.entries[i] == 0) {
840                 return PRNOENT;
841             }
842         }                       /* for all coentry slots */
843         hloc = nptr;
844         nptr = centry.next;
845         memcpy((char *)&centry, (char *)&hentry, sizeof(centry));
846     }                           /* while there are coentries */
847     return PRNOENT;
848 }
849
850 #endif /* SUPERGROUPS */
851
852 /* DeleteEntry - delete the entry in tentry at loc, removing it from all
853  * groups, putting groups owned by it on orphan chain, and freeing the space */
854
855 afs_int32
856 DeleteEntry(struct ubik_trans *at, struct prentry *tentry, afs_int32 loc)
857 {
858     afs_int32 code;
859     struct contentry centry;
860     afs_int32 i;
861     afs_int32 nptr;
862
863     if (strchr(tentry->name, '@')) {
864         if (tentry->flags & PRGRP) {
865             /* If there are still foreign user accounts from that cell
866              * don't delete the group */
867             if (tentry->count)
868                 return PRBADARG;
869         } else {
870             /* adjust quota */
871
872             afs_int32 loc = FindByID(at, tentry->cellid);
873             struct prentry centry;
874             if (loc) {
875                 code = pr_Read(at, 0, loc, &centry, sizeof(centry));
876                 if (code)
877                     return code;
878                 if (ntohl(centry.flags) & PRQUOTA) {
879                     centry.ngroups = htonl(ntohl(centry.ngroups) + 1);
880                 }
881                 code = pr_Write(at, 0, loc, &centry, sizeof(centry));
882                 if (code)
883                     return code;
884             }
885         }
886     }
887     /* First remove the entire membership list */
888     for (i = 0; i < PRSIZE; i++) {
889         if (tentry->entries[i] == PRBADID)
890             continue;
891         if (tentry->entries[i] == 0)
892             break;
893 #if defined(SUPERGROUPS)
894         if ((tentry->flags & PRGRP) && tentry->entries[i] < 0)  /* Supergroup */
895             code = RemoveFromSGEntry(at, tentry->id, tentry->entries[i]);
896         else
897 #endif
898             code = RemoveFromEntry(at, tentry->id, tentry->entries[i]);
899         if (code)
900             return code;
901     }
902 #if defined(SUPERGROUPS)
903     {
904         struct prentryg *tentryg = (struct prentryg *)tentry;
905
906         /* Then remove the entire supergroup list */
907         for (i = 0; i < SGSIZE; i++) {
908             if (tentryg->supergroup[i] == PRBADID)
909                 continue;
910             if (tentryg->supergroup[i] == 0)
911                 break;
912             code = RemoveFromEntry(at, tentry->id, tentryg->supergroup[i]);
913             if (code)
914                 return code;
915         }
916     }
917 #endif /* SUPERGROUPS */
918     nptr = tentry->next;
919     while (nptr != 0) {
920         code = pr_ReadCoEntry(at, 0, nptr, &centry);
921         if (code != 0)
922             return PRDBFAIL;
923         for (i = 0; i < COSIZE; i++) {
924             if (centry.entries[i] == PRBADID)
925                 continue;
926             if (centry.entries[i] == 0)
927                 break;
928             code = RemoveFromEntry(at, tentry->id, centry.entries[i]);
929             if (code)
930                 return code;
931         }
932         code = FreeBlock(at, nptr);     /* free continuation block */
933         if (code)
934             return code;
935         nptr = centry.next;
936     }
937
938     /* Remove us from other's owned chain.  Note that this will zero our owned
939      * field (on disk) so this step must follow the above step in case we are
940      * on our own owned list. */
941     if (tentry->flags & PRGRP) {
942         if (tentry->owner) {
943             code = RemoveFromOwnerChain(at, tentry->id, tentry->owner);
944             if (code)
945                 return code;
946         } else {
947             code = RemoveFromOrphan(at, tentry->id);
948             if (code)
949                 return code;
950         }
951     }
952
953     code = RemoveFromIDHash(at, tentry->id, &loc);
954     if (code != PRSUCCESS)
955         return code;
956     code = RemoveFromNameHash(at, tentry->name, &loc);
957     if (code != PRSUCCESS)
958         return code;
959
960     if (tentry->flags & PRGRP) {
961         afs_int32 loc = FindByID(at, tentry->creator);
962         struct prentry centry;
963         int admin;
964
965         if (loc) {
966             code = pr_Read(at, 0, loc, &centry, sizeof(centry));
967             if (code)
968                 return code;
969             admin = ((tentry->creator == SYSADMINID)
970                      || IsAMemberOf(at, tentry->creator, SYSADMINID));
971             if (ntohl(centry.flags) & PRQUOTA) {
972                 if (!(admin && (ntohl(centry.ngroups) >= 20))) {
973                     centry.ngroups = htonl(ntohl(centry.ngroups) + 1);
974                 }
975             }
976             code = pr_Write(at, 0, loc, &centry, sizeof(centry));
977             if (code)
978                 return code;
979         }
980     }
981
982     if (tentry->flags & PRGRP) {
983         if (inc_header_word(at, groupcount, -1))
984             return PRDBFAIL;
985     } else if (tentry->flags & PRINST) {
986         if (inc_header_word(at, instcount, -1))
987             return PRDBFAIL;
988     } else {
989         if (strchr(tentry->name, '@')) {
990             if (inc_header_word(at, foreigncount, -1))
991                 return PRDBFAIL;
992         } else {
993             if (inc_header_word(at, usercount, -1))
994                 return PRDBFAIL;
995         }
996     }
997     code = FreeBlock(at, loc);
998     return code;
999 }
1000
1001 /* AddToEntry - add aid to entry's entries list, alloc'ing a continuation block
1002  * if needed.
1003  *
1004  * Note the entry is written out by this routine. */
1005
1006 afs_int32
1007 AddToEntry(struct ubik_trans *tt, struct prentry *entry, afs_int32 loc, afs_int32 aid)
1008 {
1009     afs_int32 code;
1010     afs_int32 i;
1011     struct contentry nentry;
1012     struct contentry aentry;
1013     afs_int32 nptr;
1014     afs_int32 last;             /* addr of last cont. block */
1015     afs_int32 first = 0;
1016     afs_int32 cloc = 0;
1017     afs_int32 slot = -1;
1018
1019     if (entry->id == aid)
1020         return PRINCONSISTENT;
1021 #ifdef PR_REMEMBER_TIMES
1022     entry->addTime = time(0);
1023 #endif
1024     for (i = 0; i < PRSIZE; i++) {
1025         if (entry->entries[i] == aid)
1026             return PRIDEXIST;
1027         if (entry->entries[i] == PRBADID) {     /* remember this spot */
1028             first = 1;
1029             slot = i;
1030         } else if (entry->entries[i] == 0) {    /* end of the line */
1031             if (slot == -1) {
1032                 first = 1;
1033                 slot = i;
1034             }
1035             break;
1036         }
1037     }
1038     last = 0;
1039     nptr = entry->next;
1040     while (nptr != 0) {
1041         code = pr_ReadCoEntry(tt, 0, nptr, &nentry);
1042         if (code != 0)
1043             return code;
1044         last = nptr;
1045         if (!(nentry.flags & PRCONT))
1046             return PRDBFAIL;
1047         for (i = 0; i < COSIZE; i++) {
1048             if (nentry.entries[i] == aid)
1049                 return PRIDEXIST;
1050             if (nentry.entries[i] == PRBADID) {
1051                 if (slot == -1) {
1052                     slot = i;
1053                     cloc = nptr;
1054                 }
1055             } else if (nentry.entries[i] == 0) {
1056                 if (slot == -1) {
1057                     slot = i;
1058                     cloc = nptr;
1059                 }
1060                 break;
1061             }
1062         }
1063         nptr = nentry.next;
1064     }
1065     if (slot != -1) {           /* we found a place */
1066         entry->count++;
1067         if (first) {            /* place is in first block */
1068             entry->entries[slot] = aid;
1069             code = pr_WriteEntry(tt, 0, loc, entry);
1070             if (code != 0)
1071                 return code;
1072             return PRSUCCESS;
1073         }
1074         code = pr_WriteEntry(tt, 0, loc, entry);
1075         if (code)
1076             return code;
1077         code = pr_ReadCoEntry(tt, 0, cloc, &aentry);
1078         if (code != 0)
1079             return code;
1080         aentry.entries[slot] = aid;
1081         code = pr_WriteCoEntry(tt, 0, cloc, &aentry);
1082         if (code != 0)
1083             return code;
1084         return PRSUCCESS;
1085     }
1086     /* have to allocate a continuation block if we got here */
1087     nptr = AllocBlock(tt);
1088     if (last) {
1089         /* then we should tack new block after last block in cont. chain */
1090         nentry.next = nptr;
1091         code = pr_WriteCoEntry(tt, 0, last, &nentry);
1092         if (code != 0)
1093             return code;
1094     } else {
1095         entry->next = nptr;
1096     }
1097     memset(&aentry, 0, sizeof(aentry));
1098     aentry.flags |= PRCONT;
1099     aentry.id = entry->id;
1100     aentry.next = 0;
1101     aentry.entries[0] = aid;
1102     code = pr_WriteCoEntry(tt, 0, nptr, &aentry);
1103     if (code != 0)
1104         return code;
1105     /* don't forget to update count, here! */
1106     entry->count++;
1107     code = pr_WriteEntry(tt, 0, loc, entry);
1108     return code;
1109
1110 }
1111
1112 #if defined(SUPERGROUPS)
1113
1114 /* AddToSGEntry - add aid to entry's supergroup list, alloc'ing a
1115  * continuation block if needed.
1116  *
1117  * Note the entry is written out by this routine. */
1118
1119 afs_int32
1120 AddToSGEntry(struct ubik_trans *tt, struct prentry *entry, afs_int32 loc, afs_int32 aid)
1121 {
1122     register afs_int32 code;
1123     afs_int32 i;
1124     struct contentry nentry;
1125     struct contentry aentry;
1126     struct prentryg *entryg;
1127     afs_int32 nptr;
1128     afs_int32 last;             /* addr of last cont. block */
1129     afs_int32 first = 0;
1130     afs_int32 cloc = 0;
1131     afs_int32 slot = -1;
1132
1133     if (entry->id == aid)
1134         return PRINCONSISTENT;
1135 #ifdef PR_REMEMBER_TIMES
1136     entry->addTime = time(NULL);
1137 #endif
1138     entryg = (struct prentryg *)entry;
1139     for (i = 0; i < SGSIZE; i++) {
1140         if (entryg->supergroup[i] == aid)
1141             return PRIDEXIST;
1142         if (entryg->supergroup[i] == PRBADID) { /* remember this spot */
1143             first = 1;
1144             slot = i;
1145         } else if (entryg->supergroup[i] == 0) {        /* end of the line */
1146             if (slot == -1) {
1147                 first = 1;
1148                 slot = i;
1149             }
1150             break;
1151         }
1152     }
1153     last = 0;
1154     nptr = entryg->nextsg;
1155     while (nptr) {
1156         code = pr_ReadCoEntry(tt, 0, nptr, &nentry);
1157         if (code != 0)
1158             return code;
1159         last = nptr;
1160         if (!(nentry.flags & PRCONT))
1161             return PRDBFAIL;
1162         for (i = 0; i < COSIZE; i++) {
1163             if (nentry.entries[i] == aid)
1164                 return PRIDEXIST;
1165             if (nentry.entries[i] == PRBADID) {
1166                 if (slot == -1) {
1167                     slot = i;
1168                     cloc = nptr;
1169                 }
1170             } else if (nentry.entries[i] == 0) {
1171                 if (slot == -1) {
1172                     slot = i;
1173                     cloc = nptr;
1174                 }
1175                 break;
1176             }
1177         }
1178         nptr = nentry.next;
1179     }
1180     if (slot != -1) {           /* we found a place */
1181         entryg->countsg++;
1182         if (first) {            /* place is in first block */
1183             entryg->supergroup[slot] = aid;
1184             code = pr_WriteEntry(tt, 0, loc, entry);
1185             if (code != 0)
1186                 return code;
1187             return PRSUCCESS;
1188         }
1189         code = pr_WriteEntry(tt, 0, loc, entry);
1190         if (code)
1191             return code;
1192         code = pr_ReadCoEntry(tt, 0, cloc, &aentry);
1193         if (code != 0)
1194             return code;
1195         aentry.entries[slot] = aid;
1196         code = pr_WriteCoEntry(tt, 0, cloc, &aentry);
1197         if (code != 0)
1198             return code;
1199         return PRSUCCESS;
1200     }
1201     /* have to allocate a continuation block if we got here */
1202     nptr = AllocBlock(tt);
1203     if (last) {
1204         /* then we should tack new block after last block in cont. chain */
1205         nentry.next = nptr;
1206         code = pr_WriteCoEntry(tt, 0, last, &nentry);
1207         if (code != 0)
1208             return code;
1209     } else {
1210         entryg->nextsg = nptr;
1211     }
1212     memset(&aentry, 0, sizeof(aentry));
1213     aentry.flags |= PRCONT;
1214     aentry.id = entry->id;
1215     aentry.next = 0;
1216     aentry.entries[0] = aid;
1217     code = pr_WriteCoEntry(tt, 0, nptr, &aentry);
1218     if (code != 0)
1219         return code;
1220     /* don't forget to update count, here! */
1221     entryg->countsg++;
1222     code = pr_WriteEntry(tt, 0, loc, entry);
1223     return code;
1224
1225 }
1226 #endif /* SUPERGROUPS */
1227
1228 afs_int32
1229 AddToPRList(prlist *alist, int *sizeP, afs_int32 id)
1230 {
1231     char *tmp;
1232     int count;
1233
1234     if (alist->prlist_len >= *sizeP) {
1235         count = alist->prlist_len + 100;
1236         if (alist->prlist_val) {
1237             tmp =
1238                 (char *)realloc(alist->prlist_val, count * sizeof(afs_int32));
1239         } else {
1240             tmp = (char *)malloc(count * sizeof(afs_int32));
1241         }
1242         if (!tmp)
1243             return (PRNOMEM);
1244         alist->prlist_val = (afs_int32 *) tmp;
1245         *sizeP = count;
1246     }
1247     alist->prlist_val[alist->prlist_len++] = id;
1248     return 0;
1249 }
1250
1251 afs_int32
1252 GetList(struct ubik_trans *at, struct prentry *tentry, prlist *alist, afs_int32 add)
1253 {
1254     afs_int32 code;
1255     afs_int32 i;
1256     struct contentry centry;
1257     afs_int32 nptr;
1258     int size;
1259     int count = 0;
1260
1261     size = 0;
1262     alist->prlist_val = 0;
1263     alist->prlist_len = 0;
1264
1265     for (i = 0; i < PRSIZE; i++) {
1266         if (tentry->entries[i] == PRBADID)
1267             continue;
1268         if (tentry->entries[i] == 0)
1269             break;
1270         code = AddToPRList(alist, &size, tentry->entries[i]);
1271         if (code)
1272             return code;
1273 #if defined(SUPERGROUPS)
1274         if (!add)
1275             continue;
1276         code = GetListSG2(at, tentry->entries[i], alist, &size, depthsg);
1277         if (code)
1278             return code;
1279 #endif
1280     }
1281
1282     for (nptr = tentry->next; nptr != 0; nptr = centry.next) {
1283         /* look through cont entries */
1284         code = pr_ReadCoEntry(at, 0, nptr, &centry);
1285         if (code != 0)
1286             return code;
1287         for (i = 0; i < COSIZE; i++) {
1288             if (centry.entries[i] == PRBADID)
1289                 continue;
1290             if (centry.entries[i] == 0)
1291                 break;
1292             code = AddToPRList(alist, &size, centry.entries[i]);
1293             if (code)
1294                 return code;
1295 #if defined(SUPERGROUPS)
1296             if (!add)
1297                 continue;
1298             code = GetListSG2(at, centry.entries[i], alist, &size, depthsg);
1299             if (code)
1300                 return code;
1301 #endif
1302         }
1303         if (count++ > 50) {
1304 #ifndef AFS_PTHREAD_ENV
1305             IOMGR_Poll();
1306 #endif
1307             count = 0;
1308         }
1309     }
1310
1311     if (add) {                  /* this is for a CPS, so tack on appropriate stuff */
1312         if (tentry->id != ANONYMOUSID && tentry->id != ANYUSERID) {
1313             if ((code = AddToPRList(alist, &size, ANYUSERID))
1314                 || (code = AddAuthGroup(tentry, alist, &size))
1315                 || (code = AddToPRList(alist, &size, tentry->id)))
1316                 return code;
1317         } else {
1318             if ((code = AddToPRList(alist, &size, ANYUSERID))
1319                 || (code = AddToPRList(alist, &size, tentry->id)))
1320                 return code;
1321         }
1322     }
1323 #ifndef AFS_PTHREAD_ENV
1324     if (alist->prlist_len > 100)
1325         IOMGR_Poll();
1326 #endif
1327     qsort(alist->prlist_val, alist->prlist_len, sizeof(afs_int32), IDCmp);
1328     return PRSUCCESS;
1329 }
1330
1331
1332 afs_int32
1333 GetList2(struct ubik_trans *at, struct prentry *tentry, struct prentry *tentry2, prlist *alist, afs_int32 add)
1334 {
1335     afs_int32 code = 0;
1336     afs_int32 i;
1337     struct contentry centry;
1338     afs_int32 nptr;
1339     afs_int32 size;
1340     int count = 0;
1341
1342     size = 0;
1343     alist->prlist_val = 0;
1344     alist->prlist_len = 0;
1345     for (i = 0; i < PRSIZE; i++) {
1346         if (tentry->entries[i] == PRBADID)
1347             continue;
1348         if (tentry->entries[i] == 0)
1349             break;
1350         code = AddToPRList(alist, &size, tentry->entries[i]);
1351         if (code)
1352             return code;
1353 #if defined(SUPERGROUPS)
1354         if (!add)
1355             continue;
1356         code = GetListSG2(at, tentry->entries[i], alist, &size, depthsg);
1357         if (code)
1358             return code;
1359 #endif
1360     }
1361
1362     nptr = tentry->next;
1363     while (nptr != 0) {
1364         /* look through cont entries */
1365         code = pr_ReadCoEntry(at, 0, nptr, &centry);
1366         if (code != 0)
1367             return code;
1368         for (i = 0; i < COSIZE; i++) {
1369             if (centry.entries[i] == PRBADID)
1370                 continue;
1371             if (centry.entries[i] == 0)
1372                 break;
1373             code = AddToPRList(alist, &size, centry.entries[i]);
1374             if (code)
1375                 return code;
1376 #if defined(SUPERGROUPS)
1377             if (!add)
1378                 continue;
1379             code = GetListSG2(at, centry.entries[i], alist, &size, depthsg);
1380             if (code)
1381                 return code;
1382 #endif
1383         }
1384         nptr = centry.next;
1385         if (count++ > 50) {
1386 #ifndef AFS_PTHREAD_ENV
1387             IOMGR_Poll();
1388 #endif
1389             count = 0;
1390         }
1391     }
1392
1393     for (i = 0; i < PRSIZE; i++) {
1394         if (tentry2->entries[i] == PRBADID)
1395             continue;
1396         if (tentry2->entries[i] == 0)
1397             break;
1398         code = AddToPRList(alist, &size, tentry2->entries[i]);
1399         if (code)
1400             break;
1401     }
1402
1403     if (!code) {
1404         nptr = tentry2->next;
1405         while (nptr != 0) {
1406             /* look through cont entries */
1407             code = pr_ReadCoEntry(at, 0, nptr, &centry);
1408             if (code != 0)
1409                 break;
1410             for (i = 0; i < COSIZE; i++) {
1411                 if (centry.entries[i] == PRBADID)
1412                     continue;
1413                 if (centry.entries[i] == 0)
1414                     break;
1415                 code = AddToPRList(alist, &size, centry.entries[i]);
1416                 if (code)
1417                     break;
1418             }
1419             nptr = centry.next;
1420             if (count++ > 50) {
1421 #ifndef AFS_PTHREAD_ENV
1422                 IOMGR_Poll();
1423 #endif
1424                 count = 0;
1425             }
1426         }
1427     }
1428     if (add) {                  /* this is for a CPS, so tack on appropriate stuff */
1429         if (tentry->id != ANONYMOUSID && tentry->id != ANYUSERID) {
1430             if ((code = AddToPRList(alist, &size, ANYUSERID))
1431                 || (code = AddToPRList(alist, &size, AUTHUSERID))
1432                 || (code = AddToPRList(alist, &size, tentry->id)))
1433                 return code;
1434         } else {
1435             if ((code = AddToPRList(alist, &size, ANYUSERID))
1436                 || (code = AddToPRList(alist, &size, tentry->id)))
1437                 return code;
1438         }
1439     }
1440 #ifndef AFS_PTHREAD_ENV
1441     if (alist->prlist_len > 100)
1442         IOMGR_Poll();
1443 #endif
1444     qsort(alist->prlist_val, alist->prlist_len, sizeof(afs_int32), IDCmp);
1445     return PRSUCCESS;
1446 }
1447
1448 #if defined(SUPERGROUPS)
1449
1450 afs_int32
1451 GetListSG2(struct ubik_trans *at, afs_int32 gid, prlist *alist, afs_int32 *sizeP, afs_int32 depth)
1452 {
1453     register afs_int32 code;
1454     struct prentry tentry;
1455     struct prentryg *tentryg = (struct prentryg *)&tentry;
1456     afs_int32 i;
1457     struct contentry centry;
1458     afs_int32 nptr;
1459     int count = 0;
1460     afs_int32 temp;
1461     int didsomething;
1462 #if DEBUG_SG_MAP
1463     int predictfound, predictflagged;
1464 #endif
1465
1466 #if DEBUG_SG_MAP
1467     predictfound = 0;
1468     if (!in_map(sg_flagged, -gid)) {
1469         predictflagged = 0;
1470         fprintf(stderr, "GetListSG2: I have not yet searched for gid=%d\n",
1471                 gid);
1472     } else if (predictflagged = 1, in_map(sg_found, -gid)) {
1473         predictfound = 1;
1474         fprintf(stderr,
1475                 "GetListSG2: I have already searched for gid=%d, and predict success.\n",
1476                 gid);
1477     }
1478 #endif
1479
1480     if (in_map(sg_flagged, -gid) && !in_map(sg_found, -gid)) {
1481 #if DEBUG_SG_MAP
1482         fprintf(stderr,
1483                 "GetListSG2: I have already searched for gid=%d, and predict failure.\n",
1484                 gid);
1485 #else
1486         return 0;
1487 #endif
1488     }
1489
1490     if (depth < 1)
1491         return 0;
1492     temp = FindByID(at, gid);
1493     if (!temp) {
1494         code = PRNOENT;
1495         return code;
1496     }
1497     code = pr_ReadEntry(at, 0, temp, &tentry);
1498     if (code)
1499         return code;
1500 #if DEBUG_SG_MAP
1501     fprintf(stderr, "GetListSG2: lookup for gid=%d [\n", gid);
1502 #endif
1503     didsomething = 0;
1504
1505     for (i = 0; i < SGSIZE; i++) {
1506         if (tentryg->supergroup[i] == PRBADID)
1507             continue;
1508         if (tentryg->supergroup[i] == 0)
1509             break;
1510         didsomething = 1;
1511 #if DEBUG_SG_MAP
1512         fprintf(stderr, "via gid=%d, added %d\n", gid,
1513                 e.tentryg.supergroup[i]);
1514 #endif
1515         code = AddToPRList(alist, sizeP, tentryg->supergroup[i]);
1516         if (code)
1517             return code;
1518         code =
1519             GetListSG2(at, tentryg->supergroup[i], alist, sizeP, depth - 1);
1520         if (code)
1521             return code;
1522     }
1523
1524     nptr = tentryg->nextsg;
1525     while (nptr) {
1526         didsomething = 1;
1527         /* look through cont entries */
1528         code = pr_ReadCoEntry(at, 0, nptr, &centry);
1529         if (code != 0)
1530             return code;
1531         for (i = 0; i < COSIZE; i++) {
1532             if (centry.entries[i] == PRBADID)
1533                 continue;
1534             if (centry.entries[i] == 0)
1535                 break;
1536 #if DEBUG_SG_MAP
1537             fprintf(stderr, "via gid=%d, added %d\n", gid,
1538                     e.centry.entries[i]);
1539 #endif
1540             code = AddToPRList(alist, sizeP, centry.entries[i]);
1541             if (code)
1542                 return code;
1543             code = GetListSG2(at, centry.entries[i], alist, sizeP, depth - 1);
1544             if (code)
1545                 return code;
1546         }
1547         nptr = centry.next;
1548         if (count++ > 50) {
1549 #ifndef AFS_PTHREAD_ENV
1550             IOMGR_Poll();
1551 #endif
1552             count = 0;
1553         }
1554     }
1555 #if DEBUG_SG_MAP
1556     fprintf(stderr, "] for gid %d, done [flag=%s]\n", gid,
1557             didsomething ? "TRUE" : "FALSE");
1558     if (predictflagged && didsomething != predictfound)
1559         fprintf(stderr, "**** for gid=%d, didsomething=%d predictfound=%d\n",
1560                 didsomething, predictfound);
1561 #endif
1562     if (didsomething)
1563         sg_found = add_map(sg_found, -gid);
1564     else
1565         sg_found = bic_map(sg_found, add_map(NIL_MAP, -gid));
1566     sg_flagged = add_map(sg_flagged, -gid);
1567     return 0;
1568 }
1569
1570 afs_int32
1571 GetSGList(struct ubik_trans *at, struct prentry *tentry, prlist *alist)
1572 {
1573     register afs_int32 code;
1574     afs_int32 i;
1575     struct contentry centry;
1576     struct prentryg *tentryg;
1577     afs_int32 nptr;
1578     int size;
1579     int count = 0;
1580
1581     size = 0;
1582     alist->prlist_val = 0;
1583     alist->prlist_len = 0;
1584
1585     tentryg = (struct prentryg *)tentry;
1586     for (i = 0; i < SGSIZE; i++) {
1587         if (tentryg->supergroup[i] == PRBADID)
1588             continue;
1589         if (tentryg->supergroup[i] == 0)
1590             break;
1591         code = AddToPRList(alist, &size, tentryg->supergroup[i]);
1592         if (code)
1593             return code;
1594     }
1595
1596     nptr = tentryg->nextsg;
1597     while (nptr) {
1598         /* look through cont entries */
1599         code = pr_ReadCoEntry(at, 0, nptr, &centry);
1600         if (code != 0)
1601             return code;
1602         for (i = 0; i < COSIZE; i++) {
1603             if (centry.entries[i] == PRBADID)
1604                 continue;
1605             if (centry.entries[i] == 0)
1606                 break;
1607             code = AddToPRList(alist, &size, centry.entries[i]);
1608             if (code)
1609                 return code;
1610         }
1611         nptr = centry.next;
1612         if (count++ > 50) {
1613 #ifndef AFS_PTHREAD_ENV
1614             IOMGR_Poll();
1615 #endif
1616             count = 0;
1617         }
1618     }
1619
1620 #ifndef AFS_PTHREAD_ENV
1621     if (alist->prlist_len > 100)
1622         IOMGR_Poll();
1623 #endif
1624     qsort((char *)alist->prlist_val, (int)alist->prlist_len,
1625           sizeof(afs_int32), IDCmp);
1626     return PRSUCCESS;
1627 }
1628 #endif /* SUPERGROUPS */
1629
1630 afs_int32
1631 GetOwnedChain(struct ubik_trans *ut, afs_int32 *next, prlist *alist)
1632 {
1633     afs_int32 code;
1634     struct prentry tentry;
1635     int size;
1636     int count = 0;
1637
1638     size = 0;
1639     alist->prlist_val = 0;
1640     alist->prlist_len = 0;
1641
1642     for (; *next; *next = ntohl(tentry.nextOwned)) {
1643         code = pr_Read(ut, 0, *next, &tentry, sizeof(tentry));
1644         if (code)
1645             return code;
1646         code = AddToPRList(alist, &size, ntohl(tentry.id));
1647         if (alist->prlist_len >= PR_MAXGROUPS) {
1648             return PRTOOMANY;
1649         }
1650         if (code)
1651             return code;
1652         if (count++ > 50) {
1653 #ifndef AFS_PTHREAD_ENV
1654             IOMGR_Poll();
1655 #endif
1656             count = 0;
1657         }
1658     }
1659 #ifndef AFS_PTHREAD_ENV
1660     if (alist->prlist_len > 100)
1661         IOMGR_Poll();
1662 #endif
1663     qsort(alist->prlist_val, alist->prlist_len, sizeof(afs_int32), IDCmp);
1664     return PRSUCCESS;
1665 }
1666
1667 afs_int32
1668 GetMax(struct ubik_trans *at, afs_int32 *uid, afs_int32 *gid)
1669 {
1670     *uid = ntohl(cheader.maxID);
1671     *gid = ntohl(cheader.maxGroup);
1672     return PRSUCCESS;
1673 }
1674
1675 afs_int32
1676 SetMax(struct ubik_trans *at, afs_int32 id, afs_int32 flag)
1677 {
1678     afs_int32 code;
1679     if (flag & PRGRP) {
1680         cheader.maxGroup = htonl(id);
1681         code =
1682             pr_Write(at, 0, 16, (char *)&cheader.maxGroup,
1683                      sizeof(cheader.maxGroup));
1684         if (code != 0)
1685             return code;
1686     } else {
1687         cheader.maxID = htonl(id);
1688         code =
1689             pr_Write(at, 0, 20, (char *)&cheader.maxID,
1690                      sizeof(cheader.maxID));
1691         if (code != 0)
1692             return code;
1693     }
1694     return PRSUCCESS;
1695 }
1696
1697 afs_int32
1698 read_DbHeader(struct ubik_trans *tt)
1699 {
1700     afs_int32 code;
1701
1702     if (!ubik_CacheUpdate(tt))
1703         return 0;
1704
1705     code = pr_Read(tt, 0, 0, (char *)&cheader, sizeof(cheader));
1706     if (code != 0) {
1707         afs_com_err(whoami, code, "Couldn't read header");
1708     }
1709     return code;
1710 }
1711
1712 int pr_noAuth;
1713 afs_int32 initd = 0;
1714
1715 afs_int32
1716 Initdb(void)
1717 {
1718     afs_int32 code;
1719     struct ubik_trans *tt;
1720     afs_int32 len;
1721
1722     /* init the database.  We'll try reading it, but if we're starting
1723      * from scratch, we'll have to do a write transaction. */
1724
1725     pr_noAuth = afsconf_GetNoAuthFlag(prdir);
1726
1727     code = ubik_BeginTransReadAny(dbase, UBIK_READTRANS, &tt);
1728     if (code)
1729         return code;
1730     code = ubik_SetLock(tt, 1, 1, LOCKREAD);
1731     if (code) {
1732         ubik_AbortTrans(tt);
1733         return code;
1734     }
1735     if (!initd) {
1736         initd = 1;
1737     } else if (!ubik_CacheUpdate(tt)) {
1738         code = ubik_EndTrans(tt);
1739         return code;
1740     }
1741
1742     len = sizeof(cheader);
1743     code = pr_Read(tt, 0, 0, (char *)&cheader, len);
1744     if (code != 0) {
1745         afs_com_err(whoami, code, "couldn't read header");
1746         ubik_AbortTrans(tt);
1747         return code;
1748     }
1749     if ((ntohl(cheader.version) == PRDBVERSION)
1750         && ntohl(cheader.headerSize) == sizeof(cheader)
1751         && ntohl(cheader.eofPtr) != 0
1752         && FindByID(tt, ANONYMOUSID) != 0) {
1753         /* database exists, so we don't have to build it */
1754         code = ubik_EndTrans(tt);
1755         if (code)
1756             return code;
1757         return PRSUCCESS;
1758     }
1759     /* else we need to build a database */
1760     code = ubik_EndTrans(tt);
1761     if (code)
1762         return code;
1763
1764     /* Only rebuild database if the db was deleted (the header is zero) and we
1765      * are running noAuth. */
1766     {
1767         char *bp = (char *)&cheader;
1768         int i;
1769         for (i = 0; i < sizeof(cheader); i++)
1770             if (bp[i]) {
1771                 code = PRDBBAD;
1772                 afs_com_err(whoami, code,
1773                         "Can't rebuild database because it is not empty");
1774                 return code;
1775             }
1776     }
1777     if (!pr_noAuth) {
1778         code = PRDBBAD;
1779         afs_com_err(whoami, code,
1780                 "Can't rebuild database because not running NoAuth");
1781         return code;
1782     }
1783
1784     code = ubik_BeginTrans(dbase, UBIK_WRITETRANS, &tt);
1785     if (code)
1786         return code;
1787
1788     code = ubik_SetLock(tt, 1, 1, LOCKWRITE);
1789     if (code) {
1790         ubik_AbortTrans(tt);
1791         return code;
1792     }
1793
1794     /* before doing a rebuild, check again that the dbase looks bad, because
1795      * the previous check was only under a ReadAny transaction, and there could
1796      * actually have been a good database out there.  Now that we have a
1797      * real write transaction, make sure things are still bad.
1798      */
1799     if ((ntohl(cheader.version) == PRDBVERSION)
1800         && ntohl(cheader.headerSize) == sizeof(cheader)
1801         && ntohl(cheader.eofPtr) != 0
1802         && FindByID(tt, ANONYMOUSID) != 0) {
1803         /* database exists, so we don't have to build it */
1804         code = ubik_EndTrans(tt);
1805         if (code)
1806             return code;
1807         return PRSUCCESS;
1808     }
1809
1810     /* Initialize the database header */
1811     if ((code = set_header_word(tt, version, htonl(PRDBVERSION)))
1812         || (code = set_header_word(tt, headerSize, htonl(sizeof(cheader))))
1813         || (code = set_header_word(tt, eofPtr, cheader.headerSize))) {
1814         afs_com_err(whoami, code, "couldn't write header words");
1815         ubik_AbortTrans(tt);
1816         return code;
1817     }
1818 #define InitialGroup(id,name) do {    \
1819     afs_int32 temp = (id);                    \
1820     afs_int32 flag = (id) < 0 ? PRGRP : 0; \
1821     code = CreateEntry                \
1822         (tt, (name), &temp, /*idflag*/1, flag, SYSADMINID, SYSADMINID); \
1823     if (code) {                       \
1824         afs_com_err (whoami, code, "couldn't create %s with id %di.",   \
1825                  (name), (id));       \
1826         ubik_AbortTrans(tt);          \
1827         return code;                  \
1828     }                                 \
1829 } while (0)
1830
1831     InitialGroup(SYSADMINID, "system:administrators");
1832     InitialGroup(SYSBACKUPID, "system:backup");
1833     InitialGroup(ANYUSERID, "system:anyuser");
1834     InitialGroup(AUTHUSERID, "system:authuser");
1835     InitialGroup(SYSVIEWERID, "system:ptsviewers");
1836     InitialGroup(ANONYMOUSID, "anonymous");
1837
1838     /* Well, we don't really want the max id set to anonymousid, so we'll set
1839      * it back to 0 */
1840     code = set_header_word(tt, maxID, 0);       /* correct in any byte order */
1841     if (code) {
1842         afs_com_err(whoami, code, "couldn't reset max id");
1843         ubik_AbortTrans(tt);
1844         return code;
1845     }
1846
1847     code = ubik_EndTrans(tt);
1848     if (code)
1849         return code;
1850     return PRSUCCESS;
1851 }
1852
1853 afs_int32
1854 ChangeEntry(struct ubik_trans *at, afs_int32 aid, afs_int32 cid, char *name, afs_int32 oid, afs_int32 newid)
1855 {
1856     afs_int32 code;
1857     afs_int32 i, pos;
1858 #if defined(SUPERGROUPS)
1859     afs_int32 nextpos;
1860 #else
1861     afs_int32 nptr;
1862 #endif
1863     struct prentry tentry, tent;
1864     afs_int32 loc;
1865     afs_int32 oldowner;
1866     char holder[PR_MAXNAMELEN];
1867     char temp[PR_MAXNAMELEN];
1868     char oldname[PR_MAXNAMELEN];
1869     char *atsign;
1870
1871     memset(holder, 0, PR_MAXNAMELEN);
1872     memset(temp, 0, PR_MAXNAMELEN);
1873     loc = FindByID(at, aid);
1874     if (!loc)
1875         return PRNOENT;
1876     code = pr_ReadEntry(at, 0, loc, &tentry);
1877     if (code)
1878         return PRDBFAIL;
1879     if (restricted && !IsAMemberOf(at, cid, SYSADMINID)) 
1880         return PRPERM;
1881     if (tentry.owner != cid && !IsAMemberOf(at, cid, SYSADMINID)
1882         && !IsAMemberOf(at, cid, tentry.owner) && !pr_noAuth)
1883         return PRPERM;
1884 #ifdef PR_REMEMBER_TIMES
1885     tentry.changeTime = time(0);
1886 #endif
1887
1888     /* we're actually trying to change the id */
1889     if (newid && (newid != aid)) {
1890         if (!IsAMemberOf(at, cid, SYSADMINID) && !pr_noAuth)
1891             return PRPERM;
1892
1893         pos = FindByID(at, newid);
1894         if (pos)
1895             return PRIDEXIST;   /* new id already in use! */
1896         if ((aid < 0 && newid > 0) || (aid > 0 && newid < 0))
1897             return PRPERM;
1898
1899         /* Should check that foreign users id to change to is good: inRange() */
1900
1901         /* if new id is not in use, rehash things */
1902         code = RemoveFromIDHash(at, aid, &loc);
1903         if (code != PRSUCCESS)
1904             return code;
1905         tentry.id = newid;
1906         code = pr_WriteEntry(at, 0, loc, &tentry);
1907         if (code)
1908             return code;
1909         code = AddToIDHash(at, tentry.id, loc);
1910         if (code)
1911             return code;
1912
1913         /* get current data */
1914         code = pr_ReadEntry(at, 0, loc, &tentry);
1915         if (code)
1916             return PRDBFAIL;
1917
1918 #if defined(SUPERGROUPS)
1919         if (tentry.id > (afs_int32) ntohl(cheader.maxID))
1920             code = set_header_word(at, maxID, htonl(tentry.id));
1921         if (code)
1922             return PRDBFAIL;
1923
1924         /* need to fix up: membership
1925          * (supergroups?)
1926          * ownership
1927          */
1928
1929         for (i = 0; i < PRSIZE; i++) {
1930             if (tentry.entries[i] == PRBADID)
1931                 continue;
1932             if (tentry.entries[i] == 0)
1933                 break;
1934             if ((tentry.flags & PRGRP) && tentry.entries[i] < 0) {      /* Supergroup */
1935                 return 5;       /* not yet, in short. */
1936             } else {
1937                 code = ChangeIDEntry(at, aid, newid, tentry.entries[i]);
1938             }
1939             if (code)
1940                 return code;
1941         }
1942         for (pos = ntohl(tentry.owned); pos; pos = nextpos) {
1943             code = pr_ReadEntry(at, 0, pos, &tent);
1944             if (code)
1945                 break;
1946             tent.owner = newid;
1947             nextpos = tent.nextOwned;
1948             code = pr_WriteEntry(at, 0, pos, &tent);
1949             if (code)
1950                 break;
1951         }
1952         pos = tentry.next;
1953         while (pos) {
1954 #define centry  (*(struct contentry*)&tent)
1955             code = pr_ReadCoEntry(at, 0, pos, &centry);
1956             if ((centry.id != aid)
1957                 || !(centry.flags & PRCONT)) {
1958                 fprintf(stderr,
1959                         "ChangeEntry: bad database aid=%d centry.id=%d .flags=%d\n",
1960                         aid, centry.id, centry.flags);
1961                 return PRDBBAD;
1962             }
1963             centry.id = newid;
1964             for (i = 0; i < COSIZE; i++) {
1965                 if (centry.entries[i] == PRBADID)
1966                     continue;
1967                 if (centry.entries[i] == 0)
1968                     break;
1969                 if ((centry.flags & PRGRP) && centry.entries[i] < 0) {  /* Supergroup */
1970                     return 5;   /* not yet, in short. */
1971                 } else {
1972                     code = ChangeIDEntry(at, aid, newid, centry.entries[i]);
1973                 }
1974                 if (code)
1975                     return code;
1976             }
1977             code = pr_WriteCoEntry(at, 0, pos, &centry);
1978             pos = centry.next;
1979 #undef centry
1980         }
1981         if (code)
1982             return code;
1983
1984 #else /* SUPERGROUPS */
1985
1986
1987         /* Also change the references from the membership list */
1988         for (i = 0; i < PRSIZE; i++) {
1989             if (tentry.entries[i] == PRBADID)
1990                 continue;
1991             if (tentry.entries[i] == 0)
1992                 break;
1993             pos = FindByID(at, tentry.entries[i]);
1994             if (!pos)
1995                 return (PRDBFAIL);
1996             code = RemoveFromEntry(at, aid, tentry.entries[i]);
1997             if (code)
1998                 return code;
1999             code = pr_ReadEntry(at, 0, pos, &tent);
2000             if (code)
2001                 return code;
2002             code = AddToEntry(at, &tent, pos, newid);
2003             if (code)
2004                 return code;
2005         }
2006         /* Look through cont entries too. This needs to be broken into
2007          * seperate transaction so that no one transaction becomes too 
2008          * large to complete.
2009          */
2010         for (nptr = tentry.next; nptr; nptr = centry.next) {
2011             code = pr_ReadCoEntry(at, 0, nptr, &centry);
2012             if (code)
2013                 return code;
2014             for (i = 0; i < COSIZE; i++) {
2015                 if (centry.entries[i] == PRBADID)
2016                     continue;
2017                 if (centry.entries[i] == 0)
2018                     break;
2019                 pos = FindByID(at, centry.entries[i]);
2020                 if (!pos)
2021                     return (PRDBFAIL);
2022                 code = RemoveFromEntry(at, aid, centry.entries[i]);
2023                 if (code)
2024                     return code;
2025                 code = pr_ReadEntry(at, 0, pos, &tent);
2026                 if (code)
2027                     return code;
2028                 code = AddToEntry(at, &tent, pos, newid);
2029                 if (code)
2030                     return code;
2031             }
2032         }
2033 #endif /* SUPERGROUPS */
2034     }
2035
2036     atsign = strchr(tentry.name, '@');  /* check for foreign entry */
2037
2038     /* Change the owner */
2039     if (oid && (oid != tentry.owner)) {
2040         /* only groups can have their owner's changed */
2041         if (!(tentry.flags & PRGRP))
2042             return PRPERM;
2043         if (atsign != NULL)
2044             return PRPERM;
2045         oldowner = tentry.owner;
2046         tentry.owner = oid;
2047         /* The entry must be written through first so Remove and Add routines
2048          * can operate on disk data */
2049         code = pr_WriteEntry(at, 0, loc, &tentry);
2050         if (code)
2051             return PRDBFAIL;
2052
2053         /* switch owner chains */
2054         if (oldowner)           /* if it has an owner */
2055             code = RemoveFromOwnerChain(at, tentry.id, oldowner);
2056         else                    /* must be an orphan */
2057             code = RemoveFromOrphan(at, tentry.id);
2058         if (code)
2059             return code;
2060         code = AddToOwnerChain(at, tentry.id, tentry.owner);
2061         if (code)
2062             return code;
2063
2064         /* fix up the name */
2065         if (strlen(name) == 0)
2066             name = tentry.name;
2067         /* get current data */
2068         code = pr_ReadEntry(at, 0, loc, &tentry);
2069         if (code)
2070             return PRDBFAIL;
2071     }
2072
2073     /* Change the name, if name is a ptr to tentry.name then this name change
2074      * is due to a chown, otherwise caller has specified a new name */
2075     if ((name == tentry.name) || (*name && (strcmp(tentry.name, name) != 0))) {
2076         strncpy(oldname, tentry.name, PR_MAXNAMELEN);
2077         if (tentry.flags & PRGRP) {
2078             /* don't let foreign cell groups change name */
2079             if (atsign != NULL)
2080                 return PRPERM;
2081             code = CorrectGroupName(at, name, cid, tentry.owner, tentry.name);
2082             if (code)
2083                 return code;
2084
2085             if (name == tentry.name) {  /* owner fixup */
2086                 if (strcmp(oldname, tentry.name) == 0)
2087                     goto nameOK;
2088             } else {            /* new name, caller must be correct */
2089                 if (strcmp(name, tentry.name) != 0)
2090                     return PRBADNAM;
2091             }
2092         } else
2093             /* Allow a foreign name change only if the cellname part is
2094              * the same */
2095         {
2096             char *newatsign;
2097
2098             newatsign = strchr(name, '@');
2099             if (newatsign != atsign) {  /* if they are the same no problem */
2100                 /*if the pointers are not equal the strings better be */
2101                 if ((atsign == NULL) || (newatsign == NULL)
2102                     || strcmp(atsign, newatsign))
2103                     return PRPERM;
2104             }
2105             if (!CorrectUserName(name))
2106                 return PRBADNAM;
2107         }
2108
2109         pos = FindByName(at, name, &tent);
2110         if (pos)
2111             return PREXIST;
2112         code = RemoveFromNameHash(at, oldname, &loc);
2113         if (code != PRSUCCESS)
2114             return code;
2115         strncpy(tentry.name, name, PR_MAXNAMELEN);
2116         code = pr_WriteEntry(at, 0, loc, &tentry);
2117         if (code)
2118             return PRDBFAIL;
2119         code = AddToNameHash(at, tentry.name, loc);
2120         if (code != PRSUCCESS)
2121             return code;
2122       nameOK:;
2123     }
2124     return PRSUCCESS;
2125 }
2126
2127
2128 static afs_int32
2129 allocNextId(struct ubik_trans * at, struct prentry * cellEntry)
2130 {
2131     /* Id's for foreign cell entries are constructed as follows:
2132      * The 16 low order bits are the group id of the cell and the
2133      * top 16 bits identify the particular users in that cell */
2134
2135     afs_int32 id;
2136     afs_int32 cellid = ((ntohl(cellEntry->id)) & 0x0000ffff);
2137
2138     id = (ntohl(cellEntry->nusers) + 1);
2139     while (FindByID(at, ((id << 16) | cellid))) {
2140         id++;
2141         if (id > 0xffff)
2142             return 0;
2143     }
2144
2145     cellEntry->nusers = htonl(id);
2146     /* use the field nusers to keep 
2147      * the next available id in that
2148      * foreign cell's group. Note :
2149      * It would seem more appropriate
2150      * to use ngroup for that and nusers
2151      * to enforce the quota, however pts
2152      * does not have an option to change 
2153      * foreign users quota yet  */
2154
2155     id = (id << 16) | cellid;
2156     return id;
2157 }
2158
2159 static int
2160 inRange(struct prentry *cellEntry, afs_int32 aid)
2161 {
2162     afs_uint32 id, cellid, groupid;
2163
2164
2165     /*
2166      * The only thing that we want to make sure here is that
2167      * the id is in the legal range of this group. If it is
2168      * a duplicate we don't care since it will get caught 
2169      * in a different check.
2170      */
2171
2172     cellid = aid & 0x0000ffff;
2173     groupid = (ntohl(cellEntry->id)) & 0x0000ffff;
2174     if (cellid != groupid)
2175         return 0;               /* not in range */
2176
2177     /* 
2178      * if we got here we're ok but we need to update the nusers
2179      * field in order to get the id correct the next time that 
2180      * we try to allocate it automatically
2181      */
2182
2183     id = aid >> 16;
2184     if (id > ntohl(cellEntry->nusers))
2185         cellEntry->nusers = htonl(id);
2186     return 1;
2187
2188 }
2189
2190 static int
2191 AddAuthGroup(struct prentry *tentry, prlist *alist, afs_int32 *size)
2192 {
2193     if (!(strchr(tentry->name, '@')))
2194         return (AddToPRList(alist, size, AUTHUSERID));
2195     else
2196         return PRSUCCESS;
2197 }