![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to 512restor.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 3BSD / cmd|
Return to 512restor.c CVS log | Up to [CSRG BSD Unix] / 3BSD / cmd |
1.1 ! root 1: #define MAXINO 3000 ! 2: #define BITS 8 ! 3: #define MAXXTR 60 ! 4: #define NCACHE 3 ! 5: ! 6: #ifndef STANDALONE ! 7: #include <stdio.h> ! 8: #include <signal.h> ! 9: #endif ! 10: #include <sys/param.h> ! 11: #include <sys/inode.h> ! 12: #include <sys/ino.h> ! 13: #include <sys/fblk.h> ! 14: #include <sys/filsys.h> ! 15: #include <sys/dir.h> ! 16: ! 17: #define OBSIZE 512 ! 18: ! 19: /* from old <ino.h> */ ! 20: ! 21: #define OINOPB 8 /* 8 inodes per block */ ! 22: ! 23: /* old <dumprestor.h> */ ! 24: #define NTREC 20 ! 25: #define MLEN 16 ! 26: #define MSIZ 4096 ! 27: ! 28: #define TS_TAPE 1 ! 29: #define TS_INODE 2 ! 30: #define TS_BITS 3 ! 31: #define TS_ADDR 4 ! 32: #define TS_END 5 ! 33: #define TS_CLRI 6 ! 34: #define MAGIC (int)60011 ! 35: #define CHECKSUM (int)84446 ! 36: struct spcl ! 37: { ! 38: int c_type; ! 39: time_t c_date; ! 40: time_t c_ddate; ! 41: int c_volume; ! 42: daddr_t c_tapea; ! 43: ino_t c_inumber; ! 44: int c_magic; ! 45: int c_checksum; ! 46: struct dinode c_dinode; ! 47: int c_count; ! 48: char c_addr[OBSIZE]; ! 49: } spcl; ! 50: ! 51: struct idates ! 52: { ! 53: char id_name[16]; ! 54: char id_incno; ! 55: time_t id_ddate; ! 56: }; ! 57: ! 58: /* end of old <dumprestor.h> */ ! 59: ! 60: #define MWORD(m,i) (m[(unsigned)(i-1)/MLEN]) ! 61: #define MBIT(i) (1<<((unsigned)(i-1)%MLEN)) ! 62: #define BIS(i,w) (MWORD(w,i) |= MBIT(i)) ! 63: #define BIC(i,w) (MWORD(w,i) &= ~MBIT(i)) ! 64: #define BIT(i,w) (MWORD(w,i) & MBIT(i)) ! 65: ! 66: struct filsys sblock; ! 67: ! 68: int fi; ! 69: ino_t ino, maxi, curino; ! 70: ! 71: int mt; ! 72: char tapename[] = "/dev/rmt1"; ! 73: char *magtape = tapename; ! 74: #ifdef STANDALONE ! 75: char mbuf[50]; ! 76: #endif ! 77: ! 78: #ifndef STANDALONE ! 79: daddr_t seekpt; ! 80: int df, ofile; ! 81: char dirfile[] = "rstXXXXXX"; ! 82: ! 83: struct { ! 84: ino_t t_ino; ! 85: daddr_t t_seekpt; ! 86: } inotab[MAXINO]; ! 87: int ipos; ! 88: ! 89: #define ONTAPE 1 ! 90: #define XTRACTD 2 ! 91: #define XINUSE 4 ! 92: struct xtrlist { ! 93: ino_t x_ino; ! 94: char x_flags; ! 95: } xtrlist[MAXXTR]; ! 96: ! 97: char name[12]; ! 98: ! 99: char drblock[BSIZE]; ! 100: int bpt; ! 101: #endif ! 102: ! 103: int eflag; ! 104: ! 105: int volno = 1; ! 106: ! 107: struct dinode tino, dino; ! 108: daddr_t taddr[NADDR]; ! 109: ! 110: daddr_t curbno; ! 111: ! 112: short dumpmap[MSIZ]; ! 113: short clrimap[MSIZ]; ! 114: ! 115: ! 116: int bct = NTREC+1; ! 117: char tbf[NTREC*OBSIZE]; ! 118: ! 119: struct cache { ! 120: daddr_t c_bno; ! 121: int c_time; ! 122: char c_block[BSIZE]; ! 123: } cache[NCACHE]; ! 124: int curcache; ! 125: ! 126: main(argc, argv) ! 127: char *argv[]; ! 128: { ! 129: register char *cp; ! 130: char command; ! 131: int done(); ! 132: ! 133: #ifndef STANDALONE ! 134: mktemp(dirfile); ! 135: if (argc < 2) { ! 136: usage: ! 137: printf("Usage: oldrestor x file file..., oldrestor r filesys, or oldrestor t\n"); ! 138: exit(1); ! 139: } ! 140: argv++; ! 141: argc -= 2; ! 142: for (cp = *argv++; *cp; cp++) { ! 143: switch (*cp) { ! 144: case '-': ! 145: break; ! 146: case 'f': ! 147: magtape = *argv++; ! 148: argc--; ! 149: break; ! 150: case 'r': ! 151: case 'R': ! 152: case 't': ! 153: case 'x': ! 154: command = *cp; ! 155: break; ! 156: default: ! 157: printf("Bad key character %c\n", *cp); ! 158: goto usage; ! 159: } ! 160: } ! 161: if (command == 'x') { ! 162: if (signal(SIGINT, done) == SIG_IGN) ! 163: signal(SIGINT, SIG_IGN); ! 164: if (signal(SIGTERM, done) == SIG_IGN) ! 165: signal(SIGTERM, SIG_IGN); ! 166: ! 167: df = creat(dirfile, 0666); ! 168: if (df < 0) { ! 169: printf("restor: %s - cannot create directory temporary\n", dirfile); ! 170: exit(1); ! 171: } ! 172: close(df); ! 173: df = open(dirfile, 2); ! 174: } ! 175: doit(command, argc, argv); ! 176: if (command == 'x') ! 177: unlink(dirfile); ! 178: exit(0); ! 179: #else ! 180: magtape = "tape"; ! 181: doit('r', 1, 0); ! 182: #endif ! 183: } ! 184: ! 185: doit(command, argc, argv) ! 186: char command; ! 187: int argc; ! 188: char *argv[]; ! 189: { ! 190: extern char *ctime(); ! 191: register i, k; ! 192: ino_t d; ! 193: #ifndef STANDALONE ! 194: int xtrfile(), skip(); ! 195: #endif ! 196: int rstrfile(), rstrskip(); ! 197: struct dinode *ip, *ip1; ! 198: ! 199: #ifndef STANDALONE ! 200: if ((mt = open(magtape, 0)) < 0) { ! 201: printf("%s: cannot open tape\n", magtape); ! 202: exit(1); ! 203: } ! 204: #else ! 205: do { ! 206: printf("Tape? "); ! 207: gets(mbuf); ! 208: mt = open(mbuf, 0); ! 209: } while (mt == -1); ! 210: magtape = mbuf; ! 211: #endif ! 212: switch(command) { ! 213: #ifndef STANDALONE ! 214: case 't': ! 215: if (readhdr(&spcl) == 0) { ! 216: printf("Tape is not a dump tape\n"); ! 217: exit(1); ! 218: } ! 219: printf("Dump date: %s", ctime(&spcl.c_date)); ! 220: printf("Dumped from: %s", ctime(&spcl.c_ddate)); ! 221: return; ! 222: case 'x': ! 223: if (readhdr(&spcl) == 0) { ! 224: printf("Tape is not a dump tape\n"); ! 225: exit(1); ! 226: } ! 227: if (checkvol(&spcl, 1) == 0) { ! 228: printf("Tape is not volume 1 of the dump\n"); ! 229: exit(1); ! 230: } ! 231: pass1(); /* This sets the various maps on the way by */ ! 232: i = 0; ! 233: while (i < MAXXTR-1 && argc--) { ! 234: if ((d = psearch(*argv)) == 0 || BIT(d, dumpmap) == 0) { ! 235: printf("%s: not on the tape\n", *argv++); ! 236: continue; ! 237: } ! 238: xtrlist[i].x_ino = d; ! 239: xtrlist[i].x_flags |= XINUSE; ! 240: printf("%s: inode %u\n", *argv, d); ! 241: argv++; ! 242: i++; ! 243: } ! 244: newvol: ! 245: flsht(); ! 246: close(mt); ! 247: getvol: ! 248: printf("Mount desired tape volume: Specify volume #: "); ! 249: if (gets(tbf) == NULL) ! 250: return; ! 251: volno = atoi(tbf); ! 252: if (volno <= 0) { ! 253: printf("Volume numbers are positive numerics\n"); ! 254: goto getvol; ! 255: } ! 256: mt = open(magtape, 0); ! 257: if (readhdr(&spcl) == 0) { ! 258: printf("tape is not dump tape\n"); ! 259: goto newvol; ! 260: } ! 261: if (checkvol(&spcl, volno) == 0) { ! 262: printf("Wrong volume (%d)\n", spcl.c_volume); ! 263: goto newvol; ! 264: } ! 265: rbits: ! 266: while (gethead(&spcl) == 0) ! 267: ; ! 268: if (checktype(&spcl, TS_INODE) == 1) { ! 269: printf("Can't find inode mask!\n"); ! 270: goto newvol; ! 271: } ! 272: if (checktype(&spcl, TS_BITS) == 0) ! 273: goto rbits; ! 274: readbits(dumpmap); ! 275: i = 0; ! 276: for (k = 0; xtrlist[k].x_flags; k++) { ! 277: if (BIT(xtrlist[k].x_ino, dumpmap)) { ! 278: xtrlist[k].x_flags |= ONTAPE; ! 279: i++; ! 280: } ! 281: } ! 282: while (i > 0) { ! 283: again: ! 284: if (ishead(&spcl) == 0) ! 285: while(gethead(&spcl) == 0) ! 286: ; ! 287: if (checktype(&spcl, TS_END) == 1) { ! 288: printf("end of tape\n"); ! 289: checkdone: ! 290: for (k = 0; xtrlist[k].x_flags; k++) ! 291: if ((xtrlist[k].x_flags&XTRACTD) == 0) ! 292: goto newvol; ! 293: return; ! 294: } ! 295: if (checktype(&spcl, TS_INODE) == 0) { ! 296: gethead(&spcl); ! 297: goto again; ! 298: } ! 299: d = spcl.c_inumber; ! 300: for (k = 0; xtrlist[k].x_flags; k++) { ! 301: if (d == xtrlist[k].x_ino) { ! 302: printf("extract file %u\n", xtrlist[k].x_ino); ! 303: sprintf(name, "%u", xtrlist[k].x_ino); ! 304: if ((ofile = creat(name, 0666)) < 0) { ! 305: printf("%s: cannot create file\n", name); ! 306: i--; ! 307: continue; ! 308: } ! 309: chown(name, spcl.c_dinode.di_uid, spcl.c_dinode.di_gid); ! 310: getfile(ino, xtrfile, skip, spcl.c_dinode.di_size); ! 311: i--; ! 312: xtrlist[k].x_flags |= XTRACTD; ! 313: close(ofile); ! 314: goto done; ! 315: } ! 316: } ! 317: gethead(&spcl); ! 318: done: ! 319: ; ! 320: } ! 321: goto checkdone; ! 322: #endif ! 323: case 'r': ! 324: case 'R': ! 325: #ifndef STANDALONE ! 326: if ((fi = open(*argv, 2)) < 0) { ! 327: printf("%s: cannot open\n", *argv); ! 328: exit(1); ! 329: } ! 330: #else ! 331: do { ! 332: char charbuf[50]; ! 333: ! 334: printf("Disk? "); ! 335: gets(charbuf); ! 336: fi = open(charbuf, 2); ! 337: } while (fi == -1); ! 338: #endif ! 339: #ifndef STANDALONE ! 340: if (command == 'R') { ! 341: printf("Enter starting volume number: "); ! 342: if (gets(tbf) == EOF) { ! 343: volno = 1; ! 344: printf("\n"); ! 345: } ! 346: else ! 347: volno = atoi(tbf); ! 348: } ! 349: else ! 350: #endif ! 351: volno = 1; ! 352: printf("Last chance before scribbling on %s. ", ! 353: #ifdef STANDALONE ! 354: "disk"); ! 355: #else ! 356: *argv); ! 357: #endif ! 358: while (getchar() != '\n'); ! 359: dread((daddr_t)1, (char *)&sblock, sizeof(sblock)); ! 360: maxi = (sblock.s_isize-2)*INOPB; ! 361: if (readhdr(&spcl) == 0) { ! 362: printf("Missing volume record\n"); ! 363: exit(1); ! 364: } ! 365: if (checkvol(&spcl, volno) == 0) { ! 366: printf("Tape is not volume %d\n", volno); ! 367: exit(1); ! 368: } ! 369: gethead(&spcl); ! 370: for (;;) { ! 371: ragain: ! 372: if (ishead(&spcl) == 0) { ! 373: printf("Missing header block\n"); ! 374: while (gethead(&spcl) == 0) ! 375: ; ! 376: eflag++; ! 377: } ! 378: if (checktype(&spcl, TS_END) == 1) { ! 379: printf("End of tape\n"); ! 380: close(mt); ! 381: dwrite( (daddr_t) 1, (char *) &sblock); ! 382: return; ! 383: } ! 384: if (checktype(&spcl, TS_CLRI) == 1) { ! 385: readbits(clrimap); ! 386: for (ino = 1; ino <= maxi; ino++) ! 387: if (BIT(ino, clrimap) == 0) { ! 388: getdino(ino, &tino); ! 389: if (tino.di_mode == 0) ! 390: continue; ! 391: itrunc(&tino); ! 392: clri(&tino); ! 393: putdino(ino, &tino); ! 394: } ! 395: dwrite( (daddr_t) 1, (char *) &sblock); ! 396: goto ragain; ! 397: } ! 398: if (checktype(&spcl, TS_BITS) == 1) { ! 399: readbits(dumpmap); ! 400: goto ragain; ! 401: } ! 402: if (checktype(&spcl, TS_INODE) == 0) { ! 403: printf("Unknown header type\n"); ! 404: eflag++; ! 405: gethead(&spcl); ! 406: goto ragain; ! 407: } ! 408: ino = spcl.c_inumber; ! 409: if (eflag) ! 410: printf("Resynced at inode %u\n", ino); ! 411: eflag = 0; ! 412: if (ino > maxi) { ! 413: printf("%u: ilist too small\n", ino); ! 414: gethead(&spcl); ! 415: goto ragain; ! 416: } ! 417: dino = spcl.c_dinode; ! 418: getdino(ino, &tino); ! 419: curbno = 0; ! 420: itrunc(&tino); ! 421: clri(&tino); ! 422: for (i = 0; i < NADDR; i++) ! 423: taddr[i] = 0; ! 424: l3tol(taddr, dino.di_addr, 1); ! 425: getfile(d, rstrfile, rstrskip, dino.di_size); ! 426: ip = &tino; ! 427: ltol3(ip->di_addr, taddr, NADDR); ! 428: ip1 = &dino; ! 429: ip->di_mode = ip1->di_mode; ! 430: ip->di_nlink = ip1->di_nlink; ! 431: ip->di_uid = ip1->di_uid; ! 432: ip->di_gid = ip1->di_gid; ! 433: ip->di_size = ip1->di_size; ! 434: ip->di_atime = ip1->di_atime; ! 435: ip->di_mtime = ip1->di_mtime; ! 436: ip->di_ctime = ip1->di_ctime; ! 437: putdino(ino, &tino); ! 438: } ! 439: } ! 440: } ! 441: ! 442: /* ! 443: * Read the tape, bulding up a directory structure for extraction ! 444: * by name ! 445: */ ! 446: #ifndef STANDALONE ! 447: pass1() ! 448: { ! 449: register i; ! 450: struct dinode *ip; ! 451: int putdir(), null(); ! 452: ! 453: while (gethead(&spcl) == 0) { ! 454: printf("Can't find directory header!\n"); ! 455: } ! 456: for (;;) { ! 457: if (checktype(&spcl, TS_BITS) == 1) { ! 458: readbits(dumpmap); ! 459: continue; ! 460: } ! 461: if (checktype(&spcl, TS_CLRI) == 1) { ! 462: readbits(clrimap); ! 463: continue; ! 464: } ! 465: if (checktype(&spcl, TS_INODE) == 0) { ! 466: finish: ! 467: flsh(); ! 468: close(mt); ! 469: return; ! 470: } ! 471: ip = &spcl.c_dinode; ! 472: i = ip->di_mode & IFMT; ! 473: if (i != IFDIR) { ! 474: goto finish; ! 475: } ! 476: inotab[ipos].t_ino = spcl.c_inumber; ! 477: inotab[ipos++].t_seekpt = seekpt; ! 478: getfile(spcl.c_inumber, putdir, null, spcl.c_dinode.di_size); ! 479: putent("\000\000/"); ! 480: } ! 481: } ! 482: #endif ! 483: ! 484: /* ! 485: * Do the file extraction, calling the supplied functions ! 486: * with the blocks ! 487: */ ! 488: getfile(n, f1, f2, size) ! 489: ino_t n; ! 490: int (*f2)(), (*f1)(); ! 491: long size; ! 492: { ! 493: register i; ! 494: struct spcl addrblock; ! 495: char buf[BSIZE]; ! 496: ! 497: addrblock = spcl; ! 498: curino = n; ! 499: goto start; ! 500: for (;;) { ! 501: if (gethead(&addrblock) == 0) { ! 502: printf("Missing address (header) block\n"); ! 503: goto eloop; ! 504: } ! 505: if (checktype(&addrblock, TS_ADDR) == 0) { ! 506: spcl = addrblock; ! 507: curino = 0; ! 508: curino = 0; ! 509: return; ! 510: } ! 511: start: ! 512: for (i = 0; i < addrblock.c_count; i += 2) { ! 513: if (addrblock.c_addr[i]) ! 514: readtape(buf, 0); ! 515: else ! 516: clearbuf(buf, 0); ! 517: if (size > OBSIZE && addrblock.c_addr[i+1]) ! 518: readtape(buf, 1); ! 519: else ! 520: clearbuf(buf, 1); ! 521: if (addrblock.c_addr[i] || size > OBSIZE && addrblock.c_addr[i + 1]) ! 522: (*f1)(buf, size > BSIZE ? (long) BSIZE : size); ! 523: else ! 524: (*f2)(buf, size > BSIZE ? (long) BSIZE : size); ! 525: if ((size -= BSIZE) <= 0) { ! 526: eloop: ! 527: while (gethead(&spcl) == 0) ! 528: ; ! 529: if (checktype(&spcl, TS_ADDR) == 1) ! 530: goto eloop; ! 531: curino = 0; ! 532: return; ! 533: } ! 534: } ! 535: } ! 536: } ! 537: ! 538: /* ! 539: * Do the tape i\/o, dealling with volume changes ! 540: * etc.. ! 541: */ ! 542: readtape(b, part) ! 543: char *b; ! 544: { ! 545: register i; ! 546: struct spcl tmpbuf; ! 547: ! 548: if (bct >= NTREC) { ! 549: for (i = 0; i < NTREC; i++) ! 550: ((struct spcl *)&tbf[i*OBSIZE])->c_magic = 0; ! 551: bct = 0; ! 552: if ((i = read(mt, tbf, NTREC*OBSIZE)) < 0) { ! 553: printf("Tape read error: inode %u\n", curino); ! 554: eflag++; ! 555: exit(1); ! 556: } ! 557: if (i == 0) { ! 558: bct = NTREC + 1; ! 559: volno++; ! 560: loop: ! 561: flsht(); ! 562: close(mt); ! 563: printf("Mount volume %d\n", volno); ! 564: while (getchar() != '\n') ! 565: ; ! 566: if ((mt = open(magtape, 0)) == -1) { ! 567: printf("Cannot open tape!\n"); ! 568: goto loop; ! 569: } ! 570: if (readhdr(&tmpbuf) == 0) { ! 571: printf("Not a dump tape.Try again\n"); ! 572: goto loop; ! 573: } ! 574: if (checkvol(&tmpbuf, volno) == 0) { ! 575: printf("Wrong tape. Try again\n"); ! 576: goto loop; ! 577: } ! 578: readtape(b, part); ! 579: return; ! 580: } ! 581: } ! 582: copy(&tbf[(bct++*OBSIZE)], b + part * OBSIZE, OBSIZE); ! 583: } ! 584: ! 585: flsht() ! 586: { ! 587: bct = NTREC+1; ! 588: } ! 589: ! 590: copy(f, t, s) ! 591: register char *f, *t; ! 592: { ! 593: register i; ! 594: ! 595: i = s; ! 596: do ! 597: *t++ = *f++; ! 598: while (--i); ! 599: } ! 600: ! 601: clearbuf(cp, part) ! 602: register char *cp; ! 603: { ! 604: register i; ! 605: ! 606: cp += part * OBSIZE; ! 607: i = OBSIZE; ! 608: do ! 609: *cp++ = 0; ! 610: while (--i); ! 611: } ! 612: ! 613: /* ! 614: * Put and get the directory entries from the compressed ! 615: * directory file ! 616: */ ! 617: #ifndef STANDALONE ! 618: putent(cp) ! 619: char *cp; ! 620: { ! 621: register i; ! 622: ! 623: for (i = 0; i < sizeof(ino_t); i++) ! 624: writec(*cp++); ! 625: for (i = 0; i < DIRSIZ; i++) { ! 626: writec(*cp); ! 627: if (*cp++ == 0) ! 628: return; ! 629: } ! 630: return; ! 631: } ! 632: ! 633: getent(bf) ! 634: register char *bf; ! 635: { ! 636: register i; ! 637: ! 638: for (i = 0; i < sizeof(ino_t); i++) ! 639: *bf++ = readc(); ! 640: for (i = 0; i < DIRSIZ; i++) ! 641: if ((*bf++ = readc()) == 0) ! 642: return; ! 643: return; ! 644: } ! 645: ! 646: /* ! 647: * read/write te directory file ! 648: */ ! 649: writec(c) ! 650: char c; ! 651: { ! 652: drblock[bpt++] = c; ! 653: seekpt++; ! 654: if (bpt >= BSIZE) { ! 655: bpt = 0; ! 656: write(df, drblock, BSIZE); ! 657: } ! 658: } ! 659: ! 660: readc() ! 661: { ! 662: if (bpt >= BSIZE) { ! 663: read(df, drblock, BSIZE); ! 664: bpt = 0; ! 665: } ! 666: return(drblock[bpt++]); ! 667: } ! 668: ! 669: mseek(pt) ! 670: daddr_t pt; ! 671: { ! 672: bpt = BSIZE; ! 673: lseek(df, pt, 0); ! 674: } ! 675: ! 676: flsh() ! 677: { ! 678: write(df, drblock, bpt+1); ! 679: } ! 680: ! 681: /* ! 682: * search the directory inode ino ! 683: * looking for entry cp ! 684: */ ! 685: ino_t ! 686: search(inum, cp) ! 687: ino_t inum; ! 688: char *cp; ! 689: { ! 690: register i; ! 691: struct direct dir; ! 692: ! 693: for (i = 0; i < MAXINO; i++) ! 694: if (inotab[i].t_ino == inum) { ! 695: goto found; ! 696: } ! 697: return(0); ! 698: found: ! 699: mseek(inotab[i].t_seekpt); ! 700: do { ! 701: getent((char *)&dir); ! 702: if (direq(dir.d_name, "/")) ! 703: return(0); ! 704: } while (direq(dir.d_name, cp) == 0); ! 705: return(dir.d_ino); ! 706: } ! 707: ! 708: /* ! 709: * Search the directory tree rooted at inode 2 ! 710: * for the path pointed at by n ! 711: */ ! 712: psearch(n) ! 713: char *n; ! 714: { ! 715: register char *cp, *cp1; ! 716: char c; ! 717: ! 718: ino = 2; ! 719: if (*(cp = n) == '/') ! 720: cp++; ! 721: next: ! 722: cp1 = cp + 1; ! 723: while (*cp1 != '/' && *cp1) ! 724: cp1++; ! 725: c = *cp1; ! 726: *cp1 = 0; ! 727: ino = search(ino, cp); ! 728: if (ino == 0) { ! 729: *cp1 = c; ! 730: return(0); ! 731: } ! 732: *cp1 = c; ! 733: if (c == '/') { ! 734: cp = cp1+1; ! 735: goto next; ! 736: } ! 737: return(ino); ! 738: } ! 739: ! 740: direq(s1, s2) ! 741: register char *s1, *s2; ! 742: { ! 743: register i; ! 744: ! 745: for (i = 0; i < DIRSIZ; i++) ! 746: if (*s1++ == *s2) { ! 747: if (*s2++ == 0) ! 748: return(1); ! 749: } else ! 750: return(0); ! 751: return(1); ! 752: } ! 753: #endif ! 754: ! 755: /* ! 756: * read/write a disk block, be sure to update the buffer ! 757: * cache if needed. ! 758: */ ! 759: dwrite(bno, b) ! 760: daddr_t bno; ! 761: char *b; ! 762: { ! 763: register i; ! 764: ! 765: for (i = 0; i < NCACHE; i++) { ! 766: if (cache[i].c_bno == bno) { ! 767: copy(b, cache[i].c_block, BSIZE); ! 768: cache[i].c_time = 0; ! 769: break; ! 770: } ! 771: else ! 772: cache[i].c_time++; ! 773: } ! 774: lseek(fi, bno*BSIZE, 0); ! 775: if(write(fi, b, BSIZE) != BSIZE) { ! 776: #ifdef STANDALONE ! 777: printf("disk write error %D\n", bno); ! 778: #else ! 779: fprintf(stderr, "disk write error %ld\n", bno); ! 780: #endif ! 781: exit(1); ! 782: } ! 783: } ! 784: ! 785: dread(bno, buf, cnt) ! 786: daddr_t bno; ! 787: char *buf; ! 788: { ! 789: register i, j; ! 790: ! 791: j = 0; ! 792: for (i = 0; i < NCACHE; i++) { ! 793: if (++curcache >= NCACHE) ! 794: curcache = 0; ! 795: if (cache[curcache].c_bno == bno) { ! 796: copy(cache[curcache].c_block, buf, cnt); ! 797: cache[curcache].c_time = 0; ! 798: return; ! 799: } ! 800: else { ! 801: cache[curcache].c_time++; ! 802: if (cache[j].c_time < cache[curcache].c_time) ! 803: j = curcache; ! 804: } ! 805: } ! 806: ! 807: lseek(fi, bno*BSIZE, 0); ! 808: if (read(fi, cache[j].c_block, BSIZE) != BSIZE) { ! 809: #ifdef STANDALONE ! 810: printf("read error %D\n", bno); ! 811: #else ! 812: printf("read error %ld\n", bno); ! 813: #endif ! 814: exit(1); ! 815: } ! 816: copy(cache[j].c_block, buf, cnt); ! 817: cache[j].c_time = 0; ! 818: cache[j].c_bno = bno; ! 819: } ! 820: ! 821: /* ! 822: * the inode manpulation routines. Like the system. ! 823: * ! 824: * clri zeros the inode ! 825: */ ! 826: clri(ip) ! 827: struct dinode *ip; ! 828: { ! 829: int i, *p; ! 830: i = sizeof(struct dinode)/sizeof(int); ! 831: p = (int *)ip; ! 832: do ! 833: *p++ = 0; ! 834: while(--i); ! 835: } ! 836: ! 837: /* ! 838: * itrunc/tloop/bfree free all of the blocks pointed at by the inode ! 839: */ ! 840: itrunc(ip) ! 841: register struct dinode *ip; ! 842: { ! 843: register i; ! 844: daddr_t bn, iaddr[NADDR]; ! 845: ! 846: if (ip->di_mode == 0) ! 847: return; ! 848: i = ip->di_mode & IFMT; ! 849: if (i != IFDIR && i != IFREG) ! 850: return; ! 851: l3tol(iaddr, ip->di_addr, NADDR); ! 852: for(i=NADDR-1;i>=0;i--) { ! 853: bn = iaddr[i]; ! 854: if(bn == 0) continue; ! 855: switch(i) { ! 856: ! 857: default: ! 858: bfree(bn); ! 859: break; ! 860: ! 861: case NADDR-3: ! 862: tloop(bn, 0, 0); ! 863: break; ! 864: ! 865: case NADDR-2: ! 866: tloop(bn, 1, 0); ! 867: break; ! 868: ! 869: case NADDR-1: ! 870: tloop(bn, 1, 1); ! 871: } ! 872: } ! 873: ip->di_size = 0; ! 874: } ! 875: ! 876: tloop(bn, f1, f2) ! 877: daddr_t bn; ! 878: int f1, f2; ! 879: { ! 880: register i; ! 881: daddr_t nb; ! 882: union { ! 883: char data[BSIZE]; ! 884: daddr_t indir[NINDIR]; ! 885: } ibuf; ! 886: ! 887: dread(bn, ibuf.data, BSIZE); ! 888: for(i=NINDIR-1;i>=0;i--) { ! 889: nb = ibuf.indir[i]; ! 890: if(nb) { ! 891: if(f1) ! 892: tloop(nb, f2, 0); ! 893: else ! 894: bfree(nb); ! 895: } ! 896: } ! 897: bfree(bn); ! 898: } ! 899: ! 900: bfree(bn) ! 901: daddr_t bn; ! 902: { ! 903: register i; ! 904: union { ! 905: char data[BSIZE]; ! 906: struct fblk frees; ! 907: } fbuf; ! 908: ! 909: if(sblock.s_nfree >= NICFREE) { ! 910: fbuf.df_nfree = sblock.s_nfree; ! 911: for(i=0;i<NICFREE;i++) ! 912: fbuf.df_free[i] = sblock.s_free[i]; ! 913: sblock.s_nfree = 0; ! 914: dwrite(bn, fbuf.data); ! 915: } ! 916: sblock.s_free[sblock.s_nfree++] = bn; ! 917: } ! 918: ! 919: /* ! 920: * allocate a block off the free list. ! 921: */ ! 922: daddr_t ! 923: balloc() ! 924: { ! 925: daddr_t bno; ! 926: register i; ! 927: static char zeroes[BSIZE]; ! 928: union { ! 929: char data[BSIZE]; ! 930: struct fblk frees; ! 931: } fbuf; ! 932: ! 933: if(sblock.s_nfree == 0 || (bno=sblock.s_free[--sblock.s_nfree]) == 0) { ! 934: #ifdef STANDALONE ! 935: printf("Out of space\n"); ! 936: #else ! 937: fprintf(stderr, "Out of space.\n"); ! 938: #endif ! 939: exit(1); ! 940: } ! 941: if(sblock.s_nfree == 0) { ! 942: dread(bno, fbuf.data, BSIZE); ! 943: sblock.s_nfree = fbuf.df_nfree; ! 944: for(i=0;i<NICFREE;i++) ! 945: sblock.s_free[i] = fbuf.df_free[i]; ! 946: } ! 947: dwrite(bno, zeroes); ! 948: return(bno); ! 949: } ! 950: ! 951: /* ! 952: * map a block number into a block address, ensuring ! 953: * all of the correct indirect blocks are around. Allocate ! 954: * the block requested. ! 955: */ ! 956: daddr_t ! 957: bmap(iaddr, bn) ! 958: daddr_t iaddr[NADDR]; ! 959: daddr_t bn; ! 960: { ! 961: register i; ! 962: int j, sh; ! 963: daddr_t nb, nnb; ! 964: daddr_t indir[NINDIR]; ! 965: ! 966: /* ! 967: * blocks 0..NADDR-4 are direct blocks ! 968: */ ! 969: if(bn < NADDR-3) { ! 970: iaddr[bn] = nb = balloc(); ! 971: return(nb); ! 972: } ! 973: ! 974: /* ! 975: * addresses NADDR-3, NADDR-2, and NADDR-1 ! 976: * have single, double, triple indirect blocks. ! 977: * the first step is to determine ! 978: * how many levels of indirection. ! 979: */ ! 980: sh = 0; ! 981: nb = 1; ! 982: bn -= NADDR-3; ! 983: for(j=3; j>0; j--) { ! 984: sh += NSHIFT; ! 985: nb <<= NSHIFT; ! 986: if(bn < nb) ! 987: break; ! 988: bn -= nb; ! 989: } ! 990: if(j == 0) { ! 991: return((daddr_t)0); ! 992: } ! 993: ! 994: /* ! 995: * fetch the address from the inode ! 996: */ ! 997: if((nb = iaddr[NADDR-j]) == 0) { ! 998: iaddr[NADDR-j] = nb = balloc(); ! 999: } ! 1000: ! 1001: /* ! 1002: * fetch through the indirect blocks ! 1003: */ ! 1004: for(; j<=3; j++) { ! 1005: dread(nb, (char *)indir, BSIZE); ! 1006: sh -= NSHIFT; ! 1007: i = (bn>>sh) & NMASK; ! 1008: nnb = indir[i]; ! 1009: if(nnb == 0) { ! 1010: nnb = balloc(); ! 1011: indir[i] = nnb; ! 1012: dwrite(nb, (char *)indir); ! 1013: } ! 1014: nb = nnb; ! 1015: } ! 1016: return(nb); ! 1017: } ! 1018: ! 1019: /* ! 1020: * read the tape into buf, then return whether or ! 1021: * or not it is a header block. ! 1022: */ ! 1023: gethead(buf) ! 1024: struct spcl *buf; ! 1025: { ! 1026: readtape((char *)buf, 0); ! 1027: if (buf->c_magic != MAGIC || checksum((int *) buf) == 0) ! 1028: return(0); ! 1029: return(1); ! 1030: } ! 1031: ! 1032: /* ! 1033: * return whether or not the buffer contains a header block ! 1034: */ ! 1035: ishead(buf) ! 1036: struct spcl *buf; ! 1037: { ! 1038: if (buf->c_magic != MAGIC || checksum((int *) buf) == 0) ! 1039: return(0); ! 1040: return(1); ! 1041: } ! 1042: ! 1043: checktype(b, t) ! 1044: struct spcl *b; ! 1045: int t; ! 1046: { ! 1047: return(b->c_type == t); ! 1048: } ! 1049: ! 1050: ! 1051: checksum(b) ! 1052: int *b; ! 1053: { ! 1054: register i, j; ! 1055: ! 1056: j = OBSIZE/sizeof(int); ! 1057: i = 0; ! 1058: do ! 1059: i += *b++; ! 1060: while (--j); ! 1061: if (i != CHECKSUM) { ! 1062: printf("Checksum error %o\n", i); ! 1063: return(0); ! 1064: } ! 1065: return(1); ! 1066: } ! 1067: ! 1068: checkvol(b, t) ! 1069: struct spcl *b; ! 1070: int t; ! 1071: { ! 1072: if (b->c_volume == t) ! 1073: return(1); ! 1074: return(0); ! 1075: } ! 1076: ! 1077: readhdr(b) ! 1078: struct spcl *b; ! 1079: { ! 1080: if (gethead(b) == 0) ! 1081: return(0); ! 1082: if (checktype(b, TS_TAPE) == 0) ! 1083: return(0); ! 1084: return(1); ! 1085: } ! 1086: ! 1087: /* ! 1088: * The next routines are called during file extraction to ! 1089: * put the data into the right form and place. ! 1090: */ ! 1091: #ifndef STANDALONE ! 1092: xtrfile(b, size) ! 1093: char *b; ! 1094: long size; ! 1095: { ! 1096: write(ofile, b, (int) size); ! 1097: } ! 1098: ! 1099: null() {;} ! 1100: ! 1101: skip() ! 1102: { ! 1103: lseek(ofile, (long) OBSIZE, 1); ! 1104: } ! 1105: #endif ! 1106: ! 1107: ! 1108: rstrfile(b, s) ! 1109: char *b; ! 1110: long s; ! 1111: { ! 1112: daddr_t d; ! 1113: ! 1114: d = bmap(taddr, curbno); ! 1115: dwrite(d, b); ! 1116: curbno += 1; ! 1117: } ! 1118: ! 1119: rstrskip(b, s) ! 1120: char *b; ! 1121: long s; ! 1122: { ! 1123: curbno += 1; ! 1124: } ! 1125: ! 1126: #ifndef STANDALONE ! 1127: putdir(b) ! 1128: char *b; ! 1129: { ! 1130: register struct direct *dp; ! 1131: register i; ! 1132: ! 1133: for (dp = (struct direct *) b, i = 0; i < BSIZE; dp++, i += sizeof(*dp)) { ! 1134: if (dp->d_ino == 0) ! 1135: continue; ! 1136: putent((char *) dp); ! 1137: } ! 1138: } ! 1139: #endif ! 1140: ! 1141: /* ! 1142: * read/write an inode from the disk ! 1143: */ ! 1144: getdino(inum, b) ! 1145: ino_t inum; ! 1146: struct dinode *b; ! 1147: { ! 1148: daddr_t bno; ! 1149: char buf[BSIZE]; ! 1150: ! 1151: bno = (ino - 1)/INOPB; ! 1152: bno += 2; ! 1153: dread(bno, buf, BSIZE); ! 1154: copy(&buf[((inum-1)%INOPB)*sizeof(struct dinode)], (char *) b, sizeof(struct dinode)); ! 1155: } ! 1156: ! 1157: putdino(inum, b) ! 1158: ino_t inum; ! 1159: struct dinode *b; ! 1160: { ! 1161: daddr_t bno; ! 1162: char buf[BSIZE]; ! 1163: ! 1164: bno = ((ino - 1)/INOPB) + 2; ! 1165: dread(bno, buf, BSIZE); ! 1166: copy((char *) b, &buf[((inum-1)%INOPB)*sizeof(struct dinode)], sizeof(struct dinode)); ! 1167: dwrite(bno, buf); ! 1168: } ! 1169: ! 1170: /* ! 1171: * read a bit mask from the tape into m. ! 1172: */ ! 1173: readbits(m) ! 1174: short *m; ! 1175: { ! 1176: register i; ! 1177: ! 1178: i = spcl.c_count; ! 1179: ! 1180: while (i--) { ! 1181: readtape((char *) m, 0); ! 1182: m += (OBSIZE/(MLEN/BITS)); ! 1183: } ! 1184: while (gethead(&spcl) == 0) ! 1185: ; ! 1186: } ! 1187: ! 1188: done() ! 1189: { ! 1190: unlink(dirfile); ! 1191: exit(0); ! 1192: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.