]>
Commit | Line | Data |
---|---|---|
68bbc9c3 | 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 <moira.h> | |
11 | #include "dbck.h" | |
208a4f4a | 12 | EXEC SQL INCLUDE sqlca; |
68bbc9c3 | 13 | |
14 | static char phase2_qc_rcsid[] = "$Header$"; | |
15 | ||
16 | ||
17 | show_mcm_mach(id) | |
18 | int id; | |
208a4f4a | 19 | { |
20 | EXEC SQL BEGIN DECLARE SECTION; | |
21 | int iid = id, found = 1; | |
22 | char name[33]; | |
23 | EXEC SQL END DECLARE SECTION; | |
24 | ||
208a4f4a | 25 | EXEC SQL DECLARE csr201 CURSOR FOR |
26 | SELECT cluster.name FROM cluster, mcmap | |
27 | WHERE cluster.clu_id=mcmap.clu_id AND mcmap.mach_id = :iid; | |
28 | EXEC SQL OPEN csr201; | |
29 | while(1) { | |
30 | EXEC SQL FETCH csr201 INTO :name; | |
7bf0a6f3 | 31 | if (sqlca.sqlcode != 0) { |
32 | ingerr(&sqlca.sqlcode); | |
33 | break; | |
34 | } | |
68bbc9c3 | 35 | |
208a4f4a | 36 | strtrim(name); |
37 | found = 0; | |
38 | printf("Clusqter %s, non-existant machine %d in cluster map\n", name, id); | |
39 | } | |
40 | EXEC SQL CLOSE csr201; | |
68bbc9c3 | 41 | return(found); |
208a4f4a | 42 | } |
68bbc9c3 | 43 | |
44 | show_mcm_clu(id) | |
45 | int id; | |
208a4f4a | 46 | { |
47 | EXEC SQL BEGIN DECLARE SECTION; | |
48 | int iid = id, found = 1; | |
49 | char name[33]; | |
50 | EXEC SQL END DECLARE SECTION; | |
51 | ||
208a4f4a | 52 | EXEC SQL DECLARE csr202 CURSOR FOR |
53 | SELECT machine.name FROM machine, mcmap | |
54 | WHERE machine.mach_id=mcmap.mach_id AND mcmap.clu_id=:iid; | |
55 | EXEC SQL OPEN csr202; | |
56 | while(1) { | |
57 | EXEC SQL FETCH csr202 INTO :name; | |
7bf0a6f3 | 58 | if (sqlca.sqlcode != 0) { |
59 | ingerr(&sqlca.sqlcode); | |
60 | break; | |
61 | } | |
68bbc9c3 | 62 | |
208a4f4a | 63 | strtrim(name); |
64 | found = 0; | |
65 | printf("Machine %s, non-existant cluster %d in cluster map\n", name, id); | |
66 | } | |
67 | EXEC SQL CLOSE csr202; | |
68bbc9c3 | 68 | return(found); |
208a4f4a | 69 | } |
68bbc9c3 | 70 | |
71 | pobox_check(id, u, hint) | |
72 | int id; | |
73 | struct user *u; | |
74 | int hint; | |
75 | { | |
76 | switch (u->potype) { | |
77 | case 'P': | |
78 | if (!hash_lookup(machines, u->pobox_id)) { | |
79 | printf("User %s(%s) has P.O.Box on non-existant machine %d\n", | |
80 | u->login, u->fullname, u->pobox_id); | |
81 | if (single_fix("Delete", 0)) { | |
82 | remove_pobox(u->users_id); | |
83 | u->potype = 'N'; | |
84 | } | |
85 | } | |
86 | break; | |
87 | case 'S': | |
88 | if (!string_check(u->pobox_id)) { | |
89 | printf("User %s(%s) has P.O.Box with non-existant string %d\n", | |
90 | u->login, u->fullname, u->pobox_id); | |
91 | if (single_fix("Delete", 0)) { | |
92 | remove_pobox(u->users_id); | |
93 | u->potype = 'N'; | |
94 | } | |
95 | } | |
96 | break; | |
97 | default: | |
98 | ; | |
99 | } | |
100 | } | |
101 | ||
102 | ||
103 | remove_pobox(id) | |
104 | int id; | |
208a4f4a | 105 | { |
106 | EXEC SQL BEGIN DECLARE SECTION; | |
107 | int rowcount, iid = id; | |
108 | EXEC SQL END DECLARE SECTION; | |
7bf0a6f3 | 109 | |
208a4f4a | 110 | EXEC SQL UPDATE users SET potype='NONE' WHERE users.users_id = :iid; |
111 | EXEC SQL INQUIRE_SQL(:rowcount = rowcount); | |
68bbc9c3 | 112 | if (rowcount > 0) |
113 | printf("%d entr%s removed\n", rowcount, rowcount==1?"y":"ies"); | |
114 | else | |
115 | printf("Not removed\n"); | |
116 | modified("users"); | |
208a4f4a | 117 | } |
68bbc9c3 | 118 | |
119 | show_svc(id) | |
120 | int id; | |
208a4f4a | 121 | { |
122 | EXEC SQL BEGIN DECLARE SECTION; | |
123 | int iid = id, found = 1; | |
124 | char label[17], data[33]; | |
125 | EXEC SQL END DECLARE SECTION; | |
126 | ||
208a4f4a | 127 | EXEC SQL DECLARE csr203 CURSOR FOR |
128 | SELECT serv_label, serv_cluster FROM svc | |
129 | WHERE clu_id = :iid; | |
130 | EXEC SQL OPEN csr203; | |
131 | while(1) { | |
132 | EXEC SQL FETCH csr203 INTO :label, :data; | |
7bf0a6f3 | 133 | if (sqlca.sqlcode != 0) { |
134 | ingerr(&sqlca.sqlcode); | |
135 | break; | |
136 | } | |
208a4f4a | 137 | |
138 | strtrim(label); | |
139 | strtrim(data); | |
140 | found = 0; | |
141 | printf("Cluster data [%s] %s for non-existant cluster %d\n", | |
142 | label, data, id); | |
143 | } | |
144 | EXEC SQL CLOSE csr203; | |
68bbc9c3 | 145 | return(found); |
208a4f4a | 146 | } |
68bbc9c3 | 147 | |
148 | list_check(id, l, hint) | |
149 | int id; | |
150 | struct list *l; | |
151 | int hint; | |
152 | { | |
153 | switch (l->acl_type) { | |
154 | case 'L': | |
155 | if (!hash_lookup(lists, l->acl_id)) { | |
156 | printf("List %s has bad LIST acl %d\n", l->name, l->acl_id); | |
157 | if (single_fix("Patch", 1)) { | |
158 | fix_list_acl(l->list_id); | |
159 | } | |
160 | } | |
161 | break; | |
162 | case 'U': | |
163 | if (!hash_lookup(users, l->acl_id)) { | |
164 | printf("List %s has bad USER acl %d\n", l->name, l->acl_id); | |
165 | if (single_fix("Patch", 1)) { | |
166 | fix_list_acl(l->list_id); | |
167 | } | |
168 | } | |
169 | break; | |
170 | } | |
171 | } | |
172 | ||
173 | fix_list_acl(id) | |
174 | int id; | |
208a4f4a | 175 | { |
176 | EXEC SQL BEGIN DECLARE SECTION; | |
177 | int rowcount, iid = id; | |
178 | EXEC SQL END DECLARE SECTION; | |
179 | ||
208a4f4a | 180 | EXEC SQL UPDATE list SET acl_id = :iid, acl_type='LIST' |
181 | WHERE list_id = :iid; | |
182 | EXEC SQL INQUIRE_SQL(:rowcount = rowcount); | |
68bbc9c3 | 183 | if (rowcount > 0) |
184 | printf("%d entr%s fixed\n", rowcount, rowcount==1?"y":"ies"); | |
185 | else | |
186 | printf("Not fixed\n"); | |
187 | modified("list"); | |
208a4f4a | 188 | } |
68bbc9c3 | 189 | |
190 | ||
191 | show_member_list(id) | |
192 | int id; | |
208a4f4a | 193 | { |
194 | EXEC SQL BEGIN DECLARE SECTION; | |
195 | int mid, iid = id, found = 1; | |
196 | char mtype[9], *name = ""; | |
197 | EXEC SQL END DECLARE SECTION; | |
198 | ||
208a4f4a | 199 | EXEC SQL DECLARE csr204 CURSOR FOR |
200 | SELECT member_type, member_id FROM imembers | |
201 | WHERE list_id = :iid AND direct=1; | |
202 | EXEC SQL OPEN csr204; | |
203 | while(1) { | |
204 | EXEC SQL FETCH csr204 INTO :mtype, :mid; | |
7bf0a6f3 | 205 | if (sqlca.sqlcode != 0) { |
206 | ingerr(&sqlca.sqlcode); | |
207 | break; | |
208 | } | |
208a4f4a | 209 | |
210 | strtrim(mtype); | |
211 | found = 0; | |
212 | if (mtype[0] == 'L') | |
213 | name = ((struct list *) hash_lookup(lists, mid))->name; | |
214 | else if (mtype[0] == 'U') | |
215 | name = ((struct user *) hash_lookup(users, mid))->login; | |
216 | else if (mtype[0] == 'S' || mtype[0] == 'K') | |
217 | name = ((struct string *) hash_lookup(strings, mid))->name; | |
218 | printf("Non-existant list %d has member %s %s\n", iid, mtype, name); | |
219 | } | |
220 | EXEC SQL CLOSE csr204; | |
68bbc9c3 | 221 | return(found); |
208a4f4a | 222 | } |
68bbc9c3 | 223 | |
224 | show_mem_user(id) | |
225 | int id; | |
208a4f4a | 226 | { |
227 | EXEC SQL BEGIN DECLARE SECTION; | |
228 | int lid, iid = id, found = 1; | |
229 | char name[33]; | |
230 | EXEC SQL END DECLARE SECTION; | |
231 | ||
208a4f4a | 232 | EXEC SQL DECLARE csr205 CURSOR FOR |
233 | SELECT list_id FROM imembers | |
234 | WHERE member_id = :iid AND member_type='USER' AND direct=1; | |
235 | EXEC SQL OPEN csr205; | |
236 | while(1) { | |
237 | EXEC SQL FETCH csr205 INTO :lid; | |
7bf0a6f3 | 238 | if (sqlca.sqlcode != 0) { |
239 | ingerr(&sqlca.sqlcode); | |
240 | break; | |
241 | } | |
208a4f4a | 242 | |
243 | found = 0; | |
244 | printf("List %s has non-existant user member, id %d\n", | |
245 | ((struct list *)hash_lookup(lists, lid))->name, iid); | |
246 | } | |
247 | EXEC SQL CLOSE csr205; | |
68bbc9c3 | 248 | return(found); |
208a4f4a | 249 | } |
68bbc9c3 | 250 | |
251 | show_mem_list(id) | |
252 | int id; | |
208a4f4a | 253 | { |
254 | EXEC SQL BEGIN DECLARE SECTION; | |
255 | int lid, iid = id, found = 1; | |
256 | char name[33]; | |
257 | EXEC SQL END DECLARE SECTION; | |
258 | ||
208a4f4a | 259 | EXEC SQL DECLARE csr206 CURSOR FOR |
260 | SELECT list_id FROM imembers | |
261 | WHERE member_id = :iid AND member_type='LIST' AND direct=1; | |
262 | EXEC SQL OPEN csr206; | |
263 | while(1) { | |
264 | EXEC SQL FETCH csr206 INTO :lid; | |
7bf0a6f3 | 265 | if (sqlca.sqlcode != 0) { |
266 | ingerr(&sqlca.sqlcode); | |
267 | break; | |
268 | } | |
208a4f4a | 269 | |
270 | found = 0; | |
271 | printf("List %s has non-existant list member, id %d\n", | |
272 | ((struct list *)hash_lookup(lists, lid))->name, iid); | |
273 | } | |
274 | EXEC SQL CLOSE csr206; | |
68bbc9c3 | 275 | return(found); |
208a4f4a | 276 | } |
68bbc9c3 | 277 | |
278 | show_mem_str(id) | |
279 | int id; | |
208a4f4a | 280 | { |
281 | EXEC SQL BEGIN DECLARE SECTION; | |
282 | int lid, iid = id, found = 1; | |
283 | char name[33]; | |
284 | EXEC SQL END DECLARE SECTION; | |
285 | ||
208a4f4a | 286 | EXEC SQL DECLARE csr207 CURSOR FOR |
287 | SELECT list_id FROM imembers | |
288 | WHERE member_id = :iid AND member_type='STRING' AND direct=1; | |
289 | EXEC SQL OPEN csr207; | |
290 | while(1) { | |
291 | EXEC SQL FETCH csr207 INTO :lid; | |
7bf0a6f3 | 292 | if (sqlca.sqlcode != 0) { |
293 | ingerr(&sqlca.sqlcode); | |
294 | break; | |
295 | } | |
208a4f4a | 296 | |
297 | found = 0; | |
298 | printf("List %s has non-existant string member, id %d\n", | |
299 | ((struct list *)hash_lookup(lists, lid))->name, iid); | |
300 | } | |
301 | EXEC SQL CLOSE csr207; | |
68bbc9c3 | 302 | return(found); |
208a4f4a | 303 | } |
68bbc9c3 | 304 | |
305 | ||
306 | show_mem_krb(id) | |
307 | int id; | |
208a4f4a | 308 | { |
309 | EXEC SQL BEGIN DECLARE SECTION; | |
310 | int lid, iid = id, found = 1; | |
311 | char name[33]; | |
312 | EXEC SQL END DECLARE SECTION; | |
313 | ||
208a4f4a | 314 | EXEC SQL DECLARE csr208 CURSOR FOR |
315 | SELECT list_id FROM imembers | |
316 | WHERE member_id = :iid AND member_type='KERBEROS' AND direct=1; | |
317 | EXEC SQL OPEN csr208; | |
318 | while(1) { | |
319 | EXEC SQL FETCH csr208 INTO :lid; | |
7bf0a6f3 | 320 | if (sqlca.sqlcode != 0) { |
321 | ingerr(&sqlca.sqlcode); | |
322 | break; | |
323 | } | |
68bbc9c3 | 324 | |
208a4f4a | 325 | found = 0; |
326 | printf("List %s has non-existant kerberos member, id %d\n", | |
327 | ((struct list *)hash_lookup(lists, lid))->name, iid); | |
328 | } | |
329 | EXEC SQL CLOSE csr208; | |
330 | return(found); | |
331 | } | |
68bbc9c3 | 332 | |
68bbc9c3 | 333 | |
208a4f4a | 334 | del_mem_user(id) |
335 | EXEC SQL BEGIN DECLARE SECTION; | |
336 | int id; | |
337 | EXEC SQL END DECLARE SECTION; | |
338 | { | |
339 | EXEC SQL BEGIN DECLARE SECTION; | |
340 | int rowcount; | |
341 | EXEC SQL END DECLARE SECTION; | |
342 | ||
208a4f4a | 343 | EXEC SQL DELETE FROM imembers WHERE member_type='USER' AND |
344 | member_id = :id AND direct = 1; | |
345 | EXEC SQL INQUIRE_SQL(:rowcount = rowcount); | |
68bbc9c3 | 346 | if (rowcount > 0) |
347 | printf("%d entr%s deleted\n", rowcount, rowcount==1?"y":"ies"); | |
348 | else | |
349 | printf("Not deleted\n"); | |
350 | modified("imembers"); | |
208a4f4a | 351 | } |
68bbc9c3 | 352 | |
208a4f4a | 353 | del_mem_list(id) |
354 | EXEC SQL BEGIN DECLARE SECTION; | |
355 | int id; | |
356 | EXEC SQL END DECLARE SECTION; | |
357 | { | |
358 | EXEC SQL BEGIN DECLARE SECTION; | |
359 | int rowcount; | |
360 | EXEC SQL END DECLARE SECTION; | |
361 | ||
208a4f4a | 362 | EXEC SQL DELETE FROM imembers WHERE member_type='LIST' AND |
363 | member_id = :id AND direct=1; | |
364 | EXEC SQL INQUIRE_SQL(:rowcount = rowcount); | |
68bbc9c3 | 365 | if (rowcount > 0) |
366 | printf("%d entr%s deleted\n", rowcount, rowcount==1?"y":"ies"); | |
367 | else | |
368 | printf("Not deleted\n"); | |
369 | modified("imembers"); | |
208a4f4a | 370 | } |
68bbc9c3 | 371 | |
208a4f4a | 372 | del_mem_str(id) |
373 | EXEC SQL BEGIN DECLARE SECTION; | |
374 | int id; | |
375 | EXEC SQL END DECLARE SECTION; | |
376 | { | |
377 | EXEC SQL BEGIN DECLARE SECTION; | |
378 | int rowcount; | |
379 | EXEC SQL END DECLARE SECTION; | |
380 | ||
208a4f4a | 381 | EXEC SQL DELETE FROM imembers WHERE member_type='STRING' AND |
382 | member_id = :id AND direct=1; | |
383 | EXEC SQL INQUIRE_SQL(:rowcount = rowcount); | |
68bbc9c3 | 384 | if (rowcount > 0) |
385 | printf("%d entr%s deleted\n", rowcount, rowcount==1?"y":"ies"); | |
386 | else | |
387 | printf("Not deleted\n"); | |
388 | modified("imembers"); | |
208a4f4a | 389 | } |
68bbc9c3 | 390 | |
68bbc9c3 | 391 | |
208a4f4a | 392 | del_mem_krb(id) |
393 | EXEC SQL BEGIN DECLARE SECTION; | |
394 | int id; | |
395 | EXEC SQL END DECLARE SECTION; | |
396 | { | |
397 | EXEC SQL BEGIN DECLARE SECTION; | |
398 | int rowcount; | |
399 | EXEC SQL END DECLARE SECTION; | |
400 | ||
208a4f4a | 401 | EXEC SQL DELETE FROM imembers WHERE member_type='KERBEROS' AND |
402 | member_id = :id AND direct=1; | |
403 | EXEC SQL INQUIRE_SQL(:rowcount = rowcount); | |
68bbc9c3 | 404 | if (rowcount > 0) |
405 | printf("%d entr%s deleted\n", rowcount, rowcount==1?"y":"ies"); | |
406 | else | |
407 | printf("Not deleted\n"); | |
408 | modified("imembers"); | |
208a4f4a | 409 | } |
68bbc9c3 | 410 | |
411 | ||
208a4f4a | 412 | show_sh(id) |
413 | EXEC SQL BEGIN DECLARE SECTION; | |
414 | int id; | |
415 | EXEC SQL END DECLARE SECTION; | |
416 | { | |
417 | EXEC SQL BEGIN DECLARE SECTION; | |
418 | char name[33]; | |
419 | EXEC SQL END DECLARE SECTION; | |
68bbc9c3 | 420 | int found = 1; |
421 | ||
208a4f4a | 422 | EXEC SQL DECLARE csr209 CURSOR FOR |
423 | SELECT service FROM serverhosts | |
424 | WHERE mach_id = :id; | |
425 | EXEC SQL OPEN csr209; | |
426 | while(1) { | |
427 | EXEC SQL FETCH csr209 INTO :name; | |
7bf0a6f3 | 428 | if (sqlca.sqlcode != 0) { |
429 | ingerr(&sqlca.sqlcode); | |
430 | break; | |
431 | } | |
208a4f4a | 432 | |
433 | found = 0; | |
434 | printf("ServerHost entry for service %s non-existant host %d\n", | |
435 | name, id); | |
436 | } | |
437 | EXEC SQL CLOSE csr209; | |
68bbc9c3 | 438 | return(found); |
208a4f4a | 439 | } |
68bbc9c3 | 440 | |
208a4f4a | 441 | del_sh_mach(id) |
442 | EXEC SQL BEGIN DECLARE SECTION; | |
443 | int id; | |
444 | EXEC SQL END DECLARE SECTION; | |
445 | { | |
446 | EXEC SQL BEGIN DECLARE SECTION; | |
447 | int rowcount; | |
448 | EXEC SQL END DECLARE SECTION; | |
68bbc9c3 | 449 | |
208a4f4a | 450 | EXEC SQL DELETE FROM serverhosts WHERE mach_id = :id; |
451 | EXEC SQL INQUIRE_SQL(:rowcount = rowcount); | |
68bbc9c3 | 452 | if (rowcount > 0) |
453 | printf("%d entr%s deleted\n", rowcount, rowcount==1?"y":"ies"); | |
454 | else | |
455 | printf("Not deleted\n"); | |
456 | modified("serverhosts"); | |
208a4f4a | 457 | } |
68bbc9c3 | 458 | |
459 | ||
460 | static int fnchecklen; | |
461 | ||
462 | fsmatch(id, n, f) | |
463 | int id; | |
464 | struct nfsphys *n; | |
465 | struct filesys *f; | |
466 | { | |
467 | if (n->mach_id == f->mach_id && | |
468 | !strncmp(f->dir, n->dir, strlen(n->dir)) && | |
469 | strlen(n->dir) > fnchecklen) { | |
470 | f->phys_id = id; | |
471 | fnchecklen = strlen(n->dir); | |
472 | } | |
473 | } | |
474 | ||
475 | ||
208a4f4a | 476 | check_fs(id, f, hint) |
477 | EXEC SQL BEGIN DECLARE SECTION; | |
478 | int id; | |
479 | EXEC SQL END DECLARE SECTION; | |
68bbc9c3 | 480 | register struct filesys *f; |
481 | int hint; | |
208a4f4a | 482 | { |
483 | EXEC SQL BEGIN DECLARE SECTION; | |
484 | int id1, id2, id3, rowcount; | |
485 | char *dir; | |
486 | EXEC SQL END DECLARE SECTION; | |
68bbc9c3 | 487 | struct nfsphys *n; |
488 | struct machine *m; | |
489 | ||
490 | if (!hash_lookup(machines, f->mach_id)) { | |
491 | printf("Filesys %s with bad machine %d\n", f->name, f->mach_id); | |
492 | if (single_fix("Fix", 0)) { | |
208a4f4a | 493 | EXEC SQL UPDATE filesys SET mach_id = 0 WHERE filsys_id = :id; |
494 | EXEC SQL INQUIRE_SQL(:rowcount = rowcount); | |
68bbc9c3 | 495 | if (rowcount > 0) |
496 | printf("%d entr%s fixed\n",rowcount, rowcount==1?"y":"ies"); | |
497 | else | |
498 | printf("Not fixed\n"); | |
499 | modified("filesys"); | |
500 | f->mach_id = 0; | |
501 | } | |
502 | } | |
503 | ||
504 | if (!hash_lookup(users, f->owner)) { | |
505 | printf("Filesys %s with bad owning user %d\n", f->name, f->owner); | |
506 | if (single_fix("Fix", 1)) { | |
507 | zero_fix("filesys", "owner", "filsys_id", f->filsys_id); | |
508 | f->owner = 0; | |
509 | } | |
510 | } | |
511 | if (!hash_lookup(lists, f->owners)) { | |
512 | printf("Filesys %s with bad owning group %d\n", f->name, f->owners); | |
513 | if (single_fix("Fix", 1)) { | |
514 | zero_fix("filesys", "owners", "filsys_id", f->filsys_id); | |
515 | f->owners = 0; | |
516 | } | |
517 | } | |
518 | ||
519 | if (f->type == 'N') { | |
520 | if (!hash_lookup(nfsphys, f->phys_id)) { | |
521 | m = (struct machine *)hash_lookup(machines, f->mach_id); | |
522 | printf("Filesys %s with bad phys_id %d\n", f->name, f->phys_id); | |
523 | if (single_fix("Fix", 1)) { | |
524 | fnchecklen = 0; | |
525 | hash_step(nfsphys, fsmatch, f); | |
526 | if (fnchecklen != 0) { | |
527 | id1 = f->phys_id; | |
528 | id2 = f->filsys_id; | |
529 | id3 = f->mach_id; | |
208a4f4a | 530 | EXEC SQL UPDATE filesys SET phys_id = :id1 WHERE filsys_id = :id2; |
531 | EXEC SQL INQUIRE_SQL(:rowcount = rowcount); | |
68bbc9c3 | 532 | if (rowcount > 0) |
533 | printf("%d entr%s fixed\n",rowcount, rowcount==1?"y":"ies"); | |
534 | else | |
535 | printf("Not fixed\n"); | |
536 | modified("filesys"); | |
537 | } else { | |
538 | printf("No NFSphys exsits for %s:%s\n", m->name, f->dir); | |
539 | if (single_fix("Create", 0)) { | |
540 | dir = f->dir; | |
541 | id1 = f->phys_id; | |
542 | id2 = f->filsys_id; | |
543 | id3 = f->mach_id; | |
544 | if (set_next_object_id("nfsphys_id", "nfsphys") != | |
545 | MR_SUCCESS) { | |
546 | printf("Unable to assign unique ID\n"); | |
547 | return; | |
548 | } | |
208a4f4a | 549 | EXEC SQL SELECT COUNT(*) INTO :rowcount FROM numvalues |
550 | WHERE name='nfsphys_id'; | |
68bbc9c3 | 551 | if (rowcount != 1) { |
552 | printf("Unable to retrieve unique ID\n"); | |
553 | return; | |
554 | } | |
208a4f4a | 555 | EXEC SQL INSERT INTO mfsphys (mfsphys_id, mach_id, |
556 | device, dir, status, allocated, size, modtime, | |
557 | modby, modwith) VALUES (:id1, :id3, '???', :dir, | |
558 | 0, 0, 0, 'now', 0, 'dbck'); | |
559 | EXEC SQL INQUIRE_SQL(:rowcount = rowcount); | |
68bbc9c3 | 560 | if (rowcount > 0) |
561 | printf("%d entr%s created\n", rowcount, | |
562 | rowcount==1?"y":"ies"); | |
563 | else | |
564 | printf("Not created\n"); | |
565 | modified("nfsphys"); | |
566 | n = (struct nfsphys *)malloc(sizeof(struct nfsphys)); | |
567 | if (n == NULL) | |
568 | out_of_mem("storing new nfsphys"); | |
569 | strcpy(n->dir, dir); | |
570 | n->mach_id = id3; | |
571 | n->nfsphys_id = id1; | |
572 | n->allocated = 0; | |
573 | n->count = 0; | |
574 | hash_store(nfsphys, id1, n); | |
208a4f4a | 575 | EXEC SQL UPDATE filesys SET phys_id = :id1 |
576 | WHERE filsys_id = :id2; | |
577 | EXEC SQL INQUIRE_SQL(:rowcount = rowcount); | |
68bbc9c3 | 578 | if (rowcount > 0) |
579 | printf("%d filesys entr%s fixed\n", rowcount, | |
580 | rowcount==1?"y":"ies"); | |
581 | else | |
582 | printf("Not fixed\n"); | |
583 | modified("filesys"); | |
584 | } | |
585 | } | |
586 | } | |
587 | } | |
588 | } | |
208a4f4a | 589 | } |
68bbc9c3 | 590 | |
591 | ||
592 | check_nfsphys(id, n, hint) | |
593 | int id; | |
594 | struct nfsphys *n; | |
595 | int hint; | |
596 | { | |
597 | if (!hash_lookup(machines, n->mach_id)) { | |
598 | printf("NFSphys %d(%s) on non-existant machine %d\n", | |
599 | id, n->dir, n->mach_id); | |
600 | if (single_fix("Delete", 0)) | |
601 | single_delete("nfsphys", "nfsphys_id", id); | |
602 | } | |
603 | } | |
604 | ||
208a4f4a | 605 | show_fsg_missing(id) |
606 | EXEC SQL BEGIN DECLARE SECTION; | |
607 | int id; | |
608 | EXEC SQL END DECLARE SECTION; | |
609 | { | |
610 | EXEC SQL BEGIN DECLARE SECTION; | |
611 | int id1, found = 1; | |
612 | EXEC SQL END DECLARE SECTION; | |
68bbc9c3 | 613 | struct filesys *f; |
614 | ||
208a4f4a | 615 | EXEC SQL DECLARE csr210 CURSOR FOR |
616 | SELECT filsys_id FROM fsgroup | |
617 | WHERE group_id = :id; | |
618 | EXEC SQL OPEN csr210; | |
619 | while(1) { | |
620 | EXEC SQL FETCH csr210 INTO :id1; | |
7bf0a6f3 | 621 | if (sqlca.sqlcode != 0) { |
622 | ingerr(&sqlca.sqlcode); | |
623 | break; | |
624 | } | |
208a4f4a | 625 | |
626 | found = 0; | |
627 | if (f = (struct filesys *) hash_lookup(filesys, id1)) | |
628 | printf("Missing fsgroup %d has member filesystem %s\n", id, f->name); | |
629 | else | |
630 | printf("Missing fsgroup %d has member filesystem %d\n", id, id1); | |
631 | } | |
632 | EXEC SQL CLOSE csr210; | |
68bbc9c3 | 633 | return(found); |
208a4f4a | 634 | } |
68bbc9c3 | 635 | |
636 | show_fsg_type(f) | |
637 | struct filesys *f; | |
638 | { | |
639 | char *t; | |
640 | ||
641 | switch (f->type) { | |
642 | case 'N': | |
643 | t = "NFS"; | |
644 | break; | |
645 | case 'R': | |
646 | t = "RVD"; | |
647 | break; | |
648 | case 'A': | |
649 | t = "AFS"; | |
650 | break; | |
651 | case 'E': | |
652 | t = "ERR"; | |
653 | break; | |
654 | case 'F': | |
655 | t = "FSGROUP"; | |
656 | break; | |
657 | case 'M': | |
658 | t = "MUL"; | |
659 | break; | |
660 | default: | |
661 | t = "???"; | |
662 | } | |
663 | printf("FSGroup %s has type %s instead of FSGROUP\n", f->name, t); | |
664 | return(0); | |
665 | } | |
666 | ||
667 | fix_fsg_type(f) | |
668 | struct filesys *f; | |
208a4f4a | 669 | { |
670 | EXEC SQL BEGIN DECLARE SECTION; | |
671 | int rowcount, id = f->filsys_id; | |
672 | EXEC SQL END DECLARE SECTION; | |
68bbc9c3 | 673 | |
208a4f4a | 674 | EXEC SQL UPDATE filesys SET type='FSGROUP' WHERE filsys_id = :id; |
675 | EXEC SQL INQUIRE_SQL(:rowcount = rowcount); | |
68bbc9c3 | 676 | if (rowcount > 0) |
677 | printf("%d entr%s fixed\n", rowcount, rowcount==1?"y":"ies"); | |
678 | else | |
679 | printf("Not fixed\n"); | |
680 | modified("filesys"); | |
208a4f4a | 681 | } |
68bbc9c3 | 682 | |
208a4f4a | 683 | show_fsg_nomember(id) |
684 | EXEC SQL BEGIN DECLARE SECTION; | |
685 | int id; | |
686 | EXEC SQL END DECLARE SECTION; | |
687 | { | |
688 | EXEC SQL BEGIN DECLARE SECTION; | |
689 | int id1, found = 1; | |
690 | EXEC SQL END DECLARE SECTION; | |
68bbc9c3 | 691 | struct filesys *f; |
692 | ||
208a4f4a | 693 | EXEC SQL DECLARE csr211 CURSOR FOR |
694 | SELECT group_id FROM fsgroup | |
695 | WHERE filsys_id = :id; | |
696 | EXEC SQL OPEN csr211; | |
697 | while(1) { | |
698 | EXEC SQL FETCH csr211 INTO :id1; | |
7bf0a6f3 | 699 | if (sqlca.sqlcode != 0) { |
700 | ingerr(&sqlca.sqlcode); | |
701 | break; | |
702 | } | |
208a4f4a | 703 | |
704 | found = 0; | |
705 | if (f = (struct filesys *) hash_lookup(filesys, id1)) | |
706 | printf("FSGroup %s has missing member %d\n", f->name, id); | |
707 | else | |
708 | printf("FSGroup %d has missing member %d\n", id1, id); | |
709 | } | |
710 | EXEC SQL CLOSE csr211; | |
68bbc9c3 | 711 | return(found); |
208a4f4a | 712 | } |
713 | ||
714 | show_quota_nouser(id) | |
715 | EXEC SQL BEGIN DECLARE SECTION; | |
716 | int id; | |
717 | EXEC SQL END DECLARE SECTION; | |
718 | { | |
719 | EXEC SQL BEGIN DECLARE SECTION; | |
720 | int id1, found = 1; | |
721 | EXEC SQL END DECLARE SECTION; | |
722 | ||
208a4f4a | 723 | EXEC SQL DECLARE csr212 CURSOR FOR |
724 | SELECT filsys_id FROM quota | |
725 | WHERE entity_id = :id AND type='USER'; | |
726 | EXEC SQL OPEN csr212; | |
727 | while(1) { | |
728 | EXEC SQL FETCH csr212 INTO :id1; | |
7bf0a6f3 | 729 | if (sqlca.sqlcode != 0) { |
730 | ingerr(&sqlca.sqlcode); | |
731 | break; | |
732 | } | |
208a4f4a | 733 | |
734 | found = 0; | |
735 | printf("Quota on fs %d for non-existant user %d\n", id1, id); | |
736 | } | |
737 | EXEC SQL CLOSE csr212; | |
68bbc9c3 | 738 | return(found); |
208a4f4a | 739 | } |
740 | ||
741 | show_quota_nolist(id) | |
742 | EXEC SQL BEGIN DECLARE SECTION; | |
743 | int id; | |
744 | EXEC SQL END DECLARE SECTION; | |
745 | { | |
746 | EXEC SQL BEGIN DECLARE SECTION; | |
747 | int id1, found = 1; | |
748 | EXEC SQL END DECLARE SECTION; | |
749 | ||
208a4f4a | 750 | EXEC SQL DECLARE csr213 CURSOR FOR |
751 | SELECT filsys_id FROM quota | |
752 | WHERE entity_id = :id AND type='GROUP'; | |
753 | EXEC SQL OPEN csr213; | |
754 | while(1) { | |
755 | EXEC SQL FETCH csr213 INTO :id1; | |
7bf0a6f3 | 756 | if (sqlca.sqlcode != 0) { |
757 | ingerr(&sqlca.sqlcode); | |
758 | break; | |
759 | } | |
208a4f4a | 760 | |
761 | found = 0; | |
762 | printf("Quota on fs %d for non-existant list %d\n", id1, id); | |
763 | } | |
764 | EXEC SQL CLOSE csr213; | |
68bbc9c3 | 765 | return(found); |
208a4f4a | 766 | } |
68bbc9c3 | 767 | |
208a4f4a | 768 | fix_quota_nouser(id) |
769 | EXEC SQL BEGIN DECLARE SECTION; | |
770 | int id; | |
771 | EXEC SQL END DECLARE SECTION; | |
772 | { | |
773 | EXEC SQL BEGIN DECLARE SECTION; | |
774 | int rowcount, id1; | |
775 | EXEC SQL END DECLARE SECTION; | |
68bbc9c3 | 776 | |
777 | id1 = ((struct filesys *)hash_lookup(filesys, id))->phys_id; | |
208a4f4a | 778 | EXEC SQL DELETE FROM quota |
779 | WHERE entity_id = :id AND type = 'USER'; | |
780 | EXEC SQL INQUIRE_SQL(:rowcount = rowcount); | |
68bbc9c3 | 781 | if (rowcount > 0) |
782 | printf("%d entr%s deleted\n",rowcount, rowcount==1?"y":"ies"); | |
783 | else | |
784 | printf("Not deleted\n"); | |
785 | modified("quota"); | |
208a4f4a | 786 | } |
68bbc9c3 | 787 | |
208a4f4a | 788 | fix_quota_nolist(id) |
789 | EXEC SQL BEGIN DECLARE SECTION; | |
790 | int id; | |
791 | EXEC SQL END DECLARE SECTION; | |
792 | { | |
793 | EXEC SQL BEGIN DECLARE SECTION; | |
794 | int rowcount, id1; | |
795 | EXEC SQL END DECLARE SECTION; | |
68bbc9c3 | 796 | |
797 | id1 = ((struct filesys *)hash_lookup(filesys, id))->phys_id; | |
208a4f4a | 798 | EXEC SQL DELETE FROM quota WHERE entity_id = :id AND type='GROUP'; |
799 | EXEC SQL INQUIRE_SQL(:rowcount = rowcount); | |
68bbc9c3 | 800 | if (rowcount > 0) |
801 | printf("%d entr%s deleted\n",rowcount, rowcount==1?"y":"ies"); | |
802 | else | |
803 | printf("Not deleted\n"); | |
804 | modified("quota"); | |
208a4f4a | 805 | } |
806 | ||
807 | show_quota_nofs(id) | |
808 | EXEC SQL BEGIN DECLARE SECTION; | |
809 | int id; | |
810 | EXEC SQL END DECLARE SECTION; | |
811 | { | |
812 | EXEC SQL BEGIN DECLARE SECTION; | |
813 | int id1, found = 1; | |
814 | char type[9]; | |
815 | EXEC SQL END DECLARE SECTION; | |
816 | ||
208a4f4a | 817 | EXEC SQL DECLARE csr214 CURSOR FOR |
818 | SELECT entity_id, type FROM quota | |
819 | WHERE filsys_id = :id; | |
820 | EXEC SQL OPEN csr214; | |
821 | while(1) { | |
822 | EXEC SQL FETCH csr214 INTO :id1, :type; | |
7bf0a6f3 | 823 | if (sqlca.sqlcode != 0) { |
824 | ingerr(&sqlca.sqlcode); | |
825 | break; | |
826 | } | |
208a4f4a | 827 | |
828 | found = 0; | |
829 | printf("Quota for %s %d on non-existant filesys %d\n", type, id1, id); | |
830 | } | |
831 | EXEC SQL CLOSE csr214; | |
68bbc9c3 | 832 | return(found); |
208a4f4a | 833 | } |
68bbc9c3 | 834 | |
835 | fix_quota_nofs(id) | |
836 | { | |
837 | single_delete("quota", "filsys_id", id); | |
838 | } | |
839 | ||
208a4f4a | 840 | show_quota_wrongpid(id) |
841 | EXEC SQL BEGIN DECLARE SECTION; | |
842 | int id; | |
843 | EXEC SQL END DECLARE SECTION; | |
844 | { | |
845 | EXEC SQL BEGIN DECLARE SECTION; | |
846 | int id1, found = 1; | |
847 | char type[9]; | |
848 | EXEC SQL END DECLARE SECTION; | |
68bbc9c3 | 849 | struct user *u; |
850 | struct filesys *f; | |
851 | ||
852 | f = (struct filesys *)hash_lookup(filesys, id); | |
208a4f4a | 853 | EXEC SQL DECLARE csr215 CURSOR FOR |
854 | SELECT entity_id, type FROM quota | |
855 | WHERE filsys_id = :id; | |
856 | EXEC SQL OPEN csr215; | |
857 | while(1) { | |
858 | EXEC SQL FETCH csr215 INTO :id1, :type; | |
7bf0a6f3 | 859 | if (sqlca.sqlcode != 0) { |
860 | ingerr(&sqlca.sqlcode); | |
861 | break; | |
862 | } | |
208a4f4a | 863 | |
864 | found = 0; | |
865 | printf("Quota for %s %d on filesys %s has wrong phys_id %d\n", | |
866 | type, id1, f->name, id); | |
867 | } | |
868 | EXEC SQL CLOSE csr215; | |
68bbc9c3 | 869 | return(found); |
208a4f4a | 870 | } |
68bbc9c3 | 871 | |
208a4f4a | 872 | fix_quota_physid(id) |
873 | EXEC SQL BEGIN DECLARE SECTION; | |
874 | int id; | |
875 | EXEC SQL END DECLARE SECTION; | |
876 | { | |
877 | EXEC SQL BEGIN DECLARE SECTION; | |
878 | int rowcount, id1; | |
879 | EXEC SQL END DECLARE SECTION; | |
68bbc9c3 | 880 | |
881 | id1 = ((struct filesys *)hash_lookup(filesys, id))->phys_id; | |
208a4f4a | 882 | EXEC SQL UPDATE quota SET phys_id = :id1 |
883 | WHERE filsys_id = :id AND phys_id != :id1; | |
884 | EXEC SQL INQUIRE_SQL(:rowcount = rowcount); | |
68bbc9c3 | 885 | if (rowcount > 0) |
886 | printf("%d entr%s fixed\n",rowcount, rowcount==1?"y":"ies"); | |
887 | else | |
888 | printf("Not fixed\n"); | |
889 | modified("quota"); | |
208a4f4a | 890 | } |
68bbc9c3 | 891 | |
208a4f4a | 892 | show_srv_user(id) |
893 | EXEC SQL BEGIN DECLARE SECTION; | |
894 | int id; | |
895 | EXEC SQL END DECLARE SECTION; | |
896 | { | |
897 | EXEC SQL BEGIN DECLARE SECTION; | |
898 | char name[33]; | |
899 | EXEC SQL END DECLARE SECTION; | |
68bbc9c3 | 900 | int found = 1; |
901 | ||
208a4f4a | 902 | EXEC SQL DECLARE csr216 CURSOR FOR |
903 | SELECT name FROM servers | |
904 | WHERE acl_type='USER' and acl_id = :id; | |
905 | EXEC SQL OPEN csr216; | |
906 | while(1) { | |
907 | EXEC SQL FETCH csr216 INTO :name; | |
7bf0a6f3 | 908 | if (sqlca.sqlcode != 0) { |
909 | ingerr(&sqlca.sqlcode); | |
910 | break; | |
911 | } | |
208a4f4a | 912 | |
68bbc9c3 | 913 | strtrim(name); |
914 | printf("Service %s has acl non-existant user %d\n", name, id); | |
915 | found = 0; | |
208a4f4a | 916 | } |
917 | EXEC SQL CLOSE csr216; | |
68bbc9c3 | 918 | return(found); |
208a4f4a | 919 | } |
68bbc9c3 | 920 | |
208a4f4a | 921 | show_srv_list(id) |
922 | EXEC SQL BEGIN DECLARE SECTION; | |
923 | int id; | |
924 | EXEC SQL END DECLARE SECTION; | |
925 | { | |
926 | EXEC SQL BEGIN DECLARE SECTION; | |
927 | char name[33]; | |
928 | EXEC SQL END DECLARE SECTION; | |
68bbc9c3 | 929 | int found = 1; |
930 | ||
208a4f4a | 931 | EXEC SQL DECLARE csr217 CURSOR FOR |
932 | SELECT name FROM servers | |
933 | WHERE acl_type='LIST' AND acl_id = :id; | |
934 | EXEC SQL OPEN csr217; | |
935 | while(1) { | |
936 | EXEC SQL FETCH csr217 INTO :name; | |
7bf0a6f3 | 937 | if (sqlca.sqlcode != 0) { |
938 | ingerr(&sqlca.sqlcode); | |
939 | break; | |
940 | } | |
208a4f4a | 941 | |
68bbc9c3 | 942 | strtrim(name); |
943 | printf("Service %s has acl non-existant list %d\n", name, id); | |
944 | found = 0; | |
208a4f4a | 945 | } |
946 | EXEC SQL CLOSE csr217; | |
68bbc9c3 | 947 | return(found); |
208a4f4a | 948 | } |
68bbc9c3 | 949 | |
208a4f4a | 950 | zero_srv_user(id) |
951 | EXEC SQL BEGIN DECLARE SECTION; | |
952 | int id; | |
953 | EXEC SQL END DECLARE SECTION; | |
954 | { | |
955 | EXEC SQL BEGIN DECLARE SECTION; | |
956 | int rowcount; | |
957 | EXEC SQL END DECLARE SECTION; | |
958 | ||
208a4f4a | 959 | EXEC SQL UPDATE servers SET acl_id=0 WHERE acl_id = :id AND |
960 | acl_type='USER'; | |
961 | EXEC SQL INQUIRE_SQL(:rowcount = rowcount); | |
68bbc9c3 | 962 | if (rowcount > 0) |
963 | printf("%d entr%s fixed\n", rowcount, rowcount==1?"y":"ies"); | |
964 | else | |
965 | printf("Not fixed\n"); | |
966 | modified("servers"); | |
208a4f4a | 967 | } |
68bbc9c3 | 968 | |
208a4f4a | 969 | zero_srv_list(id) |
970 | EXEC SQL BEGIN DECLARE SECTION; | |
971 | int id; | |
972 | EXEC SQL END DECLARE SECTION; | |
973 | { | |
974 | EXEC SQL BEGIN DECLARE SECTION; | |
975 | int rowcount; | |
976 | EXEC SQL END DECLARE SECTION; | |
977 | ||
208a4f4a | 978 | EXEC SQL UPDATE servers SET acl_id=0 WHERE acl_id = :id AND |
979 | acl_type='LIST'; | |
980 | EXEC SQL INQUIRE_SQL(:rowcount = rowcount); | |
68bbc9c3 | 981 | if (rowcount > 0) |
982 | printf("%d entr%s fixed\n", rowcount, rowcount==1?"y":"ies"); | |
983 | else | |
984 | printf("Not fixed\n"); | |
985 | modified("servers"); | |
208a4f4a | 986 | } |
68bbc9c3 | 987 | |
988 | ||
208a4f4a | 989 | show_krb_usr(id) |
990 | EXEC SQL BEGIN DECLARE SECTION; | |
991 | int id; | |
992 | EXEC SQL END DECLARE SECTION; | |
993 | { | |
994 | EXEC SQL BEGIN DECLARE SECTION; | |
995 | int found = 1, id1; | |
996 | EXEC SQL END DECLARE SECTION; | |
68bbc9c3 | 997 | struct string *s; |
998 | char *ss; | |
999 | ||
208a4f4a | 1000 | EXEC SQL DECLARE csr218 CURSOR FOR |
1001 | SELECT string_id FROM krbmap | |
1002 | WHERE users_id = :id ; | |
1003 | EXEC SQL OPEN csr218; | |
1004 | while(1) { | |
1005 | EXEC SQL FETCH csr218 INTO :id1; | |
7bf0a6f3 | 1006 | if (sqlca.sqlcode != 0) { |
1007 | ingerr(&sqlca.sqlcode); | |
1008 | break; | |
1009 | } | |
208a4f4a | 1010 | |
68bbc9c3 | 1011 | if (s = ((struct string *)hash_lookup(strings, id1))) |
208a4f4a | 1012 | ss = s->name; |
68bbc9c3 | 1013 | else |
208a4f4a | 1014 | ss = "[unknown]"; |
68bbc9c3 | 1015 | found = 0; |
1016 | printf("Kerberos map for non-existant user %d to principal %s\n", | |
1017 | id, s); | |
208a4f4a | 1018 | } |
1019 | EXEC SQL CLOSE csr218; | |
68bbc9c3 | 1020 | return(found); |
208a4f4a | 1021 | } |
68bbc9c3 | 1022 | |
1023 | ||
208a4f4a | 1024 | show_krb_str(id) |
1025 | EXEC SQL BEGIN DECLARE SECTION; | |
1026 | int id; | |
1027 | EXEC SQL END DECLARE SECTION; | |
1028 | { | |
1029 | EXEC SQL BEGIN DECLARE SECTION; | |
1030 | int found = 1, id1; | |
1031 | EXEC SQL END DECLARE SECTION; | |
68bbc9c3 | 1032 | struct user *u; |
1033 | char *s; | |
1034 | ||
208a4f4a | 1035 | EXEC SQL DECLARE csr219 CURSOR FOR |
1036 | SELECT users_id FROM krbmap | |
1037 | WHERE string_id = :id; | |
1038 | EXEC SQL OPEN csr219; | |
1039 | while(1) { | |
1040 | EXEC SQL FETCH csr219 INTO :id1; | |
7bf0a6f3 | 1041 | if (sqlca.sqlcode != 0) { |
1042 | ingerr(&sqlca.sqlcode); | |
1043 | break; | |
1044 | } | |
208a4f4a | 1045 | |
68bbc9c3 | 1046 | if (u = ((struct user *)hash_lookup(users, id1))) |
208a4f4a | 1047 | s = u->login; |
68bbc9c3 | 1048 | else |
208a4f4a | 1049 | s = "[???]"; |
68bbc9c3 | 1050 | found = 0; |
1051 | printf("Kerberos map for user %s (%d) to non-existant string %d\n", | |
1052 | s, id1, id); | |
208a4f4a | 1053 | } |
1054 | EXEC SQL CLOSE csr219; | |
68bbc9c3 | 1055 | return(found); |
208a4f4a | 1056 | } |
68bbc9c3 | 1057 | |
1058 | ||
208a4f4a | 1059 | show_pdm_mach(id) |
1060 | EXEC SQL BEGIN DECLARE SECTION; | |
1061 | int id; | |
1062 | EXEC SQL END DECLARE SECTION; | |
1063 | { | |
1064 | EXEC SQL BEGIN DECLARE SECTION; | |
1065 | char name[33]; | |
1066 | EXEC SQL END DECLARE SECTION; | |
68bbc9c3 | 1067 | int found = 1; |
1068 | ||
208a4f4a | 1069 | EXEC SQL DECLARE csr220 CURSOR FOR |
1070 | SELECT name FROM palladium | |
1071 | WHERE mach_id = :id; | |
1072 | EXEC SQL OPEN csr220; | |
1073 | while(1) { | |
1074 | EXEC SQL FETCH csr220 INTO :name; | |
7bf0a6f3 | 1075 | if (sqlca.sqlcode != 0) { |
1076 | ingerr(&sqlca.sqlcode); | |
1077 | break; | |
1078 | } | |
208a4f4a | 1079 | |
68bbc9c3 | 1080 | strtrim(name); |
1081 | printf("Palladium server/supervisor %s is on non-existant machine %d\n", | |
1082 | name, id); | |
1083 | found = 0; | |
208a4f4a | 1084 | } |
1085 | EXEC SQL CLOSE csr220; | |
68bbc9c3 | 1086 | return(found); |
208a4f4a | 1087 | } |
68bbc9c3 | 1088 | |
1089 | ||
1090 | phase2() | |
208a4f4a | 1091 | { |
1092 | EXEC SQL BEGIN DECLARE SECTION; | |
1093 | int id1, id2, id3, id4, id5; | |
1094 | char type[9], name[33]; | |
1095 | EXEC SQL END DECLARE SECTION; | |
68bbc9c3 | 1096 | struct save_queue *sq, *sq1, *sq2, *sq3, *sq4, *sq5; |
1097 | struct filesys *f; | |
1098 | struct list *l; | |
1099 | struct nfsphys *n; | |
1100 | struct machine *m; | |
1101 | ||
1102 | printf("Phase 2 - Checking references\n"); | |
1103 | ||
1104 | dprintf("Checking users...\n"); | |
1105 | hash_step(users, pobox_check, NULL); | |
1106 | ||
1107 | dprintf("Checking mcmap...\n"); | |
1108 | sq1 = sq_create(); | |
1109 | sq2 = sq_create(); | |
208a4f4a | 1110 | EXEC SQL DECLARE csr221 CURSOR FOR |
1111 | SELECT mach_id, clu_id FROM mcmap; | |
1112 | EXEC SQL OPEN csr221; | |
1113 | while(1) { | |
1114 | EXEC SQL FETCH csr221 INTO :id1, :id2; | |
7bf0a6f3 | 1115 | if (sqlca.sqlcode != 0) { |
1116 | ingerr(&sqlca.sqlcode); | |
1117 | break; | |
1118 | } | |
208a4f4a | 1119 | |
68bbc9c3 | 1120 | if (!(m = (struct machine *)hash_lookup(machines, id1))) |
208a4f4a | 1121 | sq_save_unique_data(sq1, id1); |
68bbc9c3 | 1122 | if (!hash_lookup(clusters, id2)) |
208a4f4a | 1123 | sq_save_unique_data(sq2, id2); |
68bbc9c3 | 1124 | if (m) m->clucount++; |
208a4f4a | 1125 | } |
1126 | EXEC SQL CLOSE csr221; | |
68bbc9c3 | 1127 | generic_delete(sq1, show_mcm_mach, "mcmap", "mach_id", 1); |
1128 | generic_delete(sq2, show_mcm_clu, "mcmap", "clu_id", 1); | |
1129 | ||
1130 | dprintf("Checking service clusters...\n"); | |
1131 | sq1 = sq_create(); | |
208a4f4a | 1132 | EXEC SQL DECLARE csr222 CURSOR FOR |
1133 | SELECT clu_id FROM svc; | |
1134 | EXEC SQL OPEN csr222; | |
1135 | while(1) { | |
1136 | EXEC SQL FETCH csr222 INTO :id1; | |
7bf0a6f3 | 1137 | if (sqlca.sqlcode != 0) { |
1138 | ingerr(&sqlca.sqlcode); | |
1139 | break; | |
1140 | } | |
208a4f4a | 1141 | |
68bbc9c3 | 1142 | if (!hash_lookup(clusters, id1)) |
1143 | sq_save_unique_data(sq1, id1); | |
208a4f4a | 1144 | } |
1145 | EXEC SQL CLOSE csr222; | |
68bbc9c3 | 1146 | generic_delete(sq1, show_svc, "svc", "clu_id", 1); |
1147 | ||
1148 | dprintf("Checking lists...\n"); | |
1149 | hash_step(lists, list_check, NULL); | |
1150 | ||
1151 | dprintf("Checking members...\n"); | |
1152 | sq1 = sq_create(); | |
1153 | sq2 = sq_create(); | |
1154 | sq3 = sq_create(); | |
1155 | sq4 = sq_create(); | |
1156 | sq5 = sq_create(); | |
64842aba | 1157 | |
208a4f4a | 1158 | EXEC SQL DECLARE csr223 CURSOR FOR |
64842aba | 1159 | SELECT list_id, member_type, member_id, ref_count, direct |
1160 | FROM imembers ORDER BY list_id; | |
208a4f4a | 1161 | EXEC SQL OPEN csr223; |
1162 | while(1) { | |
1163 | EXEC SQL FETCH csr223 INTO :id1, :type, :id2, :id3, :id4; | |
7bf0a6f3 | 1164 | if (sqlca.sqlcode != 0) { |
1165 | ingerr(&sqlca.sqlcode); | |
1166 | break; | |
1167 | } | |
208a4f4a | 1168 | |
68bbc9c3 | 1169 | if ((l = (struct list *) hash_lookup(lists, id1)) == NULL) |
1170 | sq_save_unique_data(sq1, id1); | |
1171 | else if (type[0] == 'U' && !hash_lookup(users, id2)) | |
1172 | sq_save_unique_data(sq2, id2); | |
1173 | else if (type[0] == 'L' && !hash_lookup(lists, id2)) | |
1174 | sq_save_unique_data(sq3, id2); | |
1175 | else if (type[0] == 'S' && !string_check(id2)) | |
1176 | sq_save_unique_data(sq4, id2); | |
1177 | else if (type[0] == 'K' && !string_check(id2)) | |
1178 | sq_save_unique_data(sq5, id2); | |
1179 | else | |
1180 | l->members++; | |
208a4f4a | 1181 | } |
1182 | EXEC SQL CLOSE csr223; | |
68bbc9c3 | 1183 | generic_delete(sq1, show_member_list, "imembers", "list_id", 1); |
1184 | generic_fix(sq2, show_mem_user, "Delete", del_mem_user, 1); | |
1185 | generic_fix(sq3, show_mem_list, "Delete", del_mem_list, 1); | |
1186 | generic_fix(sq4, show_mem_str, "Delete", del_mem_str, 1); | |
1187 | generic_fix(sq5, show_mem_krb, "Delete", del_mem_krb, 1); | |
1188 | ||
1189 | dprintf("Checking servers...\n"); | |
1190 | sq1 = sq_create(); | |
1191 | sq2 = sq_create(); | |
208a4f4a | 1192 | EXEC SQL DECLARE csr224 CURSOR FOR |
1193 | SELECT name, acl_type, acl_id FROM servers; | |
1194 | EXEC SQL OPEN csr224; | |
1195 | while(1) { | |
1196 | EXEC SQL FETCH csr224 INTO :name, :type, :id1; | |
7bf0a6f3 | 1197 | if (sqlca.sqlcode != 0) { |
1198 | ingerr(&sqlca.sqlcode); | |
1199 | break; | |
1200 | } | |
208a4f4a | 1201 | |
68bbc9c3 | 1202 | strtrim(type); |
1203 | if (!strcmp(type, "USER") && !hash_lookup(users, id1)) { | |
1204 | sq_save_data(sq1, id1); | |
1205 | } else if (!strcmp(type, "LIST") && !hash_lookup(lists, id1)) { | |
1206 | sq_save_data(sq2, id1); | |
1207 | } | |
208a4f4a | 1208 | } |
1209 | EXEC SQL CLOSE csr224; | |
68bbc9c3 | 1210 | generic_fix(sq1, show_srv_user, "Fix", zero_srv_user, 1); |
1211 | generic_fix(sq2, show_srv_list, "Fix", zero_srv_list, 1); | |
1212 | ||
7bf0a6f3 | 1213 | dprintf("Checking serverhosts...\n"); |
68bbc9c3 | 1214 | sq = sq_create(); |
208a4f4a | 1215 | EXEC SQL DECLARE csr225 CURSOR FOR |
7bf0a6f3 | 1216 | SELECT mach_id FROM serverhosts; |
208a4f4a | 1217 | EXEC SQL OPEN csr225; |
1218 | while(1) { | |
1219 | EXEC SQL FETCH csr225 INTO :id1; | |
7bf0a6f3 | 1220 | if (sqlca.sqlcode != 0) { |
1221 | ingerr(&sqlca.sqlcode); | |
1222 | break; | |
1223 | } | |
208a4f4a | 1224 | |
68bbc9c3 | 1225 | if (!hash_lookup(machines, id1)) |
1226 | sq_save_data(sq, id1); | |
208a4f4a | 1227 | } |
1228 | EXEC SQL CLOSE csr225; | |
68bbc9c3 | 1229 | generic_fix(sq, show_sh, "Delete", del_sh_mach, 0); |
1230 | ||
1231 | dprintf("Checking nfsphys...\n"); | |
1232 | hash_step(nfsphys, check_nfsphys, NULL); | |
1233 | ||
1234 | dprintf("Checking filesys...\n"); | |
1235 | hash_step(filesys, check_fs, NULL); | |
1236 | ||
1237 | dprintf("Checking filesystem groups...\n"); | |
1238 | sq1 = sq_create(); | |
1239 | sq2 = sq_create(); | |
1240 | sq3 = sq_create(); | |
208a4f4a | 1241 | EXEC SQL DECLARE csr226 CURSOR FOR |
1242 | SELECT group_id, filsys_id FROM fsgroup; | |
1243 | EXEC SQL OPEN csr226; | |
1244 | while(1) { | |
1245 | EXEC SQL FETCH csr226 INTO :id1, :id2; | |
7bf0a6f3 | 1246 | if (sqlca.sqlcode != 0) { |
1247 | ingerr(&sqlca.sqlcode); | |
1248 | break; | |
1249 | } | |
208a4f4a | 1250 | |
68bbc9c3 | 1251 | if (!(f = (struct filesys *) hash_lookup(filesys, id1))) |
1252 | sq_save_data(sq1, id1); | |
1253 | if (!hash_lookup(filesys, id2)) | |
1254 | sq_save_data(sq3, id2); | |
208a4f4a | 1255 | } |
1256 | EXEC SQL CLOSE csr226; | |
68bbc9c3 | 1257 | generic_delete(sq1, show_fsg_missing, "fsgroup", "group_id", 0); |
1258 | generic_delete(sq3, show_fsg_nomember, "fsgroup", "filsys_id", 1); | |
1259 | ||
1260 | dprintf("Checking quotas...\n"); | |
1261 | sq1 = sq_create(); | |
1262 | sq2 = sq_create(); | |
1263 | sq3 = sq_create(); | |
1264 | sq4 = sq_create(); | |
208a4f4a | 1265 | EXEC SQL DECLARE csr227 CURSOR FOR |
1266 | SELECT entity_id, type, filsys_id, phys_id, quota FROM quota; | |
1267 | EXEC SQL OPEN csr227; | |
1268 | while(1) { | |
1269 | EXEC SQL FETCH csr227 INTO :id1, :type, :id2, :id3, :id4; | |
7bf0a6f3 | 1270 | if (sqlca.sqlcode != 0) { |
1271 | ingerr(&sqlca.sqlcode); | |
1272 | break; | |
1273 | } | |
208a4f4a | 1274 | |
68bbc9c3 | 1275 | if (type[0] == 'U' && id1 != 0 && !hash_lookup(users, id1)) |
1276 | sq_save_data(sq1, id1); | |
1277 | else if (type[0] == 'G' && !hash_lookup(lists, id1)) | |
1278 | sq_save_data(sq4, id1); | |
1279 | else if (!(f = (struct filesys *) hash_lookup(filesys, id2))) | |
1280 | sq_save_data(sq2, id2); | |
1281 | else if (id3 != f->phys_id || | |
1282 | ((n = (struct nfsphys*) hash_lookup(nfsphys, id3)) == | |
1283 | (struct nfsphys *)NULL)) | |
1284 | sq_save_data(sq3, id2); | |
1285 | else | |
1286 | n->count += id4; | |
208a4f4a | 1287 | } |
1288 | EXEC SQL CLOSE csr227; | |
68bbc9c3 | 1289 | generic_fix(sq1, show_quota_nouser, "Delete", fix_quota_nouser, 1); |
1290 | generic_fix(sq2, show_quota_nofs, "Delete", fix_quota_nofs, 0); | |
1291 | generic_fix(sq3, show_quota_wrongpid, "Fix", fix_quota_physid, 1); | |
1292 | generic_fix(sq4, show_quota_nolist, "Delete", fix_quota_nolist, 1); | |
1293 | ||
1294 | dprintf("Not checking zephyr.\n"); | |
1295 | ||
1296 | dprintf("Checking hostaccess...\n"); | |
208a4f4a | 1297 | EXEC SQL DECLARE csr228 CURSOR FOR |
1298 | SELECT mach_id, acl_type, acl_id FROM hostaccess; | |
1299 | EXEC SQL OPEN csr228; | |
1300 | while(1) { | |
1301 | EXEC SQL FETCH csr228 INTO :id1, :type, :id2; | |
7bf0a6f3 | 1302 | if (sqlca.sqlcode != 0) { |
1303 | ingerr(&sqlca.sqlcode); | |
1304 | break; | |
1305 | } | |
208a4f4a | 1306 | |
68bbc9c3 | 1307 | strtrim(type); |
1308 | if (!hash_lookup(machines, id1)) { | |
1309 | printf("Hostaccess for non-existant host %d\n", id1); | |
1310 | printf("Not fixing this error\n"); | |
1311 | } | |
1312 | if (!strcmp(type, "USER") && !hash_lookup(users, id2)) { | |
1313 | printf("Hostaccess for %d is non-existant user %d\n", id1, id2); | |
1314 | printf("Not fixing this error\n"); | |
1315 | } else if (!strcmp(type, "LIST") && !hash_lookup(lists, id2)) { | |
1316 | printf("Hostaccess for %d is non-existant list %d\n", id1, id2); | |
1317 | printf("Not fixing this error\n"); | |
1318 | } | |
208a4f4a | 1319 | } |
1320 | EXEC SQL CLOSE csr228; | |
68bbc9c3 | 1321 | |
1322 | dprintf("Checking palladium...\n"); | |
1323 | sq1 = sq_create(); | |
208a4f4a | 1324 | EXEC SQL DECLARE csr229 CURSOR FOR |
1325 | SELECT mach_id FROM palladium; | |
1326 | EXEC SQL OPEN csr229; | |
1327 | while(1) { | |
1328 | EXEC SQL FETCH csr229 INTO :id1; | |
7bf0a6f3 | 1329 | if (sqlca.sqlcode != 0) { |
1330 | ingerr(&sqlca.sqlcode); | |
1331 | break; | |
1332 | } | |
208a4f4a | 1333 | |
68bbc9c3 | 1334 | if (!hash_lookup(machines, id1)) { |
1335 | sq_save_unique_data(sq1, id1); | |
1336 | } | |
208a4f4a | 1337 | } |
1338 | EXEC SQL CLOSE csr229; | |
68bbc9c3 | 1339 | generic_delete(sq1, show_pdm_mach, "palladium", "mach_id", 1); |
1340 | ||
1341 | dprintf("Checking krbmap...\n"); | |
1342 | sq1 = sq_create(); | |
1343 | sq2 = sq_create(); | |
208a4f4a | 1344 | EXEC SQL DECLARE csr230 CURSOR FOR |
1345 | SELECT users_id, string_id FROM krbmap; | |
1346 | EXEC SQL OPEN csr230; | |
1347 | while(1) { | |
1348 | EXEC SQL FETCH csr230 INTO :id1, :id2; | |
7bf0a6f3 | 1349 | if (sqlca.sqlcode != 0) { |
1350 | ingerr(&sqlca.sqlcode); | |
1351 | break; | |
1352 | } | |
208a4f4a | 1353 | |
68bbc9c3 | 1354 | if (!hash_lookup(users, id1)) |
1355 | sq_save_unique_data(sq1, id1); | |
1356 | if (!string_check(id2)) | |
1357 | sq_save_unique_data(sq2, id2); | |
208a4f4a | 1358 | } |
1359 | EXEC SQL CLOSE csr230; | |
68bbc9c3 | 1360 | generic_delete(sq1, show_krb_usr, "krbmap", "users_id", 1); |
1361 | generic_delete(sq2, show_krb_str, "krbmap", "string_id", 1); | |
1362 | ||
1363 | dprintf("Checking capacls...\n"); | |
208a4f4a | 1364 | EXEC SQL DECLARE csr231 CURSOR FOR |
1365 | SELECT list_id, tag FROM capacls; | |
1366 | EXEC SQL OPEN csr231; | |
1367 | while(1) { | |
1368 | EXEC SQL FETCH csr231 INTO :id1, :name; | |
7bf0a6f3 | 1369 | if (sqlca.sqlcode != 0) { |
1370 | ingerr(&sqlca.sqlcode); | |
1371 | break; | |
1372 | } | |
208a4f4a | 1373 | |
68bbc9c3 | 1374 | if (!hash_lookup(lists, id1)) { |
1375 | printf("Capacl for %s is non-existant list %d\n", name, id1); | |
1376 | printf("Not fixing this error\n"); | |
1377 | } | |
208a4f4a | 1378 | } |
1379 | EXEC SQL CLOSE csr231; | |
68bbc9c3 | 1380 | |
208a4f4a | 1381 | } |
68bbc9c3 | 1382 |