[moira.git] / dbck / phase2.qc

/* $Header$
 *
 *  (c) Copyright 1988 by the Massachusetts Institute of Technology.
 *  For copying and distribution information, please see the file
 *  <mit-copyright.h>.
 */

#include <mit-copyright.h>
#include <stdio.h>
#include <sms.h>
#include "dbck.h"

static char phase2_qc_rcsid[] = "$Header$";


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");
    modified("users");
##}

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");
    modified("list");
##}


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");
    modified("members");
##}

##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");
    modified("members");
##}

##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");
    modified("members");
##}


##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");
    modified("serverhosts");
##}


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");
		modified("filesys");
		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");
		  modified("filesys");
		} 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");
			modified("nfsphys");
			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 = id2
##			inquire_equel(rowcount = "rowcount")
			if (rowcount > 0)
			  printf("%d filesys entr%s fixed\n", rowcount,
				 rowcount==1?"y":"ies");
			else
			  printf("Not fixed\n");
			modified("filesys");
		    }
	        }
	    }
	}
    }
##}


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_fsg_missing(id)
##int id;
##{
##  int id1, found = 1;
    struct filesys *f;

##  retrieve (id1 = fsgroup.filsys_id) where fsgroup.group_id = id {
      found = 0;
      if (f = (struct filesys *) hash_lookup(filesys, id1))
	printf("Missing fsgroup %d has member filesystem %s\n", id, f->name);
      else
	printf("Missing fsgroup %d has member filesystem %d\n", id, id1);
##  }
    return(found);
##}

show_fsg_type(f)
struct filesys *f;
{
    char *t;

    switch (f->type) {
    case 'N':
	t = "NFS";
	break;
    case 'R':
	t = "RVD";
	break;
    case 'E':
	t = "ERR";
	break;
    case 'F':
	t = "FSGROUP";
	break;
    default:
	t = "???";
    }
    printf("FSGroup %s has type %s instead of FSGROUP\n", f->name, t);
    return(0);
}

fix_fsg_type(f)
struct filesys *f;
##{
##  int rowcount, id = f->filsys_id;

##  replace filesys (type = "FSGROUP") 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");
    modified("filesys");
##}

##show_fsg_nomember(id)
##int id;
##{
##  int id1, found = 1;
    struct filesys *f;

##  retrieve (id1 = fsgroup.group_id) where fsgroup.filsys_id = id {
      found = 0;
      if (f = (struct filesys *) hash_lookup(filesys, id1))
	printf("FSGroup %s has missing member %d\n", f->name, id);
      else
	printf("FSGroup %d has missing member %d\n", id1, id);
##  }
    return(found);
##}

##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");
    modified("nfsquota");
##}

##show_srv_user(id)
##int id;
##{
##  char name[33];
    int found = 1;

##  retrieve (name = s.#name) where s.acl_type = "USER" and s.acl_id = id {
	strtrim(name);
	printf("Service %s has acl non-existant user %d\n", name, id);
	found = 0;
##  }
    return(found);
##}

##show_srv_list(id)
##int id;
##{
##  char name[33];
    int found = 1;

##  retrieve (name = s.#name) where s.acl_type = "LIST" and s.acl_id = id {
	strtrim(name);
	printf("Service %s has acl non-existant list %d\n", name, id);
	found = 0;
##  }
    return(found);
##}

##zero_srv_user(id)
##int id;
##{
##  int rowcount;

##  replace servers (acl_id = 0) where servers.acl_id = id and
##	servers.acl_type = "USER"
##  inquire_equel(rowcount = "rowcount")
    if (rowcount > 0)
      printf("%d entr%s fixed\n", rowcount, rowcount==1?"y":"ies");
    else
      printf("Not fixed\n");
    modified("servers");
##}

##zero_srv_list(id)
##int id;
##{
##  int rowcount;

##  replace servers (acl_id = 0) where servers.acl_id = id and
##	servers.acl_type = "LIST"
##  inquire_equel(rowcount = "rowcount")
    if (rowcount > 0)
      printf("%d entr%s fixed\n", rowcount, rowcount==1?"y":"ies");
    else
      printf("Not fixed\n");
    modified("servers");
##}


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);
	if (m) 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);
	else
	  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");
    sq1 = sq_create();
    sq2 = sq_create();
##  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)) {
	    sq_save_data(sq1, id1);
	} else if (!strcmp(type, "LIST") && !hash_lookup(lists, id1)) {
	    sq_save_data(sq2, id1);
	}
