src/ptserver/utils.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 #include <afsconfig.h>
  11 #include <afs/param.h>
  12
  13 #include <roken.h>
  14
  15 #include <lock.h>
  16 #include <ubik.h>
  17
  18 #include "ptserver.h"
  19 #include "pterror.h"
  20
  21 #if defined(SUPERGROUPS)
  22 extern afs_int32 depthsg;
  23 afs_int32 IsAMemberOfSG(struct ubik_trans *at, afs_int32 aid, afs_int32 gid,
  24                         afs_int32 depth);
  25 #endif
  26
  27 static afs_int32
  28 IDHash(afs_int32 x)
  29 {
  30     /* returns hash bucket for x */
  31     return ((abs(x)) % HASHSIZE);
  32 }
  33
  34 afs_int32
  35 NameHash(char *aname)
  36 {
  37     /* returns hash bucket for aname */
  38     unsigned int hash = 0;
  39     size_t i;
  40 /* stolen directly from the HashString function in the vol package */
  41     for (i = strlen(aname), aname += i - 1; i--; aname--)
  42         hash = (hash * 31) + (*(unsigned char *)aname - 31);
  43     return (hash % HASHSIZE);
  44 }
  45
  46
  47 afs_int32
  48 pr_Write(struct ubik_trans *tt, afs_int32 afd, afs_int32 pos, void *buff, afs_int32 len)
  49 {
  50     /* package up seek and write into one procedure for ease of use */
  51     afs_int32 code;
  52     if ((pos < sizeof(cheader)) && (buff != (char *)&cheader + pos)) {
  53         fprintf(stderr,
  54                 "ptserver: dbwrite: Illegal attempt to write a location 0\n");
  55         return PRDBFAIL;
  56     }
  57     code = ubik_Seek(tt, afd, pos);
  58     if (code)
  59         return code;
  60     code = ubik_Write(tt, buff, len);
  61     return code;
  62 }
  63
  64 afs_int32
  65 pr_Read(struct ubik_trans *tt, afs_int32 afd, afs_int32 pos, void *buff, afs_int32 len)
  66 {
  67     /* same thing for read */
  68     afs_int32 code;
  69     code = ubik_Seek(tt, afd, pos);
  70     if (code)
  71         return code;
  72     code = ubik_Read(tt, buff, len);
  73     return code;
  74 }
  75
  76 int
  77 pr_WriteEntry(struct ubik_trans *tt, afs_int32 afd, afs_int32 pos, struct prentry *tentry)
  78 {
  79     afs_int32 code;
  80     afs_int32 i;
  81     struct prentry nentry;
  82
  83     if (ntohl(1) != 1) {        /* Need to swap bytes. */
  84         memset(&nentry, 0, sizeof(nentry));     /* make sure reseved fields are zero */
  85         nentry.flags = htonl(tentry->flags);
  86         nentry.id = htonl(tentry->id);
  87         nentry.cellid = htonl(tentry->cellid);
  88         nentry.next = htonl(tentry->next);
  89         nentry.nextID = htonl(tentry->nextID);
  90         nentry.nextName = htonl(tentry->nextName);
  91         nentry.owner = htonl(tentry->owner);
  92         nentry.creator = htonl(tentry->creator);
  93         nentry.ngroups = htonl(tentry->ngroups);
  94         nentry.nusers = htonl(tentry->nusers);
  95         nentry.count = htonl(tentry->count);
  96         nentry.instance = htonl(tentry->instance);
  97         nentry.owned = htonl(tentry->owned);
  98         nentry.nextOwned = htonl(tentry->nextOwned);
  99         nentry.parent = htonl(tentry->parent);
 100         nentry.sibling = htonl(tentry->sibling);
 101         nentry.child = htonl(tentry->child);
 102         strncpy(nentry.name, tentry->name, PR_MAXNAMELEN);
 103 #ifdef PR_REMEMBER_TIMES
 104         nentry.createTime = htonl(tentry->createTime);
 105         nentry.addTime = htonl(tentry->addTime);
 106         nentry.removeTime = htonl(tentry->removeTime);
 107         nentry.changeTime = htonl(tentry->changeTime);
 108 #endif
 109         for (i = 0; i < PRSIZE; i++)
 110             nentry.entries[i] = htonl(tentry->entries[i]);
 111         tentry = &nentry;
 112     }
 113     code = pr_Write(tt, afd, pos, (char *)tentry, sizeof(struct prentry));
 114     return (code);
 115 }
 116
 117 int
 118 pr_ReadEntry(struct ubik_trans *tt, afs_int32 afd, afs_int32 pos, struct prentry *tentry)
 119 {
 120     afs_int32 code;
 121     afs_int32 i;
 122     struct prentry nentry;
 123     code = ubik_Seek(tt, afd, pos);
 124     if (code)
 125         return (code);
 126     if (ntohl(1) == 1) {        /* no swapping needed */
 127         code = ubik_Read(tt, (char *)tentry, sizeof(struct prentry));
 128         return (code);
 129     }
 130     code = ubik_Read(tt, (char *)&nentry, sizeof(struct prentry));
 131     if (code)
 132         return (code);
 133     memset(tentry, 0, sizeof(*tentry)); /* make sure reseved fields are zero */
 134     tentry->flags = ntohl(nentry.flags);
 135     tentry->id = ntohl(nentry.id);
 136     tentry->cellid = ntohl(nentry.cellid);
 137     tentry->next = ntohl(nentry.next);
 138     tentry->nextID = ntohl(nentry.nextID);
 139     tentry->nextName = ntohl(nentry.nextName);
 140     tentry->owner = ntohl(nentry.owner);
 141     tentry->creator = ntohl(nentry.creator);
 142     tentry->ngroups = ntohl(nentry.ngroups);
 143     tentry->nusers = ntohl(nentry.nusers);
 144     tentry->count = ntohl(nentry.count);
 145     tentry->instance = ntohl(nentry.instance);
 146     tentry->owned = ntohl(nentry.owned);
 147     tentry->nextOwned = ntohl(nentry.nextOwned);
 148     tentry->parent = ntohl(nentry.parent);
 149     tentry->sibling = ntohl(nentry.sibling);
 150     tentry->child = ntohl(nentry.child);
 151     strncpy(tentry->name, nentry.name, PR_MAXNAMELEN);
 152 #ifdef PR_REMEMBER_TIMES
 153     tentry->createTime = ntohl(nentry.createTime);
 154     tentry->addTime = ntohl(nentry.addTime);
 155     tentry->removeTime = ntohl(nentry.removeTime);
 156     tentry->changeTime = ntohl(nentry.changeTime);
 157 #endif
 158     for (i = 0; i < PRSIZE; i++)
 159         tentry->entries[i] = ntohl(nentry.entries[i]);
 160     return (code);
 161 }
 162
 163 int
 164 pr_WriteCoEntry(struct ubik_trans *tt, afs_int32 afd, afs_int32 pos, struct contentry *tentry)
 165 {
 166     afs_int32 code;
 167     afs_int32 i;
 168     struct contentry nentry;
 169
 170     if (ntohl(1) != 1) {        /* No need to swap */
 171         memset(&nentry, 0, sizeof(nentry));     /* make reseved fields zero */
 172         nentry.flags = htonl(tentry->flags);
 173         nentry.id = htonl(tentry->id);
 174         nentry.cellid = htonl(tentry->cellid);
 175         nentry.next = htonl(tentry->next);
 176         for (i = 0; i < COSIZE; i++)
 177             nentry.entries[i] = htonl(tentry->entries[i]);
 178         tentry = &nentry;
 179     }
 180     code = pr_Write(tt, afd, pos, (char *)tentry, sizeof(struct contentry));
 181     return (code);
 182 }
 183
 184 int
 185 pr_ReadCoEntry(struct ubik_trans *tt, afs_int32 afd, afs_int32 pos, struct contentry *tentry)
 186 {
 187     afs_int32 code;
 188     afs_int32 i;
 189     struct contentry nentry;
 190     code = ubik_Seek(tt, afd, pos);
 191     if (code)
 192         return (code);
 193     if (ntohl(1) == 1) {        /* No swapping needed. */
 194         code = ubik_Read(tt, (char *)tentry, sizeof(struct contentry));
 195         return (code);
 196     }
 197     code = ubik_Read(tt, (char *)&nentry, sizeof(struct contentry));
 198     if (code)
 199         return (code);
 200     memset(tentry, 0, sizeof(*tentry)); /* make reseved fields zero */
 201     tentry->flags = ntohl(nentry.flags);
 202     tentry->id = ntohl(nentry.id);
 203     tentry->cellid = ntohl(nentry.cellid);
 204     tentry->next = ntohl(nentry.next);
 205     for (i = 0; i < COSIZE; i++)
 206         tentry->entries[i] = ntohl(nentry.entries[i]);
 207     return (code);
 208 }
 209
 210 /* AllocBloc - allocate a free block of storage for entry, returning address of
 211  * new entry */
 212
 213 afs_int32
 214 AllocBlock(struct ubik_trans *at)
 215 {
 216     afs_int32 code;
 217     afs_int32 temp;
 218     struct prentry tentry;
 219
 220     if (cheader.freePtr) {
 221         /* allocate this dude */
 222         temp = ntohl(cheader.freePtr);
 223         code = pr_ReadEntry(at, 0, temp, &tentry);
 224         if (code)
 225             return 0;
 226         cheader.freePtr = htonl(tentry.next);
 227         code =
 228             pr_Write(at, 0, 8, (char *)&cheader.freePtr,
 229                      sizeof(cheader.freePtr));
 230         if (code != 0)
 231             return 0;
 232         return temp;
 233     } else {
 234         /* hosed, nothing on free list, grow file */
 235         temp = ntohl(cheader.eofPtr);   /* remember this guy */
 236         cheader.eofPtr = htonl(temp + ENTRYSIZE);
 237         code =
 238             pr_Write(at, 0, 12, (char *)&cheader.eofPtr,
 239                      sizeof(cheader.eofPtr));
 240         if (code != 0)
 241             return 0;
 242         return temp;
 243     }
 244 }
 245
 246 afs_int32
 247 FreeBlock(struct ubik_trans *at, afs_int32 pos)
 248 {
 249     /* add a block of storage to the free list */
 250     afs_int32 code;
 251     struct prentry tentry;
 252
 253     memset(&tentry, 0, sizeof(tentry));
 254     tentry.next = ntohl(cheader.freePtr);
 255     tentry.flags |= PRFREE;
 256     cheader.freePtr = htonl(pos);
 257     code =
 258         pr_Write(at, 0, 8, (char *)&cheader.freePtr, sizeof(cheader.freePtr));
 259     if (code != 0)
 260         return code;
 261     code = pr_WriteEntry(at, 0, pos, &tentry);
 262     if (code != 0)
 263         return code;
 264     return PRSUCCESS;
 265 }
 266
 267 afs_int32
 268 FindByID(struct ubik_trans *at, afs_int32 aid)
 269 {
 270     /* returns address of entry if found, 0 otherwise */
 271     afs_int32 code;
 272     afs_int32 i;
 273     struct prentry tentry;
 274     afs_int32 entry;
 275
 276     if ((aid == PRBADID) || (aid == 0))
 277         return 0;
 278     i = IDHash(aid);
 279     entry = ntohl(cheader.idHash[i]);
 280     if (entry == 0)
 281         return entry;
 282     memset(&tentry, 0, sizeof(tentry));
 283     code = pr_ReadEntry(at, 0, entry, &tentry);
 284     if (code != 0)
 285         return 0;
 286     if (aid == tentry.id)
 287         return entry;
 288     osi_Assert(entry != tentry.nextID);
 289     entry = tentry.nextID;
 290     while (entry != 0) {
 291         memset(&tentry, 0, sizeof(tentry));
 292         code = pr_ReadEntry(at, 0, entry, &tentry);
 293         if (code != 0)
 294             return 0;
 295         if (aid == tentry.id)
 296             return entry;
 297         osi_Assert(entry != tentry.nextID);
 298         entry = tentry.nextID;
 299     }
 300     return 0;
 301 }
 302
 303 afs_int32
 304 FindByName(struct ubik_trans *at, char aname[PR_MAXNAMELEN], struct prentry *tentryp)
 305 {
 306     /* ditto */
 307     afs_int32 code;
 308     afs_int32 i;
 309     afs_int32 entry;
 310
 311     i = NameHash(aname);
 312     entry = ntohl(cheader.nameHash[i]);
 313     if (entry == 0)
 314         return entry;
 315     memset(tentryp, 0, sizeof(struct prentry));
 316     code = pr_ReadEntry(at, 0, entry, tentryp);
 317     if (code != 0)
 318         return 0;
 319     if ((strncmp(aname, tentryp->name, PR_MAXNAMELEN)) == 0)
 320         return entry;
 321     osi_Assert(entry != tentryp->nextName);
 322     entry = tentryp->nextName;
 323     while (entry != 0) {
 324         memset(tentryp, 0, sizeof(struct prentry));
 325         code = pr_ReadEntry(at, 0, entry, tentryp);
 326         if (code != 0)
 327             return 0;
 328         if ((strncmp(aname, tentryp->name, PR_MAXNAMELEN)) == 0)
 329             return entry;
 330         osi_Assert(entry != tentryp->nextName);
 331         entry = tentryp->nextName;
 332     }
 333     return 0;
 334 }
 335
 336 afs_int32
 337 AllocID(struct ubik_trans *at, afs_int32 flag, afs_int32 *aid)
 338 {
 339     /* allocs an id from the proper area of address space, based on flag */
 340     afs_int32 code = 1;
 341     afs_int32 i = 0;
 342     int maxcount = 50;  /* to prevent infinite loops */
 343
 344     if (flag & PRGRP) {
 345         *aid = ntohl(cheader.maxGroup);
 346         while (code && i < maxcount) {
 347             --(*aid);
 348             code = FindByID(at, *aid);
 349             i++;
 350         }
 351         if (code)
 352             return PRNOIDS;
 353         cheader.maxGroup = htonl(*aid);
 354         code =
 355             pr_Write(at, 0, 16, (char *)&cheader.maxGroup,
 356                      sizeof(cheader.maxGroup));
 357         if (code)
 358             return PRDBFAIL;
 359         return PRSUCCESS;
 360     } else if (flag & PRFOREIGN) {
 361         *aid = ntohl(cheader.maxForeign);
 362         while (code && i < maxcount) {
 363             ++(*aid);
 364             code = FindByID(at, *aid);
 365             i++;
 366         }
 367         if (code)
 368             return PRNOIDS;
 369         cheader.maxForeign = htonl(*aid);
 370         code =
 371             pr_Write(at, 0, 24, (char *)&cheader.maxForeign,
 372                      sizeof(cheader.maxForeign));
 373         if (code)
 374             return PRDBFAIL;
 375         return PRSUCCESS;
 376     } else {
 377         *aid = ntohl(cheader.maxID);
 378         while (code && i < maxcount) {
 379             ++(*aid);
 380             code = FindByID(at, *aid);
 381             i++;
 382         }
 383         if (code)
 384             return PRNOIDS;
 385         cheader.maxID = htonl(*aid);
 386         code =
 387             pr_Write(at, 0, 20, (char *)&cheader.maxID,
 388                      sizeof(cheader.maxID));
 389         if (code)
 390             return PRDBFAIL;
 391         return PRSUCCESS;
 392     }
 393 }
 394
 395 afs_int32
 396 IDToName(struct ubik_trans *at, afs_int32 aid, char aname[PR_MAXNAMELEN])
 397 {
 398     afs_int32 temp;
 399     struct prentry tentry;
 400     afs_int32 code;
 401
 402     temp = FindByID(at, aid);
 403     if (temp == 0)
 404         return PRNOENT;
 405     code = pr_Read(at, 0, temp, (char *)&tentry, sizeof(tentry));
 406     if (code)
 407         return code;
 408     strncpy(aname, tentry.name, PR_MAXNAMELEN);
 409     return PRSUCCESS;
 410 }
 411
 412 afs_int32
 413 NameToID(struct ubik_trans *at, char aname[PR_MAXNAMELEN], afs_int32 *aid)
 414 {
 415     afs_int32 temp;
 416     struct prentry tentry;
 417
 418     temp = FindByName(at, aname, &tentry);
 419     if (!temp)
 420         return PRNOENT;
 421     *aid = tentry.id;
 422     return PRSUCCESS;
 423 }
 424
 425 int
 426 IDCmp(const void *a, const void *b)
 427 {
 428     /* used to sort CPS's so that comparison with acl's is easier */
 429     if (*(afs_int32 *)a > *(afs_int32 *)b) {
 430         return 1;
 431     } else if (*(afs_int32 *)a == *(afs_int32 *)b) {
 432         return 0;
 433     } else /* (*a < *b) */ {
 434         return -1;
 435     }
 436 }
 437
 438 afs_int32
 439 RemoveFromIDHash(struct ubik_trans *tt, afs_int32 aid, afs_int32 *loc)          /* ??? in case ID hashed twice ??? */
 440 {
 441     /* remove entry designated by aid from id hash table */
 442     afs_int32 code;
 443     afs_int32 current, trail, i;
 444     struct prentry tentry;
 445     struct prentry bentry;
 446
 447     if ((aid == PRBADID) || (aid == 0))
 448         return PRINCONSISTENT;
 449     i = IDHash(aid);
 450     current = ntohl(cheader.idHash[i]);
 451     memset(&tentry, 0, sizeof(tentry));
 452     memset(&bentry, 0, sizeof(bentry));
 453     trail = 0;
 454     if (current == 0)
 455         return PRSUCCESS;       /* already gone */
 456     code = pr_ReadEntry(tt, 0, current, &tentry);
 457     if (code)
 458         return PRDBFAIL;
 459     while (aid != tentry.id) {
 460         osi_Assert(trail != current);
 461         trail = current;
 462         current = tentry.nextID;
 463         if (current == 0)
 464             break;
 465         code = pr_ReadEntry(tt, 0, current, &tentry);
 466         if (code)
 467             return PRDBFAIL;
 468     }
 469     if (current == 0)
 470         return PRSUCCESS;       /* we didn't find him, so he's already gone */
 471     if (trail == 0) {
 472         /* it's the first entry! */
 473         cheader.idHash[i] = htonl(tentry.nextID);
 474         code =
 475             pr_Write(tt, 0, 72 + HASHSIZE * 4 + i * 4,
 476                      (char *)&cheader.idHash[i], sizeof(cheader.idHash[i]));
 477         if (code)
 478             return PRDBFAIL;
 479     } else {
 480         code = pr_ReadEntry(tt, 0, trail, &bentry);
 481         if (code)
 482             return PRDBFAIL;
 483         bentry.nextID = tentry.nextID;
 484         code = pr_WriteEntry(tt, 0, trail, &bentry);
 485     }
 486     *loc = current;
 487     return PRSUCCESS;
 488 }
 489
 490 afs_int32
 491 AddToIDHash(struct ubik_trans *tt, afs_int32 aid, afs_int32 loc)
 492 {
 493     /* add entry at loc designated by aid to id hash table */
 494     afs_int32 code;
 495     afs_int32 i;
 496     struct prentry tentry;
 497
 498     if ((aid == PRBADID) || (aid == 0))
 499         return PRINCONSISTENT;
 500     i = IDHash(aid);
 501     memset(&tentry, 0, sizeof(tentry));
 502     code = pr_ReadEntry(tt, 0, loc, &tentry);
 503     if (code)
 504         return PRDBFAIL;
 505     tentry.nextID = ntohl(cheader.idHash[i]);
 506     cheader.idHash[i] = htonl(loc);
 507     code = pr_WriteEntry(tt, 0, loc, &tentry);
 508     if (code)
 509         return PRDBFAIL;
 510     code =
 511         pr_Write(tt, 0, 72 + HASHSIZE * 4 + i * 4, (char *)&cheader.idHash[i],
 512                  sizeof(cheader.idHash[i]));
 513     if (code)
 514         return PRDBFAIL;
 515     return PRSUCCESS;
 516 }
 517
 518 afs_int32
 519 RemoveFromNameHash(struct ubik_trans *tt, char *aname, afs_int32 *loc)
 520 {
 521     /* remove from name hash */
 522     afs_int32 code;
 523     afs_int32 current, trail, i;
 524     struct prentry tentry;
 525     struct prentry bentry;
 526
 527     i = NameHash(aname);
 528     current = ntohl(cheader.nameHash[i]);
 529     memset(&tentry, 0, sizeof(tentry));
 530     memset(&bentry, 0, sizeof(bentry));
 531     trail = 0;
 532     if (current == 0)
 533         return PRSUCCESS;       /* already gone */
 534     code = pr_ReadEntry(tt, 0, current, &tentry);
 535     if (code)
 536         return PRDBFAIL;
 537     while (strcmp(aname, tentry.name)) {
 538         osi_Assert(trail != current);
 539         trail = current;
 540         current = tentry.nextName;
 541         if (current == 0)
 542             break;
 543         code = pr_ReadEntry(tt, 0, current, &tentry);
 544         if (code)
 545             return PRDBFAIL;
 546     }
 547     if (current == 0)
 548         return PRSUCCESS;       /* we didn't find him, already gone */
 549     if (trail == 0) {
 550         /* it's the first entry! */
 551         cheader.nameHash[i] = htonl(tentry.nextName);
 552         code =
 553             pr_Write(tt, 0, 72 + i * 4, (char *)&cheader.nameHash[i],
 554                      sizeof(cheader.nameHash[i]));
 555         if (code)
 556             return PRDBFAIL;
 557     } else {
 558         code = pr_ReadEntry(tt, 0, trail, &bentry);
 559         if (code)
 560             return PRDBFAIL;
 561         bentry.nextName = tentry.nextName;
 562         code = pr_WriteEntry(tt, 0, trail, &bentry);
 563     }
 564     *loc = current;
 565     return PRSUCCESS;
 566 }
 567
 568 afs_int32
 569 AddToNameHash(struct ubik_trans *tt, char *aname, afs_int32 loc)
 570 {
 571     /* add to name hash */
 572     afs_int32 code;
 573     afs_int32 i;
 574     struct prentry tentry;
 575
 576     i = NameHash(aname);
 577     memset(&tentry, 0, sizeof(tentry));
 578     code = pr_ReadEntry(tt, 0, loc, &tentry);
 579     if (code)
 580         return PRDBFAIL;
 581     tentry.nextName = ntohl(cheader.nameHash[i]);
 582     cheader.nameHash[i] = htonl(loc);
 583     code = pr_WriteEntry(tt, 0, loc, &tentry);
 584     if (code)
 585         return PRDBFAIL;
 586     code =
 587         pr_Write(tt, 0, 72 + i * 4, (char *)&cheader.nameHash[i],
 588                  sizeof(cheader.nameHash[i]));
 589     if (code)
 590         return PRDBFAIL;
 591     return PRSUCCESS;
 592 }
 593
 594 afs_int32
 595 AddToOwnerChain(struct ubik_trans *at, afs_int32 gid, afs_int32 oid)
 596 {
 597     /* add entry designated by gid to owner chain of entry designated by oid */
 598     afs_int32 code;
 599     afs_int32 loc;
 600     struct prentry tentry;
 601     struct prentry gentry;
 602     afs_int32 gloc;
 603
 604     loc = FindByID(at, oid);
 605     if (!loc)
 606         return PRNOENT;
 607     code = pr_ReadEntry(at, 0, loc, &tentry);
 608     if (code != 0)
 609         return PRDBFAIL;
 610     if (oid == gid) {           /* added it to its own chain */
 611         tentry.nextOwned = tentry.owned;
 612         tentry.owned = loc;
 613     } else {
 614         gloc = FindByID(at, gid);
 615         code = pr_ReadEntry(at, 0, gloc, &gentry);
 616         if (code != 0)
 617             return PRDBFAIL;
 618         gentry.nextOwned = tentry.owned;
 619         tentry.owned = gloc;
 620         code = pr_WriteEntry(at, 0, gloc, &gentry);
 621         if (code != 0)
 622             return PRDBFAIL;
 623     }
 624     code = pr_WriteEntry(at, 0, loc, &tentry);
 625     if (code != 0)
 626         return PRDBFAIL;
 627     return PRSUCCESS;
 628 }
 629
 630 /* RemoveFromOwnerChain - remove gid from owner chain for oid */
 631
 632 afs_int32
 633 RemoveFromOwnerChain(struct ubik_trans *at, afs_int32 gid, afs_int32 oid)
 634 {
 635     afs_int32 code;
 636     afs_int32 nptr;
 637     struct prentry thisEntry;
 638     struct prentry thatEntry;
 639     struct prentry *te;         /* pointer to current (this) entry */
 640     struct prentry *le;         /* pointer to previous (last) entry */
 641     afs_int32 loc, lastLoc;
 642
 643     loc = FindByID(at, oid);
 644     if (!loc)
 645         return PRNOENT;
 646     code = pr_ReadEntry(at, 0, loc, &thisEntry);
 647     if (code != 0)
 648         return PRDBFAIL;
 649     le = &thisEntry;
 650     lastLoc = 0;
 651     nptr = thisEntry.owned;
 652     while (nptr != 0) {
 653         if (nptr == lastLoc)
 654             te = le;
 655         else {
 656             if (&thisEntry == le)
 657                 te = &thatEntry;
 658             else
 659                 te = &thisEntry;
 660             code = pr_ReadEntry(at, 0, nptr, te);
 661             if (code != 0)
 662                 return PRDBFAIL;
 663         }
 664         if (te->id == gid) {
 665             /* found it */
 666             if (lastLoc == 0) { /* modifying first of chain */
 667                 le->owned = te->nextOwned;
 668                 lastLoc = loc;  /* so we write to correct location */
 669             } else
 670                 le->nextOwned = te->nextOwned;
 671             te->nextOwned = 0;
 672             if (te != le) {
 673                 code = pr_WriteEntry(at, 0, nptr, te);
 674                 if (code != 0)
 675                     return PRDBFAIL;
 676             }
 677             code = pr_WriteEntry(at, 0, lastLoc, le);
 678             if (code != 0)
 679                 return PRDBFAIL;
 680             return PRSUCCESS;
 681         }
 682         lastLoc = nptr;
 683         le = te;
 684         nptr = te->nextOwned;
 685     }
 686     return PRSUCCESS;           /* already removed? */
 687 }
 688
 689 /* AddToOrphan - add gid to orphan list, as it's owner has died */
 690
 691 afs_int32
 692 AddToOrphan(struct ubik_trans *at, afs_int32 gid)
 693 {
 694     afs_int32 code;
 695     afs_int32 loc;
 696     struct prentry tentry;
 697
 698     loc = FindByID(at, gid);
 699     if (!loc)
 700         return PRNOENT;
 701     code = pr_ReadEntry(at, 0, loc, &tentry);
 702     if (code != 0)
 703         return PRDBFAIL;
 704     tentry.nextOwned = ntohl(cheader.orphan);
 705     code = set_header_word(at, orphan, htonl(loc));
 706     if (code != 0)
 707         return PRDBFAIL;
 708     tentry.owner = 0;           /* so there's no confusion later */
 709     code = pr_WriteEntry(at, 0, loc, &tentry);
 710     if (code != 0)
 711         return PRDBFAIL;
 712     return PRSUCCESS;
 713 }
 714
 715 afs_int32
 716 RemoveFromOrphan(struct ubik_trans *at, afs_int32 gid)
 717 {
 718     /* remove gid from the orphan list */
 719     afs_int32 code;
 720     afs_int32 loc;
 721     afs_int32 nptr;
 722     struct prentry tentry;
 723     struct prentry bentry;
 724
 725     loc = FindByID(at, gid);
 726     if (!loc)
 727         return PRNOENT;
 728     code = pr_ReadEntry(at, 0, loc, &tentry);
 729     if (code != 0)
 730         return PRDBFAIL;
 731     if (cheader.orphan == htonl(loc)) {
 732         cheader.orphan = htonl(tentry.nextOwned);
 733         tentry.nextOwned = 0;
 734         code =
 735             pr_Write(at, 0, 32, (char *)&cheader.orphan,
 736                      sizeof(cheader.orphan));
 737         if (code != 0)
 738             return PRDBFAIL;
 739         code = pr_WriteEntry(at, 0, loc, &tentry);
 740         if (code != 0)
 741             return PRDBFAIL;
 742         return PRSUCCESS;
 743     }
 744     nptr = ntohl(cheader.orphan);
 745     memset(&bentry, 0, sizeof(bentry));
 746     loc = 0;
 747     while (nptr != 0) {
 748         code = pr_ReadEntry(at, 0, nptr, &tentry);
 749         if (code != 0)
 750             return PRDBFAIL;
 751         if (gid == tentry.id) {
 752             /* found it */
 753             bentry.nextOwned = tentry.nextOwned;
 754             tentry.nextOwned = 0;
 755             code = pr_WriteEntry(at, 0, loc, &bentry);
 756             if (code != 0)
 757                 return PRDBFAIL;
 758             code = pr_WriteEntry(at, 0, nptr, &tentry);
 759             if (code != 0)
 760                 return PRDBFAIL;
 761             return PRSUCCESS;
 762         }
 763         loc = nptr;
 764         nptr = tentry.nextOwned;
 765         memcpy(&bentry, &tentry, sizeof(tentry));
 766     }
 767     return PRSUCCESS;
 768 }
 769
 770 afs_int32
 771 IsOwnerOf(struct ubik_trans *at, afs_int32 aid, afs_int32 gid)
 772 {
 773     /* returns 1 if aid is the owner of gid, 0 otherwise */
 774     afs_int32 code;
 775     struct prentry tentry;
 776     afs_int32 loc;
 777
 778     loc = FindByID(at, gid);
 779     if (!loc)
 780         return 0;
 781     code = pr_ReadEntry(at, 0, loc, &tentry);
 782     if (code != 0)
 783         return 0;
 784     if (tentry.owner == aid)
 785         return 1;
 786     return 0;
 787 }
 788
 789 afs_int32
 790 OwnerOf(struct ubik_trans *at, afs_int32 gid)
 791 {
 792     /* returns the owner of gid */
 793     afs_int32 code;
 794     afs_int32 loc;
 795     struct prentry tentry;
 796
 797     loc = FindByID(at, gid);
 798     if (!loc)
 799         return 0;
 800     code = pr_ReadEntry(at, 0, loc, &tentry);
 801     if (code != 0)
 802         return 0;
 803     return tentry.owner;
 804 }
 805
 806
 807 afs_int32
 808 IsAMemberOf(struct ubik_trans *at, afs_int32 aid, afs_int32 gid)
 809 {
 810     /* returns true if aid is a member of gid */
 811 #if !defined(SUPERGROUPS)
 812     struct prentry tentry;
 813     struct contentry centry;
 814     afs_int32 code;
 815     afs_int32 i;
 816     afs_int32 loc;
 817 #endif
 818
 819     /* special case anyuser and authuser */
 820     if (gid == ANYUSERID)
 821         return 1;
 822     if (gid == AUTHUSERID && aid != ANONYMOUSID)
 823         return 1;
 824     /* check -localauth case */
 825     if (gid == SYSADMINID && aid == SYSADMINID)
 826         return 1;
 827     if ((gid == 0) || (aid == 0))
 828         return 0;
 829 #if defined(SUPERGROUPS)
 830     return IsAMemberOfSG(at, aid, gid, depthsg);
 831 #else
 832     loc = FindByID(at, gid);
 833     if (!loc)
 834         return 0;
 835     memset(&tentry, 0, sizeof(tentry));
 836     code = pr_ReadEntry(at, 0, loc, &tentry);
 837     if (code)
 838         return 0;
 839     if (!(tentry.flags & PRGRP))
 840         return 0;
 841     for (i = 0; i < PRSIZE; i++) {
 842         if (tentry.entries[i] == 0)
 843             return 0;
 844         if (tentry.entries[i] == aid)
 845             return 1;
 846     }
 847     if (tentry.next) {
 848         loc = tentry.next;
 849         while (loc) {
 850             memset(&centry, 0, sizeof(centry));
 851             code = pr_ReadCoEntry(at, 0, loc, &centry);
 852             if (code)
 853                 return 0;
 854             for (i = 0; i < COSIZE; i++) {
 855                 if (centry.entries[i] == aid)
 856                     return 1;
 857                 if (centry.entries[i] == 0)
 858                     return 0;
 859             }
 860             loc = centry.next;
 861         }
 862     }
 863     return 0;                   /* actually, should never get here */
 864 #endif
 865 }
 866
 867
 868 #if defined(SUPERGROUPS)
 869 afs_int32
 870 IsAMemberOfSG(struct ubik_trans *at, afs_int32 aid, afs_int32 gid, afs_int32 depth)
 871 {
 872     /* returns true if aid is a member of gid */
 873     struct prentry tentry;
 874     struct contentry centry;
 875     afs_int32 code;
 876     afs_int32 i;
 877     afs_int32 loc;
 878
 879     if (depth < 1)
 880         return 0;
 881     loc = FindByID(at, gid);
 882     if (!loc)
 883         return 0;
 884     memset(&tentry, 0, sizeof(tentry));
 885     code = pr_ReadEntry(at, 0, loc, &tentry);
 886     if (code)
 887         return 0;
 888     if (!(tentry.flags & PRGRP))
 889         return 0;
 890     for (i = 0; i < PRSIZE; i++) {
 891         gid = tentry.entries[i];
 892         if (gid == 0)
 893             return 0;
 894         if (gid == aid)
 895             return 1;
 896         if (gid == ANYUSERID)
 897             return 1;
 898         if (gid == AUTHUSERID && aid != ANONYMOUSID)
 899             return 1;
 900         if (gid < 0) {
 901 #ifndef AFS_PTHREAD_ENV
 902             IOMGR_Poll();
 903 #endif
 904             if (IsAMemberOfSG(at, aid, gid, depth - 1))
 905                 return 1;
 906         }
 907     }
 908     if (tentry.next) {
 909         loc = tentry.next;
 910         while (loc) {
 911             memset(&centry, 0, sizeof(centry));
 912             code = pr_ReadCoEntry(at, 0, loc, &centry);
 913             if (code)
 914                 return 0;
 915             for (i = 0; i < COSIZE; i++) {
 916                 gid = centry.entries[i];
 917                 if (gid == 0)
 918                     return 0;
 919                 if (gid == aid)
 920                     return 1;
 921                 if (gid == ANYUSERID)
 922                     return 1;
 923                 if (gid == AUTHUSERID && aid != ANONYMOUSID)
 924                     return 1;
 925                 if (gid < 0) {
 926 #ifndef AFS_PTHREAD_ENV
 927                     IOMGR_Poll();
 928 #endif
 929                     if (IsAMemberOfSG(at, aid, gid, depth - 1))
 930                         return 1;
 931                 }
 932             }
 933             loc = centry.next;
 934         }
 935     }
 936     return 0;                   /* actually, should never get here */
 937 }
 938 #endif /* SUPERGROUPS */