3 * (c) Copyright 1988 by the Massachusetts Institute of Technology.
4 * For copying and distribution information, please see the file
8 #include <mit-copyright.h>
12 EXEC SQL INCLUDE sqlca;
14 static char phase1_qc_rcsid[] = "$Header$";
16 EXEC SQL WHENEVER SQLERROR DO dbmserr();
21 printf("User %s (%s, status %d) has duplicate ID\n",
22 u->login, u->fullname, u->status);
26 handle_duplicate_logins(sq)
27 struct save_queue *sq;
29 struct user *u, *uu, *tmp;
31 uu = (struct user *)0;
32 if(sq_get_data(sq,&uu)) {
33 while (sq_get_data(sq, &u)) {
34 if (!strcmp(u->login, uu->login)) {
35 if (uu->status == 1 || u->status == 0) {
40 printf("User %s (%s, status %d) and\n",
41 u->login, u->fullname, u->status);
42 printf("User %s (%s, status %d) have duplicate logins\n",
43 uu->login, uu->fullname, uu->status);
44 if (!strcmp(u->fullname, uu->fullname) &&
45 single_fix("Delete the second one")) {
46 single_delete("users", "users_id", uu->users_id);
47 } else if (single_fix("Unregister the second one"))
49 EXEC SQL BEGIN DECLARE SECTION;
50 int id = uu->users_id, rowcount;
51 EXEC SQL END DECLARE SECTION;
53 EXEC SQL UPDATE users SET login = '#' || CHAR(users.unix_uid),
54 status=0 WHERE users_id = :id;
55 rowcount = sqlca.sqlerrd[2];
57 printf("%d entr%s fixed\n", rowcount, rowcount==1?"y":"ies");
59 printf("Not fixed\n");
72 u->users_id = generic_fix_id("users", "users_id", "login",
73 u->users_id, u->login);
80 printf("Sorry, don't know how to fix that\n");
86 printf("Machine %s has duplicate ID %d\n", m->name, m->mach_id);
93 printf("Machine %s (%d) has duplicate name\n", m->name, m->mach_id);
100 m->mach_id = generic_fix_id("machine", "mach_id", "name",
101 m->mach_id, m->name);
107 printf("Cluster %s has duplicate ID %d\n", c->name, c->clu_id);
114 printf("Cluster %s (%d) has duplicate name\n", c->name, c->clu_id);
121 c->clu_id = generic_fix_id("cluster", "clu_id", "name", c->clu_id, c->name);
127 printf("List %s has duplicate ID %d\n", l->name, l->list_id);
134 printf("List %s (%d) has duplicate name\n", l->name, l->list_id);
141 l->list_id = generic_fix_id("list", "list_id", "name", l->list_id, l->name);
147 printf("Filesys %s has duplicate ID %d\n", f->name, f->filsys_id);
154 f->filsys_id = generic_fix_id("filesys", "filsys_id", "label",
155 f->filsys_id, f->name);
162 printf("NfsPhys %s:%s has duplicate ID %d\n",
163 ((struct machine *)hash_lookup(machines, n->mach_id))->name,
164 n->dir, n->nfsphys_id);
171 n->nfsphys_id = generic_fix_id("nfsphys", "nfsphys_id", "dir",
172 n->nfsphys_id, n->dir);
178 printf("String %s has duplicate ID %d\n", s->name, s->string_id);
185 printf("String %d is a duplicate\n", id);
189 print_dup_map(key, data, hint)
194 printf("String %d is a duplicate of string %d\n", key, data);
200 EXEC SQL BEGIN DECLARE SECTION;
201 char name[81], name1[81], last[17], first[17], buf[257];
202 int id, id1, id2, id3, aid, aid2, status;
203 int sid, sid2, sid3, sid4, sid5;
204 EXEC SQL END DECLARE SECTION;
205 int i, q, retval, tmp;
206 struct save_queue *sq;
216 printf("Phase 1 - Looking for duplicates\n");
218 /* self-join strings table on "string" to get duplicate strings, then
219 build a duplicates table to merge them. */
221 dprintf("Looking for duplicate strings...\n");
222 string_dups = create_hash( 100 );
223 if(!string_dups) out_of_mem("storing duplicate strings");
225 EXEC SQL DECLARE csr116 CURSOR FOR
226 SELECT s1.string_id, s2.string_id FROM strings s1, strings s2
227 where s1.string = s2.string and s1.string_id < s2.string_id;
228 EXEC SQL OPEN csr116;
229 /* The SELECT gives us two columns, both with non-negative integers.
230 * The number in the left column is always the smaller of the two,
231 * and each row includes string IDs for identical strings. We use
232 * them to make a mapping from id-to-delete to id-to-keep for all
237 EXEC SQL FETCH csr116 INTO :id1, :id2;
238 if (sqlca.sqlcode != 0) break;
240 /* If id2 is already stored, skip this row. */
241 i = int_hash_lookup( string_dups, id2 );
242 if( i > 0 ) { continue; }
243 /* Follow the chain of id1 equivalent IDs back to the lowest one. */
245 while((tmp=int_hash_lookup(string_dups, id))>0)
247 int_hash_store( string_dups, id2, id );
249 EXEC SQL CLOSE csr116;
250 dprintf("found %d duplicates\n", q);
251 int_hash_step(string_dups, print_dup_map, NULL);
252 /* We don't want to delete the duplicates now because if the dbck
253 is cancelled, a LOT of state will be lost. So, we'll just let
254 them not get marked as used and then phase3 will clean them up */
256 dprintf("Loading strings...\n");
258 strings = create_hash(75000);
259 if(!sq || !strings) out_of_mem("loading strings");
261 EXEC SQL DECLARE csr101 CURSOR FOR
262 SELECT string_id, string FROM strings ORDER BY string_id;
263 EXEC SQL OPEN csr101;
266 EXEC SQL FETCH csr101 INTO :id, :buf;
267 if (sqlca.sqlcode != 0) break;
269 s = (struct string *) malloc(sizeof(struct string));
271 out_of_mem("storing strings");
272 s->name = strsave(strtrim(buf));
275 retval = hash_store(strings, id, s);
276 if ( retval == -1 ) {
277 out_of_mem("storing strings in hash table");
278 } else if ( retval == 1 ) { /* duplicate string_id*/
279 sq_save_data(sq, hash_lookup(strings, id));
283 EXEC SQL CLOSE csr101;
284 /* I'm not at all convinced this will work, so...
285 generic_delete(sq, show_str_id, "strings", "string_id", 0);
289 printf("Loaded %d strings\n", q);
291 dprintf("Loading users...\n");
293 users = create_hash(30000);
294 if(!sq || !users) out_of_mem("loading users");
296 EXEC SQL DECLARE csr102 CURSOR FOR
297 SELECT users_id, login, last, first, status, potype, pop_id, box_id,
298 modby, fmodby, pmodby, comments, sigwho FROM users
300 EXEC SQL OPEN csr102;
302 EXEC SQL FETCH csr102 INTO :id, :name, :last, :first, :status,
303 :buf, :id2, :id3, :sid, :sid2, :sid3, :sid4, :sid5;
304 if (sqlca.sqlcode != 0) break;
306 u = (struct user *) malloc(sizeof(struct user));
308 out_of_mem("storing users");
309 strcpy(u->login, strtrim(name));
311 sprintf(buf, "%s, %s", strtrim(last), strtrim(first));
312 u->fullname = strsave(buf);
325 /* If potype is SMTP, box_id is a string_id for the strings tbl */
331 retval = hash_store(users, id, u);
332 if ( retval == -1 ) {
333 out_of_mem("storing users in hash table");
334 } else if ( retval == 1 ) {
335 sq_save_data(sq, hash_lookup(users, id));
339 EXEC SQL CLOSE csr102;
341 generic_fix(sq, show_user_id, "Change ID", fix_user_id, 0);
345 if(!sq) out_of_mem("finding duplicate logins");
347 EXEC SQL DECLARE csr103 CURSOR FOR
348 SELECT u1.users_id FROM users u1, users u2
349 WHERE u1.login = u2.login and u1.rowid != u2.rowid;
350 EXEC SQL OPEN csr103;
352 EXEC SQL FETCH csr103 INTO :id;
353 if (sqlca.sqlcode != 0) break;
354 sq_save_data(sq, hash_lookup(users, id));
356 EXEC SQL CLOSE csr103;
357 handle_duplicate_logins(sq);
361 dprintf("Scanning krbmap...\n");
363 EXEC SQL DECLARE csr113 CURSOR FOR
364 SELECT k1.users_id FROM krbmap k1, krbmap k2
365 WHERE k1.users_id = k2.users_id AND k1.rowid != k2.rowid;
366 EXEC SQL OPEN csr113;
368 EXEC SQL FETCH csr113 INTO :id;
369 if (sqlca.sqlcode != 0) break;
371 printf("User %d is in the krbmap more than once!\n", id);
372 printf("Not fixing this error\n");
374 EXEC SQL CLOSE csr113;
376 EXEC SQL DECLARE csr114 CURSOR FOR
377 SELECT k1.string_id FROM krbmap k1, krbmap k2
378 WHERE k1.string_id = k2.string_id AND k1.rowid != k2.rowid;
379 EXEC SQL OPEN csr114;
381 EXEC SQL FETCH csr114 INTO :id;
382 if (sqlca.sqlcode != 0) break;
384 printf("Principal %d is in the krbmap more than once!\n", id);
385 printf("Not fixing this error\n");
387 EXEC SQL CLOSE csr114;
390 dprintf("Loading machines...\n");
392 machines = create_hash(20000);
393 if(!sq || !machines) out_of_mem("loading machines");
395 EXEC SQL DECLARE csr104 CURSOR FOR
396 SELECT mach_id, name, snet_id, owner_type, owner_id,
397 acomment, ocomment, creator, modby
398 FROM machine ORDER BY mach_id;
399 EXEC SQL OPEN csr104;
401 EXEC SQL FETCH csr104 INTO :id, :name, :id2, :buf, :id3, :sid2,
403 if (sqlca.sqlcode != 0) break;
405 m = (struct machine *) malloc(sizeof(struct machine));
407 out_of_mem("storing machines");
408 strcpy(m->name, strtrim(name));
409 m->owner_type = buf[0];
418 retval = hash_store(machines, id, m);
419 if ( retval == -1 ) {
420 out_of_mem("storing machines in hash table");
421 } else if ( retval == 1 ) {
422 sq_save_data(sq, hash_lookup(machines, id));
426 EXEC SQL CLOSE csr104;
427 generic_fix(sq, show_mach_id, "Change ID", fix_mach_id, 0);
431 if(!sq) out_of_mem("looking for duplicate machine names");
433 EXEC SQL DECLARE csr105 CURSOR FOR
434 SELECT m1.mach_id FROM machine m1, machine m2
435 WHERE m1.name = m2.name AND m1.rowid != m2.rowid;
436 EXEC SQL OPEN csr105;
438 EXEC SQL FETCH csr105 INTO :id;
439 if (sqlca.sqlcode != 0) break;
441 sq_save_data(sq, hash_lookup(machines, id));
443 EXEC SQL CLOSE csr105;
444 generic_fix(sq, show_mach_name, "Change name", cant_fix, 0);
446 EXEC SQL DECLARE csr_hal1 CURSOR FOR
447 SELECT h1.name, m1.mach_id, m2.mach_id
448 FROM hostalias h1, machine m1, hostalias h2, machine m2
449 WHERE h1.name=h2.name AND h1.mach_id!=h2.mach_id
450 AND m1.mach_id=h1.mach_id AND m2.mach_id=h2.mach_id;
451 EXEC SQL OPEN csr_hal1;
453 EXEC SQL FETCH csr_hal1 INTO :name, :id1, :id2;
454 if(sqlca.sqlcode!=0) break;
455 printf("Aliases for machines %d and %d have duplicate name %s\n",
456 id1, id2, strtrim(name));
459 EXEC SQL CLOSE csr_hal1;
461 EXEC SQL DECLARE csr_hal2 CURSOR FOR
462 SELECT h1.name, m1.mach_id, m2.mach_id
463 FROM hostalias h1, machine m1, machine m2
464 WHERE h1.name=m1.name AND h1.mach_id=m2.mach_id;
465 EXEC SQL OPEN csr_hal2;
467 EXEC SQL FETCH csr_hal2 INTO :name, :id1, :id2;
468 if(sqlca.sqlcode!=0) break;
469 printf("Machine %d has alias `%s' that conflicts with machine %d\n",
470 id2, strtrim(name), id1);
473 EXEC SQL CLOSE csr_hal2;
476 dprintf("Loading subnets...\n");
477 subnets = create_hash(254);
478 if(!subnets) out_of_mem("loading subnets");
480 EXEC SQL DECLARE csr115 CURSOR FOR
481 SELECT snet_id, name, owner_type, owner_id, modby from subnet;
482 EXEC SQL OPEN csr115;
484 EXEC SQL FETCH csr115 INTO :id, :name, :buf, :id2, :sid;
485 if (sqlca.sqlcode != 0) break;
487 sn = (struct subnet *) malloc(sizeof(struct machine));
489 out_of_mem("storing subnets");
490 strcpy(sn->name, strtrim(name));
491 sn->owner_type=buf[0];
495 retval = hash_store(subnets, id, sn);
496 if ( retval == -1 ) {
497 out_of_mem("storing subnets in hash table");
498 } else if ( retval == 1 ) {
499 printf("Duplicate subnet ID: %d (%s)\n", id, name);
500 /* should add code to delete */
503 EXEC SQL CLOSE csr115;
505 dprintf("Loading clusters...\n");
507 clusters = create_hash(100);
508 if(!sq || !clusters) out_of_mem("loading clusters");
510 EXEC SQL DECLARE csr106 CURSOR FOR
511 SELECT clu_id, name, modby FROM clusters;
512 EXEC SQL OPEN csr106;
514 EXEC SQL FETCH csr106 INTO :id, :name, :sid;
515 if (sqlca.sqlcode != 0) break;
517 c = (struct cluster *) malloc(sizeof(struct cluster));
519 out_of_mem("storing clusters");
520 strcpy(c->name, strtrim(name));
523 retval = hash_store(clusters, id, c);
524 if ( retval == -1 ) {
525 out_of_mem("storing clusters in hash table");
526 } else if ( retval == 1 ) {
527 sq_save_data(sq, hash_lookup(clusters, id));
531 EXEC SQL CLOSE csr106;
532 generic_fix(sq, show_clu_id, "Change ID", fix_clu_id, 0);
536 if(!sq) out_of_mem("looking for duplicate cluster names");
538 EXEC SQL DECLARE csr107 CURSOR FOR
539 SELECT c1.clu_id FROM clusters c1, clusters c2
540 WHERE c1.name=c2.name AND c1.rowid != c2.rowid;
541 EXEC SQL OPEN csr107;
543 EXEC SQL FETCH csr107 INTO :id;
544 if (sqlca.sqlcode != 0) break;
546 sq_save_data(sq, hash_lookup(clusters, id));
548 EXEC SQL CLOSE csr107;
549 generic_fix(sq, show_clu_name, "Change name", cant_fix, 0);
552 dprintf("Loading lists...\n");
554 lists = create_hash(50000);
555 if(!sq || !lists) out_of_mem("loading lists");
557 EXEC SQL DECLARE csr108 CURSOR FOR
558 SELECT list_id, name, acl_id, acl_type, modby FROM list
560 EXEC SQL OPEN csr108;
562 EXEC SQL FETCH csr108 INTO :id, :name, :aid, :buf, :sid;
563 if (sqlca.sqlcode != 0) break;
564 l = (struct list *) malloc(sizeof(struct list));
566 out_of_mem("storing lists");
567 strcpy(l->name, strtrim(name));
568 l->acl_type = buf[0];
572 retval = hash_store(lists, id, l);
573 if ( retval == -1 ) {
574 out_of_mem("storing lists in hash table");
575 } else if ( retval == 1 ) {
576 sq_save_data(sq, hash_lookup(lists, id));
580 EXEC SQL CLOSE csr108;
581 generic_fix(sq, show_list_id, "Change ID", fix_list_id, 0);
585 if(!sq) out_of_mem("looking for duplicate list names");
587 EXEC SQL DECLARE csr109 CURSOR FOR
588 SELECT l1.list_id FROM list l1, list l2
589 WHERE l1.name=l2.name AND l1.rowid != l2.rowid;
590 EXEC SQL OPEN csr109;
592 EXEC SQL FETCH csr109 INTO :id;
593 if (sqlca.sqlcode != 0) break;
595 sq_save_data(sq, hash_lookup(lists, id));
597 EXEC SQL CLOSE csr109;
598 generic_fix(sq, show_list_name, "Change name", cant_fix, 0);
601 dprintf("Loading filesys...\n");
603 filesys = create_hash(30000);
604 if(!sq || !filesys) out_of_mem("loading filesys");
606 EXEC SQL DECLARE csr110 CURSOR FOR
607 SELECT filsys_id, label, owner, owners, phys_id, mach_id,
608 type, name, modby FROM filesys ORDER BY filsys_id;
609 EXEC SQL OPEN csr110;
611 EXEC SQL FETCH csr110 INTO :id, :name, :aid, :aid2, :id2, :id3,
613 if (sqlca.sqlcode != 0) break;
615 f = (struct filesys *) malloc(sizeof(struct filesys));
617 out_of_mem("storing filesystems");
618 strcpy(f->name, strtrim(name));
619 strcpy(f->dir, strtrim(name1));
626 retval = hash_store(filesys, id, f);
627 if ( retval == -1 ) {
628 out_of_mem("storing filesys in hash table");
629 } else if ( retval == 1 ) {
630 sq_save_data(sq, hash_lookup(filesys, id));
634 EXEC SQL CLOSE csr110;
636 generic_fix(sq, show_fs_id, "Change ID", fix_fs_id, 0);
638 dprintf("Loading nfsphys...\n");
640 nfsphys = create_hash(500);
641 if(!sq || !nfsphys) out_of_mem("loading nfsphs");
643 EXEC SQL DECLARE csr111 CURSOR FOR
644 SELECT nfsphys_id, dir, mach_id, allocated, modby FROM nfsphys;
645 EXEC SQL OPEN csr111;
647 EXEC SQL FETCH csr111 INTO :id, :name, :id2, :id3, :sid;
648 if (sqlca.sqlcode != 0) break;
650 n = (struct nfsphys *) malloc(sizeof(struct nfsphys));
652 out_of_mem("storing nfsphys");
653 strcpy(n->dir, strtrim(name));
658 retval = hash_store(nfsphys, id, n);
659 if ( retval == -1 ) {
660 out_of_mem("storing nfsphys in hash table");
661 } else if ( retval == 1 ) {
662 sq_save_data(sq, hash_lookup(nfsphys, id));
666 EXEC SQL CLOSE csr111;
668 generic_fix(sq, show_np_id, "Change ID", fix_np_id, 0);