##  }
    generic_fix(sq1, show_srv_user, "Fix", zero_srv_user, 1);
    generic_fix(sq2, show_srv_list, "Fix", zero_srv_list, 1);

    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, 0);

    dprintf("Checking nfsphys...\n");
    hash_step(nfsphys, check_nfsphys, NULL);

    dprintf("Checking filesys...\n");
    hash_step(filesys, check_fs, NULL);

    dprintf("Checking filesystem groups...\n");
    sq1 = sq_create();
    sq2 = sq_create();
    sq3 = sq_create();
##  retrieve (id1 = fsgroup.group_id, id2 = fsgroup.filsys_id) {
    	if (!(f = (struct filesys *) hash_lookup(filesys, id1)))
	  sq_save_data(sq1, id1);
	if (f->type  != 'F')
	  sq_save_data(sq2, f);
    	if (!hash_lookup(filesys, id2))
	  sq_save_data(sq3, id2);
##  }
    generic_delete(sq1, show_fsg_missing, "fsgroup", "group_id", 0);
    generic_fix(sq2, show_fsg_type, "Change to \"FSTYPE\"", fix_fsg_type, 0);
    generic_delete(sq3, show_fsg_nomember, "fsgroup", "filsys_id", 1);

    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);
	    printf("Not fixing this error\n");
	}
	if (!strcmp(type, "USER") && !hash_lookup(users, id2)) {
	    printf("Hostaccess for %d is non-existant user %d\n", id1, id2);
	    printf("Not fixing this error\n");
	} else if (!strcmp(type, "LIST") && !hash_lookup(lists, id2)) {
	    printf("Hostaccess for %d is non-existant list %d\n", id1, id2);
	    printf("Not fixing this error\n");
	}
##  }

    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);
	    printf("Not fixing this error\n");
	}
##  }

##}
Commit	Line	Data
d2543f8c	1	/* $Header$
	2	*
	3	* (c) Copyright 1988 by the Massachusetts Institute of Technology.
	4	* For copying and distribution information, please see the file
	5	* <mit-copyright.h>.
	6	*/
	7
	8	#include <mit-copyright.h>
	9	#include <stdio.h>
	10	#include <sms.h>
	11	#include "dbck.h"
	12
8ccfc7d5	13	static char phase2_qc_rcsid[] = "$Header$";
	14
	15
d2543f8c	16	show_mcm_mach(id)
	17	int id;
	18	##{
	19	## int iid = id, found = 1;
	20	## char name[33];
	21
	22	## retrieve (name = cluster.#name) where cluster.clu_id = mcmap.clu_id
	23	## and mcmap.mach_id = iid {
	24	strtrim(name);
	25	found = 0;
	26	printf("Cluster %s, non-existant machine %d in cluster map\n", name, id);
	27	## }
	28	return(found);
	29	##}
	30
	31	show_mcm_clu(id)
	32	int id;
	33	##{
	34	## int iid = id, found = 1;
	35	## char name[33];
	36
	37	## retrieve (name = machine.#name) where machine.mach_id = mcmap.mach_id
	38	## and mcmap.clu_id = iid {
	39	strtrim(name);
	40	found = 0;
	41	printf("Machine %s, non-existant cluster %d in cluster map\n", name, id);
	42	## }
	43	return(found);
	44	##}
	45
	46	pobox_check(id, u, hint)
	47	int id;
	48	struct user *u;
	49	int hint;
	50	{
	51	switch (u->potype) {
	52	case 'P':
	53	if (!hash_lookup(machines, u->pobox_id)) {
	54	printf("User %s(%s) has P.O.Box on non-existant machine %d\n",
	55	u->login, u->fullname, u->pobox_id);
	56	if (single_fix("Delete", 0)) {
	57	remove_pobox(u->users_id);
	58	u->potype = 'N';
	59	}
	60	}
	61	break;
	62	case 'S':
	63	if (!string_check(u->pobox_id)) {
	64	printf("User %s(%s) has P.O.Box with non-existant string %d\n",
	65	u->login, u->fullname, u->pobox_id);
	66	if (single_fix("Delete", 0)) {
	67	remove_pobox(u->users_id);
	68	u->potype = 'N';
	69	}
	70	}
	71	break;
	72	default:
	73	;
	74	}
	75	}
	76
	77
	78	remove_pobox(id)
	79	int id;
