src/ptserver/db_verify.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 #include <afsconfig.h>
  11 #include <afs/param.h>
  12 #include <afs/stds.h>
  13
  14 #include <roken.h>
  15
  16 /*
  17  *                      (3) Define a structure, idused, instead of an
  18  *                          array of long integers, idmap, to count group
  19  *                          memberships. These structures are on a linked
  20  *                          list, with each structure containing IDCOUNT
  21  *                          slots for id's.
  22  *                      (4) Add new functions to processs the structure
  23  *                          described above:
  24  *                             zeromap(), idcount(), inccount().
  25  *                      (5) Add code, primarily in WalkNextChain():
  26  *                           1. Test id's, allowing groups within groups.
  27  *                           2. Count the membership list for supergroups,
  28  *                              and follow the continuation chain for
  29  *                              supergroups.
  30  *                      (6) Add fprintf statements for various error
  31  *                          conditions.
  32  */
  33
  34
  35 #ifdef AFS_NT40_ENV
  36 #include <WINNT/afsevent.h>
  37 #else
  38 #include <sys/file.h>
  39 #endif
  40
  41 #include <afs/cellconfig.h>
  42 #include <afs/afsutil.h>
  43 #include <ubik.h>
  44 #include <afs/cmd.h>
  45 #include <afs/com_err.h>
  46
  47 #include "ptint.h"
  48 #include "pterror.h"
  49 #include "ptserver.h"
  50 #include "ptuser.h"
  51 #include "display.h"
  52
  53 struct prheader cheader;
  54 int fd;
  55 const char *pr_dbaseName;
  56 char *whoami = "db_verify";
  57 #define UBIK_HEADERSIZE 64
  58
  59 afs_int32
  60 printheader(struct prheader *h)
  61 {
  62     printf("Version           = %d\n", ntohl(h->version));
  63     printf("Header Size       = %d\n", ntohl(h->headerSize));
  64     printf("Free Ptr          = 0x%x\n", ntohl(h->freePtr));
  65     printf("EOF  Ptr          = 0x%x\n", ntohl(h->eofPtr));
  66     printf("Max Group     ID  = %d\n", ntohl(h->maxGroup));
  67     printf("Max User      ID  = %d\n", ntohl(h->maxID));
  68     printf("Max Foreign   ID  = %d\n", ntohl(h->maxForeign));
  69 /* printf("Max Sub/Super ID  = %d\n", ntohl(h->maxInst)); */
  70     printf("Orphaned groups   = %d\n", ntohl(h->orphan));
  71     printf("User      Count   = %d\n", ntohl(h->usercount));
  72     printf("Group     Count   = %d\n", ntohl(h->groupcount));
  73 /* printf("Foreign   Count   = %d\n", ntohl(h->foreigncount)); NYI */
  74 /* printf("Sub/super Count   = %d\n", ntohl(h->instcount));    NYI */
  75     printf("Name Hash         = %d buckets\n", HASHSIZE);
  76     printf("ID   Hash         = %d buckets\n", HASHSIZE);
  77     return 0;
  78 }
  79
  80 static afs_int32
  81 pr_Read(afs_int32 pos, void *buff, afs_int32 len)
  82 {
  83     afs_int32 code;
  84
  85     code = lseek(fd, UBIK_HEADERSIZE + pos, 0);
  86     if (code == -1)
  87         return errno;
  88
  89     code = read(fd, buff, len);
  90     if (code != len)
  91         return -1;
  92     if (code == -1)
  93         return errno;
  94
  95     return 0;
  96 }
  97
  98 /* InitDB ()
  99  *   Initializes the a transaction on the database and reads the header into
 100  * the static variable cheader.  If successful it returns a read-locked
 101  * transaction.  If ubik reports that cached database info should be up to date
 102  * the cheader structure is not re-read from the ubik.
 103  */
 104
 105 afs_int32
 106 ReadHeader(void)
 107 {
 108     afs_int32 code;
 109
 110     code = pr_Read(0, (char *)&cheader, sizeof(cheader));
 111     if (code) {
 112         afs_com_err(whoami, code, "couldn't read header");
 113         return code;
 114     }
 115     /* Check and see if database exists and is approximately OK. */
 116     if (ntohl(cheader.headerSize) != sizeof(cheader)
 117         || ntohl(cheader.eofPtr) == 0) {
 118         if (code)
 119             return code;
 120         afs_com_err(whoami, PRDBBAD, "header is bad");
 121         return PRDBBAD;
 122     }
 123     return 0;
 124 }
 125
 126 static afs_int32
 127 IDHash(afs_int32 x)
 128 {
 129     /* returns hash bucket for x */
 130     return ((abs(x)) % HASHSIZE);
 131 }
 132
 133 static afs_int32
 134 NameHash(char *aname)
 135 {
 136     /* returns hash bucket for aname */
 137     unsigned int hash = 0;
 138     int i;
 139 /* stolen directly from the HashString function in the vol package */
 140     for (i = strlen(aname), aname += i - 1; i--; aname--)
 141         hash = (hash * 31) + (*(unsigned char *)aname - 31);
 142     return (hash % HASHSIZE);
 143 }
 144
 145 #define MAP_NAMEHASH 1
 146 #define MAP_IDHASH 2
 147 #define MAP_HASHES (MAP_NAMEHASH | MAP_IDHASH)
 148 #define MAP_CONT 4
 149 #define MAP_FREE 8
 150 #define MAP_OWNED 0x10
 151 #define MAP_RECREATE 0x20
 152
 153 struct misc_data {
 154     int nEntries;               /* number of database entries */
 155     int anon;                   /* found anonymous Id */
 156     afs_int32 maxId;            /* user */
 157     afs_int32 minId;            /* group */
 158     afs_int32 maxForId;         /* foreign user id */
 159 #if defined(SUPERGROUPS)
 160 #define IDCOUNT 512
 161     struct idused {
 162         int idstart;
 163         afs_int32 idcount[IDCOUNT];
 164         struct idused *idnext;
 165     } *idmap;
 166 #else
 167     int idRange;                /* number of ids in map */
 168     afs_int32 *idmap;           /* map of all id's: midId is origin */
 169 #endif                          /* SUPERGROUPS */
 170     int nusers;                 /* counts of each type */
 171     int ngroups;
 172     int nforeigns;
 173     int ninsts;
 174     int ncells;
 175     int maxOwnerLength;         /* longest owner chain */
 176     int maxContLength;          /* longest chain of cont. blks */
 177     int orphanLength;           /* length of orphan list */
 178     int freeLength;             /* length of free list */
 179     int verbose;
 180     int listuheader;
 181     int listpheader;
 182     int listentries;
 183     FILE *recreate;             /* stream for recreate instructions */
 184 };
 185
 186 #if defined(SUPERGROUPS)
 187 void zeromap(struct idused *idmap);
 188 void inccount(struct idused **idmapp, int id);
 189 int idcount(struct idused **idmapp, int id);
 190 #endif
 191
 192 int
 193 readUbikHeader(struct misc_data *misc)
 194 {
 195     int offset, r;
 196     struct ubik_hdr uheader;
 197
 198     offset = lseek(fd, 0, 0);
 199     if (offset != 0) {
 200         printf("error: lseek to 0 failed: %d %d\n", offset, errno);
 201         return (-1);
 202     }
 203
 204     /* now read the info */
 205     r = read(fd, &uheader, sizeof(uheader));
 206     if (r != sizeof(uheader)) {
 207         printf("error: read of %" AFS_SIZET_FMT " bytes failed: %d %d\n",
 208                sizeof(uheader), r, errno);
 209         return (-1);
 210     }
 211
 212     uheader.magic = ntohl(uheader.magic);
 213     uheader.size = ntohs(uheader.size);
 214     uheader.version.epoch = ntohl(uheader.version.epoch);
 215     uheader.version.counter = ntohl(uheader.version.counter);
 216
 217     if (misc->listuheader) {
 218         printf("Ubik Header\n");
 219         printf("   Magic           = 0x%x\n", uheader.magic);
 220         printf("   Size            = %u\n", uheader.size);
 221         printf("   Version.epoch   = %u\n", uheader.version.epoch);
 222         printf("   Version.counter = %u\n", uheader.version.counter);
 223     }
 224
 225     if (uheader.size != UBIK_HEADERSIZE)
 226         printf("Ubik header size is %u (should be %u)\n", uheader.size,
 227                UBIK_HEADERSIZE);
 228     if (uheader.magic != UBIK_MAGIC)
 229         printf("Ubik header magic is 0x%x (should be 0x%x)\n", uheader.magic,
 230                UBIK_MAGIC);
 231
 232     return (0);
 233 }
 234
 235 afs_int32
 236 ConvertDiskAddress(afs_uint32 ea, int *eiP)
 237 {
 238     int i;
 239
 240     *eiP = -1;
 241
 242     if (ea < sizeof(cheader))
 243         return PRDBADDR;
 244     if (ea >= ntohl(cheader.eofPtr))
 245         return PRDBADDR;
 246     ea -= sizeof(cheader);
 247     i = ea / sizeof(struct prentry);
 248     if (i * sizeof(struct prentry) != ea)
 249         return PRDBADDR;
 250 /*    if ((i < 0) || (i >= misc->nEntries)) return PRDBADDR; */
 251     *eiP = i;
 252     return 0;
 253 }
 254
 255 int
 256 PrintEntryError(struct misc_data *misc, afs_int32 ea, struct prentry *e, int indent)
 257 {
 258
 259     pr_PrintEntry(stderr, /*net order */ 0, ea, e, indent);
 260     return 0;
 261 }
 262
 263 afs_int32
 264 WalkHashTable(afs_int32 hashtable[],    /* hash table to walk */
 265               int hashType,             /* hash function to use */
 266               char map[],               /* one byte per db entry */
 267               struct misc_data *misc)   /* stuff to keep track of */
 268 {
 269     afs_int32 code;
 270     int hi;                     /* index in hash table */
 271     afs_int32 ea;               /* entry's db addr */
 272     int ei;                     /* entry's index */
 273     char bit;                   /* bits to check for in map */
 274     struct prentry e;
 275     afs_int32 next_ea;
 276     afs_int32 id;
 277     afs_int32 flags;
 278     afs_int32 hash;
 279
 280     bit = hashType;
 281
 282     for (hi = 0; hi < HASHSIZE; hi++) {
 283         ea = 0;
 284         next_ea = ntohl(hashtable[hi]);
 285         while (next_ea) {
 286             code = ConvertDiskAddress(next_ea, &ei);
 287             if (code) {
 288                 fprintf(stderr, "Bad chain address %d\n", next_ea);
 289                 if (ea) {
 290                     fprintf(stderr, "Last entry in chain:\n");
 291                     if (PrintEntryError(misc, ea, &e, 2))
 292                         return PRDBBAD;
 293                 }
 294                 fprintf(stderr, "Skipping remainder of hash bucket %d\n", hi);
 295                 break;
 296             }
 297             ea = next_ea;
 298             code = pr_Read(ea, (char *)&e, sizeof(e));
 299             if (code)
 300                 return code;
 301
 302             id = ntohl(e.id);
 303
 304             if (((e.flags & htonl((PRGRP | PRINST))) == 0)
 305                 && (strchr(e.name, '@'))) {
 306                 /* Foreign user */
 307                 if (id > misc->maxForId)
 308                     misc->maxForId = id;
 309             } else {
 310                 if (id == ANONYMOUSID)
 311                     misc->anon++;
 312                 else if (id > misc->maxId)
 313                     misc->maxId = id;
 314                 if (id < misc->minId)
 315                     misc->minId = id;
 316             }
 317
 318             switch (hashType) {
 319             case MAP_NAMEHASH:
 320                 next_ea = ntohl(e.nextName);
 321                 hash = NameHash(e.name);
 322                 break;
 323             case MAP_IDHASH:
 324                 next_ea = ntohl(e.nextID);
 325                 hash = IDHash(id);
 326                 break;
 327             default:
 328                 fprintf(stderr, "unknown hash table type %d\n", hashType);
 329                 return PRBADARG;
 330             }
 331
 332             if (map[ei] & bit) {
 333                 fprintf(stderr,
 334                         "Entry found twice in hash table: bucket %d\n", hi);
 335                 if (hi != hash)
 336                     fprintf(stderr, "also in wrong bucket: should be in %d\n",
 337                             hash);
 338                 if (PrintEntryError(misc, ea, &e, 2))
 339                     return PRDBBAD;
 340                 break;
 341             }
 342             map[ei] |= bit;
 343
 344             flags = ntohl(e.flags);
 345             switch (flags & PRTYPE) {
 346             case PRFREE:
 347                 fprintf(stderr, "ENTRY IS FREE");
 348                 goto abort;
 349             case PRCONT:
 350                 fprintf(stderr, "ENTRY IS CONTINUATION");
 351                 goto abort;
 352             case PRGRP:
 353             case PRUSER:
 354                 break;
 355             case PRCELL:
 356             case PRFOREIGN:
 357             case PRINST:
 358                 fprintf(stderr, "ENTRY IS unexpected type (flags=0x%x)\n",
 359                         flags);
 360                 break;
 361             default:
 362                 fprintf(stderr, "ENTRY IS OF unknown type (flags=0x%x)\n",
 363                         flags);
 364                 goto abort;
 365             }
 366
 367             if (hash != hi) {
 368                 fprintf(stderr, "entry hashed in bucket %d should be %d\n",
 369                         hi, hash);
 370               abort:
 371                 if (PrintEntryError(misc, ea, &e, 2))
 372                     return PRDBBAD;
 373                 continue;
 374             }
 375         }
 376     }
 377     return 0;
 378 }
 379
 380 afs_int32
 381 WalkNextChain(char map[],               /* one byte per db entry */
 382               struct misc_data *misc,   /* stuff to keep track of */
 383               afs_int32 ea, struct prentry *e)
 384 {
 385     afs_int32 head;
 386     int bit;
 387     afs_int32 code;
 388     struct prentry c;           /* continuation entry */
 389     afs_int32 na;               /* next thread */
 390     int ni;
 391     afs_int32 eid = 0;
 392     int count = 0;              /* number of members, set to > 9999 if */
 393                                 /* list ends early */
 394     int i;
 395     int noErrors = 1;
 396     int length;                 /* length of chain */
 397 #if defined(SUPERGROUPS)
 398     int sgcount = 0;            /* number of sgentrys */
 399     afs_int32 sghead;
 400 #define g (((struct prentryg *)e))
 401 #endif
 402
 403     if (e) {
 404         head = ntohl(e->next);
 405         eid = ntohl(e->id);
 406         bit = MAP_CONT;
 407 #if defined(SUPERGROUPS)
 408         sghead = ntohl(g->next);
 409 #endif
 410         for (i = 0; i < PRSIZE; i++) {
 411             afs_int32 id = ntohl(e->entries[i]);
 412             if (id == PRBADID)
 413                 continue;
 414             else if (id) {
 415                 int eid_s, id_s;
 416                 count++;
 417                 /* in case the ids are large, convert to pure sign. */
 418                 if (id > 0)
 419                     id_s = 1;
 420                 else
 421                     id_s = -1;
 422                 if (eid > 0)
 423                     eid_s = 1;
 424                 else
 425                     eid_s = -1;
 426 #if defined(SUPERGROUPS)
 427                 if (id_s > 0 && eid_s > 0) {
 428                     fprintf(stderr,
 429                             "User can't be member of user in membership list\n");
 430                     if (PrintEntryError(misc, ea, e, 2))
 431                         return PRDBBAD;
 432                     noErrors = 0;
 433                 }
 434 #else
 435                 if (id_s * eid_s > 0) { /* sign should be different */
 436                     fprintf(stderr,
 437                             "Bad user/group dicotomy in membership list\n");
 438                     if (PrintEntryError(misc, ea, e, 2))
 439                         return PRDBBAD;
 440                     noErrors = 0;
 441                 }
 442 #endif /* SUPERGROUPS */
 443                 /* count each user as a group, and each group a user is in */
 444 #if defined(SUPERGROUPS)
 445                 if (!(id < 0 && eid < 0) && (id != ANONYMOUSID))
 446                     inccount(&misc->idmap, id);
 447 #else
 448                 if ((id >= misc->minId) && (id <= misc->maxId)
 449                     && (id != ANONYMOUSID))
 450                     misc->idmap[id - misc->minId]++;
 451 #endif /* SUPERGROUPS */
 452             } else if (head)
 453                 count = 9999;
 454             else
 455                 break;
 456         }
 457 #if defined(SUPERGROUPS)
 458         sghead = ntohl(g->nextsg);
 459         if ((e->flags & htonl(PRGRP))) {
 460             for (i = 0; i < SGSIZE; ++i) {
 461                 afs_int32 id = ntohl(g->supergroup[i]);
 462                 if (id == PRBADID)
 463                     continue;
 464                 else if (id) {
 465                     if (id > 0) {
 466                         fprintf(stderr,
 467                                 "User can't be member of supergroup list\n");
 468                         if (PrintEntryError(misc, ea, e, 2))
 469                             return PRDBBAD;
 470                         noErrors = 0;
 471                     }
 472                     sgcount++;
 473                     inccount(&misc->idmap, id);
 474                 }
 475             }
 476         }
 477 #endif /* SUPERGROUPS */
 478     } else {
 479         head = ntohl(cheader.freePtr);
 480 #if defined(SUPERGROUPS)
 481         sghead = 0;
 482 #endif
 483         bit = MAP_FREE;
 484     }
 485
 486 #if defined(SUPERGROUPS)
 487     length = 0;
 488     for (na = sghead; na; na = ntohl(c.next)) {
 489         code = ConvertDiskAddress(na, &ni);
 490         if (code) {
 491             fprintf(stderr, "Bad SGcontinuation ptr %d", na);
 492             if (PrintEntryError(misc, ea, e, 2))
 493                 return PRDBBAD;
 494             if (na != sghead) {
 495                 fprintf(stderr, "last block: \n");
 496                 if (PrintEntryError(misc, na, &c, 4))
 497                     return PRDBBAD;
 498             }
 499             return 0;
 500         }
 501         code = pr_Read(na, (char *)&c, sizeof(c));
 502         if (code)
 503             return code;
 504         length++;
 505
 506         if (map[ni]) {
 507             fprintf(stderr, "Continuation entry reused\n");
 508             if (PrintEntryError(misc, ea, e, 2))
 509                 return PRDBBAD;
 510             if (PrintEntryError(misc, na, &c, 4))
 511                 return PRDBBAD;
 512             noErrors = 0;
 513             break;
 514         }
 515         map[ni] |= bit;
 516         if ((ntohl(c.id) != eid)) {
 517             fprintf(stderr, "Continuation id mismatch\n");
 518             if (PrintEntryError(misc, ea, e, 2))
 519                 return PRDBBAD;
 520             if (PrintEntryError(misc, na, &c, 4))
 521                 return PRDBBAD;
 522             noErrors = 0;
 523             continue;
 524         }
 525
 526         /* update membership count */
 527         for (i = 0; i < COSIZE; i++) {
 528             afs_int32 id = ntohl(c.entries[i]);
 529             if (id == PRBADID)
 530                 continue;
 531             else if (id) {
 532                 int eid_s, id_s;
 533                 sgcount++;
 534                 /* in case the ids are large, convert to pure sign. */
 535                 if (id > 0)
 536                     id_s = 1;
 537                 else
 538                     id_s = -1;
 539                 if (eid > 0)
 540                     eid_s = 1;
 541                 else
 542                     eid_s = -1;
 543                 if (id_s > 0) {
 544                     fprintf(stderr,
 545                             "User can't be member of supergroup list\n");
 546                     if (PrintEntryError(misc, ea, e, 2))
 547                         return PRDBBAD;
 548                     if (PrintEntryError(misc, na, &c, 4))
 549                         return PRDBBAD;
 550                     noErrors = 0;
 551                 }
 552                 /* count each user as a group, and each group a user is in */
 553                 if ((id != ANONYMOUSID))
 554                     inccount(&misc->idmap, id);
 555             } else if (c.next)
 556                 count = 9999;
 557             else
 558                 break;
 559         }
 560     }
 561     if (length > misc->maxContLength)
 562         misc->maxContLength = length;
 563 #endif /* SUPERGROUPS */
 564     length = 0;
 565     for (na = head; na; na = ntohl(c.next)) {
 566         code = ConvertDiskAddress(na, &ni);
 567         if (code) {
 568             fprintf(stderr, "Bad continuation ptr %d", na);
 569             if (e == 0)
 570                 fprintf(stderr, "walking free list");
 571             else if (PrintEntryError(misc, ea, e, 2))
 572                 return PRDBBAD;
 573             if (na != head) {
 574                 fprintf(stderr, "last block: \n");
 575                 if (PrintEntryError(misc, na, &c, 4))
 576                     return PRDBBAD;
 577             }
 578             return 0;
 579         }
 580         code = pr_Read(na, (char *)&c, sizeof(c));
 581         if (code)
 582             return code;
 583         length++;
 584
 585         if (map[ni]) {
 586             fprintf(stderr, "Continuation entry reused\n");
 587             if (e == 0)
 588                 fprintf(stderr, "walking free list");
 589             else if (PrintEntryError(misc, ea, e, 2))
 590                 return PRDBBAD;
 591             if (PrintEntryError(misc, na, &c, 4))
 592                 return PRDBBAD;
 593             noErrors = 0;
 594             break;
 595         }
 596         map[ni] |= bit;
 597         if (e && (ntohl(c.id) != eid)) {
 598             fprintf(stderr, "Continuation id mismatch\n");
 599             if (e == 0)
 600                 fprintf(stderr, "walking free list");
 601             else if (PrintEntryError(misc, ea, e, 2))
 602                 return PRDBBAD;
 603             if (PrintEntryError(misc, na, &c, 4))
 604                 return PRDBBAD;
 605             noErrors = 0;
 606             continue;
 607         }
 608
 609         /* update membership count */
 610         if (e)
 611             for (i = 0; i < COSIZE; i++) {
 612                 afs_int32 id = ntohl(c.entries[i]);
 613                 if (id == PRBADID)
 614                     continue;
 615                 else if (id) {
 616                     int eid_s, id_s;
 617                     count++;
 618                     /* in case the ids are large, convert to pure sign. */
 619                     if (id > 0)
 620                         id_s = 1;
 621                     else
 622                         id_s = -1;
 623                     if (eid > 0)
 624                         eid_s = 1;
 625                     else
 626                         eid_s = -1;
 627 #if defined(SUPERGROUPS)
 628                     if (id_s > 0 && eid_s > 0) {
 629                         fprintf(stderr,
 630                                 "User can't be member of user in membership list\n");
 631                         if (PrintEntryError(misc, ea, e, 2))
 632                             return PRDBBAD;
 633                         if (PrintEntryError(misc, na, &c, 4))
 634                             return PRDBBAD;
 635                         noErrors = 0;
 636                     }
 637 #else
 638                     if (id_s * eid_s > 0) {     /* sign should be different */
 639                         fprintf(stderr,
 640                                 "Bad user/group dicotomy in membership list\n");
 641                         if (PrintEntryError(misc, ea, e, 2))
 642                             return PRDBBAD;
 643                         if (PrintEntryError(misc, na, &c, 4))
 644                             return PRDBBAD;
 645                         noErrors = 0;
 646                     }
 647 #endif /* SUPERGROUPS */
 648                     /* count each user as a group, and each group a user is in */
 649 #if defined(SUPERGROUPS)
 650                     if (!(id < 0 && eid < 0) && (id != ANONYMOUSID))
 651                         inccount(&misc->idmap, id);
 652 #else
 653                     if ((id >= misc->minId) && (id <= misc->maxId)
 654                         && (id != ANONYMOUSID))
 655                         misc->idmap[id - misc->minId]++;
 656 #endif /* SUPERGROUPS */
 657                 } else if (c.next)
 658                     count = 9999;
 659                 else
 660                     break;
 661             }
 662     }
 663     if (e && noErrors && (count != ntohl(e->count))) {
 664 #if defined(SUPERGROUPS)
 665         if (count >= 9999)
 666             fprintf(stderr, "Membership list ends early\n");
 667 #else
 668         if (count > 9999)
 669             fprintf(stderr, "Membership list ends early\n");
 670 #endif /* SUPERGROUPS */
 671         fprintf(stderr, "Count was %d should be %d\n", count,
 672                 ntohl(e->count));
 673         if (PrintEntryError(misc, ea, e, 2))
 674             return PRDBBAD;
 675 #if defined(SUPERGROUPS)
 676         noErrors = 0;
 677     }
 678     if (e && (e->flags & htonl(PRGRP)) && (sgcount != ntohl(g->countsg))) {
 679         fprintf(stderr, "SGCount was %d should be %d\n", sgcount,
 680                 ntohl(g->countsg));
 681         if (PrintEntryError(misc, ea, e, 2))
 682             return PRDBBAD;
 683 #endif
 684     }
 685
 686     if (e) {
 687         if (length > misc->maxContLength)
 688             misc->maxContLength = length;
 689     } else
 690         misc->freeLength = length;
 691
 692     return 0;
 693 #if defined(SUPERGROUPS)
 694 #undef g
 695 #endif
 696 }
 697
 698 afs_int32
 699 WalkOwnedChain(char map[],              /* one byte per db entry */
 700                struct misc_data *misc,  /* stuff to keep track of */
 701                afs_int32 ea, struct prentry *e)
 702 {
 703     afs_int32 head;
 704     afs_int32 code;
 705     struct prentry c;           /* continuation entry */
 706     afs_int32 na;               /* next thread */
 707     int ni;
 708     afs_int32 eid = 0;
 709     int length;                 /* length of chain */
 710
 711     if (e) {
 712         head = ntohl(e->owned);
 713         eid = ntohl(e->id);
 714     } else
 715         head = ntohl(cheader.orphan);
 716
 717     length = 0;
 718     for (na = head; na; na = ntohl(c.nextOwned)) {
 719         code = ConvertDiskAddress(na, &ni);
 720         if (code) {
 721             fprintf(stderr, "Bad owned list ptr %d", na);
 722             if (e == 0)
 723                 fprintf(stderr, "walking orphan list");
 724             else if (PrintEntryError(misc, ea, e, 2))
 725                 return PRDBBAD;
 726             if (na != head) {
 727                 fprintf(stderr, "last block: \n");
 728                 if (PrintEntryError(misc, na, &c, 4))
 729                     return PRDBBAD;
 730             }
 731             return 0;
 732         }
 733         code = pr_Read(na, (char *)&c, sizeof(c));
 734         if (code)
 735             return code;
 736         length++;
 737
 738         if (map[ni] & MAP_OWNED) {
 739             fprintf(stderr, "Entry on multiple owner chains\n");
 740             if (e == 0)
 741                 fprintf(stderr, "walking orphan list");
 742             else if (PrintEntryError(misc, ea, e, 2))
 743                 return PRDBBAD;
 744             if (PrintEntryError(misc, na, &c, 4))
 745                 return PRDBBAD;
 746             break;
 747         }
 748         map[ni] |= MAP_OWNED;
 749         if ((map[ni] & MAP_HASHES) != MAP_HASHES) {
 750             fprintf(stderr, "Owned entry not hashed properly\n");
 751           abort:
 752             if (e == 0)
 753                 fprintf(stderr, "walking orphan list");
 754             else if (PrintEntryError(misc, ea, e, 2))
 755                 return PRDBBAD;
 756             if (PrintEntryError(misc, na, &c, 4))
 757                 return PRDBBAD;
 758             continue;
 759         }
 760         if (e) {
 761             if (ntohl(c.owner) != eid) {
 762                 fprintf(stderr, "Owner id mismatch\n");
 763                 goto abort;
 764             }
 765         } else /* orphan */ if (c.owner) {
 766             fprintf(stderr, "Orphan group owner not zero\n");
 767             goto abort;
 768         }
 769     }
 770
 771     if (e) {
 772         if (length > misc->maxOwnerLength)
 773             misc->maxOwnerLength = length;
 774     } else
 775         misc->orphanLength = length;
 776
 777     return 0;
 778 }
 779
 780 afs_int32
 781 WalkChains(char map[],          /* one byte per db entry */
 782            struct misc_data *misc)      /* stuff to keep track of */
 783 {
 784     afs_int32 code;
 785     int ei;
 786     afs_int32 ea;               /* entry's db addr */
 787     struct prentry e;
 788     afs_int32 id;
 789     int type;
 790
 791     /* check all entries found in hash table walks */
 792     for (ei = 0; ei < misc->nEntries; ei++)
 793         if (map[ei] & MAP_HASHES) {
 794             ea = ei * sizeof(struct prentry) + sizeof(cheader);
 795             code = pr_Read(ea, (char *)&e, sizeof(e));
 796             if (code)
 797                 return code;
 798
 799             if ((map[ei] & MAP_HASHES) != MAP_HASHES) {
 800                 fprintf(stderr, "entry not in both hashtables\n");
 801                 if ((map[ei] & MAP_NAMEHASH) != MAP_NAMEHASH)
 802                     fprintf(stderr, "--> entry not in Name hashtable\n");
 803                 if ((map[ei] & MAP_IDHASH) != MAP_IDHASH)
 804                     fprintf(stderr, "--> entry not in ID hashtable\n");
 805
 806               abort:
 807                 if (PrintEntryError(misc, ea, &e, 2))
 808                     return PRDBBAD;
 809                 continue;
 810             }
 811
 812             id = ntohl(e.id);
 813
 814             type = ntohl(e.flags) & PRTYPE;
 815             switch (type) {
 816             case PRGRP:
 817                 if (id >= 0) {
 818                     fprintf(stderr, "Group id not negative\n");
 819                     goto abort;
 820                 }
 821                 /* special case sysadmin: it owns itself */
 822                 if (id == SYSADMINID) {
 823                     if (ntohl(e.owner) != SYSADMINID) {
 824                         fprintf(stderr,
 825                                 "System:administrators doesn't own itself\n");
 826                         goto abort;
 827                     }
 828                 }
 829                 code = WalkOwnedChain(map, misc, ea, &e);
 830                 if (code)
 831                     return code;
 832                 code = WalkNextChain(map, misc, ea, &e);
 833                 if (code)
 834                     return code;
 835                 misc->ngroups++;
 836                 break;
 837             case PRUSER:
 838                 if (id <= 0) {
 839 #if defined(SUPERGROUPS)
 840                     fprintf(stderr, "User id not positive\n");
 841 #else
 842                     fprintf(stderr, "User id negative\n");
 843 #endif
 844                     goto abort;
 845                 }
 846
 847                 /* Users are owned by sysadmin, but sysadmin doesn't have an owner
 848                  * chain.  Check this then set the owned bit. */
 849                 if (ntohl(e.owner) != SYSADMINID) {
 850                     fprintf(stderr,
 851                             "User not owned by system:administrators\n");
 852                     goto abort;
 853                 }
 854                 if (e.nextOwned) {
 855                     fprintf(stderr, "User has owned pointer\n");
 856                     goto abort;
 857                 }
 858                 map[ei] |= MAP_OWNED;
 859
 860                 code = WalkOwnedChain(map, misc, ea, &e);
 861                 if (code)
 862                     return code;
 863                 code = WalkNextChain(map, misc, ea, &e);
 864                 if (code)
 865                     return code;
 866                 if (strchr(e.name, '@') == 0) {
 867                     misc->nusers++;     /* Not a foreign user */
 868                 } else {
 869                     misc->nforeigns++;  /* A foreign user */
 870                 }
 871                 break;
 872             case PRFREE:
 873             case PRCONT:
 874             case PRCELL:
 875                 misc->ncells++;
 876                 break;
 877             case PRFOREIGN:
 878                 fprintf(stderr,
 879                         "ENTRY IS unexpected type [PRFOREIGN] (flags=0x%x)\n",
 880                         ntohl(e.flags));
 881                 break;
 882             case PRINST:
 883                 misc->ninsts++;
 884                 break;
 885             default:
 886                 fprintf(stderr, "entry with unexpected type");
 887                 goto abort;
 888             }
 889         }
 890
 891     return 0;
 892 }
 893
 894 afs_int32
 895 GC(char map[], struct misc_data *misc)
 896 {
 897     afs_int32 code;
 898     int ei;
 899     afs_int32 ea;
 900     struct prentry e;
 901     char m;
 902
 903     for (ei = 0; ei < misc->nEntries; ei++) {
 904         ea = ei * sizeof(struct prentry) + sizeof(cheader);
 905         code = pr_Read(ea, (char *)&e, sizeof(e));
 906         if (code)
 907             return code;
 908         m = map[ei];
 909         if (m == 0) {
 910             fprintf(stderr, "Unreferenced entry:");
 911             if (PrintEntryError(misc, ea, &e, 2))
 912                 return PRDBBAD;
 913         }
 914         /* all users and groups should be owned, and their membership counts
 915          * should be okay */
 916         else if ((m & MAP_HASHES) == MAP_HASHES) {
 917             afs_int32 id;
 918             int refCount;
 919             if (!(m & MAP_OWNED)) {
 920                 fprintf(stderr, "Entry not on any owner chain:\n");
 921                 if (PrintEntryError(misc, ea, &e, 2))
 922                     return PRDBBAD;
 923             }
 924             id = ntohl(e.id);
 925 #if defined(SUPERGROUPS)
 926             if ((id != ANONYMOUSID)
 927                 && ((refCount = idcount(&misc->idmap, id)) != ntohl(e.count)))
 928 #else
 929             if ((id >= misc->minId) && (id <= misc->maxId)
 930                 && (id != ANONYMOUSID)
 931                 && ((refCount = misc->idmap[id - misc->minId]) !=
 932                     ntohl(e.count)))
 933 #endif /* SUPERGROUPS */
 934               {
 935                 afs_int32 na;
 936                 fprintf(stderr,
 937                         "Entry membership count is inconsistent: %d entries refer to this one\n",
 938                         refCount);
 939                 if (PrintEntryError(misc, ea, &e, 2))
 940                     return PRDBBAD;
 941
 942                 /* get continuation blocks too */
 943                 for (na = ntohl(e.next); na; na = ntohl(e.next)) {
 944                     int ni;
 945                     code = ConvertDiskAddress(na, &ni);
 946                     if (code)
 947                         return code;
 948                     code = pr_Read(na, (char *)&e, sizeof(e));
 949                     if (code)
 950                         return code;
 951                     if (PrintEntryError(misc, na, &e, 4))
 952                         return PRDBBAD;
 953                 }
 954             }
 955         }
 956     }
 957     return 0;
 958 }
 959
 960 char *
 961 QuoteName(char *s)
 962 {
 963     char *qs;
 964     if (strpbrk(s, " \t")) {
 965         asprintf(&qs, "\"%s\"", s);
 966     } else
 967         qs = s;
 968     return qs;
 969 }
 970
 971 afs_int32
 972 DumpRecreate(char map[], struct misc_data *misc)
 973 {
 974     afs_int32 code;
 975     int ei;
 976     afs_int32 ea;
 977     struct prentry e;
 978     afs_int32 id;
 979     afs_int32 flags;
 980     afs_int32 owner;
 981     char *name;
 982     int builtinUsers = 0;
 983     int createLow = 0;          /* users uncreate from here */
 984 #if defined(SUPERGROUPS)
 985     struct idused *idmap;       /* map of all id's */
 986 #else
 987     afs_int32 *idmap;           /* map of all id's */
 988 #endif
 989     int found;
 990     FILE *rc;
 991
 992     rc = misc->recreate;
 993     idmap = misc->idmap;
 994 #if defined(SUPERGROUPS)
 995     zeromap(idmap);
 996 #else
 997     memset(idmap, 0, misc->idRange * sizeof(misc->idmap[0]));
 998 #endif
 999     do {
1000         found = 0;
1001         for (ei = createLow; ei < misc->nEntries; ei++) {
1002             if ((map[ei] & MAP_HASHES) && (map[ei] & MAP_RECREATE) == 0) {
1003                 afs_int32 mask;
1004                 afs_int32 access;
1005                 int gq, uq;
1006
1007                 ea = ei * sizeof(struct prentry) + sizeof(cheader);
1008                 code = pr_Read(ea, (char *)&e, sizeof(e));
1009                 if (code)
1010                     return code;
1011
1012                 if (misc->listentries)
1013                     pr_PrintEntry(stdout, 0 /*not in host order */ , ea, &e,
1014                                   0);
1015
1016                 id = ntohl(e.id);
1017                 flags = ntohl(e.flags);
1018                 owner = ntohl(e.owner);
1019                 name = QuoteName(e.name);
1020
1021                 if (!strcmp(e.name, "system:administrators")
1022                     || !strcmp(e.name, "system:anyuser")
1023                     || !strcmp(e.name, "system:authuser")
1024                     || !strcmp(e.name, "system:backup")
1025                     || !strcmp(e.name, "anonymous")) {
1026                     builtinUsers++;
1027                     goto user_done;
1028                 }
1029
1030                 /* check for duplicate id.  This may still lead to duplicate
1031                  * names. */
1032 #if defined(SUPERGROUPS)
1033                 if (idcount(&idmap, id))
1034 #else
1035                 if (idmap[id - misc->minId])
1036 #endif
1037                   {
1038                     fprintf(stderr, "Skipping entry with duplicate id %di\n",
1039                             id);
1040                     goto user_done;
1041                 }
1042
1043                 /* If owner doesn't exist skip for now, unless we're our own
1044                  * owner.  If so, a special case allows a group to own itself
1045                  * if caller is sysadmin.  This leaves only owner cycles to
1046                  * deal with. */
1047
1048                 if ((owner < misc->minId) || (owner > misc->maxId)) {
1049                     if (owner == ANONYMOUSID)
1050                         fprintf(stderr,
1051                                 "Warning: id %di is owned by ANONYMOUS; using sysadmin instead\n",
1052                                 id);
1053                     else
1054                         fprintf(stderr,
1055                                 "Bogus owner (%d) of id %di; using sysadmin instead\n",
1056                                 owner, id);
1057                     owner = SYSADMINID;
1058                 }
1059                 if (id == owner) {
1060                     fprintf(stderr, "Warning: group %s is self owning\n",
1061                             name);
1062                 } else if (owner == 0) {
1063                     fprintf(stderr,
1064                             "Warning: orphan group %s will become self owning.\n",
1065                             name);
1066                     owner = id;
1067                 }
1068 #if defined(SUPERGROUPS)
1069                 else if (!idcount(&idmap, owner))
1070                     goto user_skip;
1071 #else
1072                 else if (idmap[owner - misc->minId] == 0)
1073                     goto user_skip;
1074 #endif
1075
1076                 if (rc)
1077                     fprintf(rc, "cr %s %d %d\n", name, id, owner);
1078
1079                 gq = uq = access = mask = 0;
1080                 if (flags & PRACCESS) {
1081                     access = (flags >> PRIVATE_SHIFT);
1082                     mask |= PR_SF_ALLBITS;
1083                 }
1084                 if (flags & PRQUOTA) {
1085                     gq = ntohl(e.ngroups);
1086                     uq = ntohl(e.nusers);
1087                     mask |= PR_SF_NGROUPS | PR_SF_NUSERS;
1088                 }
1089                 if (mask && rc) {
1090                     fprintf(rc, "sf %d %x %x %d %d\n", id, mask, access, gq,
1091                             uq);
1092                 }
1093               user_done:
1094                 map[ei] |= MAP_RECREATE;
1095 #if defined(SUPERGROUPS)
1096                 if (id != ANONYMOUSID)
1097                     inccount(&idmap, id);
1098 #else
1099                 if (id != ANONYMOUSID)
1100                     idmap[id - misc->minId]++;
1101 #endif
1102                 found++;
1103             }
1104             /* bump low water mark if possible */
1105             if (ei == createLow)
1106                 createLow++;
1107           user_skip:;
1108         }
1109         misc->verbose = 0;
1110     } while (found);
1111
1112     /* Now create the entries with circular owner dependencies and make them
1113      * own themselves.  This is the only way to create them with the correct
1114      * names. */
1115     for (ei = 0; ei < misc->nEntries; ei++)
1116         if (((map[ei] & MAP_HASHES) == MAP_HASHES)
1117             && (map[ei] & MAP_RECREATE) == 0) {
1118             ea = ei * sizeof(struct prentry) + sizeof(cheader);
1119             code = pr_Read(ea, (char *)&e, sizeof(e));
1120             if (code)
1121                 return code;
1122
1123             id = ntohl(e.id);
1124             name = QuoteName(e.name);
1125             fprintf(stderr, "Warning: group %s in self owning cycle\n", name);
1126             if (rc)
1127                 fprintf(rc, "cr %s %d %d\n", name, id, id);
1128 #if defined(SUPERGROUPS)
1129             inccount(&idmap, id);
1130 #else
1131             idmap[id - misc->minId]++;
1132 #endif
1133         }
1134     for (ei = 0; ei < misc->nEntries; ei++)
1135         if (((map[ei] & MAP_HASHES) == MAP_HASHES)
1136             && (map[ei] & MAP_RECREATE) == 0) {
1137             ea = ei * sizeof(struct prentry) + sizeof(cheader);
1138             code = pr_Read(ea, (char *)&e, sizeof(e));
1139             if (code)
1140                 return code;
1141
1142             owner = ntohl(e.owner);
1143 #if defined(SUPERGROUPS)
1144             if (!idcount(&idmap, owner))
1145 #else
1146             if (idmap[owner - misc->minId] == 0)
1147 #endif
1148               {
1149                 fprintf(stderr,
1150                         "Skipping chown of '%s' to non-existant owner %di\n",
1151                         e.name, owner);
1152             } else if (rc)
1153                 fprintf(rc, "ce %d \"\" %d 0\n", ntohl(e.id), e.owner);
1154         }
1155
1156     if (rc == 0)
1157         return 0;
1158
1159     /* Reconstruct membership information based on the groups' user lists. */
1160     for (ei = 0; ei < misc->nEntries; ei++) {
1161         if ((map[ei] & MAP_HASHES) == MAP_HASHES) {
1162             ea = ei * sizeof(struct prentry) + sizeof(cheader);
1163             code = pr_Read(ea, (char *)&e, sizeof(e));
1164             if (code)
1165                 return code;
1166
1167             id = ntohl(e.id);
1168             flags = ntohl(e.flags);
1169
1170             if ((id < 0) && (flags & PRGRP)) {
1171                 int count = 0;
1172                 afs_int32 na;
1173                 int i;
1174                 for (i = 0; i < PRSIZE; i++) {
1175                     afs_int32 uid = ntohl(e.entries[i]);
1176                     if (uid == 0)
1177                         break;
1178                     if (uid == PRBADID)
1179                         continue;
1180 #if !defined(SUPERGROUPS)
1181                     if (uid > 0) {
1182 #endif
1183                         fprintf(rc, "au %d %d\n", uid, id);
1184                         count++;
1185 #if !defined(SUPERGROUPS)
1186                     } else
1187                         fprintf(stderr, "Skipping %di in group %di\n", uid,
1188                                 id);
1189 #endif
1190                 }
1191                 na = ntohl(e.next);
1192                 while (na) {
1193                     struct prentry c;
1194                     code = pr_Read(na, (char *)&c, sizeof(c));
1195                     if (code)
1196                         return code;
1197
1198                     if ((id == ntohl(c.id)) && (c.flags & htonl(PRCONT))) {
1199                         for (i = 0; i < COSIZE; i++) {
1200                             afs_int32 uid = ntohl(c.entries[i]);
1201                             if (uid == 0)
1202                                 break;
1203                             if (uid == PRBADID)
1204                                 continue;
1205 #if !defined(SUPERGROUPS)
1206                             if (uid > 0) {
1207 #endif
1208                                 fprintf(rc, "au %d %d\n", uid, id);
1209                                 count++;
1210 #if !defined(SUPERGROUPS)
1211                             } else
1212                                 fprintf(stderr, "Skipping %di in group %di\n",
1213                                         uid, id);
1214 #endif
1215                         }
1216                     } else {
1217                         fprintf(stderr, "Skipping continuation block at %d\n",
1218                                 na);
1219                         break;
1220                     }
1221                     na = ntohl(c.next);
1222                 }
1223                 if (count != ntohl(e.count))
1224                     fprintf(stderr,
1225                             "Group membership count problem found %d should be %d\n",
1226                             count, ntohl(e.count));
1227             } else if ((id < 0) || (flags & PRGRP)) {
1228                 fprintf(stderr, "Skipping group %di\n", id);
1229             }
1230         }
1231     }
1232     return 0;
1233 }
1234
1235 afs_int32
1236 CheckPrDatabase(struct misc_data *misc) /* info & statistics */
1237 {
1238     afs_int32 code;
1239     afs_int32 eof;
1240     int n;
1241     char *map;                  /* map of each entry in db */
1242
1243     eof = ntohl(cheader.eofPtr);
1244     eof -= sizeof(cheader);
1245     n = eof / sizeof(struct prentry);
1246     if ((eof < 0) || (n * sizeof(struct prentry) != eof)) {
1247         code = PRDBBAD;
1248         afs_com_err(whoami, code,
1249                     "eof ptr no good: eof=%d, sizeof(prentry)=%" AFS_SIZET_FMT,
1250                 eof, sizeof(struct prentry));
1251       abort:
1252         return code;
1253     }
1254     if (misc->verbose)
1255         printf("Database has %d entries\n", n);
1256     map = (char *)malloc(n);
1257     memset(map, 0, n);
1258     misc->nEntries = n;
1259
1260     if (misc->verbose) {
1261         printf("\nChecking name hash table\n");
1262         fflush(stdout);
1263     }
1264     code = WalkHashTable(cheader.nameHash, MAP_NAMEHASH, map, misc);
1265     if (code) {
1266         afs_com_err(whoami, code, "walking name hash");
1267         goto abort;
1268     }
1269     if (misc->verbose) {
1270         printf("\nChecking id hash table\n");
1271         fflush(stdout);
1272     }
1273     code = WalkHashTable(cheader.idHash, MAP_IDHASH, map, misc);
1274     if (code) {
1275         afs_com_err(whoami, code, "walking id hash");
1276         goto abort;
1277     }
1278
1279     /* hash walk calculates min and max id */
1280 #if defined(SUPERGROUPS)
1281     misc->idmap = 0;
1282 #else
1283     n = ((misc->maxId > misc->maxForId) ? misc->maxId : misc->maxForId);
1284     misc->idRange = n - misc->minId + 1;
1285     misc->idmap = (afs_int32 *) malloc(misc->idRange * sizeof(afs_int32));
1286     if (!misc->idmap) {
1287         afs_com_err(whoami, 0, "Unable to malloc space for max ids of %d",
1288                 misc->idRange);
1289         code = -1;
1290         goto abort;
1291     }
1292     memset(misc->idmap, 0, misc->idRange * sizeof(misc->idmap[0]));
1293 #endif /* SUPERGROUPS */
1294
1295     if (misc->verbose) {
1296         printf("\nChecking entry chains\n");
1297         fflush(stdout);
1298     }
1299     code = WalkChains(map, misc);
1300     if (code) {
1301         afs_com_err(whoami, code, "walking chains");
1302         goto abort;
1303     }
1304     if (misc->verbose) {
1305         printf("\nChecking free list\n");
1306         fflush(stdout);
1307     }
1308     code = WalkNextChain(map, misc, 0, 0);
1309     if (code) {
1310         afs_com_err(whoami, code, "walking free list");
1311         goto abort;
1312     }
1313     if (misc->verbose) {
1314         printf("\nChecking orphans list\n");
1315         fflush(stdout);
1316     }
1317     code = WalkOwnedChain(map, misc, 0, 0);
1318     if (code) {
1319         afs_com_err(whoami, code, "walking orphan list");
1320         goto abort;
1321     }
1322
1323     if (misc->verbose) {
1324         printf("\nChecking for unreferenced entries\n");
1325         fflush(stdout);
1326     }
1327     code = GC(map, misc);
1328     if (code) {
1329         afs_com_err(whoami, code, "looking for unreferenced entries");
1330         goto abort;
1331     }
1332
1333     DumpRecreate(map, misc);    /* check for owner cycles */
1334     if (misc->recreate)
1335         fclose(misc->recreate);
1336
1337     if (misc->anon != 2)        /* once for each hash table */
1338         fprintf(stderr, "Problems with ANON=%d\n", misc->anon);
1339     if (misc->ncells || misc->ninsts)
1340         fprintf(stderr, "Unexpected entry type\n");
1341     if (misc->nusers != ntohl(cheader.usercount)) {
1342         fprintf(stderr,
1343                 "User count inconsistent: should be %d, header claims: %d\n",
1344                 misc->nusers, ntohl(cheader.usercount));
1345     }
1346     if (misc->ngroups != ntohl(cheader.groupcount)) {
1347         fprintf(stderr,
1348                 "Group count inconsistent: should be %d, header claims: %d\n",
1349                 misc->ngroups, ntohl(cheader.groupcount));
1350     }
1351     if (misc->maxId > ntohl(cheader.maxID))
1352         fprintf(stderr,
1353                 "Database's max user Id (%d) is smaller than largest user's Id (%d).\n",
1354                 ntohl(cheader.maxID), misc->maxId);
1355     if (misc->minId < ntohl(cheader.maxGroup))
1356         fprintf(stderr,
1357                 "Database's max group Id (%d) is smaller than largest group's Id (%d).\n",
1358                 ntohl(cheader.maxGroup), misc->minId);
1359
1360     if (misc->verbose) {
1361         printf("\nMaxId = %d, MinId = %d, MaxForeignId = %d\n", misc->maxId,
1362                misc->minId, misc->maxForId);
1363         printf
1364             ("Free list is %d entries in length, %d groups on orphan list\n",
1365              misc->freeLength, misc->orphanLength);
1366         printf
1367             ("The longest owner list is %d, the longest continuation block chain is %d\n",
1368              misc->maxOwnerLength, misc->maxContLength);
1369         printf("%d users ; %d foreign users ; and %d groups\n", misc->nusers,
1370                misc->nforeigns, misc->ngroups);
1371     }
1372
1373     free(map);
1374     return code;
1375 }
1376
1377 #include "AFS_component_version_number.c"
1378
1379 int
1380 WorkerBee(struct cmd_syndesc *as, void *arock)
1381 {
1382     afs_int32 code;
1383     char *recreateFile;
1384     struct misc_data misc;      /* info & statistics */
1385
1386     initialize_PT_error_table();
1387     initialize_U_error_table();
1388
1389     pr_dbaseName = AFSDIR_SERVER_PRDB_FILEPATH;
1390     memset(&misc, 0, sizeof(misc));
1391
1392     pr_dbaseName = as->parms[0].items->data;    /* -database */
1393     misc.listuheader = (as->parms[1].items ? 1 : 0);    /* -uheader  */
1394     misc.listpheader = (as->parms[2].items ? 1 : 0);    /* -pheader  */
1395     misc.listentries = (as->parms[3].items ? 1 : 0);    /* -entries  */
1396     misc.verbose = (as->parms[4].items ? 1 : 0);        /* -verbose  */
1397     recreateFile = (as->parms[5].items ? as->parms[5].items->data : NULL);      /* -rebuild  */
1398
1399     fd = open(pr_dbaseName, O_RDONLY, 0);
1400     if (fd == -1) {
1401         afs_com_err(whoami, errno, "Open failed on db %s", pr_dbaseName);
1402         exit(2);
1403     }
1404
1405     /* Read the ubik header */
1406     if (misc.listuheader) {
1407         readUbikHeader(&misc);
1408     }
1409
1410     code = ReadHeader();
1411     if (code)
1412         return code;
1413     if (misc.listpheader)
1414         printheader(&cheader);
1415
1416     if (recreateFile) {
1417         misc.recreate = fopen(recreateFile, "w");
1418         if (misc.recreate == 0) {
1419             afs_com_err(whoami, errno,
1420                     "can't create file for recreation instructions: %s",
1421                     recreateFile);
1422             exit(4);
1423         }
1424     }
1425     code = CheckPrDatabase(&misc);
1426     if (code) {
1427         afs_com_err(whoami, code, "Checking prserver database");
1428         exit(3);
1429     }
1430     exit(0);
1431 }
1432
1433 int
1434 main(int argc, char *argv[])
1435 {
1436     struct cmd_syndesc *ts;
1437
1438     setlinebuf(stdout);
1439
1440     ts = cmd_CreateSyntax(NULL, WorkerBee, NULL, "PRDB check");
1441     cmd_AddParm(ts, "-database", CMD_SINGLE, CMD_REQUIRED, "ptdb_file");
1442     cmd_AddParm(ts, "-uheader", CMD_FLAG, CMD_OPTIONAL,
1443                 "Display UBIK header");
1444     cmd_AddParm(ts, "-pheader", CMD_FLAG, CMD_OPTIONAL,
1445                 "Display KADB header");
1446     cmd_AddParm(ts, "-entries", CMD_FLAG, CMD_OPTIONAL, "Display entries");
1447     cmd_AddParm(ts, "-verbose", CMD_FLAG, CMD_OPTIONAL, "verbose");
1448     cmd_AddParm(ts, "-rebuild", CMD_SINGLE, CMD_OPTIONAL | CMD_HIDE,
1449                 "out_file");
1450
1451     return cmd_Dispatch(argc, argv);
1452 }
1453
1454
1455 #if defined(SUPERGROUPS)
1456
1457 /* new routines to deal with very large ID numbers */
1458
1459 void
1460 zeromap(struct idused *idmap)
1461 {
1462     while (idmap) {
1463         memset(idmap->idcount, 0, sizeof idmap->idcount);
1464         idmap = idmap->idnext;
1465     }
1466 }
1467
1468 void
1469 inccount(struct idused **idmapp, int id)
1470 {
1471     struct idused *idmap;
1472
1473     if (IDCOUNT & (IDCOUNT - 1)) {
1474         fprintf(stderr, "IDCOUNT must be power of 2!\n");
1475         exit(1);
1476     }
1477     while ((idmap = *idmapp) != NULL) {
1478         if (idmap->idstart == (id & ~(IDCOUNT - 1)))
1479             break;
1480         idmapp = &idmap->idnext;
1481     }
1482     if (!idmap) {
1483         idmap = (struct idused *)malloc(sizeof *idmap);
1484         if (!idmap) {
1485             perror("idmap");
1486             exit(1);
1487         }
1488         memset(idmap, 0, sizeof idmap);
1489         idmap->idstart = id & ~(IDCOUNT - 1);
1490         idmap->idnext = *idmapp;
1491         *idmapp = idmap;
1492     }
1493     ++idmap->idcount[id & (IDCOUNT - 1)];
1494 }
1495
1496 int
1497 idcount(struct idused **idmapp, int id)
1498 {
1499     struct idused *idmap;
1500
1501     if (IDCOUNT & (IDCOUNT - 1)) {
1502         fprintf(stderr, "IDCOUNT must be power of 2!\n");
1503         exit(1);
1504     }
1505     while ((idmap = *idmapp) != NULL) {
1506         if (idmap->idstart == (id & ~(IDCOUNT - 1))) {
1507             return idmap->idcount[id & (IDCOUNT - 1)];
1508         }
1509         idmapp = &idmap->idnext;
1510     }
1511     return 0;
1512 }
1513 #endif /* SUPERGROUPS */