dbck/phase4.pc

   1 /* $Id$
   2  *
   3  * (c) Copyright 1988-1998 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 <moira.h>
  10 #include "dbck.h"
  11
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <string.h>
  15
  16 EXEC SQL INCLUDE sqlca;
  17
  18 RCSID("$Header$");
  19
  20 EXEC SQL WHENEVER SQLERROR DO dbmserr();
  21
  22 void count_boxes(int id, void *user, void *boxes);
  23 void check_box_counts(int id, void *cnt, void *counts);
  24 void check_nfs_counts(int id, void *nfsphys, void *hint);
  25
  26 void count_boxes(int id, void *user, void *boxes)
  27 {
  28   struct user *u = user;
  29   int i;
  30
  31   if (u->potype == 'P')
  32     {
  33       if ((i = (int) hash_lookup(boxes, u->pobox_id)))
  34         {
  35           if (hash_store(boxes, u->pobox_id, (void *)(i + 1)) == -1)
  36             out_of_mem("storing poboxes in hash table");
  37         }
  38       else
  39         {
  40           printf("User %s(%s) has pobox on non-POP server %d\n",
  41                  u->fullname, u->login, u->pobox_id);
  42           printf("Not fixing this error\n");
  43         }
  44     }
  45 }
  46
  47
  48 void check_box_counts(int id, void *cnt, void *counts)
  49 {
  50   EXEC SQL BEGIN DECLARE SECTION;
  51   int oldval, rowcount, iid = id, icnt = (int)cnt;
  52   EXEC SQL END DECLARE SECTION;
  53
  54   oldval = (int) hash_lookup(counts, id);
  55   icnt--;
  56   if (oldval != icnt)
  57     {
  58       printf("Count wrong on POBox machine %s; is %d in db, counted %d\n",
  59              ((struct machine *) hash_lookup(machines, id))->name,
  60              oldval, icnt);
  61       if (single_fix("Update", 1))
  62         {
  63           EXEC SQL UPDATE serverhosts SET value1 = :icnt
  64             WHERE service = 'POP' AND mach_id = :iid;
  65           rowcount = sqlca.sqlerrd[2];
  66           if (rowcount > 0)
  67             printf("%d entr%s fixed\n", rowcount, rowcount == 1 ? "y" : "ies");
  68           else
  69             printf("Not fixed\n");
  70           modified("serverhosts");
  71         }
  72     }
  73 }
  74
  75
  76 void check_nfs_counts(int id, void *nfsphys, void *hint)
  77 {
  78   struct nfsphys *n = nfsphys;
  79   EXEC SQL BEGIN DECLARE SECTION;
  80   int iid = id, val, rowcount;
  81   EXEC SQL END DECLARE SECTION;
  82
  83   val = n->count;
  84   if (n->allocated != val)
  85     {
  86       printf("Count wrong on NFSphys %s:%s; is %d in db, counted %d\n",
  87              ((struct machine *) hash_lookup(machines, n->mach_id))->name,
  88              n->dir, n->allocated, val);
  89       if (single_fix("Update", 1))
  90         {
  91           EXEC SQL UPDATE nfsphys SET allocated = :val
  92             WHERE nfsphys_id = :iid;
  93           rowcount = sqlca.sqlerrd[2];
  94           if (rowcount > 0)
  95             printf("%d entr%s fixed\n", rowcount, rowcount == 1 ? "y" : "ies");
  96           else
  97             printf("Not fixed\n");
  98           modified("nfsphys");
  99         }
 100     }
 101 }
 102
 103
 104 void phase4(void)
 105 {
 106   struct hash *boxes, *counts;
 107   int id, cnt;
 108
 109   printf("Phase 4 - Checking counts\n");
 110
 111   dprintf("Doing POBoxes...\n");
 112   boxes = create_hash(10);
 113   counts = create_hash(10);
 114   EXEC SQL DECLARE csr401 CURSOR FOR
 115     SELECT mach_id, value1 FROM serverhosts
 116     WHERE service = 'POP';
 117   EXEC SQL OPEN csr401;
 118   while (1)
 119     {
 120       EXEC SQL FETCH csr401 INTO :id, :cnt;
 121       if (sqlca.sqlcode)
 122         break;
 123
 124       if (hash_store(boxes, id, (void *)1) == -1)
 125         out_of_mem("storing poboxes");
 126       if (hash_store(counts, id, (void *)cnt) == -1)
 127         out_of_mem("storing pobox counts in hash table");
 128     }
 129   EXEC SQL CLOSE csr401;
 130   hash_step(users, count_boxes, boxes);
 131   hash_step(boxes, check_box_counts, counts);
 132
 133   dprintf("Doing NFSphys...\n");
 134   hash_step(nfsphys, check_nfs_counts, 0);
 135 }
 136
 137
 138 void count_only_setup(void)
 139 {
 140   EXEC SQL BEGIN DECLARE SECTION;
 141   int id, status, id2, id3;
 142   char name[33], last[17], first[17], buf[257];
 143   EXEC SQL END DECLARE SECTION;
 144   struct user *u;
 145   struct nfsphys *n;
 146   struct machine *m;
 147
 148   dprintf("Loading users...\n");
 149   users = create_hash(30000);
 150   EXEC SQL DECLARE csr402 CURSOR FOR
 151     SELECT users_id, login, last, first, status,
 152     potype, pop_id, box_id FROM users
 153     WHERE potype = 'POP';
 154   EXEC SQL OPEN csr402;
 155   while (1)
 156     {
 157       EXEC SQL FETCH csr402 INTO :id, :name, :last, :first, :status,
 158         :buf, :id2, :id3;
 159       if (sqlca.sqlcode)
 160         break;
 161
 162       u = malloc(sizeof(struct user));
 163       if (!u)
 164         out_of_mem("storing users");
 165       strcpy(u->login, strtrim(name));
 166       u->potype = buf[0];
 167       sprintf(buf, "%s, %s", strtrim(last), strtrim(first));
 168       u->fullname = strdup(buf);
 169       u->status = status;
 170       u->users_id = id;
 171       switch (u->potype)
 172         {
 173         case 'P':
 174           u->pobox_id = id2;
 175           break;
 176         case 'S':
 177           u->pobox_id = id3;
 178           break;
 179         default:
 180           u->pobox_id = 0;
 181         }
 182       if (hash_store(users, id, u) == -1)
 183         out_of_mem("storing users in hash table");
 184     }
 185   EXEC SQL CLOSE csr402;
 186
 187   dprintf("Loading machines...\n");
 188   machines = create_hash(20000);
 189   EXEC SQL DECLARE csr403 CURSOR FOR
 190     SELECT mach_id, name FROM machine;
 191   EXEC SQL OPEN csr403;
 192   while (1)
 193     {
 194       EXEC SQL FETCH csr403 INTO :id, :name;
 195       if (sqlca.sqlcode)
 196         break;
 197
 198         m = malloc(sizeof(struct machine));
 199         if (!m)
 200           out_of_mem("storing machines");
 201         strcpy(m->name, strtrim(name));
 202         m->mach_id = id;
 203         if (hash_store(machines, id, m) == -1)
 204           out_of_mem("storing users in hash table");
 205     }
 206   EXEC SQL CLOSE csr403;
 207
 208   dprintf("Loading nfsphys...\n");
 209   nfsphys = create_hash(500);
 210   EXEC SQL DECLARE csr404 CURSOR FOR
 211     SELECT nfsphys_id, dir, mach_id, allocated FROM nfsphys;
 212   EXEC SQL OPEN csr404;
 213   while (1)
 214     {
 215       EXEC SQL FETCH csr404 INTO :id, :name, :id2, :id3;
 216       if (sqlca.sqlcode)
 217         break;
 218
 219       n = malloc(sizeof(struct nfsphys));
 220       if (!n)
 221         out_of_mem("storing nfsphys");
 222       strcpy(n->dir, strtrim(name));
 223       n->mach_id = id2;
 224       n->nfsphys_id = id;
 225       n->allocated = id3;
 226       n->count = 0;
 227       if (hash_store(nfsphys, id, n) == -1)
 228         out_of_mem("storing nfsphys in hash table");
 229     }
 230   EXEC SQL CLOSE csr404;
 231
 232   dprintf("Counting quotas...\n");
 233   EXEC SQL DECLARE csr405 CURSOR FOR
 234     SELECT phys_id, quota FROM quota;
 235   EXEC SQL OPEN csr405;
 236   while (1)
 237     {
 238       EXEC SQL FETCH csr405 INTO :id, :id2;
 239       if (sqlca.sqlcode)
 240         break;
 241
 242       if ((n = hash_lookup(nfsphys, id)))
 243         n->count += id2;
 244     }
 245   EXEC SQL CLOSE csr405;
 246 }