80	##{
81	## int rowcount, iid = id;
82	## replace users (potype = "NONE") where users.users_id = iid
83	## inquire_equel(rowcount = "rowcount")
84	if (rowcount > 0)
85	printf("%d entr%s removed\n", rowcount, rowcount==1?"y":"ies");
86	else
87	printf("Not removed\n");
8ccfc7d5	88	modified("users");
d2543f8c	89	##}
	90
	91	show_svc(id)
	92	int id;
	93	##{
	94	## int iid = id, found = 1;
	95	## char label[17], data[33];
	96
	97	## retrieve (label = svc.serv_label, data = svc.serv_cluster)
	98	## where svc.clu_id = iid {
	99	strtrim(label);
	100	strtrim(data);
	101	found = 0;
	102	printf("Cluster data [%s] %s for non-existant cluster %d\n",
	103	label, data, id);
	104	## }
	105	return(found);
	106	##}
	107
	108	list_check(id, l, hint)
	109	int id;
	110	struct list *l;
	111	int hint;
	112	{
	113	switch (l->acl_type) {
	114	case 'L':
	115	if (!hash_lookup(lists, l->acl_id)) {
	116	printf("List %s has bad LIST acl %d\n", l->name, l->acl_id);
	117	if (single_fix("Patch", 1)) {
	118	fix_list_acl(l->list_id);
	119	}
	120	}
	121	break;
	122	case 'U':
	123	if (!hash_lookup(users, l->acl_id)) {
	124	printf("List %s has bad USER acl %d\n", l->name, l->acl_id);
	125	if (single_fix("Patch", 1)) {
	126	fix_list_acl(l->list_id);
	127	}
	128	}
	129	break;
	130	}
	131	}
	132
	133	fix_list_acl(id)
	134	int id;
	135	##{
	136	## int rowcount, iid = id;
	137	## replace list (acl_id = iid, acl_type = "LIST") where list.list_id = iid
	138	## inquire_equel(rowcount = "rowcount")
	139	if (rowcount > 0)
	140	printf("%d entr%s fixed\n", rowcount, rowcount==1?"y":"ies");
	141	else
	142	printf("Not fixed\n");
8ccfc7d5	143	modified("list");
d2543f8c	144	##}
	145
	146
	147	show_member_list(id)
	148	int id;
	149	##{
	150	## int mid, iid = id, found = 1;
	151	## char mtype[9], *name;
	152
	153	## retrieve (mtype = member.member_type, mid = member.member_id)
	154	## where member.list_id = iid {
	155	strtrim(mtype);
	156	found = 0;
	157	if (mtype[0] == 'L')
	158	strcpy(name, ((struct list *) hash_lookup(lists, mid))->name);
	159	else if (mtype[0] == 'U')
	160	strcpy(name, ((struct user *) hash_lookup(users, mid))->login);
	161	else if (mtype[0] == 'S')
	162	strcpy(name, ((struct string *) hash_lookup(strings, mid))->name);
	163	printf("Non-existant list %d has member %s %s\n", iid, mtype, name);
	164	## }
	165	return(found);
	166	##}
	167
	168	show_mem_user(id)
	169	int id;
	170	##{
	171	## int lid, iid = id, found = 1;
	172	## char name[33];
	173
	174	## retrieve (lid = members.list_id)
	175	## where members.member_id = iid and members.member_type = "USER" {
	176	found = 0;
	177	printf("List %s has non-existant user member, id %d\n",
	178	((struct list *)hash_lookup(lists, lid))->name, iid);
	179	## }
	180	return(found);
	181	##}
	182
	183	show_mem_list(id)
	184	int id;
	185	##{
	186	## int lid, iid = id, found = 1;
	187	## char name[33];
	188
	189	## retrieve (lid = members.list_id)
	190	## where members.member_id = iid and members.member_type = "LIST" {
	191	found = 0;
	192	printf("List %s has non-existant list member, id %d\n",
	193	((struct list *)hash_lookup(lists, lid))->name, iid);
	194	## }
	195	return(found);
	196	##}
	197
	198	show_mem_str(id)
	199	int id;
	200	##{
	201	## int lid, iid = id, found = 1;
	202	## char name[33];
	203
	204	## retrieve (lid = members.list_id)
	205	## where members.member_id = iid and members.member_type = "STRING" {
	206	found = 0;
	207	printf("List %s has non-existant string member, id %d\n",
208	((struct list *)hash_lookup(lists, lid))->name, iid);
209	## }
210	return(found);
211	##}
212
213
214	##del_mem_user(id)
215	##int id;
216	##{
217	## int rowcount;
218
219	## delete members where members.member_type = "USER" and
220	## members.member_id = id
221	## inquire_equel(rowcount = "rowcount");
222	if (rowcount > 0)
223	printf("%d entr%s deleted\n", rowcount, rowcount==1?"y":"ies");
224	else
225	printf("Not deleted\n");
8ccfc7d5	226	modified("members");
d2543f8c	227	##}
	228
	229	##del_mem_list(id)
	230	##int id;
	231	##{
	232	## int rowcount;
	233
	234	## delete members where members.member_type = "LIST" and
	235	## members.member_id = id
	236	## inquire_equel(rowcount = "rowcount");
	237	if (rowcount > 0)
	238	printf("%d entr%s deleted\n", rowcount, rowcount==1?"y":"ies");
	239	else
	240	printf("Not deleted\n");
