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