![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to restore.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ingres / source / support|
Return to restore.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ingres / source / support |
1.1 ! root 1: # include <stdio.h> ! 2: # include <ingres.h> ! 3: # include <aux.h> ! 4: # include <catalog.h> ! 5: # include <access.h> ! 6: # include <batch.h> ! 7: # include <opsys.h> ! 8: # include <lock.h> ! 9: # include <symbol.h> ! 10: # include <resp.h> ! 11: # include <sys/dir.h> ! 12: # include <sccs.h> ! 13: # include <signal.h> ! 14: # include <setjmp.h> ! 15: ! 16: SCCSID(@(#)restore.c 8.5 1/31/86) ! 17: ! 18: /* ! 19: ** INGRES crash recovery processor ! 20: ** to recover a database you must be the dba or the ingres superuser ! 21: ** RESTORE attempts to complete updates from batch files left in a ! 22: ** database. After finishing all the batch files it calls PURGE. ! 23: */ ! 24: ! 25: # ifndef PURGE ! 26: # ifdef xV7_UNIX ! 27: # define PURGE "purge" ! 28: # else xV7_UNIX ! 29: # define PURGE "/usr/bin/purge" ! 30: # endif xV7_UNIX ! 31: # endif PURGE ! 32: ! 33: /* first file to close on error */ ! 34: # define CLOSEFILES 3 ! 35: ! 36: extern int Status; ! 37: extern char *Usercode; ! 38: char Utemp[2]; ! 39: char *Fileset; ! 40: char Berror; /* batch error */ ! 41: char Error; ! 42: extern char Ask; ! 43: extern char Superuser; ! 44: extern char All; ! 45: extern char Qrymod; ! 46: int Direc = CLOSEFILES - 1; ! 47: extern int Wait_action; ! 48: short tTvect[100]; ! 49: short tTdbu[100]; ! 50: struct resp Resp; ! 51: DESC Btreesec; ! 52: int Btree_fd; ! 53: jmp_buf Jmpbuffer; /* buffer for nonlocal goto's on an error condition */ ! 54: ! 55: ! 56: #ifndef rewinddir ! 57: typedef DIR FILE; ! 58: #endif ! 59: extern DIR *opendir(); ! 60: extern struct direct *readdir(); ! 61: ! 62: main(argc, argv) ! 63: int argc; ! 64: char *argv[]; ! 65: { ! 66: register int fd; ! 67: register int i; ! 68: register char *dbname; ! 69: extern char *Proc_name; ! 70: auto int stat; ! 71: extern (*ExitFn)(); ! 72: extern rubproc(), exit(); ! 73: char *nargv[20]; ! 74: char **avp; ! 75: char **fvp; ! 76: extern char *Flagvect[]; ! 77: extern char *getnxtdb(); ! 78: char *lookucode(); ! 79: ! 80: Proc_name = "RESTORE"; ! 81: ! 82: /* check param list */ ! 83: argv[argc] = NULL; ! 84: # ifdef xTTR1 ! 85: tTrace(argv, 'T', tTvect, 100); ! 86: tTrace(argv, 'Z', tTdbu, 100); ! 87: # endif ! 88: ! 89: initialize(argc, argv); ! 90: ! 91: /* do it to it */ ! 92: ExitFn = rubproc; ! 93: signal(SIGQUIT, exit); ! 94: while (dbname = getnxtdb()) ! 95: { ! 96: Berror = Error = 0; ! 97: ! 98: /* first restart point for this database */ ! 99: setjmp(Jmpbuffer); ! 100: if (Error) /* if set, will cause skip to next database */ ! 101: continue; ! 102: printf("\nRestoring database: %s\t", dbname); ! 103: ! 104: acc_init(); ! 105: printf("owner: %s\n", lookucode(Admin.adhdr.adowner)); ! 106: ! 107: /* set exclusive lock on data base */ ! 108: db_lock(M_EXCL); ! 109: ! 110: restore(); /* recover batch update and modify files */ ! 111: printf("\tRecovery of batch files complete.\n"); ! 112: ! 113: /* ! 114: ** second restart point for this database ! 115: ** the batch files are completed and now the system ! 116: ** relations need checking ! 117: */ ! 118: setjmp(Jmpbuffer); ! 119: if (Error) /* again, may cause skipping to next database */ ! 120: continue; ! 121: printf("\tChecking system relations\n"); ! 122: ! 123: ! 124: /* ! 125: ** check the relation relation ! 126: ** this will mean checking for file existence, ! 127: ** and whether the relstat bits are supported by ! 128: ** the information in the other catalogs. ! 129: */ ! 130: checkrel(); ! 131: ! 132: /* ! 133: ** check the attribute relation ! 134: ** for each tuple in the attribute relation, there must ! 135: ** be a tuple in the relation relation. ! 136: ** the indexes relation doesn't need to be reverse checked ! 137: ** into the relation relation since the order things are ! 138: ** handled else where in the system is in the correct ! 139: ** order. All the other catalogs need to be reverse checked. ! 140: */ ! 141: checkatts(); ! 142: ! 143: /* only check the qrymod catalogs if qrymod is turned on */ ! 144: if (Qrymod) ! 145: { ! 146: /* check the protect relation */ ! 147: checkprotect(); ! 148: ! 149: /* check the integrities relation */ ! 150: checkinteg(); ! 151: ! 152: /* ! 153: ** check the tree relation ! 154: ** must be done last since it depends upon ! 155: ** a state of the system relations provided ! 156: ** by the other check... routines. ! 157: */ ! 158: checktree(); ! 159: } ! 160: ! 161: /* finished, close up the database and go on to the next */ ! 162: closecatalog(TRUE); ! 163: unldb(); ! 164: acc_close(); ! 165: ! 166: /* call PURGE if no errors */ ! 167: if (!Berror && !Error) ! 168: { ! 169: printf("\tCalling purge: "); ! 170: fflush(stdout); ! 171: if ((i = fork()) == -1) ! 172: printf("Can't fork\n"); ! 173: else if (!i) ! 174: { ! 175: avp = nargv; ! 176: *avp++ = "Purge"; ! 177: for (fvp = Flagvect; *fvp != NULL; ) ! 178: *avp++ = *fvp++; ! 179: *avp++ = dbname; ! 180: *avp++ = 0; ! 181: # ifdef xTTR2 ! 182: if (tTf(0, 1)) ! 183: for (avp = nargv, i = 0; *avp != NULL; avp++, i++) ! 184: printf("%d %s\n", i, *avp); ! 185: # endif ! 186: for (i=3; i <= NOFILE; i++) ! 187: close(i); ! 188: execv(ztack(Pathname, "/bin/purge"), nargv); ! 189: # ifdef xV7_UNIX ! 190: execvp(PURGE, nargv); ! 191: # else xV7_UNIX ! 192: execv(PURGE, nargv); ! 193: # endif xV7_UNIX ! 194: printf("Cannot exec %s\n", PURGE); ! 195: exit(-1); ! 196: } ! 197: else ! 198: wait(&stat); ! 199: } ! 200: } ! 201: } ! 202: /* ! 203: ** RESTORE -- find the batch files and process them ! 204: */ ! 205: restore() ! 206: { ! 207: DESC descr; ! 208: register DIR *dirp; ! 209: register struct direct *dp; ! 210: register int i; ! 211: extern char *Fileset; ! 212: extern uperr(), (*ExitFn)(); ! 213: int (*tmpfn)(); ! 214: char *lookucode(); ! 215: char *fname; ! 216: # ifndef rewinddir ! 217: char fnambuf[DIRSIZ+1]; ! 218: # endif ! 219: ! 220: if ( (dirp = opendir(".")) == NULL ) ! 221: syserr("Can't open data base directory"); ! 222: bmove(Usercode, Utemp, UCODE_SZ); ! 223: Batch_recovery = 1; ! 224: tmpfn = ExitFn; ! 225: ExitFn = uperr; ! 226: ! 227: /* restart point */ ! 228: setjmp(Jmpbuffer); ! 229: for ( dp = readdir(dirp) ; dp != NULL ; dp = readdir(dirp) ) ! 230: { ! 231: # ifdef rewinddir ! 232: fname = dp->d_name; ! 233: # else ! 234: strncpy(fnambuf, dp->d_name, DIRSIZ); ! 235: fnamebuf[DIRSIZ] = '\0'; ! 236: fname = fnamebuf; ! 237: # endif ! 238: if ( !strcmp(".",fname) || !strcmp("..",fname) ) ! 239: continue; ! 240: if (bequal("_SYSbatch", fname, 9)) ! 241: { ! 242: Fileset = &fname[9]; ! 243: Batch_fp = open(batchname(), O_RDONLY); ! 244: Batch_cnt = BATCHSIZE; ! 245: getbatch(&Batchhd, sizeof(Batchhd)); ! 246: printf("\tFound batch file: %s\n", fname); ! 247: printf("\tRelation: %s\tUser: %s\n", Batchhd.rel_name, ! 248: lookucode(Batchhd.userid)); ! 249: close(Batch_fp); ! 250: bmove(Batchhd.userid, Usercode, UCODE_SZ); ! 251: if(ask("\tUpdate? ")) ! 252: update(); ! 253: } ! 254: if (bequal(MODBATCH, fname, sizeof(MODBATCH) - 1)) ! 255: { ! 256: Fileset = &fname[sizeof(MODBATCH) - 1]; ! 257: if ((Batch_fp = open(dp->d_name, O_RDONLY)) < 0) ! 258: syserr("Can't open %s", dp->d_name); ! 259: Batch_cnt = 0; ! 260: if((i = getbatch(&descr, sizeof(descr))) != sizeof(descr)) ! 261: syserr(" cant read %d",i); ! 262: printf("\tFound incomplete modify of %.12s, user = %s\n", ! 263: descr.reldum.relid, lookucode(descr.reldum.relowner)); ! 264: ! 265: bmove(descr.reldum.relowner, Usercode, sizeof(descr.reldum.relowner)); ! 266: close(Batch_fp); ! 267: if (ask("\tComplete? ")) ! 268: modupdate(); ! 269: } ! 270: } ! 271: bmove(Utemp, Usercode, UCODE_SZ); ! 272: ExitFn = tmpfn; ! 273: closedir(dirp); ! 274: } ! 275: /* ! 276: ** handles syserr's in the update processor ! 277: */ ! 278: uperr() ! 279: { ! 280: ! 281: if (Batch_fp) ! 282: close(Batch_fp); ! 283: Berror++; ! 284: longjmp(Jmpbuffer,1); ! 285: } ! 286: ! 287: ! 288: ! 289: /* ! 290: ** Catch errors in other places ! 291: */ ! 292: rubproc() ! 293: { ! 294: register int i; ! 295: register struct desxx *p; ! 296: extern struct desxx Desxx[]; ! 297: extern int Acc_init; ! 298: ! 299: Error++; ! 300: printf("Unable to restore!\n"); ! 301: ! 302: /* restore user code */ ! 303: bmove(Utemp, Usercode, sizeof Utemp); ! 304: ! 305: /* close all possible files */ ! 306: if (Acc_init) ! 307: { ! 308: closecatalog(TRUE); ! 309: unldb(); ! 310: acc_close(); ! 311: } ! 312: ! 313: /* close users file */ ! 314: getuser(0); ! 315: ! 316: /* get everything else */ ! 317: for (i = Direc + 1; i <= NOFILE; i++) ! 318: close(i); ! 319: } ! 320: /* ! 321: ** looks up user by usercode in users file ! 322: */ ! 323: char * ! 324: lookucode(ucode) ! 325: char ucode[2]; ! 326: { ! 327: static char buf[MAXLINE + 1]; ! 328: register char *p; ! 329: ! 330: if (getuser(ucode, buf)) ! 331: syserr("cannot identify user %.2s", ucode); ! 332: for (p = buf; *p != ':'; p++); ! 333: *p = 0; ! 334: return (buf); ! 335: } ! 336: /* ! 337: ** CHECKATTS ! 338: ** Checks that all attributes are in a relation ! 339: */ ! 340: checkatts() ! 341: { ! 342: extern DESC Reldes, Attdes; ! 343: register int i; ! 344: register int once; ! 345: TID tid, limtid, reltid; ! 346: char key[MAXTUP]; ! 347: struct attribute atttup; ! 348: struct relation reltup; ! 349: char lastrel[MAXNAME + 2]; ! 350: ! 351: once = 0; ! 352: opencatalog("relation", OR_WRITE); ! 353: opencatalog("attribute", OR_WRITE); ! 354: clearkeys(&Attdes); ! 355: lastrel[0] = '\0'; ! 356: if (find(&Attdes, NOKEY, &tid, &limtid)) ! 357: syserr("CHECKATT: find"); ! 358: ! 359: while (!(i = get(&Attdes, &tid, &limtid, &atttup, TRUE))) ! 360: { ! 361: if (bequal(atttup.attrelid, lastrel, MAXNAME + 2)) ! 362: continue; ! 363: ! 364: clearkeys(&Reldes); ! 365: setkey(&Reldes, key, atttup.attrelid, ATTRELID); ! 366: setkey(&Reldes, key, atttup.attowner, ATTOWNER); ! 367: ! 368: if (i = getequal(&Reldes, key, &reltup, &reltid)) ! 369: { ! 370: if (i < 0) ! 371: syserr("ATTCHECK: getequal"); ! 372: if (!once++) ! 373: printf("\tNo relation for attribute(s):\n"); ! 374: printf("\t"); ! 375: printup(&Attdes, &atttup); ! 376: if (ask("\tDelete?")) ! 377: if (i = delete(&Attdes, &tid)) ! 378: syserr("ATTCHECK: delete=%d", i); ! 379: } ! 380: else ! 381: bmove(atttup.attrelid, lastrel, MAXNAME + 2); ! 382: } ! 383: ! 384: if (i < 0) ! 385: syserr("ATTCHECK: get=%d", i); ! 386: } ! 387: /* ! 388: ** CHECKREL -- check relation relation against every thing else ! 389: ** ! 390: ** Each tuple in the relation relation is read and each verifiable ! 391: ** characteristic is checked for accuracy. Including the existence ! 392: ** of the physical file (if not a view), the qrymod definition if ! 393: ** appropriate and the secondary indexing. ! 394: */ ! 395: ! 396: checkrel() ! 397: { ! 398: extern DESC Reldes; ! 399: register int i, j; ! 400: struct relation rel; ! 401: TID rtid, limtid; ! 402: char fname[MAXNAME + 3]; ! 403: ! 404: /* setup for search of entire relation */ ! 405: opencatalog("relation", OR_WRITE); ! 406: clearkeys(&Reldes); ! 407: if (find(&Reldes, NOKEY, &rtid, &limtid)) ! 408: syserr("CHECKREL: find"); ! 409: ! 410: /* loop until all tuples checked */ ! 411: for (;;) ! 412: { ! 413: /* for each tuple in the rel-rel */ ! 414: i = get(&Reldes, &rtid, &limtid, &rel, TRUE); ! 415: if (i > 0) ! 416: break; /* have finished */ ! 417: if (i < 0) ! 418: syserr("CHECKREL: get=%d", i); ! 419: ! 420: /* if not a view, check for the file */ ! 421: if ((rel.relstat & S_VIEW) != S_VIEW) ! 422: { ! 423: ingresname(rel.relid, rel.relowner, fname); ! 424: if ((j = open(fname, O_RDWR)) == -1) ! 425: { ! 426: printf("\tNo file for:\n\t"); ! 427: printup(&Reldes, &rel); ! 428: if (ask("\tDelete tuple? ")) ! 429: { ! 430: if(j = delete(&Reldes, &rtid)) ! 431: syserr("CHECKREL: delete=%d", j); ! 432: continue; ! 433: } ! 434: else ! 435: /* don't call purge the file might still be there */ ! 436: Error++; ! 437: } ! 438: else ! 439: close(j); ! 440: } ! 441: ! 442: /* does it think that it has a secondary index */ ! 443: if (rel.relindxd > 0) ! 444: { ! 445: /* does it really have an index? */ ! 446: if (!hasndx(rel.relid, rel.relowner)) ! 447: { ! 448: /* no, should it be fixed */ ! 449: printf("\tNo indexes entry for primary relation:\n\t"); ! 450: printup(&Reldes, &rel); ! 451: if (ask("\tAdjust? ")) ! 452: { ! 453: /* fix up relation relation entry */ ! 454: rel.relindxd = 0; ! 455: if (i = replace(&Reldes, &rtid, &rel, FALSE)) ! 456: syserr("CHECKREL: replace=%d", i); ! 457: } ! 458: } ! 459: } ! 460: ! 461: /* does it think that it is a secondary index */ ! 462: if (rel.relindxd == SECINDEX) ! 463: { ! 464: /* check to make sure */ ! 465: if (!isndx(rel.relid, rel.relowner)) ! 466: { ! 467: /* none, what should be done? */ ! 468: printf("\tNo indexes entry for index:\n\t"); ! 469: printup(&Reldes, &rel); ! 470: if(ask("\tDelete? ")) ! 471: { ! 472: /* ! 473: ** get rid of rel-rel tuple for ! 474: ** secondary index, ! 475: ** purge will do rest of ! 476: ** removal if necessary ! 477: */ ! 478: if (i = delete(&Reldes, &rtid)) ! 479: syserr("CHECKREL: delete=%d", i); ! 480: continue; /* go on to next tuple */ ! 481: } ! 482: } ! 483: } ! 484: ! 485: /* if qrymod on in the database, check those catalogs too */ ! 486: if (Qrymod) ! 487: { ! 488: /* ! 489: ** cannot deal with S_VBASE since there is no way to ! 490: ** find the tree catalog entries without decoding the ! 491: ** 'treetree' fields. ! 492: ** ! 493: ** check to see if this is a view ! 494: */ ! 495: if ((rel.relstat & S_VIEW) && !havetree(rel.relid, rel.relowner, mdVIEW)) ! 496: { ! 497: /* no entry, should it be fixed? */ ! 498: printf("\tNo tree entry for this view:\n\t"); ! 499: printup(&Reldes, &rel); ! 500: if (ask("\tDelete tuple? ")) ! 501: { ! 502: /* delete relation entry */ ! 503: if (i = delete(&Reldes, &rtid)) ! 504: syserr("CHECKREL: delete=%d", i); ! 505: continue; /* skip to next entry in rel-rel */ ! 506: } ! 507: } ! 508: ! 509: /* check to see if has 'protect' entry */ ! 510: if ((rel.relstat & S_PROTUPS) && !isprot(rel.relid, rel.relowner, -1)) ! 511: { ! 512: /* no entry, should the bit be reset */ ! 513: printf("\tNo protect entry for:\n\t"); ! 514: printup(&Reldes, &rel); ! 515: if (ask("\tAdjust? ")) ! 516: { ! 517: /* fix the bit */ ! 518: rel.relstat &= ~S_PROTUPS; ! 519: if (i = replace(&Reldes, &rtid, &rel, FALSE)) ! 520: syserr("CHECKREL: replace=%d", i); ! 521: } ! 522: } ! 523: ! 524: /* check to see if has 'integrities entry */ ! 525: if ((rel.relstat & S_INTEG) && !isinteg(rel.relid, rel.relowner, -1)) ! 526: { ! 527: /* no entry, should bit be reset */ ! 528: printf("\tNo integrities entry for:\n\t"); ! 529: printup(&Reldes, &rel); ! 530: if (ask("\tAdjust? ")) ! 531: { ! 532: /* fix up the bit */ ! 533: rel.relstat &= ~S_INTEG; ! 534: if (i = replace(&Reldes, &rtid, &rel, FALSE)) ! 535: syserr("CHECKREL: replace=%d", i); ! 536: } ! 537: } ! 538: } ! 539: } ! 540: } ! 541: /* ! 542: ** HASNDX -- the relation indicated an index, check it out ! 543: ** ! 544: ** will search the index relation for all secondary indexes ! 545: ** and check to see that each secondary index named has an ! 546: ** entry in the relation relation. ! 547: */ ! 548: hasndx(id, own) ! 549: char id[MAXNAME]; ! 550: char own[2]; ! 551: { ! 552: register int hasindexes; ! 553: register int i, j; ! 554: extern DESC Reldes, Inddes; ! 555: TID rtid; ! 556: struct relation rkey, rel; ! 557: TID itid, ihitid; ! 558: struct index ikey, ind; ! 559: ! 560: /* presume that answer is negative */ ! 561: hasindexes = FALSE; ! 562: ! 563: /* set search for all tuples with 'id' and 'own' in indexes */ ! 564: opencatalog("indexes", OR_WRITE); ! 565: clearkeys(&Inddes); ! 566: setkey(&Inddes, &ikey, id, IRELIDP); ! 567: setkey(&Inddes, &ikey, own, IOWNERP); ! 568: if (find(&Inddes, EXACTKEY, &itid, &ihitid, &ikey)) ! 569: syserr("HASNDX: find"); ! 570: ! 571: /* for each possible tuple in the indexes relation */ ! 572: for (;;) ! 573: { ! 574: i = get(&Inddes, &itid, &ihitid, &ind, TRUE); ! 575: ! 576: /* check return values */ ! 577: if (i < 0) ! 578: syserr("HASNDX: get=%d\n", i); ! 579: if (i > 0) ! 580: break; /* finished */ ! 581: ! 582: /* if key doesn't match, skip to next tuple */ ! 583: if(kcompare(&Inddes, &ikey, &ind)) ! 584: continue; ! 585: hasindexes = TRUE; ! 586: ! 587: /* verify that primary entry for sec index exists */ ! 588: opencatalog("relation", OR_WRITE); ! 589: clearkeys(&Reldes); ! 590: setkey(&Reldes, &rkey, ind.irelidi, RELID); ! 591: setkey(&Reldes, &rkey, ind.iownerp, RELOWNER); ! 592: if (j = getequal(&Reldes, &rkey, &rel, &rtid, FALSE)) ! 593: { ! 594: /* one doesn't exist, should we ignore it */ ! 595: if (j < 0) ! 596: syserr("HASNDX: getequal=%d", j); ! 597: printf("\tNo secondary index for indexes entry:\n\t"); ! 598: printup(&Inddes, &ind); ! 599: if (ask("\tDelete? ")) ! 600: { ! 601: /* get rid of bad entry in indexes relation */ ! 602: if (j = delete(&Inddes, &itid)) ! 603: syserr("HASNDX: delete=%d", j); ! 604: hasindexes = FALSE; ! 605: } ! 606: } ! 607: } ! 608: return (hasindexes); ! 609: } ! 610: /* ! 611: ** ISNDX -- so you think that you're a secondary index, I'll check it out. ! 612: ** ! 613: ** searches the indexes relation for the name of the primary relation ! 614: ** and check to see if the primary is real. Will also update the ! 615: ** 'relindxd' field of the primary if it isn't correct. ! 616: */ ! 617: isndx(id, own) ! 618: char id[MAXNAME]; ! 619: char own[2]; ! 620: { ! 621: register int isindex; ! 622: register int i; ! 623: extern DESC Inddes; ! 624: TID itid; ! 625: struct index ind, ikey; ! 626: extern DESC Reldes; ! 627: TID rtid; ! 628: struct relation rel, rkey; ! 629: ! 630: /* search for tuple in index relation, should only be one */ ! 631: opencatalog("indexes", OR_WRITE); ! 632: clearkeys(&Inddes); ! 633: setkey(&Inddes, &ikey, id, IRELIDI); ! 634: setkey(&Inddes, &ikey, own, IOWNERP); ! 635: if (i = getequal(&Inddes, &ikey, &ind, &itid)) ! 636: { ! 637: /* there isn't a tuple in the indexes relation */ ! 638: if (i < 0) ! 639: syserr("ISNDX: getequal=%d", i); ! 640: isindex = FALSE; ! 641: } ! 642: else ! 643: { ! 644: isindex = TRUE; ! 645: ! 646: /* there is a tuple in the indexes relation */ ! 647: opencatalog("relation", OR_WRITE); ! 648: clearkeys(&Reldes); ! 649: setkey(&Reldes, &rkey, ind.irelidp, RELID); ! 650: setkey(&Reldes, &rkey, ind.iownerp, RELOWNER); ! 651: ! 652: /* see if the primary relation exists */ ! 653: if (i = getequal(&Reldes, &rkey, &rel, &rtid)) ! 654: { ! 655: /* no it doesn't */ ! 656: if (i < 0) ! 657: syserr("ISNDX: getequal=%d", i); ! 658: ! 659: /* what should be done about it */ ! 660: printf("\tNo primary relation for index:\n\t"); ! 661: printup(&Inddes, &ind); ! 662: if (ask("\tDelete?")) ! 663: { ! 664: /* ! 665: ** get rid of indexes tuple, ! 666: ** a FALSE return will also get rid ! 667: ** of the relation tuple ! 668: */ ! 669: if (i = delete(&Inddes, &itid)) ! 670: syserr("ISNDX: delete=%d", i); ! 671: isindex = FALSE; ! 672: } ! 673: } ! 674: else if (!(rel.relindxd > 0) || (rel.relstat & S_INDEX) == S_INDEX) ! 675: { ! 676: /* ! 677: ** the primary tuple exists but isn't marked correctly ! 678: */ ! 679: printf("\t%.12s is index for:\n\t", rel.relid); ! 680: printup(&Reldes, &rel); ! 681: if (ask("\tMark as indexed? ")) ! 682: { ! 683: rel.relstat |= S_INDEX; ! 684: rel.relindxd = SECBASE; ! 685: if (i = replace(&Reldes, &rtid, &rel, FALSE)) ! 686: syserr("ISNDX: replace=%d", i); ! 687: } ! 688: } ! 689: } ! 690: return (isindex); ! 691: } ! 692: /* ! 693: ** HAVETREE -- check tree catalog for an entry with right name and owner ! 694: ** ! 695: ** The 'id' and 'own' parameters are used to look in the tree catalog ! 696: ** for at least on tuple that also has a 'treetype' of 'mdvalue'. ! 697: ** ! 698: ** If any tuples are found, havetree returns TRUE, else FALSE ! 699: */ ! 700: ! 701: havetree(id, own, mdvalue) ! 702: char id[MAXNAME]; ! 703: char own[2]; ! 704: int mdvalue; ! 705: { ! 706: extern DESC Treedes; ! 707: register int i; ! 708: struct tree tkey, trent; ! 709: TID ttid, thitid; ! 710: ! 711: /* search tree relation for tuple that matches */ ! 712: opencatalog("tree", OR_WRITE); ! 713: clearkeys(&Treedes); ! 714: setkey(&Treedes, &tkey, id, TREERELID); ! 715: setkey(&Treedes, &tkey, own, TREEOWNER); ! 716: setkey(&Treedes, &tkey, &mdvalue, TREETYPE); ! 717: ! 718: /* set search limit tids from the key */ ! 719: if (i = find(&Treedes, EXACTKEY, &ttid, &thitid, &tkey)) ! 720: syserr("HAVETREE: find=%d", i); ! 721: ! 722: for (;;) ! 723: { ! 724: i = get(&Treedes, &ttid, &thitid, &trent, TRUE); ! 725: ! 726: if (i < 0) ! 727: syserr("HAVETREE: get=%d", i); ! 728: if (i > 0) ! 729: break; /* finished, didn't find one */ ! 730: ! 731: if (kcompare(&Treedes, &tkey, &trent) == 0) ! 732: return (TRUE); ! 733: } ! 734: return (FALSE); ! 735: } ! 736: /* ! 737: ** ISPROT -- check in the 'protect' catalog for a tuple with right name, owner ! 738: ** ! 739: ** search the 'protect' catalog for at least on tuple with matches the ! 740: ** values in the parameters. If 'treeid' is >= 0 then it is not used as ! 741: ** a key. ! 742: ** ! 743: ** if one is found, returns TRUE, otherwise, returns FALSE ! 744: */ ! 745: ! 746: isprot(id, own, treeid) ! 747: char id[MAXNAME]; ! 748: char own[2]; ! 749: int treeid; ! 750: { ! 751: extern DESC Prodes; ! 752: register int i; ! 753: struct protect pkey, pent; ! 754: TID ptid, phitid; ! 755: ! 756: /* search the protect relation for at least on matching tuple */ ! 757: opencatalog("protect", OR_WRITE); ! 758: clearkeys(&Prodes); ! 759: setkey(&Prodes, &pkey, id, PRORELID); ! 760: setkey(&Prodes, &pkey, own, PRORELOWN); ! 761: if (treeid >= 0) ! 762: setkey(&Prodes, &pkey, &treeid, PROTREE); ! 763: ! 764: /* set search limit tids from the keys */ ! 765: if (i = find(&Prodes, EXACTKEY, &ptid, &phitid, &pkey)) ! 766: syserr("ISPROT: find=%d", i); ! 767: ! 768: for (;;) ! 769: { ! 770: i = get(&Prodes, &ptid, &phitid, &pent, TRUE); ! 771: ! 772: if (i < 0) ! 773: syserr("ISPROT: get=%d", i); ! 774: if (i > 0) ! 775: break; /* finished, didn't find one */ ! 776: ! 777: if (kcompare(&Prodes, &pkey, &pent) == 0) ! 778: return (TRUE); ! 779: } ! 780: return (FALSE); ! 781: } ! 782: /* ! 783: ** ISINTEG -- check for a tuple in 'integrities' ! 784: ** ! 785: ** searches the integrities relation for 'id' and 'own'. ! 786: ** ! 787: ** returns TRUE if one is found, else FALSE ! 788: */ ! 789: ! 790: isinteg(id, own, treeid) ! 791: char id[MAXNAME]; ! 792: char own[2]; ! 793: int treeid; ! 794: { ! 795: extern DESC Intdes; ! 796: register int i; ! 797: struct integrity inkey, integ; ! 798: TID intid, inhitid; ! 799: ! 800: /* search the entire relation for a tuple that matches */ ! 801: opencatalog("integrities", OR_WRITE); ! 802: clearkeys(&Intdes); ! 803: setkey(&Intdes, &inkey, id, INTRELID); ! 804: setkey(&Intdes, &inkey, own, INTRELOWNER); ! 805: if (treeid >= 0) ! 806: setkey(&Intdes, &inkey, &treeid, INTTREE); ! 807: ! 808: /* set the search limit tids from the key */ ! 809: if (i = find(&Intdes, EXACTKEY, &intid, &inhitid, &inkey)) ! 810: syserr("ISINTEG: find=%d", i); ! 811: ! 812: for (;;) ! 813: { ! 814: i = get(&Intdes, &intid, &inhitid, &integ, TRUE); ! 815: ! 816: if (i < 0) ! 817: syserr("ISINTEG: get=%d", i); ! 818: if (i > 0) ! 819: break; /* finished, didn't find one */ ! 820: ! 821: if (kcompare(&Intdes, &inkey, &integ) == 0) ! 822: return (TRUE); ! 823: } ! 824: return (FALSE); ! 825: } ! 826: /* ! 827: ** CHECKTREE -- check the tree catalog against the others ! 828: */ ! 829: ! 830: checktree() ! 831: { ! 832: extern DESC Treedes, Reldes; ! 833: register int i; ! 834: struct tree tkey, trent; ! 835: TID ttid, thitid; ! 836: struct relation rkey, rel; ! 837: TID rtid; ! 838: ! 839: /* search the entire tree catalog */ ! 840: opencatalog("tree", OR_WRITE); ! 841: clearkeys(&Treedes); ! 842: if (i = find(&Treedes, NOKEY, &ttid, &thitid)) ! 843: syserr("CHECKTREE: find=%d", i); ! 844: ! 845: /* for each tuple in 'tree' */ ! 846: for (;;) ! 847: { ! 848: i = get(&Treedes, &ttid, &thitid, &trent, TRUE); ! 849: if (i > 0) ! 850: break; /* finished */ ! 851: if (i < 0) ! 852: syserr("CHECKTREE: get=%d", i); ! 853: ! 854: /* verify that a tuple exists in the relation relation */ ! 855: opencatalog("relation", OR_WRITE); ! 856: clearkeys(&Reldes); ! 857: setkey(&Reldes, &rkey, trent.treerelid, RELID); ! 858: setkey(&Reldes, &rkey, trent.treeowner, RELOWNER); ! 859: ! 860: /* fetch the tuple */ ! 861: if (i = getequal(&Reldes, &rkey, &rel, &rtid)) ! 862: { ! 863: /* ! 864: ** Oops, a tuple doesn't exist in the relation ! 865: ** relation. ! 866: ** ! 867: ** maybe it's just a fatal error ! 868: */ ! 869: if (i < 0) ! 870: syserr("CHECKTREE: getequal=%d", i); ! 871: ! 872: /* not a fatal error, what to do about it? */ ! 873: printf("\tNo relation tuple for:\n\t"); ! 874: printup(&Treedes, &trent); ! 875: if (ask("\tDelete? ")) ! 876: { ! 877: if (i = delete(&Treedes, &ttid)) ! 878: syserr("CHECKTREE: delete=%d", i); ! 879: continue; /* go on to next tuple */ ! 880: } ! 881: } ! 882: else ! 883: { ! 884: /* ! 885: ** Ah. A tuple does exist. ! 886: ** ! 887: ** If the relstat bits are correct then we can stop ! 888: ** here since elsewhere the 'protect' and 'integrity' ! 889: ** entries were verified. ! 890: */ ! 891: switch (trent.treetype) ! 892: { ! 893: case mdVIEW: ! 894: /* mere existence is sufficient */ ! 895: break; ! 896: ! 897: case mdPROT: ! 898: if ((rel.relstat & S_PROTUPS) != S_PROTUPS) ! 899: { ! 900: printf("\tNo 'protect' entry for:\n\t"); ! 901: deltup: ! 902: printup(&Treedes, &trent); ! 903: if (ask("\tDelete? ")) ! 904: { ! 905: if (i = delete(&Treedes, &ttid)) ! 906: syserr("CHECKTREE: delete=%d", i); ! 907: continue; ! 908: } ! 909: } ! 910: break; ! 911: ! 912: case mdINTEG: ! 913: if ((rel.relstat & S_INTEG) != S_INTEG) ! 914: { ! 915: printf("\tNo 'integrities' entry for:\n\t"); ! 916: goto deltup; ! 917: } ! 918: break; ! 919: ! 920: default: ! 921: syserr("Unknown treetype: %d\n", trent.treetype); ! 922: } ! 923: } ! 924: } ! 925: } ! 926: /* ! 927: ** CHECKPROTECT ! 928: */ ! 929: ! 930: checkprotect() ! 931: { ! 932: register int i; ! 933: extern DESC Reldes, Prodes; ! 934: struct protect pkey, pent; ! 935: TID ptid, phitid; ! 936: struct relation rkey, rel; ! 937: TID rtid; ! 938: ! 939: /* for each entry in the 'protect' relation */ ! 940: opencatalog("protect", OR_WRITE); ! 941: clearkeys(&Prodes); ! 942: if (i = find(&Prodes, NOKEY, &ptid, &phitid)) ! 943: syserr("CHECKPROTECT: find=%d", i); ! 944: ! 945: for (;;) ! 946: { ! 947: i = get(&Prodes, &ptid, &phitid, &pent, TRUE); ! 948: if (i > 0) ! 949: break; /* finished */ ! 950: if (i < 0) ! 951: syserr("CHECKPROTECT: get=%d", i); ! 952: ! 953: /* verify that a tuple exists in 'relation' */ ! 954: opencatalog("relation", OR_WRITE); ! 955: clearkeys(&Reldes); ! 956: setkey(&Reldes, &rkey, pent.prorelid, RELID); ! 957: setkey(&Reldes, &rkey, pent.prorelown, RELOWNER); ! 958: ! 959: /* fetch the tuple if possible */ ! 960: if (i = getequal(&Reldes, &rkey, &rel, &rtid)) ! 961: { ! 962: /* ! 963: ** Oops. A tuple doesn't exits in 'relation' ! 964: ** ! 965: ** Maybe it's just a fatal error. ! 966: */ ! 967: if (i < 0) ! 968: syserr("CHECKPROTECT: getequal=%d", i); ! 969: ! 970: /* not a fatal error, what to do? */ ! 971: printf("\tNo relation for 'protect' entry:\n\t"); ! 972: printup(&Prodes, &pent); ! 973: if (ask("\tRemove 'protect' entry? ")) ! 974: { ! 975: if (i = delete(&Prodes, &ptid)) ! 976: syserr("CHECKPROTECT: delete=%d", i); ! 977: continue; /* go on to next tuple */ ! 978: } ! 979: } ! 980: else ! 981: { ! 982: /* 'relation' entry exists, check for the tree entry */ ! 983: if (pent.protree >= 0) ! 984: { ! 985: if (!havetree(pent.prorelid, pent.prorelown, mdPROT)) ! 986: { ! 987: /* no tuples in 'tree' */ ! 988: printf("\tNo tree for:\n\t"); ! 989: printup(&Prodes, &pent); ! 990: if (ask("\tDelete entry and fix relation status bits? ")) ! 991: { ! 992: if (i = delete(&Prodes, &pent)) ! 993: syserr("CHECKPROTECT: delete=%d", i); ! 994: rel.relstat &= ~S_PROTUPS; ! 995: if (i = replace(&Reldes, &rtid, &rel, FALSE)) ! 996: syserr("CHECKPROTECT: replace=%d", i); ! 997: continue; /* go on to next tuple */ ! 998: } ! 999: } ! 1000: } ! 1001: if ((rel.relstat & S_PROTUPS) != S_PROTUPS) ! 1002: { ! 1003: /* bits not set correctly */ ! 1004: printf("\tIncorrect relation status bits for:\n\t"); ! 1005: printup(&Reldes, &rel); ! 1006: if (ask("\tAdjust? ")) ! 1007: { ! 1008: rel.relstat |= S_PROTUPS; ! 1009: if (i = replace(&Reldes, &rtid, &rel, FALSE)) ! 1010: syserr("CHECKPROTECT: replace=%d", i); ! 1011: continue; /* go on to next tuple */ ! 1012: } ! 1013: } ! 1014: } ! 1015: } ! 1016: } ! 1017: /* ! 1018: ** CHECKINTEG ! 1019: */ ! 1020: ! 1021: checkinteg() ! 1022: { ! 1023: register int i; ! 1024: extern DESC Reldes, Intdes; ! 1025: struct integrity inkey, inent; ! 1026: TID intid, inhitid; ! 1027: struct relation rkey, rel; ! 1028: TID rtid; ! 1029: ! 1030: /* for each entry in 'integrities' */ ! 1031: opencatalog("integrities", OR_WRITE); ! 1032: clearkeys(&Intdes); ! 1033: if (i = find(&Intdes, NOKEY, &intid, &inhitid)) ! 1034: syserr("CHECKINTEG: find=%d", i); ! 1035: ! 1036: for (;;) ! 1037: { ! 1038: i = get(&Intdes, &intid, &inhitid, &inent, TRUE); ! 1039: if (i > 0) ! 1040: break; /* finished */ ! 1041: if (i < 0) ! 1042: syserr("CHECKINTEG: get=%d", i); ! 1043: ! 1044: /* verify that a tuple exists in 'relation' */ ! 1045: opencatalog("relation", OR_WRITE); ! 1046: clearkeys(&Reldes); ! 1047: setkey(&Reldes, &rkey, inent.intrelid, RELID); ! 1048: setkey(&Reldes, &rkey, inent.intrelowner, RELOWNER); ! 1049: ! 1050: /* fetch the tuple if possible */ ! 1051: if (i = getequal(&Reldes, &rkey, &rel, &rtid)) ! 1052: { ! 1053: /* ! 1054: ** Oops. A tuple doesn't exits in 'relation' ! 1055: ** ! 1056: ** Maybe it's just a fatal error. ! 1057: */ ! 1058: if (i < 0) ! 1059: syserr("CHECKINTEG: getequal=%d", i); ! 1060: ! 1061: /* not a fatal error, what to do? */ ! 1062: printf("\tNo relation for 'integrities' entry:\n\t"); ! 1063: printup(&Intdes, &inent); ! 1064: if (ask("\tRemove 'integrities' entry? ")) ! 1065: { ! 1066: if (i = delete(&Intdes, &intid)) ! 1067: syserr("CHECKINTEG: delete=%d", i); ! 1068: continue; /* go on to next tuple */ ! 1069: } ! 1070: } ! 1071: else ! 1072: { ! 1073: /* 'relation' entry exists, check for the tree entry */ ! 1074: if (inent.inttree >= 0) ! 1075: { ! 1076: if (!havetree(inent.intrelid, inent.intrelowner, mdINTEG)) ! 1077: { ! 1078: /* no tuples in 'tree' */ ! 1079: printf("\tNo tree for:\n\t"); ! 1080: printup(&Intdes, &inent); ! 1081: if (ask("\tDelete entry and fix relation status bits? ")) ! 1082: { ! 1083: if (i = delete(&Intdes, &inent)) ! 1084: syserr("CHECKINTEG: delete=%d", i); ! 1085: rel.relstat &= ~S_INTEG; ! 1086: if (i = replace(&Reldes, &rtid, &rel, FALSE)) ! 1087: syserr("CHECKINTEG: replace=%d", i); ! 1088: continue; /* go on to next tuple */ ! 1089: } ! 1090: } ! 1091: } ! 1092: if ((rel.relstat & S_INTEG) != S_INTEG) ! 1093: { ! 1094: /* bits not set correctly */ ! 1095: printf("\tIncorrect relation status bits for:\n\t"); ! 1096: printup(&Reldes, &rel); ! 1097: if (ask("\tAdjust? ")) ! 1098: { ! 1099: rel.relstat |= S_INTEG; ! 1100: if (i = replace(&Reldes, &rtid, &rel, FALSE)) ! 1101: syserr("CHECKINTEG: replace=%d", i); ! 1102: continue; /* go on to next tuple */ ! 1103: } ! 1104: } ! 1105: } ! 1106: } ! 1107: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.