8ccfc7d5	241	modified("members");
d2543f8c	242	##}
	243
	244	##del_mem_str(id)
	245	##int id;
	246	##{
	247	## int rowcount;
	248
	249	## delete members where members.member_type = "STRING" and
	250	## members.member_id = id
	251	## inquire_equel(rowcount = "rowcount");
	252	if (rowcount > 0)
	253	printf("%d entr%s deleted\n", rowcount, rowcount==1?"y":"ies");
	254	else
	255	printf("Not deleted\n");
8ccfc7d5	256	modified("members");
d2543f8c	257	##}
	258
	259
	260	##show_sh(id)
	261	##int id;
	262	##{
	263	## char name[33];
	264	int found = 1;
	265
	266	## retrieve (name = serverhosts.service) where serverhosts.mach_id = id {
	267	found = 0;
	268	printf("ServerHost entry for service %s non-existant host %d\n",
	269	name, id);
	270	## }
	271	return(found);
	272	##}
	273
	274	##del_sh_mach(id)
	275	##int id;
	276	##{
	277	## int rowcount;
	278
	279	## delete serverhosts where serverhosts.mach_id = id
	280	## inquire_equel(rowcount = "rowcount");
	281	if (rowcount > 0)
	282	printf("%d entr%s deleted\n", rowcount, rowcount==1?"y":"ies");
	283	else
	284	printf("Not deleted\n");
