From d2543f8c583922066a9e589db4662f8147d04a45 Mon Sep 17 00:00:00 2001 From: mar Date: Sun, 25 Sep 1988 21:48:07 +0000 Subject: [PATCH] Initial revision --- dbck/dbck.h | 78 +++++++ dbck/dbck.qc | 126 ++++++++++ dbck/fix.qc | 207 +++++++++++++++++ dbck/phase1.qc | 368 +++++++++++++++++++++++++++++ dbck/phase2.qc | 615 +++++++++++++++++++++++++++++++++++++++++++++++++ dbck/phase3.qc | 76 ++++++ dbck/phase4.qc | 167 ++++++++++++++ 7 files changed, 1637 insertions(+) create mode 100644 dbck/dbck.h create mode 100644 dbck/dbck.qc create mode 100644 dbck/fix.qc create mode 100644 dbck/phase1.qc create mode 100644 dbck/phase2.qc create mode 100644 dbck/phase3.qc create mode 100644 dbck/phase4.qc diff --git a/dbck/dbck.h b/dbck/dbck.h new file mode 100644 index 00000000..7192d0a3 --- /dev/null +++ b/dbck/dbck.h @@ -0,0 +1,78 @@ +/* $Header$ + * + * Declarations for SMS database consistancy checker + * + * (c) Copyright 1988 by the Massachusetts Institute of Technology. + * For copying and distribution information, please see the file + * . + */ + +#include +#include + +#define MODE_ASK 1 +#define MODE_NO 2 +#define MODE_PREEN 3 +#define MODE_YES 4 + +extern int debug, mode, fast, dcmenable; +extern struct hash *users, *machines, *clusters, *lists; +extern struct hash *filesys, *nfsphys, *strings; + +#define MAX_ID_VALUE 32765 +#define MIN_ID_VALUE 100 + +#define dprintf if (debug) printf + +struct user { + char login[9]; + char potype; + char *fullname; + int status; + int users_id; + int pobox_id; +}; + +struct machine { + char name[33]; + int mach_id; + int clucount; +}; + +struct cluster { + char name[33]; + int clu_id; +}; + +struct list { + char name[33]; + char acl_type; + int list_id; + int acl_id; + int members; +}; + +struct string { + char *name; + int string_id; + int refc; +}; + +struct filesys { + char name[33]; + char dir[33]; + char type; + int filsys_id; + int mach_id; + int owner; + int owners; + int phys_id; +}; + +struct nfsphys { + char dir[33]; + int mach_id; + int nfsphys_id; + int allocated; + int count; +}; diff --git a/dbck/dbck.qc b/dbck/dbck.qc new file mode 100644 index 00000000..4728253e --- /dev/null +++ b/dbck/dbck.qc @@ -0,0 +1,126 @@ +/* $Header$ + * + * SMS database consistency checker + * + * (c) Copyright 1988 by the Massachusetts Institute of Technology. + * For copying and distribution information, please see the file + * . + */ + +#include +#include +#include +#include +#include "dbck.h" + + +int debug = 1; +int mode = MODE_ASK; +int fast = 0; +struct hash *users, *machines, *clusters, *lists, *filesys, *nfsphys, *strings; +##int dcmenable; +int cleanup(); + + +main(argc, argv) +int argc; +char **argv; +{ + char **arg = argv; +## char *database; + int ingerr(); + int countonly = 0; + + database = "sms"; + + while (++arg - argv < argc) { + if (**arg == '-') + switch ((*arg)[1]) { + case 'd': + debug = atoi((*arg)[2] ? *arg+2 : *++arg); + break; + case 'n': + mode = MODE_NO; + break; + case 'y': + mode = MODE_YES; + break; + case 'p': + mode = MODE_PREEN; + break; + case 'a': + mode = MODE_ASK; + break; + case 'c': + countonly++; + break; + case 'f': + fast++; + break; + } + else + database = *arg; + } + if (countonly) + printf("Only doing counts\n"); + else if (fast) + printf("Doing fast version (skipping some checks)\n"); + if (mode == MODE_NO) + printf("Will NOT modify the database\n"); + else if (mode == MODE_PREEN) + printf("Will fix simple things without asking\n"); + else if (mode == MODE_YES) + printf("Will fix everything without asking\n"); + if (debug) + printf("Debug level is %d\n", debug); + + signal(SIGHUP, cleanup); + signal(SIGQUIT, cleanup); + signal(SIGINT, cleanup); + + IIseterr(ingerr); + printf("Opening database %s...", database); + fflush(stdout); +## ingres database + printf("done\n"); +## retrieve (dcmenable = values.value) where values.name = "dcm_enable" + dprintf("DCM disabled (was %d)\n", dcmenable); +## replace values (value = 0) where values.name = "dcm_enable" + +## begin transaction + + if (!countonly) { + phase1(); + phase2(); + phase3(); + } else { + printf("Skipping to counts\n"); + count_only_setup(); + } + phase4(); + +## end transaction +## replace values (value = dcmenable) where values.name = "dcm_enable" + printf("Done.\n"); +## exit + exit(0); +} + +ingerr(num) +int *num; +{ + printf("An ingres error occuurred, code %d\n", *num); + printf("Aborting...\n"); +## abort + exit(1); +} + + +int cleanup() +##{ + printf("Signal caught, aborting transaction\n"); +## abort +## replace values (value = dcmenable) where values.name = "dcm_enable" +## exit + exit(0); +##} diff --git a/dbck/fix.qc b/dbck/fix.qc new file mode 100644 index 00000000..6637a662 --- /dev/null +++ b/dbck/fix.qc @@ -0,0 +1,207 @@ +/* $Header$ + * + * User interface routines for dbck (SMS database consistency checker) + * + * (c) Copyright 1988 by the Massachusetts Institute of Technology. + * For copying and distribution information, please see the file + * . + */ + +#include +#include +#include +#include "dbck.h" + + +##char *_table; +##char *_idfield; + +##generic_ffunc(id) +##int id; +##{ +## int rowcount; + +## delete _table where _table._idfield = id +## inquire_equel(rowcount = "rowcount") + if (rowcount > 0) + printf("%d entr%s deleted\n", rowcount, rowcount==1?"y":"ies"); + else + printf("Not deleted\n"); +##} + + +generic_delete(sq, pfunc, table, idfield, preen) +struct save_queue *sq; +void (*pfunc)(); +char *table, *idfield; +int preen; +{ + _table = table; + _idfield = idfield; + generic_fix(sq, pfunc, "Delete", generic_ffunc, preen); +} + + +single_delete(table, idfield, id) +char *table, *idfield; +int id; +{ + _table = table; + _idfield = idfield; + generic_ffunc(id); +} + + +##zero_fix(table, zrfield, idfield, id) +##char *table, *zrfield, *idfield; +##int id; +##{ +## int rowcount; + +## replace table (zrfield = 0) where table.idfield = id +## inquire_equel(rowcount = "rowcount") + if (rowcount > 0) + printf("%d entr%s fixed\n", rowcount, rowcount==1?"y":"ies"); + else + printf("Not fixed\n"); +##} + + +generic_fix(sq, pfunc, msg, ffunc, preen) +struct save_queue *sq; +char *msg; +int (*pfunc)(), (*ffunc)(); +int preen; +{ + int id; + + while (sq_get_data(sq, &id)) { + if ((*pfunc)(id) == 0 && singe_fix(msg, preen)) + (*ffunc)(id); + } + sq_destroy(sq); +} + + +int single_fix(msg, preen) +char *msg; +int preen; +{ + int lmode; + + lmode = mode; + if (mode == MODE_PREEN) { + if (preen) + lmode = MODE_YES; + else + lmode = MODE_NO; + } + + switch (lmode) { + case MODE_ASK: + if (!prompt(msg)) + break; + case MODE_YES: + return(1); + break; + case MODE_NO: + ; + } + return(0); +} + + +int prompt(msg) +char *msg; +{ + char buf[BUFSIZ]; +## extern int dcmenable; + + while (1) { + printf("%s (Y/N/Q)? ", msg); + fflush(stdout); + gets(buf); + if (buf[0] == 'Y' || buf[0] == 'y') + return(1); + if (buf[0] == 'N' || buf[0] == 'n') + return(0); + if (buf[0] == 'Q' || buf[0] == 'q') { + if (prompt("Are you sure you want to quit")) { + if (prompt("Save database changes")) { +## end transaction +## replace values (value = dcmenable) +## where values.name = "dcm_enable" +## exit + exit(0); + } else { + cleanup(); + } + } + } + } +} + + +/** + ** set_next_object_id - set next object id in values table + ** + ** Inputs: object - object name in values table and in objects + ** table - name of table objects are found in + ** + ** - called before an APPEND operation to set the next object id to + ** be used for the new record to the next free value + ** + **/ + +int set_next_object_id(object, table) + char *object; + char *table; +##{ +## char *name, *tbl; +## int rowcount, exists, value; + + name = object; + tbl = table; +## range of v is values +## repeat retrieve (value = v.#value) where v.#name = @name +## inquire_equel(rowcount = "rowcount") + if (rowcount != 1) + return(SMS_NO_ID); + +## retrieve (exists = any(tbl.name where tbl.name = value)) +## inquire_equel(rowcount = "rowcount") + if (rowcount != 1) + return(SMS_NO_ID); + while (exists) { + value++; + if (value > MAX_ID_VALUE) + value = MIN_ID_VALUE; +## retrieve (exists = any(tbl.name where tbl.name = value)) + } + + printf("setting ID %s to %d", name, value); +## repeat replace v (#value = @value) where v.#name = @name + return(SMS_SUCCESS); +##} + + +##generic_fix_id(table, idfield, txtfield, oldid, name) +##char *table; +##char *idfield; +##char *txtfield; +##int oldid; +##char *name; +##{ +## int rowcount, id; + + set_next_object_id(table, idfield); +## retrieve (id = values.value) where values.#name = idfield +## replace table (idfield = values.value) where values.#name = idfield and +## table.idfield = oldid and table.txtfield = name +## inquire_equel(rowcount = "rowcount") + if (rowcount == 1) + printf("Fixed\n"); + else + printf("Not fixed, rowcount = %d\n", rowcount); + return(id); +##} diff --git a/dbck/phase1.qc b/dbck/phase1.qc new file mode 100644 index 00000000..3d15a484 --- /dev/null +++ b/dbck/phase1.qc @@ -0,0 +1,368 @@ +/* $Header$ + * + * (c) Copyright 1988 by the Massachusetts Institute of Technology. + * For copying and distribution information, please see the file + * . + */ + +#include +#include "dbck.h" + + +show_user_id(u) +struct user *u; +{ + printf("User %s (%s, status %d) has duplicate ID\n", + u->login, u->fullname, u->status); + return(0); +} + +handle_duplicate_logins(sq) +struct save_queue *sq; +{ + struct user *u, *uu, *tmp; + + uu = (struct user *)0; + while (sq_get_data(sq, &u)) { + if (!strcmp(u->login, uu->login)) { + if (uu->status == 1 || u->status == 0) { + tmp = u; + u = uu; + uu = tmp; + } + printf("User %s (%s, status %d) and\n", + u->login, u->fullname, u->status); + printf("User %s (%s, status %d) have duplicate logins\n", + uu->login, uu->fullname, uu->status); + if (!strcmp(u->fullname, uu->fullname) && + single_fix("Delete the second one")) { + single_delete("users", "users_id", uu->users_id); + } else if (single_fix("Unregister the second one")) +## { +## int id = uu->users_id, rowcount; + +## replace users (login = "#"+text(users.uid), status = 0) +## where users.users_id = id +## inquire_equel(rowcount = "rowcount") + if (rowcount > 0) + printf("%d entr%s fixed\n", rowcount, rowcount==1?"y":"ies"); + else + printf("Not fixed\n"); +## } + } else { + uu = u; + } + } +} + +fix_user_id(u) +struct user *u; +{ + u->users_id = generic_fix_id("users", "users_id", "login", + u->users_id, u->login); +} + + +cant_fix(id) +int id; +{ + printf("Sorry, don't know how to fix that\n"); +} + +show_mach_id(m) +struct machine *m; +{ + printf("Machine %s has duplicate ID %d\n", m->name, m->mach_id); + return(0); +} + +show_mach_name(m) +struct machine *m; +{ + printf("Machine %s (%d) has duplicate name\n", m->name, m->mach_id); + return(0); +} + +fix_mach_id(m) +struct machine *m; +{ + m->mach_id = generic_fix_id("machine", "mach_id", "name", + m->mach_id, m->name); +} + +show_clu_id(c) +struct cluster *c; +{ + printf("Cluster %s has duplicate ID %d\n", c->name, c->clu_id); + return(0); +} + +show_clu_name(c) +struct cluster *c; +{ + printf("Cluster %s (%d) has duplicate name\n", c->name, c->clu_id); + return(0); +} + +fix_clu_id(c) +struct cluster *c; +{ + c->clu_id = generic_fix_id("cluster", "clu_id", "name", c->clu_id, c->name); +} + +show_list_id(l) +struct list *l; +{ + printf("List %s has duplicate ID %d\n", l->name, l->list_id); + return(0); +} + +show_list_name(l) +struct list *l; +{ + printf("List %s (%d) has duplicate name\n", l->name, l->list_id); + return(0); +} + +fix_list_id(l) +struct list *l; +{ + l->list_id = generic_fix_id("list", "list_id", "name", l->list_id, l->name); +} + +show_fs_id(f) +struct filesys *f; +{ + printf("Filesys %s has duplicate ID %d\n", f->name, f->filsys_id); + return(0); +} + +fix_fs_id(f) +struct filesys *f; +{ + f->filsys_id = generic_fix_id("filesys", "filsys_id", "label", + f->filsys_id, f->name); +} + + +show_np_id(n) +struct nfsphys *n; +{ + printf("NfsPhys %s:%s has duplicate ID %d\n", + ((struct machine *)hash_lookup(machines, n->mach_id))->name, + n->dir, n->nfsphys_id); + return(0); +} + +fix_np_id(n) +struct nfsphys *n; +{ + n->nfsphys_id = generic_fix_id("nfsphys", "nfsphys_id", "dir", + n->nfsphys_id, n->dir); +} + +show_str_id(s) +struct string *s; +{ + printf("String %s has duplicate ID %d\n", s->name, s->string_id); + return(0); +} + + +phase1() +##{ +## char name[33], name1[33], last[17], first[17], buf[257]; +## int id, id2, id3, aid, aid2, status; + struct save_queue *sq; + struct user *u; + struct machine *m; + struct list *l; + struct cluster *c; + struct string *s; + struct filesys *f; + struct nfsphys *n; + + printf("Phase 1 - Looking for duplicates\n"); + + dprintf("Loading users...\n"); + sq = sq_create(); + users = create_hash(10000); +## range of u is users +## retrieve (id = u.users_id, name = u.login, last = u.#last, +## first = u.#first, status = u.#status, buf = u.potype, +## id2 = u.pop_id, id3 = u.box_id) { + u = (struct user *) malloc(sizeof(struct user)); + strcpy(u->login, strtrim(name)); + u->potype = buf[0]; + sprintf(buf, "%s, %s", strtrim(last), strtrim(first)); + u->fullname = strsave(buf); + u->status = status; + u->users_id = id; + switch (u->potype) { + case 'P': + u->pobox_id = id2; + break; + case 'S': + u->pobox_id = id3; + break; + default: + u->pobox_id = 0; + } + if (hash_store(users, id, u)) { + sq_save_data(sq, hash_lookup(users, id)); + sq_save_data(sq, u); + } +## } + generic_fix(sq, show_user_id, "Change ID", fix_user_id, 0); + + if (!fast) { + sq = sq_create(); +## retrieve (id = u.users_id) +## where u.login = users.login and u.tid != users.tid { + sq_save_data(sq, hash_lookup(users, id)); +## } + handle_duplicate_logins(sq); + } + + dprintf("Loading machines...\n"); + machines = create_hash(1000); + sq = sq_create(); +## range of m is machine +## retrieve (id = m.mach_id, name = m.#name) { + m = (struct machine *) malloc(sizeof(struct machine)); + strcpy(m->name, strtrim(name)); + m->mach_id = id; + m->clucount = 0; + if (hash_store(machines, id, m)) { + sq_save_data(sq, hash_lookup(machines, id)); + sq_save_data(sq, m); + } +## } + generic_fix(sq, show_mach_id, "Change ID", fix_mach_id, 0); + + if (!fast) { + sq = sq_create(); +## retrieve (id = m.mach_id) +## where m.#name = machine.#name and m.tid != machine.tid { + sq_save_data(sq, hash_lookup(machines, id)); +## } + generic_fix(sq, show_mach_name, "Change name", cant_fix, 0); + } + + dprintf("Loading clusters...\n"); + sq = sq_create(); + clusters = create_hash(100); +## range of c is cluster +## retrieve (id = cluster.clu_id, name = cluster.#name) { + c = (struct cluster *) malloc(sizeof(struct cluster)); + strcpy(c->name, strtrim(name)); + c->clu_id = id; + if (hash_store(clusters, id, c)) { + sq_save_data(sq, hash_lookup(clusters, id)); + sq_save_data(sq, c); + } +## } + generic_fix(sq, show_clu_id, "Change ID", fix_clu_id, 0); + + if (!fast) { + sq = sq_create(); +## retrieve (id = c.clu_id) +## where c.#name = cluster.#name and c.tid != cluster.tid { + sq_save_data(sq, hash_lookup(clusters, id)); +## } + generic_fix(sq, show_clu_name, "Change name", cant_fix, 0); + } + + dprintf("Loading lists...\n"); + sq = sq_create(); + lists = create_hash(10000); +## range of l is list +## retrieve (id = l.list_id, name = l.#name, +## aid = l.acl_id, buf = l.acl_type) { + l = (struct list *) malloc(sizeof(struct list)); + strcpy(l->name, strtrim(name)); + l->acl_type = buf[0]; + l->acl_id = aid; + l->list_id = id; + l->members = 0; + if (hash_store(lists, id, l)) { + sq_save_data(sq, hash_lookup(lists, id)); + sq_save_data(sq, l); + } +## } + generic_fix(sq, show_list_id, "Change ID", fix_list_id, 0); + + if (!fast) { + sq = sq_create(); +## retrieve (id = l.list_id) +## where l.#name = list.#name and l.tid != list.tid { + sq_save_data(sq, hash_lookup(lists, id)); +## } + generic_fix(sq, show_list_name, "Change name", cant_fix, 0); + } + + dprintf("Loading filesys...\n"); + sq = sq_create(); + filesys = create_hash(10000); +## retrieve (id = filesys.filsys_id, name = filesys.label, aid = filesys.owner, +## aid2 = filesys.owners, id2 = filesys.phys_id, +## id3 = filesys.mach_id, buf = filesys.type, +## name1 = filesys.#name) { + f = (struct filesys *) malloc(sizeof(struct filesys)); + strcpy(f->name, strtrim(name)); + strcpy(f->dir, strtrim(name1)); + f->filsys_id = id; + f->owner = aid; + f->owners = aid2; + f->phys_id = id2; + f->mach_id = id3; + f->type = buf[0]; + if (hash_store(filesys, id, f)) { + sq_save_data(sq, hash_lookup(filesys, id)); + sq_save_data(sq, f); + } +## } + generic_fix(sq, show_fs_id, "Change ID", fix_fs_id, 0); + + dprintf("Loading nfsphys...\n"); + sq = sq_create(); + nfsphys = create_hash(500); +## retrieve (id = nfsphys.nfsphys_id, name = nfsphys.dir, +## id2 = nfsphys.mach_id, id3 = nfsphys.allocated) { + n = (struct nfsphys *) malloc(sizeof(struct nfsphys)); + strcpy(n->dir, strtrim(name)); + n->mach_id = id2; + n->nfsphys_id = id; + n->allocated = id3; + n->count = 0; + if (hash_store(nfsphys, id, n)) { + sq_save_data(sq, hash_lookup(nfsphys, id)); + sq_save_data(sq, n); + } +## } + generic_fix(sq, show_np_id, "Change ID", fix_np_id, 0); + + dprintf("Loading strings...\n"); + sq = sq_create(); + strings = create_hash(5000); +## range of s is strings +## retrieve (id = s.string_id, buf = s.string) { + s = (struct string *) malloc(sizeof(struct string)); + s->name = strsave(strtrim(buf)); + s->string_id = id; + s->refc = 0; + if (hash_store(strings, id, s)) { + sq_save_data(sq, hash_lookup(strings, id)); + sq_save_data(sq, s); + } +## } + generic_delete(sq, show_str_id, "strings", "string_id", 0); + + if (!fast) { +## retrieve (id = s.string_id, buf = s.string) +## where s.string = strings.string and s.tid != strings.tid { + printf("String %s(%d) is a duplicate!\n", strtrim(buf), id); +## } + } +##} + diff --git a/dbck/phase2.qc b/dbck/phase2.qc new file mode 100644 index 00000000..2f5a2c01 --- /dev/null +++ b/dbck/phase2.qc @@ -0,0 +1,615 @@ +/* $Header$ + * + * (c) Copyright 1988 by the Massachusetts Institute of Technology. + * For copying and distribution information, please see the file + * . + */ + +#include +#include +#include +#include "dbck.h" + +show_mcm_mach(id) +int id; +##{ +## int iid = id, found = 1; +## char name[33]; + +## retrieve (name = cluster.#name) where cluster.clu_id = mcmap.clu_id +## and mcmap.mach_id = iid { + strtrim(name); + found = 0; + printf("Cluster %s, non-existant machine %d in cluster map\n", name, id); +## } + return(found); +##} + +show_mcm_clu(id) +int id; +##{ +## int iid = id, found = 1; +## char name[33]; + +## retrieve (name = machine.#name) where machine.mach_id = mcmap.mach_id +## and mcmap.clu_id = iid { + strtrim(name); + found = 0; + printf("Machine %s, non-existant cluster %d in cluster map\n", name, id); +## } + return(found); +##} + +pobox_check(id, u, hint) +int id; +struct user *u; +int hint; +{ + switch (u->potype) { + case 'P': + if (!hash_lookup(machines, u->pobox_id)) { + printf("User %s(%s) has P.O.Box on non-existant machine %d\n", + u->login, u->fullname, u->pobox_id); + if (single_fix("Delete", 0)) { + remove_pobox(u->users_id); + u->potype = 'N'; + } + } + break; + case 'S': + if (!string_check(u->pobox_id)) { + printf("User %s(%s) has P.O.Box with non-existant string %d\n", + u->login, u->fullname, u->pobox_id); + if (single_fix("Delete", 0)) { + remove_pobox(u->users_id); + u->potype = 'N'; + } + } + break; + default: + ; + } +} + + +remove_pobox(id) +int id; +##{ +## int rowcount, iid = id; +## replace users (potype = "NONE") where users.users_id = iid +## inquire_equel(rowcount = "rowcount") + if (rowcount > 0) + printf("%d entr%s removed\n", rowcount, rowcount==1?"y":"ies"); + else + printf("Not removed\n"); +##} + +show_svc(id) +int id; +##{ +## int iid = id, found = 1; +## char label[17], data[33]; + +## retrieve (label = svc.serv_label, data = svc.serv_cluster) +## where svc.clu_id = iid { + strtrim(label); + strtrim(data); + found = 0; + printf("Cluster data [%s] %s for non-existant cluster %d\n", + label, data, id); +## } + return(found); +##} + +list_check(id, l, hint) +int id; +struct list *l; +int hint; +{ + switch (l->acl_type) { + case 'L': + if (!hash_lookup(lists, l->acl_id)) { + printf("List %s has bad LIST acl %d\n", l->name, l->acl_id); + if (single_fix("Patch", 1)) { + fix_list_acl(l->list_id); + } + } + break; + case 'U': + if (!hash_lookup(users, l->acl_id)) { + printf("List %s has bad USER acl %d\n", l->name, l->acl_id); + if (single_fix("Patch", 1)) { + fix_list_acl(l->list_id); + } + } + break; + } +} + +fix_list_acl(id) +int id; +##{ +## int rowcount, iid = id; +## replace list (acl_id = iid, acl_type = "LIST") where list.list_id = iid +## inquire_equel(rowcount = "rowcount") + if (rowcount > 0) + printf("%d entr%s fixed\n", rowcount, rowcount==1?"y":"ies"); + else + printf("Not fixed\n"); +##} + + +show_member_list(id) +int id; +##{ +## int mid, iid = id, found = 1; +## char mtype[9], *name; + +## retrieve (mtype = member.member_type, mid = member.member_id) +## where member.list_id = iid { + strtrim(mtype); + found = 0; + if (mtype[0] == 'L') + strcpy(name, ((struct list *) hash_lookup(lists, mid))->name); + else if (mtype[0] == 'U') + strcpy(name, ((struct user *) hash_lookup(users, mid))->login); + else if (mtype[0] == 'S') + strcpy(name, ((struct string *) hash_lookup(strings, mid))->name); + printf("Non-existant list %d has member %s %s\n", iid, mtype, name); +## } + return(found); +##} + +show_mem_user(id) +int id; +##{ +## int lid, iid = id, found = 1; +## char name[33]; + +## retrieve (lid = members.list_id) +## where members.member_id = iid and members.member_type = "USER" { + found = 0; + printf("List %s has non-existant user member, id %d\n", + ((struct list *)hash_lookup(lists, lid))->name, iid); +## } + return(found); +##} + +show_mem_list(id) +int id; +##{ +## int lid, iid = id, found = 1; +## char name[33]; + +## retrieve (lid = members.list_id) +## where members.member_id = iid and members.member_type = "LIST" { + found = 0; + printf("List %s has non-existant list member, id %d\n", + ((struct list *)hash_lookup(lists, lid))->name, iid); +## } + return(found); +##} + +show_mem_str(id) +int id; +##{ +## int lid, iid = id, found = 1; +## char name[33]; + +## retrieve (lid = members.list_id) +## where members.member_id = iid and members.member_type = "STRING" { + found = 0; + printf("List %s has non-existant string member, id %d\n", + ((struct list *)hash_lookup(lists, lid))->name, iid); +## } + return(found); +##} + + +##del_mem_user(id) +##int id; +##{ +## int rowcount; + +## delete members where members.member_type = "USER" and +## members.member_id = id +## inquire_equel(rowcount = "rowcount"); + if (rowcount > 0) + printf("%d entr%s deleted\n", rowcount, rowcount==1?"y":"ies"); + else + printf("Not deleted\n"); +##} + +##del_mem_list(id) +##int id; +##{ +## int rowcount; + +## delete members where members.member_type = "LIST" and +## members.member_id = id +## inquire_equel(rowcount = "rowcount"); + if (rowcount > 0) + printf("%d entr%s deleted\n", rowcount, rowcount==1?"y":"ies"); + else + printf("Not deleted\n"); +##} + +##del_mem_str(id) +##int id; +##{ +## int rowcount; + +## delete members where members.member_type = "STRING" and +## members.member_id = id +## inquire_equel(rowcount = "rowcount"); + if (rowcount > 0) + printf("%d entr%s deleted\n", rowcount, rowcount==1?"y":"ies"); + else + printf("Not deleted\n"); +##} + + +##show_sh(id) +##int id; +##{ +## char name[33]; + int found = 1; + +## retrieve (name = serverhosts.service) where serverhosts.mach_id = id { + found = 0; + printf("ServerHost entry for service %s non-existant host %d\n", + name, id); +## } + return(found); +##} + +##del_sh_mach(id) +##int id; +##{ +## int rowcount; + +## delete serverhosts where serverhosts.mach_id = id +## inquire_equel(rowcount = "rowcount"); + if (rowcount > 0) + printf("%d entr%s deleted\n", rowcount, rowcount==1?"y":"ies"); + else + printf("Not deleted\n"); +##} + + +static int fnchecklen; + +fsmatch(id, n, f) +int id; +struct nfsphys *n; +struct filesys *f; +{ + if (n->mach_id == f->mach_id && + !strncmp(f->dir, n->dir, strlen(n->dir)) && + strlen(n->dir) > fnchecklen) { + f->phys_id = id; + fnchecklen = strlen(n->dir); + } +} + + +##check_fs(id, f, hint) +##int id; +register struct filesys *f; +int hint; +##{ +## int id1, id2, id3, rowcount; +## char *dir; + struct nfsphys *n; + struct machine *m; + + if (f->type == 'N' || f->type == 'R') { + if (!hash_lookup(machines, f->mach_id)) { + printf("Filesys %s with bad machine %d\n", f->name, f->mach_id); + if (single_fix("Fix", 0)) { +## replace filesys (mach_id = 0) where filesys.filsys_id = id +## inquire_equel(rowcount = "rowcount") + if (rowcount > 0) + printf("%d entr%s fixed\n",rowcount, rowcount==1?"y":"ies"); + else + printf("Not fixed\n"); + f->mach_id = 0; + } + } + if (!hash_lookup(users, f->owner)) { + printf("Filesys %s with bad owning user %d\n", f->name, f->owner); + if (single_fix("Fix", 1)) { + zero_fix("filesys", "owner", "filsys_id", f->filsys_id); + f->owner = 0; + } + } + if (!hash_lookup(lists, f->owners)) { + printf("Filesys %s with bad owning group %d\n", f->name, f->owners); + if (single_fix("Fix", 1)) { + zero_fix("filesys", "owners", "filsys_id", f->filsys_id); + f->owners = 0; + } + } + } + + if (f->type == 'N') { + if (!hash_lookup(nfsphys, f->phys_id)) { + m = (struct machine *)hash_lookup(machines, f->mach_id); + printf("Filesys %s with bad phys_id %d\n", f->name, f->phys_id); + if (single_fix("Fix", 1)) { + fnchecklen = 0; + hash_step(nfsphys, fsmatch, f); + if (fnchecklen != 0) { + id1 = f->phys_id; + id2 = f->filsys_id; + id3 = f->mach_id; +## replace filesys (phys_id = id1) where filesys.filsys_id = id2 +## inquire_equel(rowcount = "rowcount") + if (rowcount > 0) + printf("%d entr%s fixed\n",rowcount, rowcount==1?"y":"ies"); + else + printf("Not fixed\n"); + } else { + printf("No NFSphys exsits for %s:%s\n", m->name, f->dir); + if (single_fix("Create", 0)) { + dir = f->dir; + id1 = f->phys_id; + id2 = f->filsys_id; + id3 = f->mach_id; + if (set_next_object_id("nfsphys_id", "nfsphys") != + SMS_SUCCESS) { + printf("Unable to assign unique ID\n"); + return; + } +## retrieve (id1 = values.value) +## where values.name = "nfsphys_id" +## inquire_equel(rowcount = "rowcount") + if (rowcount != 1) { + printf("Unable to retrieve unique ID\n"); + return; + } +## append nfsphys (nfsphys_id = id1, mach_id = id3, +## device = "???", #dir = dir, status = 0, +## allocated = 0, size = 0, +## modtime = "now", modby = 0, +## modwith = "dbck") +## inquire_equel(rowcount = "rowcount") + if (rowcount > 0) + printf("%d entr%s created\n", rowcount, + rowcount==1?"y":"ies"); + else + printf("Not created\n"); + n = (struct nfsphys *)malloc(sizeof(struct nfsphys)); + strcpy(n->dir, dir); + n->mach_id = id3; + n->nfsphys_id = id1; + n->allocated = 0; + n->count = 0; + hash_store(nfsphys, id1, n); +## replace filesys (phys_id = id1) +## where filesys.filsys_id = id +## inquire_equel(rowcount = "rowcount") + if (rowcount > 0) + printf("%d filesys entr%s fixed\n", rowcount, + rowcount==1?"y":"ies"); + else + printf("Not fixed\n"); + } + } + } + } + } +##} + + +check_nfsphys(id, n, hint) +int id; +struct nfsphys *n; +int hint; +{ + if (!hash_lookup(machines, n->mach_id)) { + printf("NFSphys %d(%s) on non-existant machine %d\n", + id, n->dir, n->mach_id); + if (single_fix("Delete", 0)) + single_delete("nfsphys", "nfsphys_id", id); + } +} + +##show_quota_nouser(id) +##int id; +##{ +## int id1, found = 1; + +## retrieve (id1 = nfsquota.filsys_id) where nfsquota.users_id = id { + found = 0; + printf("NFSquota on fs %d for non-existant user %d\n", id1, id); +## } + return(found); +##} + +fix_quota_nouser(id) +{ + single_delete("nfsquota", "users_id", id); +} + +##show_quota_nofs(id) +##int id; +##{ +## int id1, found = 1; + struct user *u; + +## retrieve (id1 = nfsquota.users_id) where nfsquota.filsys_id = id { + u = (struct user *)hash_lookup(users, id1); + found = 0; + printf("NFSquota for user %s on non-existant filesys %d\n", u->login, id); +## } + return(found); +##} + +fix_quota_nofs(id) +{ + single_delete("nfsquota", "filsys_id", id); +} + +##show_quota_wrongpid(id) +##int id; +##{ +## int id1, found = 1; + struct user *u; + struct filesys *f; + + f = (struct filesys *)hash_lookup(filesys, id); +## retrieve (id1 = nfsquota.users_id) where nfsquota.filsys_id = id { + u = (struct user *)hash_lookup(users, id1); + found = 0; + printf("NFSquota for user %s on filesys %s has wrong phys_id %d\n", + u->login, f->name, id); +## } + return(found); +##} + +##fix_quota_physid(id) +##int id; +##{ +## int rowcount, id1; + + id1 = ((struct filesys *)hash_lookup(filesys, id))->phys_id; +## replace nfsquota (phys_id = id1) where nfsquota.filsys_id = id and +## nfsquota.phys_id != id1 +## inquire_equel(rowcount = "rowcount") + if (rowcount > 0) + printf("%d entr%s fixed\n",rowcount, rowcount==1?"y":"ies"); + else + printf("Not fixed\n"); +##} + + +phase2() +##{ +## int id1, id2, id3, id4, id5; +## char type[9], name[33]; + struct save_queue *sq, *sq1, *sq2, *sq3, *sq4; + struct filesys *f; + struct list *l; + struct nfsphys *n; + struct machine *m; + + printf("Phase 2 - Checking references\n"); + + dprintf("Checking users...\n"); + hash_step(users, pobox_check, NULL); + + dprintf("Checking mcmap...\n"); + sq1 = sq_create(); + sq2 = sq_create(); +## retrieve (id1 = mcmap.mach_id, id2 = mcmap.clu_id) { + if (!(m = (struct machine *)hash_lookup(machines, id1))) + sq_save_unique_data(sq1, id1); + if (!hash_lookup(clusters, id2)) + sq_save_unique_data(sq2, id2); + m->clucount++; +## } + generic_delete(sq1, show_mcm_mach, "mcmap", "mach_id", 1); + generic_delete(sq2, show_mcm_clu, "mcmap", "clu_id", 1); + + dprintf("Checking service clusters...\n"); + sq1 = sq_create(); +## retrieve (id1 = svc.clu_id) { + if (!hash_lookup(clusters, id1)) + sq_save_unique_data(sq1, id1); +## } + generic_delete(sq1, show_svc, "svc", "clu_id", 1); + + dprintf("Checking lists...\n"); + hash_step(lists, list_check, NULL); + + dprintf("Checking members...\n"); + sq1 = sq_create(); + sq2 = sq_create(); + sq3 = sq_create(); + sq4 = sq_create(); +## range of m is members +## retrieve (id1 = m.list_id, type = m.member_type, id2 = m.member_id) { + strtrim(type); + if ((l = (struct list *) hash_lookup(lists, id1)) == NULL) + sq_save_unique_data(sq1, id1); + l->members++; + if (!strcmp(type, "USER") && !hash_lookup(users, id2)) + sq_save_unique_data(sq2, id2); + else if (!strcmp(type, "LIST") && !hash_lookup(lists, id2)) + sq_save_unique_data(sq3, id2); + else if (!strcmp(type, "STRING") && !string_check(id2)) + sq_save_unique_data(sq4, id2); +## } + generic_delete(sq1, show_member_list, "members", "list_id", 1); + generic_fix(sq2, show_mem_user, "Delete", del_mem_user, 1); + generic_fix(sq3, show_mem_list, "Delete", del_mem_list, 1); + generic_fix(sq4, show_mem_str, "Delete", del_mem_str, 1); + + dprintf("Checking servers...\n"); +## range of s is servers +## retrieve (name = s.#name, type = s.acl_type, id1 = s.acl_id) { + strtrim(type); + if (!strcmp(type, "USER") && !hash_lookup(users, id1)) + printf("Service %s has acl non-existant user %d\n", name, id1); + else if (!strcmp(type, "LIST") && !hash_lookup(lists, id1)) + printf("Service %s has acl non-existant list %d\n", name, id1); +## } + + dprintf("Checking servershosts...\n"); + sq = sq_create(); +## retrieve (id1 = serverhosts.mach_id) { + if (!hash_lookup(machines, id1)) + sq_save_data(sq, id1); +## } + generic_fix(sq, show_sh, "Delete", del_sh_mach, 1); + + dprintf("Checking nfsphys...\n"); + hash_step(nfsphys, check_nfsphys, NULL); + + dprintf("Checking filesys...\n"); + hash_step(filesys, check_fs, NULL); + + dprintf("Checking nfsquota...\n"); + sq1 = sq_create(); + sq2 = sq_create(); + sq3 = sq_create(); +## retrieve (id1 = nfsquota.users_id, id2 = nfsquota.filsys_id, +## id3 = nfsquota.phys_id, id4 = nfsquota.quota) { + if (!hash_lookup(users, id1)) + sq_save_data(sq1, id1); + else if (!(f = (struct filesys *) hash_lookup(filesys, id2))) + sq_save_data(sq2, id2); + else if (id3 != f->phys_id || + ((n = (struct nfsphys*) hash_lookup(nfsphys, id3)) == + (struct nfsphys *)NULL)) + sq_save_data(sq3, id2); + else + n->count += id4; +## } + generic_fix(sq1, show_quota_nouser, "Delete", fix_quota_nouser, 1); + generic_fix(sq2, show_quota_nofs, "Delete", fix_quota_nofs, 0); + generic_fix(sq3, show_quota_wrongpid, "Fix", fix_quota_physid, 1); + + dprintf("Not checking zephyr.\n"); + + dprintf("Checking hostaccess...\n"); +## range of h is hostaccess +## retrieve (id1 = h.mach_id, type = h.acl_type, id2 = h.acl_id) { + strtrim(type); + if (!hash_lookup(machines, id1)) + printf("Hostaccess for non-existant host %d\n", id1); + if (!strcmp(type, "USER") && !hash_lookup(users, id2)) + printf("Hostaccess for %d is non-existant user %d\n", id1, id2); + else if (!strcmp(type, "LIST") && !hash_lookup(lists, id2)) + printf("Hostaccess for %d is non-existant list %d\n", id1, id2); +## } + + dprintf("Checking capacls...\n"); +## retrieve (id1 = capacls.list_id, name = capacls.tag) { + if (!hash_lookup(lists, id1)) + printf("Capacl for %s is non-existant list %d\n", name, id1); +## } + +##} + diff --git a/dbck/phase3.qc b/dbck/phase3.qc new file mode 100644 index 00000000..e5540f1e --- /dev/null +++ b/dbck/phase3.qc @@ -0,0 +1,76 @@ +/* $Header$ + * + * (c) Copyright 1988 by the Massachusetts Institute of Technology. + * For copying and distribution information, please see the file + * . + */ + +#include +#include "dbck.h" + +#define NULL 0 + + +empty_list_check(id, l, hint) +int id, hint; +struct list *l; +{ + if (l->members == 0 && l->list_id != 0) + printf("Warning: List %s is empty\n", l->name); +} + + +/* Used by other parts of the program to check that a string_id is good. + * This returns TRUE if it is, or FALSE if it is not, and as a side effect + * increments the string reference count. + */ + +int string_check(id) +int id; +{ + register struct string *s; + + s = (struct string *) hash_lookup(strings, id); + if (s == NULL) + return(0); + s->refc++; + return(1); +} + + +unref_string_check(id, s, hint) +int id, hint; +struct string *s; +{ + if (s->refc == 0) { + printf("Unreferenced string %s id %d\n", s->name, id); + if (single_fix("Delete", 1)) + single_delete("strings", "string_id", id); + } +} + + +noclu_mach_check(id, m, hint) +int id, hint; +struct machine *m; +{ + if (m->clucount == 0) + printf("Warning: machine %s is not in any clusters\n", m->name); +} + + +phase3() +##{ + printf("Phase 3 - Finding unused objects\n"); + + dprintf("Checking machines...\n"); + hash_step(machines, noclu_mach_check, NULL); + + dprintf("Checking lists...\n"); + hash_step(lists, empty_list_check, NULL); + + dprintf("Checking strings...\n"); + hash_step(strings, unref_string_check, NULL); + +##} + diff --git a/dbck/phase4.qc b/dbck/phase4.qc new file mode 100644 index 00000000..f360ac5f --- /dev/null +++ b/dbck/phase4.qc @@ -0,0 +1,167 @@ +/* $Header$ + * + * (c) Copyright 1988 by the Massachusetts Institute of Technology. + * For copying and distribution information, please see the file + * . + */ + +#include +#include "dbck.h" + + +count_boxes(id, u, boxes) +int id; +struct user *u; +struct hash *boxes; +{ + int i; + + if (u->potype == 'P') { + if (i = (int) hash_lookup(boxes, u->pobox_id)) + hash_store(boxes, u->pobox_id, i+1); + else + printf("User %s(%s) has pobox on non-POP server %d\n", + u->fullname, u->login, u->pobox_id); + } +} + + +##check_box_counts(id, cnt, counts) +##int id, cnt; +struct hash *counts; +##{ +## int newval, rowcount, error; + + newval = (int) hash_lookup(counts, id); + if (newval != cnt - 1) { + printf("Count wrong on POBox machine %s; is %d in db, counted %d\n", + ((struct machine *) hash_lookup(machines, id))->name, + newval, cnt - 1); + if (single_fix("Update", 1)) { +## range of s is serverhosts +## replace s (value1 = newval) where +## s.service = "POP" and s.mach_id = id +## inquire_equel(rowcount = "rowcount", error = "errorno") + if (error != 0) + printf("Error = %d\n", error); + if (rowcount > 0) + printf("%d entr%s fixed\n", rowcount, rowcount==1?"y":"ies"); + else + printf("Not fixed\n"); + } + } +##} + + +##check_nfs_counts(id, n, hint) +##int id, hint; +struct nfsphys *n; +##{ +## int val, rowcount; + + val = n->count; + if (n->allocated != val) { + printf("Count wrong on NFSphys %s:%s; is %d in db, counted %d\n", + ((struct machine *) hash_lookup(machines, n->mach_id))->name, + n->dir, n->allocated, val); + if (single_fix("Update", 1)) { +## replace nfsphys (allocated = val) where nfsphys.nfsphys_id = id +## inquire_equel(rowcount = "rowcount") + if (rowcount > 0) + printf("%d entr%s fixed\n", rowcount, rowcount==1?"y":"ies"); + else + printf("Not fixed\n"); + } + } +##} + + +phase4() +##{ + struct hash *boxes, *counts; +## int id, cnt; + + printf("Phase 4 - Checking counts\n"); + + dprintf("Doing POBoxes...\n"); + boxes = create_hash(10); + counts = create_hash(10); +## retrieve (id = serverhosts.mach_id, cnt = serverhosts.value1) +## where serverhosts.service = "POP" { + hash_store(boxes, id, 1); + hash_store(counts, id, cnt); +## } + hash_step(users, count_boxes, boxes); + hash_step(boxes, check_box_counts, counts); + + dprintf("Doing NFSphys...\n"); + hash_step(nfsphys, check_nfs_counts, 0); +##} + + +count_only_setup() +##{ +## int id, status, id2, id3; +## char name[33], last[17], first[17], buf[257]; + struct save_queue *sq; + struct user *u; + struct nfsphys *n; + struct machine *m; + + dprintf("Loading users...\n"); + users = create_hash(10000); +## range of u is users +## retrieve (id = u.users_id, name = u.login, last = u.#last, +## first = u.#first, status = u.#status, buf = u.potype, +## id2 = u.pop_id, id3 = u.box_id) +## where u.potype != "NONE" { + u = (struct user *) malloc(sizeof(struct user)); + strcpy(u->login, strtrim(name)); + u->potype = buf[0]; + sprintf(buf, "%s, %s", strtrim(last), strtrim(first)); + u->fullname = strsave(buf); + u->status = status; + u->users_id = id; + switch (u->potype) { + case 'P': + u->pobox_id = id2; + break; + case 'S': + u->pobox_id = id3; + break; + default: + u->pobox_id = 0; + } + hash_store(users, id, u); +## } + + dprintf("Loading machines...\n"); + machines = create_hash(1000); +## range of m is machine +## retrieve (id = m.mach_id, name = m.#name) { + m = (struct machine *) malloc(sizeof(struct machine)); + strcpy(m->name, strtrim(name)); + m->mach_id = id; + hash_store(machines, id, m); +## } + + dprintf("Loading nfsphys...\n"); + nfsphys = create_hash(500); +## retrieve (id = nfsphys.nfsphys_id, name = nfsphys.dir, +## id2 = nfsphys.mach_id, id3 = nfsphys.allocated) { + n = (struct nfsphys *) malloc(sizeof(struct nfsphys)); + strcpy(n->dir, strtrim(name)); + n->mach_id = id2; + n->nfsphys_id = id; + n->allocated = id3; + n->count = 0; + hash_store(nfsphys, id, n); +## } + + dprintf("Counting quotas...\n"); +## retrieve (id = nfsquota.phys_id, id2 = nfsquota.quota) { + if (n = (struct nfsphys *) hash_lookup(nfsphys, id)) { + n->count += id2; + } +## } +##} -- 2.45.1