source: trunk/third/moira/afssync/pt_util-fast.c @ 23095

Revision 23095, 12.9 KB checked in by ghudson, 16 years ago (diff)
Import the moira package from SIPB Debathena.
Line 
1/*
2 *
3 * ptdump: Program to dump the AFS protection server database
4 *         into an ascii file.
5 *
6 *      Assumptions: We *cheat* here and read the datafile directly, ie.
7 *                   not going through the ubik distributed data manager.
8 *                   therefore the database must be quiescent for the
9 *                   output of this program to be valid.
10 */
11
12#include <sys/types.h>
13#include <sys/time.h>
14#include <stdio.h>
15#include <ctype.h>
16#include <string.h>
17#include <sys/file.h>
18
19#include <afs/param.h>
20#include <lock.h>
21#include <netinet/in.h>
22#define UBIK_INTERNALS
23#include <ubik.h>
24#include <rx/xdr.h>
25#include <rx/rx.h>
26#include "ptint.h"
27#include "ptserver.h"
28#include "pterror.h"
29
30#define IDHash(x) (abs(x) % HASHSIZE)
31#define print_id(x) ( ((flags&DO_SYS)==0 && (x<-32767 || x>97536)) || \
32                      ((flags&DO_OTR)==0 && (x>-32768 && x<97537)))
33
34extern char *optarg;
35extern int optind;
36extern int errno;
37extern char *sys_errlist[];
38#define strerror(a) sys_errlist[a]
39
40int display_entry();
41void add_group();
42void display_groups();
43void display_group();
44void fix_pre();
45char *checkin();
46char *check_core();
47char *id_to_name();
48
49struct hash_entry {
50    char h_name[PR_MAXNAMELEN];
51    int h_id;
52    struct hash_entry *next;
53};
54struct hash_entry *hat[HASHSIZE];
55
56static struct contentry prco;
57static struct prentry pre;
58static struct prheader prh;
59static struct ubik_version uv;
60
61struct grp_list {
62    struct grp_list     *next;
63    long                groups[1024];
64};
65static struct grp_list *grp_head=0;
66static long grp_count=0;
67
68struct usr_list {
69    struct usr_list *next;
70    char name[PR_MAXNAMELEN];
71    long uid;
72};
73static struct usr_list *usr_head=0;
74
75char buffer[1024];
76int dbase_fd;
77FILE *dfp;
78
79#define FMT_BASE "%-10s %d/%d %d %d %d\n"
80#define FMT_MEM  "   %-8s %d\n"
81
82#define DO_USR 1
83#define DO_GRP 2
84#define DO_MEM 4
85#define DO_SYS 8
86#define DO_OTR 16
87
88int nflag = 0;
89int wflag = 0;
90int flags = 0;
91
92main(argc, argv)
93int argc;
94char **argv;
95{
96    register int i;
97    register long code;
98    long cc, upos, gpos;
99    struct prentry uentry, gentry;
100    struct ubik_hdr *uh;
101    char *dfile = 0;
102    char *pfile = "/usr/afs/db/prdb.DB0";
103    int need_gwrite = 0;
104   
105    while ((cc = getopt(argc, argv, "wugmxsnp:d:")) != EOF) {
106        switch (cc) {
107        case 'p':
108            pfile = optarg;
109            break;
110        case 'd':
111            dfile = optarg;
112            break;
113        case 'n':
114            nflag++;
115            break;
116        case 'w':
117            wflag++;
118            break;
119        case 'u':
120            flags |= DO_USR;
121            break;
122        case 'm':
123            flags |= (DO_GRP|DO_MEM);
124            break;
125        case 'g':
126            flags |= DO_GRP;
127            break;
128        case 's':
129            flags |= DO_SYS;
130            break;
131        case 'x':
132            flags |= DO_OTR;
133            break;
134        default:
135            fprintf(stderr,
136                    "Usage: ptdump [options] [-d data] [-p prdb]\n");
137            fputs("  Options:\n", stderr);
138            fputs("    -w  Update prdb with contents of data file\n", stderr);
139            fputs("    -u  Display users\n", stderr);
140            fputs("    -g  Display groups\n", stderr);
141            fputs("    -m  Display group members\n", stderr);
142            fputs("    -n  Follow name hash chains (not id hashes)\n", stderr);
143            fputs("    -s  Display only system (Moira) data\n", stderr);
144            fputs("    -x  Display extra users/groups\n", stderr);
145            exit(1);
146        }
147    }
148    if ((dbase_fd = open(pfile, wflag ? O_RDWR : O_RDONLY, 0600)) < 0) {
149        fprintf(stderr, "ptdump: cannot open %s: %s\n",
150                pfile, sys_errlist[errno]);
151        exit (1);
152    }
153    if (read(dbase_fd, buffer, HDRSIZE) < 0) {
154        fprintf(stderr, "ptdump: error reading %s: %s\n",
155                pfile, sys_errlist[errno]);
156        exit (1);
157    }
158
159    if (dfile) {
160        if ((dfp = fopen(dfile, wflag ? "r" : "w")) == 0) {
161            fprintf(stderr, "ptdump: error opening %s: %s\n",
162                    dfile, sys_errlist[errno]);
163            exit(1);
164        }
165    } else
166        dfp = (wflag ? stdin : stdout);
167
168    uh = (struct ubik_hdr *)buffer;
169    if (ntohl(uh->magic) != UBIK_MAGIC)
170        fprintf(stderr, "ptdump: %s: Bad UBIK_MAGIC. Is %x should be %x\n",
171                pfile, ntohl(uh->magic), UBIK_MAGIC);
172    memcpy(&uv, &uh->version, sizeof(struct ubik_version));
173    fprintf(stderr, "Ubik Version is: %d.%d\n",
174            ntohl(uv.epoch), ntohl(uv.counter));
175    if (read(dbase_fd, &prh, sizeof(struct prheader)) < 0) {
176        fprintf(stderr, "ptdump: error reading %s: %s\n",
177                pfile, sys_errlist[errno]);
178        exit (1);
179    }
180
181    Initdb();
182    initialize_pt_error_table();
183
184#define FLUSH_GROUP \
185    if (need_gwrite) { \
186        code = pr_WriteEntry(0,0,gpos,&gentry); \
187        if (code) \
188            fprintf(stderr, "Error while writing group %s: %s\n", \
189                    gentry.name, error_message(code)); \
190        else need_write = 0; \
191    }
192
193    if (wflag) {
194        struct usr_list *u;
195
196        while(fgets(buffer, sizeof(buffer), dfp)) {
197            int id, oid, cid, flags, quota, uid;
198            char name[PR_MAXNAMELEN], mem[PR_MAXNAMELEN];
199
200            if (isspace(*buffer)) {
201                sscanf(buffer, "%s %d", mem, &uid);
202
203                for (u=usr_head; u; u=u->next)
204                    if (u->uid && u->uid==uid) break;
205                if (u) {
206                    /* Add user - deferred because it is probably foreign */
207                    u->uid = 0;
208                    if (upos = FindByID(0, uid))
209                        code = PRIDEXIST;
210                    else {
211                        if (!code && (flags&(PRGRP|PRQUOTA))==(PRGRP|PRQUOTA)){
212                            gentry.ngroups++;
213                            code = pr_WriteEntry(0,0,gpos,&gentry);
214                            if (code)
215                                fprintf(stderr, "Error setting group count on %s: %s\n",
216                                        name, error_message(code));
217                        }
218                        code = CreateEntry
219                            (0, u->name, &uid, 1/*idflag*/, 1/*gflag*/,
220                             SYSADMINID/*oid*/, SYSADMINID/*cid*/);
221                    }
222                    if (code)
223                        fprintf(stderr, "Error while creating %s: %s\n",
224                                u->name, error_message(code));
225                    continue;
226                }
227                /* Add user to group */
228                if (id==ANYUSERID || id==AUTHUSERID || uid==ANONYMOUSID) {
229                    code = PRPERM;
230                }
231                if (!code && !upos) {
232                    upos = FindByID(0,uid);
233                    if (upos) code = pr_ReadEntry(0,0,upos,&uentry);
234                }
235                if (!upos || !gpos)
236                    code = PRNOENT;
237
238                /* Fast group update */
239                if (!code && (gentry.count < PRSIZE)) {
240                    gentry.count++;
241                    for (i=0; i<PRSIZE; i++) {
242                        if (gentry.entries[i] == PRBADID) {
243                            gentry.entries[i] = uid;
244                            break;
245                        }
246                    }
247                } else {
248                    FLUSH_GROUP;
249                    if (!code) code = AddToEntry (0, &gentry, gpos, uid);
250                }
251               
252                if (!code) code = AddToEntry (0, &uentry, upos, id);
253
254                if (code)
255                    fprintf(stderr, "Error while adding %s to %s: %s\n",
256                            mem, name, error_message(code));
257            } else {
258                FLUSH_GROUP;
259                sscanf(buffer, "%s %d/%d %d %d %d",
260                       name, &flags, &quota, &id, &oid, &cid);
261
262                if (gpos = FindByID(0, id))
263                    code = PRIDEXIST;
264                else {
265                    code = CreateEntry(0, name, &id, 1/*idflag*/,
266                                       flags&PRGRP, oid, cid);
267                    if (!code) gpos = FindByID(0, id);
268                }
269                if (code == PRBADNAM) {
270                    u = (struct usr_list *)malloc(sizeof(struct usr_list));
271                    u->next = usr_head;
272                    u->uid = id;
273                    strcpy(u->name, name);
274                    usr_head = u;
275                } else
276                if (code) {
277                    fprintf(stderr, "Error while creating %s: %s\n",
278                            name, error_message(code));
279                }
280                code = pr_ReadEntry(0,0,gpos,&gentry);
281                if (code)
282                    fprintf(stderr,"Error while reading group %s: %s\n",
283                            name, error_message(code));
284                else if ((flags&PRACCESS) ||
285                         (flags&(PRGRP|PRQUOTA))==(PRGRP|PRQUOTA)) {
286                    gentry.flags = flags;
287                    gentry.ngroups = quota;
288                    need_gwrite = 1;
289                    if (code)
290                        fprintf(stderr,
291                                "Error while setting flags on %s: %s\n",
292                                name, error_message(code));
293                }
294            }
295        }
296        FLUSH_GROUP;
297        for (u=usr_head; u; u=u->next)
298            if (u->uid)
299                fprintf(stderr, "Error while creating %s: %s\n",
300                        u->name, error_message(PRBADNAM));
301    } else {
302        for (i = 0; i < HASHSIZE; i++) {
303            upos = nflag ? ntohl(prh.nameHash[i]) : ntohl(prh.idHash[i]);
304            while (upos)
305                upos = display_entry(upos);
306        }
307        if (flags & DO_GRP)
308            display_groups();
309    }
310
311    lseek (dbase_fd, 0, L_SET);         /* rewind to beginning of file */
312    if (read(dbase_fd, buffer, HDRSIZE) < 0) {
313        fprintf(stderr, "ptdump: error reading %s: %s\n",
314                pfile, sys_errlist[errno]);
315        exit (1);
316    }
317    uh = (struct ubik_hdr *)buffer;
318    if ((uh->version.epoch != uv.epoch) ||
319        (uh->version.counter != uv.counter)) {
320        fprintf(stderr, "ptdump: Ubik Version number changed during execution.\n");
321        fprintf(stderr, "Old Version = %d.%d, new version = %d.%d\n",
322                ntohl(uv.epoch), ntohl(uv.counter),
323                ntohl(uh->version.epoch), ntohl(uh->version.counter));
324    }
325    close (dbase_fd);
326    exit (0);
327}
328
329int display_entry (offset)
330int offset;
331{
332    register int i;
333
334    lseek (dbase_fd, offset+HDRSIZE, L_SET);
335    read(dbase_fd, &pre, sizeof(struct prentry));
336
337    fix_pre(&pre);
338
339    if ((pre.flags & PRFREE) == 0) {
340        if (pre.flags & PRGRP) {
341            if (flags & DO_GRP)
342                add_group(pre.id);
343        } else {
344            if (print_id(pre.id) && (flags&DO_USR))
345                fprintf(dfp, FMT_BASE,
346                        pre.name, pre.flags, pre.ngroups,
347                        pre.id, pre.owner, pre.creator);
348            checkin(&pre);
349        }
350    }
351    return(nflag ? pre.nextName: pre.nextID);
352}
353
354void add_group(id)
355    long id;
356{
357    struct grp_list *g;
358    register long i;
359
360    i = grp_count++ % 1024;
361    if (i == 0) {
362        g = (struct grp_list *)malloc(sizeof(struct grp_list));
363        g->next = grp_head;
364        grp_head = g;
365    }
366    g = grp_head;
367    g->groups[i] = id;
368}
369
370void display_groups()
371{
372    register int i, id;
373    struct grp_list *g;
374
375    g = grp_head;
376    while (grp_count--) {
377        i = grp_count%1024;
378        id = g->groups[i];
379        display_group(id);
380        if (i==0) {
381            grp_head = g->next;
382            free(g);
383            g = grp_head;
384        }
385    }
386}
387
388void display_group(id)
389    int id;
390{
391    register int i, offset;
392    int print_grp = 0;
393
394    offset = ntohl(prh.idHash[IDHash(id)]);
395    while (offset) {
396        lseek(dbase_fd, offset+HDRSIZE, L_SET);
397        if (read(dbase_fd, &pre, sizeof(struct prentry)) < 0) {
398            fprintf(stderr, "ptdump: read i/o error: %s\n",
399                    strerror(errno));
400            exit (1);
401        }
402        fix_pre(&pre);
403        if (pre.id == id)
404            break;
405        offset = pre.nextID;
406    }
407
408    if (print_id(id)) {
409        fprintf(dfp, FMT_BASE,
410                pre.name, pre.flags, pre.ngroups,
411                pre.id, pre.owner, pre.creator);
412        print_grp = 1;
413    }
414
415    if ((flags&DO_MEM) == 0)
416        return;
417
418    for (i=0; i<PRSIZE; i++) {
419        if ((id=pre.entries[i]) == 0)
420            break;
421        if (id==PRBADID) continue;
422        if (print_id(id) || print_grp==1) {
423            if (print_grp==0) {
424                fprintf(dfp, FMT_BASE,
425                        pre.name, pre.flags, pre.ngroups,
426                        pre.id, pre.owner, pre.creator);
427                print_grp = 2;
428            }
429            fprintf(dfp, FMT_MEM, id_to_name(id), id);
430        }
431    }
432    if (i == PRSIZE) {
433        offset = pre.next;
434        while (offset) {
435            lseek(dbase_fd, offset+HDRSIZE, L_SET);
436            read(dbase_fd, &prco, sizeof(struct contentry));
437            prco.next = ntohl(prco.next);
438            for (i = 0; i < COSIZE; i++) {
439                prco.entries[i] = ntohl(prco.entries[i]);
440                if ((id=prco.entries[i]) == 0)
441                    break;
442                if (id==PRBADID) continue;
443                if (print_id(id) || print_grp==1) {
444                    if (print_grp==0) {
445                        fprintf(dfp, FMT_BASE,
446                                pre.name, pre.flags, pre.ngroups,
447                                pre.id, pre.owner, pre.creator);
448                        print_grp = 2;
449                    }
450                    fprintf(dfp, FMT_MEM, id_to_name(id), id);
451                }
452            }
453            if ((i == COSIZE) && prco.next)
454                offset = prco.next;
455            else offset = 0;
456        }
457    }
458}
459
460void fix_pre(pre)
461    struct prentry *pre;
462{
463    register int i;
464   
465    pre->flags = ntohl(pre->flags);
466    pre->id = ntohl(pre->id);
467    pre->cellid = ntohl(pre->cellid);
468    pre->next = ntohl(pre->next);
469    pre->nextID = ntohl(pre->nextID);
470    pre->nextName = ntohl(pre->nextName);
471    pre->owner = ntohl(pre->owner);
472    pre->creator = ntohl(pre->creator);
473    pre->ngroups = ntohl(pre->ngroups);
474    pre->nusers = ntohl(pre->nusers);
475    pre->count = ntohl(pre->count);
476    pre->instance = ntohl(pre->instance);
477    pre->owned = ntohl(pre->owned);
478    pre->nextOwned = ntohl(pre->nextOwned);
479    pre->parent = ntohl(pre->parent);
480    pre->sibling = ntohl(pre->sibling);
481    pre->child = ntohl(pre->child);
482    for (i = 0; i < PRSIZE; i++) {
483        pre->entries[i] = ntohl(pre->entries[i]);
484    }
485}
486
487char *id_to_name(id)
488int id;
489{
490    register int offset;
491    static struct prentry pre;
492    char *name;
493
494    name = check_core(id);
495    if (name) return(name);
496    offset = ntohl(prh.idHash[IDHash(id)]);
497    while (offset) {
498        lseek(dbase_fd, offset+HDRSIZE, L_SET);
499        if (read(dbase_fd, &pre, sizeof(struct prentry)) < 0) {
500            fprintf(stderr, "ptdump: read i/o error: %s\n",
501                    sys_errlist[errno]);
502            exit (1);
503        }
504        pre.id = ntohl(pre.id);
505        if (pre.id == id) {
506            name = checkin(&pre);
507            return(name);
508        }
509        offset = ntohl(pre.nextID);
510    }
511    return 0;
512}
513
514char *checkin(pre)
515struct prentry *pre;
516{
517    struct hash_entry *he, *last;
518    register int id;
519
520    id = pre->id;
521    last = (struct hash_entry *)0;
522    he = hat[IDHash(id)];
523    while (he) {
524        if (id == he->h_id) return(he->h_name);
525        last = he;
526        he = he->next;
527    }
528    he = (struct hash_entry *)malloc(sizeof(struct hash_entry));
529    if (he == 0) {
530        fprintf(stderr, "ptdump: No Memory for internal hash table.\n");
531        exit (1);
532    }
533    he->h_id = id;
534    he->next = (struct hash_entry *)0;
535    strncpy(he->h_name, pre->name, PR_MAXNAMELEN);
536    if (last == (struct hash_entry *)0) hat[IDHash(id)] = he;
537    else last->next = he;
538    return(he->h_name);
539}
540
541char *check_core(id)
542register int id;
543{
544    struct hash_entry *he;
545    he = hat[IDHash(id)];
546    while (he) {
547        if (id == he->h_id) return(he->h_name);
548        he = he->next;
549    }
550    return 0;
551}
Note: See TracBrowser for help on using the repository browser.