8ccfc7d5	285	modified("serverhosts");
d2543f8c	286	##}
	287
	288
	289	static int fnchecklen;
	290
	291	fsmatch(id, n, f)
	292	int id;
	293	struct nfsphys *n;
	294	struct filesys *f;
	295	{
	296	if (n->mach_id == f->mach_id &&
	297	!strncmp(f->dir, n->dir, strlen(n->dir)) &&
	298	strlen(n->dir) > fnchecklen) {
	299	f->phys_id = id;
	300	fnchecklen = strlen(n->dir);
	301	}
	302	}
	303
	304
	305	##check_fs(id, f, hint)
	306	##int id;
	307	register struct filesys *f;
	308	int hint;
	309	##{
	310	## int id1, id2, id3, rowcount;
	311	## char *dir;
	312	struct nfsphys *n;
	313	struct machine *m;
	314
	315	if (f->type == 'N' \|\| f->type == 'R') {
	316	if (!hash_lookup(machines, f->mach_id)) {
	317	printf("Filesys %s with bad machine %d\n", f->name, f->mach_id);
	318	if (single_fix("Fix", 0)) {
	319	## replace filesys (mach_id = 0) where filesys.filsys_id = id
	320	## inquire_equel(rowcount = "rowcount")
	321	if (rowcount > 0)
	322	printf("%d entr%s fixed\n",rowcount, rowcount==1?"y":"ies");
	323	else
	324	printf("Not fixed\n");
8ccfc7d5	325	modified("filesys");
d2543f8c	326	f->mach_id = 0;
	327	}
	328	}
	329	if (!hash_lookup(users, f->owner)) {
	330	printf("Filesys %s with bad owning user %d\n", f->name, f->owner);
	331	if (single_fix("Fix", 1)) {
	332	zero_fix("filesys", "owner", "filsys_id", f->filsys_id);
	333	f->owner = 0;
	334	}
	335	}
	336	if (!hash_lookup(lists, f->owners)) {
	337	printf("Filesys %s with bad owning group %d\n", f->name, f->owners);
	338	if (single_fix("Fix", 1)) {
	339	zero_fix("filesys", "owners", "filsys_id", f->filsys_id);
	340	f->owners = 0;
	341	}
	342	}
	343	}
	344
	345	if (f->type == 'N') {
	346	if (!hash_lookup(nfsphys, f->phys_id)) {
	347	m = (struct machine *)hash_lookup(machines, f->mach_id);
	348	printf("Filesys %s with bad phys_id %d\n", f->name, f->phys_id);
	349	if (single_fix("Fix", 1)) {
	350	fnchecklen = 0;
	351	hash_step(nfsphys, fsmatch, f);
	352	if (fnchecklen != 0) {
	353	id1 = f->phys_id;
	354	id2 = f->filsys_id;
	355	id3 = f->mach_id;
	356	## replace filesys (phys_id = id1) where filesys.filsys_id = id2
	357	## inquire_equel(rowcount = "rowcount")
	358	if (rowcount > 0)
	359	printf("%d entr%s fixed\n",rowcount, rowcount==1?"y":"ies");
	360	else
	361	printf("Not fixed\n");
8ccfc7d5	362	modified("filesys");
d2543f8c	363	} else {
	364	printf("No NFSphys exsits for %s:%s\n", m->name, f->dir);
	365	if (single_fix("Create", 0)) {
	366	dir = f->dir;
	367	id1 = f->phys_id;
	368	id2 = f->filsys_id;
	369	id3 = f->mach_id;
	370	if (set_next_object_id("nfsphys_id", "nfsphys") !=
	371	SMS_SUCCESS) {
	372	printf("Unable to assign unique ID\n");
	373	return;
	374	}
	375	## retrieve (id1 = values.value)
	376	## where values.name = "nfsphys_id"
	377	## inquire_equel(rowcount = "rowcount")
	378	if (rowcount != 1) {
	379	printf("Unable to retrieve unique ID\n");
	380	return;
	381	}
	382	## append nfsphys (nfsphys_id = id1, mach_id = id3,
	383	## device = "???", #dir = dir, status = 0,
	384	## allocated = 0, size = 0,
	385	## modtime = "now", modby = 0,
	386	## modwith = "dbck")
	387	## inquire_equel(rowcount = "rowcount")
	388	if (rowcount > 0)
	389	printf("%d entr%s created\n", rowcount,
	390	rowcount==1?"y":"ies");
	391	else
	392	printf("Not created\n");
8ccfc7d5	393	modified("nfsphys");
d2543f8c	394	n = (struct nfsphys *)malloc(sizeof(struct nfsphys));
	395	strcpy(n->dir, dir);
	396	n->mach_id = id3;
	397	n->nfsphys_id = id1;
	398	n->allocated = 0;
	399	n->count = 0;
	400	hash_store(nfsphys, id1, n);
	401	## replace filesys (phys_id = id1)
8ccfc7d5	402	## where filesys.filsys_id = id2
d2543f8c	403	## inquire_equel(rowcount = "rowcount")
	404	if (rowcount > 0)
	405	printf("%d filesys entr%s fixed\n", rowcount,
	406	rowcount==1?"y":"ies");
	407	else
	408	printf("Not fixed\n");
8ccfc7d5	409	modified("filesys");
d2543f8c	410	}
	411	}
	412	}
	413	}
	414	}
	415	##}
	416
	417
	418	check_nfsphys(id, n, hint)
	419	int id;
	420	struct nfsphys *n;
	421	int hint;
	422	{
	423	if (!hash_lookup(machines, n->mach_id)) {
	424	printf("NFSphys %d(%s) on non-existant machine %d\n",
	425	id, n->dir, n->mach_id);
	426	if (single_fix("Delete", 0))
	427	single_delete("nfsphys", "nfsphys_id", id);
	428	}
	429	}
	430
6d2387f8	431	##show_fsg_missing(id)
	432	##int id;
	433	##{
	434	## int id1, found = 1;
	435	struct filesys *f;
	436
	437	## retrieve (id1 = fsgroup.filsys_id) where fsgroup.group_id = id {
	438	found = 0;
	439	if (f = (struct filesys *) hash_lookup(filesys, id1))
	440	printf("Missing fsgroup %d has member filesystem %s\n", id, f->name);
	441	else
	442	printf("Missing fsgroup %d has member filesystem %d\n", id, id1);
	443	## }
	444	return(found);
	445	##}
	446
	447	show_fsg_type(f)
	448	struct filesys *f;
	449	{
	450	char *t;
	451
	452	switch (f->type) {
	453	case 'N':
	454	t = "NFS";
	455	break;
	456	case 'R':
	457	t = "RVD";
	458	break;
	459	case 'E':
	460	t = "ERR";
	461	break;
	462	case 'F':
	463	t = "FSGROUP";
	464	break;
	465	default:
	466	t = "???";
	467	}
	468	printf("FSGroup %s has type %s instead of FSGROUP\n", f->name, t);
	469	return(0);
	470	}
	471
	472	fix_fsg_type(f)
	473	struct filesys *f;
	474	##{
	475	## int rowcount, id = f->filsys_id;
	476
	477	## replace filesys (type = "FSGROUP") where filesys.filsys_id = id
	478	## inquire_equel(rowcount = "rowcount")
	479	if (rowcount > 0)
	480	printf("%d entr%s fixed\n", rowcount, rowcount==1?"y":"ies");
	481	else
	482	printf("Not fixed\n");
	483	modified("filesys");
	484	##}
	485
	486	##show_fsg_nomember(id)
	487	##int id;
	488	##{
	489	## int id1, found = 1;
	490	struct filesys *f;
	491
	492	## retrieve (id1 = fsgroup.group_id) where fsgroup.filsys_id = id {
	493	found = 0;
	494	if (f = (struct filesys *) hash_lookup(filesys, id1))
495	printf("FSGroup %s has missing member %d\n", f->name, id);
496	else
497	printf("FSGroup %d has missing member %d\n", id1, id);
498	## }
499	return(found);
500	##}
501
d2543f8c	502	##show_quota_nouser(id)
	503	##int id;
	504	##{
	505	## int id1, found = 1;
	506
	507	## retrieve (id1 = nfsquota.filsys_id) where nfsquota.users_id = id {
	508	found = 0;
	509	printf("NFSquota on fs %d for non-existant user %d\n", id1, id);
	510	## }
	511	return(found);
	512	##}
	513
	514	fix_quota_nouser(id)
	515	{
	516	single_delete("nfsquota", "users_id", id);
	517	}
	518
	519	##show_quota_nofs(id)
	520	##int id;
	521	##{
	522	## int id1, found = 1;
	523	struct user *u;
	524
	525	## retrieve (id1 = nfsquota.users_id) where nfsquota.filsys_id = id {
	526	u = (struct user *)hash_lookup(users, id1);
	527	found = 0;
	528	printf("NFSquota for user %s on non-existant filesys %d\n", u->login, id);
	529	## }
	530	return(found);
	531	##}
	532
	533	fix_quota_nofs(id)
	534	{
	535	single_delete("nfsquota", "filsys_id", id);
	536	}
	537
	538	##show_quota_wrongpid(id)
	539	##int id;
	540	##{
	541	## int id1, found = 1;
	542	struct user *u;
	543	struct filesys *f;
	544
	545	f = (struct filesys *)hash_lookup(filesys, id);
	546	## retrieve (id1 = nfsquota.users_id) where nfsquota.filsys_id = id {
	547	u = (struct user *)hash_lookup(users, id1);
	548	found = 0;
	549	printf("NFSquota for user %s on filesys %s has wrong phys_id %d\n",
	550	u->login, f->name, id);
	551	## }
	552	return(found);
	553	##}
	554
	555	##fix_quota_physid(id)
	556	##int id;
	557	##{
	558	## int rowcount, id1;
	559
	560	id1 = ((struct filesys *)hash_lookup(filesys, id))->phys_id;
	561	## replace nfsquota (phys_id = id1) where nfsquota.filsys_id = id and
	562	## nfsquota.phys_id != id1
	563	## inquire_equel(rowcount = "rowcount")
	564	if (rowcount > 0)
	565	printf("%d entr%s fixed\n",rowcount, rowcount==1?"y":"ies");
566	else
567	printf("Not fixed\n");
8ccfc7d5	568	modified("nfsquota");
d2543f8c	569	##}
d2543f8c	570
c90986aa	571	##show_srv_user(id)
	572	##int id;
	573	##{
	574	## char name[33];
	575	int found = 1;
	576
	577	## retrieve (name = s.#name) where s.acl_type = "USER" and s.acl_id = id {
	578	strtrim(name);
	579	printf("Service %s has acl non-existant user %d\n", name, id);
	580	found = 0;
	581	## }
	582	return(found);
	583	##}
	584
	585	##show_srv_list(id)
	586	##int id;
	587	##{
	588	## char name[33];
	589	int found = 1;
	590
	591	## retrieve (name = s.#name) where s.acl_type = "LIST" and s.acl_id = id {
	592	strtrim(name);
	593	printf("Service %s has acl non-existant list %d\n", name, id);
	594	found = 0;
	595	## }
	596	return(found);
	597	##}
	598
	599	##zero_srv_user(id)
	600	##int id;
	601	##{
	602	## int rowcount;
	603
	604	## replace servers (acl_id = 0) where servers.acl_id = id and
	605	## servers.acl_type = "USER"
	606	## inquire_equel(rowcount = "rowcount")
	607	if (rowcount > 0)
	608	printf("%d entr%s fixed\n", rowcount, rowcount==1?"y":"ies");
	609	else
	610	printf("Not fixed\n");
	611	modified("servers");
	612	##}
	613
	614	##zero_srv_list(id)
	615	##int id;
	616	##{
	617	## int rowcount;
	618
	619	## replace servers (acl_id = 0) where servers.acl_id = id and
	620	## servers.acl_type = "LIST"
	621	## inquire_equel(rowcount = "rowcount")
	622	if (rowcount > 0)
	623	printf("%d entr%s fixed\n", rowcount, rowcount==1?"y":"ies");
	624	else
	625	printf("Not fixed\n");
	626	modified("servers");
	627	##}
	628
	629
d2543f8c	630
	631	phase2()
	632	##{
	633	## int id1, id2, id3, id4, id5;
	634	## char type[9], name[33];
	635	struct save_queue sq, sq1, sq2, sq3, *sq4;
	636	struct filesys *f;
	637	struct list *l;
	638	struct nfsphys *n;
	639	struct machine *m;
	640
	641	printf("Phase 2 - Checking references\n");
	642
	643	dprintf("Checking users...\n");
	644	hash_step(users, pobox_check, NULL);
	645
	646	dprintf("Checking mcmap...\n");
	647	sq1 = sq_create();
	648	sq2 = sq_create();
	649	## retrieve (id1 = mcmap.mach_id, id2 = mcmap.clu_id) {
	650	if (!(m = (struct machine *)hash_lookup(machines, id1)))
	651	sq_save_unique_data(sq1, id1);
	652	if (!hash_lookup(clusters, id2))
	653	sq_save_unique_data(sq2, id2);
0e37bdb8	654	if (m) m->clucount++;
d2543f8c	655	## }
	656	generic_delete(sq1, show_mcm_mach, "mcmap", "mach_id", 1);
	657	generic_delete(sq2, show_mcm_clu, "mcmap", "clu_id", 1);
	658
	659	dprintf("Checking service clusters...\n");
	660	sq1 = sq_create();
	661	## retrieve (id1 = svc.clu_id) {
	662	if (!hash_lookup(clusters, id1))
	663	sq_save_unique_data(sq1, id1);
	664	## }
	665	generic_delete(sq1, show_svc, "svc", "clu_id", 1);
	666
	667	dprintf("Checking lists...\n");
	668	hash_step(lists, list_check, NULL);
	669
	670	dprintf("Checking members...\n");
	671	sq1 = sq_create();
	672	sq2 = sq_create();
	673	sq3 = sq_create();
	674	sq4 = sq_create();
	675	## range of m is members
	676	## retrieve (id1 = m.list_id, type = m.member_type, id2 = m.member_id) {
	677	strtrim(type);
	678	if ((l = (struct list *) hash_lookup(lists, id1)) == NULL)
	679	sq_save_unique_data(sq1, id1);
0e37bdb8	680	else
0e37bdb8	681	l->members++;
d2543f8c	682	if (!strcmp(type, "USER") && !hash_lookup(users, id2))
	683	sq_save_unique_data(sq2, id2);
	684	else if (!strcmp(type, "LIST") && !hash_lookup(lists, id2))
	685	sq_save_unique_data(sq3, id2);
	686	else if (!strcmp(type, "STRING") && !string_check(id2))
	687	sq_save_unique_data(sq4, id2);
	688	## }
	689	generic_delete(sq1, show_member_list, "members", "list_id", 1);
	690	generic_fix(sq2, show_mem_user, "Delete", del_mem_user, 1);
	691	generic_fix(sq3, show_mem_list, "Delete", del_mem_list, 1);
	692	generic_fix(sq4, show_mem_str, "Delete", del_mem_str, 1);
	693
	694	dprintf("Checking servers...\n");
c90986aa	695	sq1 = sq_create();
c90986aa	696	sq2 = sq_create();
d2543f8c	697	## range of s is servers
	698	## retrieve (name = s.#name, type = s.acl_type, id1 = s.acl_id) {
	699	strtrim(type);
38e6880d	700	if (!strcmp(type, "USER") && !hash_lookup(users, id1)) {
c90986aa	701	sq_save_data(sq1, id1);
38e6880d	702	} else if (!strcmp(type, "LIST") && !hash_lookup(lists, id1)) {
c90986aa	703	sq_save_data(sq2, id1);
38e6880d	704	}
d2543f8c	705	## }
c90986aa	706	generic_fix(sq1, show_srv_user, "Fix", zero_srv_user, 1);
c90986aa	707	generic_fix(sq2, show_srv_list, "Fix", zero_srv_list, 1);
d2543f8c	708
	709	dprintf("Checking servershosts...\n");
	710	sq = sq_create();
	711	## retrieve (id1 = serverhosts.mach_id) {
	712	if (!hash_lookup(machines, id1))
	713	sq_save_data(sq, id1);
	714	## }
c90986aa	715	generic_fix(sq, show_sh, "Delete", del_sh_mach, 0);
d2543f8c	716
	717	dprintf("Checking nfsphys...\n");
	718	hash_step(nfsphys, check_nfsphys, NULL);
	719
	720	dprintf("Checking filesys...\n");
	721	hash_step(filesys, check_fs, NULL);
	722
6d2387f8	723	dprintf("Checking filesystem groups...\n");
	724	sq1 = sq_create();
	725	sq2 = sq_create();
	726	sq3 = sq_create();
	727	## retrieve (id1 = fsgroup.group_id, id2 = fsgroup.filsys_id) {
	728	if (!(f = (struct filesys *) hash_lookup(filesys, id1)))
	729	sq_save_data(sq1, id1);
	730	if (f->type != 'F')
	731	sq_save_data(sq2, f);
	732	if (!hash_lookup(filesys, id2))
	733	sq_save_data(sq3, id2);
	734	## }
	735	generic_delete(sq1, show_fsg_missing, "fsgroup", "group_id", 0);
	736	generic_fix(sq2, show_fsg_type, "Change to \"FSTYPE\"", fix_fsg_type, 0);
	737	generic_delete(sq3, show_fsg_nomember, "fsgroup", "filsys_id", 1);
	738
d2543f8c	739	dprintf("Checking nfsquota...\n");
	740	sq1 = sq_create();
	741	sq2 = sq_create();
	742	sq3 = sq_create();
	743	## retrieve (id1 = nfsquota.users_id, id2 = nfsquota.filsys_id,
	744	## id3 = nfsquota.phys_id, id4 = nfsquota.quota) {
	745	if (!hash_lookup(users, id1))
	746	sq_save_data(sq1, id1);
	747	else if (!(f = (struct filesys *) hash_lookup(filesys, id2)))
	748	sq_save_data(sq2, id2);
	749	else if (id3 != f->phys_id \|\|
	750	((n = (struct nfsphys*) hash_lookup(nfsphys, id3)) ==
	751	(struct nfsphys *)NULL))
	752	sq_save_data(sq3, id2);
	753	else
	754	n->count += id4;
	755	## }
	756	generic_fix(sq1, show_quota_nouser, "Delete", fix_quota_nouser, 1);
	757	generic_fix(sq2, show_quota_nofs, "Delete", fix_quota_nofs, 0);
	758	generic_fix(sq3, show_quota_wrongpid, "Fix", fix_quota_physid, 1);
	759
	760	dprintf("Not checking zephyr.\n");
	761
	762	dprintf("Checking hostaccess...\n");
	763	## range of h is hostaccess
	764	## retrieve (id1 = h.mach_id, type = h.acl_type, id2 = h.acl_id) {
	765	strtrim(type);
38e6880d	766	if (!hash_lookup(machines, id1)) {
	767	printf("Hostaccess for non-existant host %d\n", id1);
	768	printf("Not fixing this error\n");
	769	}
	770	if (!strcmp(type, "USER") && !hash_lookup(users, id2)) {
	771	printf("Hostaccess for %d is non-existant user %d\n", id1, id2);
	772	printf("Not fixing this error\n");
	773	} else if (!strcmp(type, "LIST") && !hash_lookup(lists, id2)) {
	774	printf("Hostaccess for %d is non-existant list %d\n", id1, id2);
	775	printf("Not fixing this error\n");
	776	}
d2543f8c	777	## }
	778
	779	dprintf("Checking capacls...\n");
	780	## retrieve (id1 = capacls.list_id, name = capacls.tag) {
38e6880d	781	if (!hash_lookup(lists, id1)) {
	782	printf("Capacl for %s is non-existant list %d\n", name, id1);
	783	printf("Not fixing this error\n");
	784	}
d2543f8c	785	## }
	786
	787	##}
	788