![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tape.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / etc / restore|
Return to tape.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / etc / restore |
1.1 ! root 1: #ifndef lint ! 2: static char sccsid[] = "@(#)tape.c 3.21 (Berkeley) 83/08/11"; ! 3: #endif ! 4: ! 5: /* Copyright (c) 1983 Regents of the University of California */ ! 6: ! 7: #include "restore.h" ! 8: #include <dumprestor.h> ! 9: #include <sys/ioctl.h> ! 10: #include <sys/mtio.h> ! 11: #include <sys/file.h> ! 12: #include <setjmp.h> ! 13: #include <sys/stat.h> ! 14: ! 15: static long fssize = MAXBSIZE; ! 16: static int mt = -1; ! 17: static int pipein = 0; ! 18: static char *magtape; ! 19: static int bct = NTREC+1; ! 20: static char tbf[NTREC*TP_BSIZE]; ! 21: static union u_spcl endoftapemark; ! 22: static long blksread; ! 23: static long tapesread; ! 24: static jmp_buf restart; ! 25: static int gettingfile = 0; /* restart has a valid frame */ ! 26: ! 27: static int ofile; ! 28: static char *map; ! 29: static char lnkbuf[MAXPATHLEN + 1]; ! 30: static int pathlen; ! 31: ! 32: /* ! 33: * Set up an input source ! 34: */ ! 35: setinput(source) ! 36: char *source; ! 37: { ! 38: #ifdef RRESTORE ! 39: char *host; ! 40: #endif RRESTORE ! 41: ! 42: terminal = stdin; ! 43: #ifdef RRESTORE ! 44: host = source; ! 45: magtape = index(host, ':'); ! 46: if (magtape == 0) { ! 47: nohost: ! 48: msg("need keyletter ``f'' and device ``host:tape''\n"); ! 49: done(1); ! 50: } ! 51: *magtape++ = '\0'; ! 52: if (rmthost(host) == 0) ! 53: done(1); ! 54: setuid(getuid()); /* no longer need or want root privileges */ ! 55: #else ! 56: if (strcmp(source, "-") == 0) { ! 57: /* ! 58: * Since input is coming from a pipe we must establish ! 59: * our own connection to the terminal. ! 60: */ ! 61: terminal = fopen("/dev/tty", "r"); ! 62: if (terminal == NULL) { ! 63: perror("open(\"/dev/tty\")"); ! 64: done(1); ! 65: } ! 66: pipein++; ! 67: } ! 68: magtape = source; ! 69: #endif RRESTORE ! 70: } ! 71: ! 72: /* ! 73: * Verify that the tape drive can be accessed and ! 74: * that it actually is a dump tape. ! 75: */ ! 76: setup() ! 77: { ! 78: int i, j, *ip; ! 79: struct stat stbuf; ! 80: extern char *ctime(); ! 81: extern int xtrmap(), xtrmapskip(); ! 82: ! 83: vprintf(stdout, "Verify tape and initialize maps\n"); ! 84: #ifdef RRESTORE ! 85: if ((mt = rmtopen(magtape, 0)) < 0) ! 86: #else ! 87: if (pipein) ! 88: mt = 0; ! 89: else if ((mt = open(magtape, 0)) < 0) ! 90: #endif ! 91: { ! 92: perror(magtape); ! 93: done(1); ! 94: } ! 95: volno = 1; ! 96: setdumpnum(); ! 97: flsht(); ! 98: if (gethead(&spcl) == FAIL) { ! 99: bct--; /* push back this block */ ! 100: cvtflag++; ! 101: if (gethead(&spcl) == FAIL) { ! 102: fprintf(stderr, "Tape is not a dump tape\n"); ! 103: done(1); ! 104: } ! 105: fprintf(stderr, "Converting to new file system format.\n"); ! 106: } ! 107: if (pipein) { ! 108: endoftapemark.s_spcl.c_magic = cvtflag ? OFS_MAGIC : NFS_MAGIC; ! 109: endoftapemark.s_spcl.c_type = TS_END; ! 110: ip = (int *)&endoftapemark; ! 111: j = sizeof(union u_spcl) / sizeof(int); ! 112: i = 0; ! 113: do ! 114: i += *ip++; ! 115: while (--j); ! 116: endoftapemark.s_spcl.c_checksum = CHECKSUM - i; ! 117: } ! 118: if (vflag || command == 't' || command == 'T') { ! 119: fprintf(stdout, "Dump date: %s", ctime(&spcl.c_date)); ! 120: if (spcl.c_ddate == 0) ! 121: fprintf(stdout, "Dumped from: the epoch\n"); ! 122: else ! 123: fprintf(stdout, "Dumped from: %s", ctime(&spcl.c_ddate)); ! 124: } ! 125: if (command == 'T') ! 126: return; ! 127: dumptime = spcl.c_ddate; ! 128: dumpdate = spcl.c_date; ! 129: if (stat(".", &stbuf) < 0) { ! 130: perror("cannot stat ."); ! 131: done(1); ! 132: } ! 133: fssize = stbuf.st_blksize; ! 134: if (fssize <= 0 || ((fssize - 1) & fssize) != 0) { ! 135: fprintf(stderr, "bad block size %d\n", fssize); ! 136: done(1); ! 137: } ! 138: if (checkvol(&spcl, (long)1) == FAIL) { ! 139: fprintf(stderr, "Tape is not volume 1 of the dump\n"); ! 140: done(1); ! 141: } ! 142: if (readhdr(&spcl) == FAIL) ! 143: panic("no header after volume mark!\n"); ! 144: findinode(&spcl, 1); ! 145: if (checktype(&spcl, TS_CLRI) == FAIL) { ! 146: fprintf(stderr, "Cannot find file removal list\n"); ! 147: done(1); ! 148: } ! 149: maxino = (spcl.c_count * TP_BSIZE * NBBY) + 1; ! 150: dprintf(stdout, "maxino = %d\n", maxino); ! 151: map = calloc((unsigned)1, (unsigned)howmany(maxino, NBBY)); ! 152: if (map == (char *)NIL) ! 153: panic("no memory for file removal list\n"); ! 154: clrimap = map; ! 155: curfile.action = USING; ! 156: getfile(xtrmap, xtrmapskip); ! 157: if (checktype(&spcl, TS_BITS) == FAIL) { ! 158: fprintf(stderr, "Cannot find file dump list\n"); ! 159: done(1); ! 160: } ! 161: map = calloc((unsigned)1, (unsigned)howmany(maxino, NBBY)); ! 162: if (map == (char *)NULL) ! 163: panic("no memory for file dump list\n"); ! 164: dumpmap = map; ! 165: curfile.action = USING; ! 166: getfile(xtrmap, xtrmapskip); ! 167: } ! 168: ! 169: /* ! 170: * Prompt user to load a new dump volume. ! 171: * "Nextvol" is the next suggested volume to use. ! 172: * This suggested volume is enforced when doing full ! 173: * or incremental restores, but can be overrridden by ! 174: * the user when only extracting a subset of the files. ! 175: */ ! 176: getvol(nextvol) ! 177: long nextvol; ! 178: { ! 179: long newvol; ! 180: long savecnt, i; ! 181: union u_spcl tmpspcl; ! 182: # define tmpbuf tmpspcl.s_spcl ! 183: ! 184: if (nextvol == 1) ! 185: tapesread = 0; ! 186: if (pipein) { ! 187: if (nextvol != 1) ! 188: panic("Changing volumes on pipe input?\n"); ! 189: if (volno == 1) ! 190: return; ! 191: goto gethdr; ! 192: } ! 193: savecnt = blksread; ! 194: again: ! 195: if (pipein) ! 196: done(1); /* pipes do not get a second chance */ ! 197: if (command == 'R' || command == 'r' || curfile.action != SKIP) ! 198: newvol = nextvol; ! 199: else ! 200: newvol = 0; ! 201: while (newvol <= 0) { ! 202: if (tapesread == 0) { ! 203: fprintf(stderr, "%s%s%s%s%s", ! 204: "You have not read any tapes yet.\n", ! 205: "Unless you know which volume your", ! 206: " file(s) are on you should start\n", ! 207: "with the last volume and work", ! 208: " towards towards the first.\n"); ! 209: } else { ! 210: fprintf(stderr, "You have read volumes"); ! 211: strcpy(tbf, ": "); ! 212: for (i = 1; i < 32; i++) ! 213: if (tapesread & (1 << i)) { ! 214: fprintf(stderr, "%s%d", tbf, i); ! 215: strcpy(tbf, ", "); ! 216: } ! 217: fprintf(stderr, "\n"); ! 218: } ! 219: do { ! 220: fprintf(stderr, "Specify next volume #: "); ! 221: (void) fflush(stderr); ! 222: (void) fgets(tbf, BUFSIZ, terminal); ! 223: } while (!feof(terminal) && tbf[0] == '\n'); ! 224: if (feof(terminal)) ! 225: done(1); ! 226: newvol = atoi(tbf); ! 227: if (newvol <= 0) { ! 228: fprintf(stderr, ! 229: "Volume numbers are positive numerics\n"); ! 230: } ! 231: } ! 232: if (newvol == volno) { ! 233: tapesread |= 1 << volno; ! 234: return; ! 235: } ! 236: closemt(); ! 237: fprintf(stderr, "Mount tape volume %d then type return ", newvol); ! 238: (void) fflush(stderr); ! 239: while (getc(terminal) != '\n') ! 240: ; ! 241: #ifdef RRESTORE ! 242: if ((mt = rmtopen(magtape, 0)) == -1) ! 243: #else ! 244: if ((mt = open(magtape, 0)) == -1) ! 245: #endif ! 246: { ! 247: fprintf(stderr, "Cannot open tape!\n"); ! 248: goto again; ! 249: } ! 250: gethdr: ! 251: volno = newvol; ! 252: setdumpnum(); ! 253: flsht(); ! 254: if (readhdr(&tmpbuf) == FAIL) { ! 255: fprintf(stderr, "tape is not dump tape\n"); ! 256: volno = 0; ! 257: goto again; ! 258: } ! 259: if (checkvol(&tmpbuf, volno) == FAIL) { ! 260: fprintf(stderr, "Wrong volume (%d)\n", tmpbuf.c_volume); ! 261: volno = 0; ! 262: goto again; ! 263: } ! 264: if (tmpbuf.c_date != dumpdate || tmpbuf.c_ddate != dumptime) { ! 265: fprintf(stderr, "Wrong dump date\n\tgot: %s", ! 266: ctime(&tmpbuf.c_date)); ! 267: fprintf(stderr, "\twanted: %s", ctime(&dumpdate)); ! 268: volno = 0; ! 269: goto again; ! 270: } ! 271: tapesread |= 1 << volno; ! 272: blksread = savecnt; ! 273: if (curfile.action == USING) { ! 274: if (volno == 1) ! 275: panic("active file into volume 1\n"); ! 276: return; ! 277: } ! 278: (void) gethead(&spcl); ! 279: findinode(&spcl, curfile.action == UNKNOWN ? 1 : 0); ! 280: if (gettingfile) { ! 281: gettingfile = 0; ! 282: longjmp(restart, 1); ! 283: } ! 284: } ! 285: ! 286: /* ! 287: * handle multiple dumps per tape by skipping forward to the ! 288: * appropriate one. ! 289: */ ! 290: setdumpnum() ! 291: { ! 292: struct mtop tcom; ! 293: ! 294: if (dumpnum == 1 || volno != 1) ! 295: return; ! 296: if (pipein) { ! 297: fprintf(stderr, "Cannot have multiple dumps on pipe input\n"); ! 298: done(1); ! 299: } ! 300: tcom.mt_op = MTFSF; ! 301: tcom.mt_count = dumpnum - 1; ! 302: #ifdef RRESTORE ! 303: rmtioctl(MTFSF, dumpnum - 1); ! 304: #else ! 305: if (ioctl(mt, (int)MTIOCTOP, (char *)&tcom) < 0) ! 306: perror("ioctl MTFSF"); ! 307: #endif ! 308: } ! 309: ! 310: extractfile(name) ! 311: char *name; ! 312: { ! 313: int mode; ! 314: time_t timep[2]; ! 315: struct entry *ep; ! 316: extern int xtrlnkfile(), xtrlnkskip(); ! 317: extern int xtrfile(), xtrskip(); ! 318: ! 319: curfile.name = name; ! 320: curfile.action = USING; ! 321: timep[0] = curfile.dip->di_atime; ! 322: timep[1] = curfile.dip->di_mtime; ! 323: mode = curfile.dip->di_mode; ! 324: switch (mode & IFMT) { ! 325: ! 326: default: ! 327: fprintf(stderr, "%s: unknown file mode 0%o\n", name, mode); ! 328: skipfile(); ! 329: return (FAIL); ! 330: ! 331: case IFDIR: ! 332: if (mflag) { ! 333: ep = lookupname(name); ! 334: if (ep == NIL || ep->e_flags & EXTRACT) ! 335: panic("unextracted directory %s\n", name); ! 336: skipfile(); ! 337: return (GOOD); ! 338: } ! 339: vprintf(stdout, "extract file %s\n", name); ! 340: return (genliteraldir(name, curfile.ino)); ! 341: ! 342: case IFLNK: ! 343: lnkbuf[0] = '\0'; ! 344: pathlen = 0; ! 345: getfile(xtrlnkfile, xtrlnkskip); ! 346: if (pathlen == 0) { ! 347: vprintf(stdout, ! 348: "%s: zero length symbolic link (ignored)\n", name); ! 349: } else if (symlink(lnkbuf, name) < 0) { ! 350: fprintf(stderr, "%s: ", name); ! 351: (void) fflush(stderr); ! 352: perror("cannot create symbolic link"); ! 353: return (FAIL); ! 354: } else ! 355: vprintf(stdout, "extract symbolic link %s\n", name); ! 356: return (GOOD); ! 357: ! 358: case IFCHR: ! 359: case IFBLK: ! 360: vprintf(stdout, "extract special file %s\n", name); ! 361: if (mknod(name, mode, (int)curfile.dip->di_rdev) < 0) { ! 362: fprintf(stderr, "%s: ", name); ! 363: (void) fflush(stderr); ! 364: perror("cannot create special file"); ! 365: skipfile(); ! 366: return (FAIL); ! 367: } ! 368: (void) chown(name, curfile.dip->di_uid, curfile.dip->di_gid); ! 369: (void) chmod(name, mode); ! 370: skipfile(); ! 371: utime(name, timep); ! 372: return (GOOD); ! 373: ! 374: case IFREG: ! 375: vprintf(stdout, "extract file %s\n", name); ! 376: if ((ofile = creat(name, 0666)) < 0) { ! 377: fprintf(stderr, "%s: ", name); ! 378: (void) fflush(stderr); ! 379: perror("cannot create file"); ! 380: skipfile(); ! 381: return (FAIL); ! 382: } ! 383: (void) fchown(ofile, curfile.dip->di_uid, curfile.dip->di_gid); ! 384: (void) fchmod(ofile, mode); ! 385: getfile(xtrfile, xtrskip); ! 386: (void) close(ofile); ! 387: utime(name, timep); ! 388: return (GOOD); ! 389: } ! 390: /* NOTREACHED */ ! 391: } ! 392: ! 393: /* ! 394: * skip over bit maps on the tape ! 395: */ ! 396: skipmaps() ! 397: { ! 398: ! 399: while (checktype(&spcl, TS_CLRI) == GOOD || ! 400: checktype(&spcl, TS_BITS) == GOOD) ! 401: skipfile(); ! 402: } ! 403: ! 404: /* ! 405: * skip over a file on the tape ! 406: */ ! 407: skipfile() ! 408: { ! 409: extern int null(); ! 410: ! 411: curfile.action = SKIP; ! 412: getfile(null, null); ! 413: } ! 414: ! 415: /* ! 416: * Do the file extraction, calling the supplied functions ! 417: * with the blocks ! 418: */ ! 419: getfile(f1, f2) ! 420: int (*f2)(), (*f1)(); ! 421: { ! 422: register int i; ! 423: int curblk = 0; ! 424: off_t size = spcl.c_dinode.di_size; ! 425: static char clearedbuf[MAXBSIZE]; ! 426: char buf[MAXBSIZE / TP_BSIZE][TP_BSIZE]; ! 427: ! 428: if (checktype(&spcl, TS_END) == GOOD) ! 429: panic("ran off end of tape\n"); ! 430: if (ishead(&spcl) == FAIL) ! 431: panic("not at beginning of a file\n"); ! 432: if (!gettingfile && setjmp(restart) != 0) ! 433: return; ! 434: gettingfile++; ! 435: loop: ! 436: for (i = 0; i < spcl.c_count; i++) { ! 437: if (spcl.c_addr[i]) { ! 438: readtape(&buf[curblk++][0]); ! 439: if (curblk == fssize / TP_BSIZE) { ! 440: (*f1)(buf, size > TP_BSIZE ? ! 441: (long) (fssize) : ! 442: (curblk - 1) * TP_BSIZE + size); ! 443: curblk = 0; ! 444: } ! 445: } else { ! 446: if (curblk > 0) { ! 447: (*f1)(buf, size > TP_BSIZE ? ! 448: (long) (curblk * TP_BSIZE) : ! 449: (curblk - 1) * TP_BSIZE + size); ! 450: curblk = 0; ! 451: } ! 452: (*f2)(clearedbuf, size > TP_BSIZE ? ! 453: (long) TP_BSIZE : size); ! 454: } ! 455: if ((size -= TP_BSIZE) <= 0) ! 456: break; ! 457: } ! 458: if (readhdr(&spcl) == GOOD && size > 0) { ! 459: if (checktype(&spcl, TS_ADDR) == GOOD) ! 460: goto loop; ! 461: dprintf(stdout, "Missing address (header) block for %s\n", ! 462: curfile.name); ! 463: } ! 464: if (curblk > 0) ! 465: (*f1)(buf, (curblk * TP_BSIZE) + size); ! 466: findinode(&spcl, 1); ! 467: gettingfile = 0; ! 468: } ! 469: ! 470: /* ! 471: * The next routines are called during file extraction to ! 472: * put the data into the right form and place. ! 473: */ ! 474: xtrfile(buf, size) ! 475: char *buf; ! 476: long size; ! 477: { ! 478: ! 479: if (write(ofile, buf, (int) size) == -1) { ! 480: fprintf(stderr, "write error extracting inode %d, name %s\n", ! 481: curfile.ino, curfile.name); ! 482: perror("write"); ! 483: done(1); ! 484: } ! 485: } ! 486: ! 487: xtrskip(buf, size) ! 488: char *buf; ! 489: long size; ! 490: { ! 491: ! 492: #ifdef lint ! 493: buf = buf; ! 494: #endif ! 495: if (lseek(ofile, size, 1) == (long)-1) { ! 496: fprintf(stderr, "seek error extracting inode %d, name %s\n", ! 497: curfile.ino, curfile.name); ! 498: perror("lseek"); ! 499: done(1); ! 500: } ! 501: } ! 502: ! 503: xtrlnkfile(buf, size) ! 504: char *buf; ! 505: long size; ! 506: { ! 507: ! 508: pathlen += size; ! 509: if (pathlen > MAXPATHLEN) { ! 510: fprintf(stderr, "symbolic link name: %s->%s%s; too long %d\n", ! 511: curfile.name, lnkbuf, buf, pathlen); ! 512: done(1); ! 513: } ! 514: (void) strcat(lnkbuf, buf); ! 515: } ! 516: ! 517: xtrlnkskip(buf, size) ! 518: char *buf; ! 519: long size; ! 520: { ! 521: ! 522: #ifdef lint ! 523: buf = buf, size = size; ! 524: #endif ! 525: fprintf(stderr, "unallocated block in symbolic link %s\n", ! 526: curfile.name); ! 527: done(1); ! 528: } ! 529: ! 530: xtrmap(buf, size) ! 531: char *buf; ! 532: long size; ! 533: { ! 534: ! 535: bcopy(buf, map, size); ! 536: map += size; ! 537: } ! 538: ! 539: xtrmapskip(buf, size) ! 540: char *buf; ! 541: long size; ! 542: { ! 543: ! 544: #ifdef lint ! 545: buf = buf; ! 546: #endif ! 547: panic("hole in map\n"); ! 548: map += size; ! 549: } ! 550: ! 551: null() {;} ! 552: ! 553: /* ! 554: * Do the tape i/o, dealing with volume changes ! 555: * etc.. ! 556: */ ! 557: readtape(b) ! 558: char *b; ! 559: { ! 560: register long i; ! 561: long rd, newvol; ! 562: int cnt; ! 563: ! 564: if (bct >= NTREC) { ! 565: for (i = 0; i < NTREC; i++) ! 566: ((struct s_spcl *)&tbf[i*TP_BSIZE])->c_magic = 0; ! 567: bct = 0; ! 568: cnt = NTREC*TP_BSIZE; ! 569: rd = 0; ! 570: getmore: ! 571: #ifdef RRESTORE ! 572: i = rmtread(&tbf[rd], cnt); ! 573: #else ! 574: i = read(mt, &tbf[rd], cnt); ! 575: #endif ! 576: if (i > 0 && i != NTREC*TP_BSIZE) { ! 577: if (!pipein) ! 578: panic("partial block read: %d should be %d\n", ! 579: i, NTREC*TP_BSIZE); ! 580: rd += i; ! 581: cnt -= i; ! 582: if (cnt > 0) ! 583: goto getmore; ! 584: i = rd; ! 585: } ! 586: if (i < 0) { ! 587: fprintf(stderr, "Tape read error while "); ! 588: switch (curfile.action) { ! 589: default: ! 590: fprintf(stderr, "trying to set up tape\n"); ! 591: break; ! 592: case UNKNOWN: ! 593: fprintf(stderr, "trying to resyncronize\n"); ! 594: break; ! 595: case USING: ! 596: fprintf(stderr, "restoring %s\n", curfile.name); ! 597: break; ! 598: case SKIP: ! 599: fprintf(stderr, "skipping over inode %d\n", ! 600: curfile.ino); ! 601: break; ! 602: } ! 603: if (!yflag && !reply("continue")) ! 604: done(1); ! 605: i = NTREC*TP_BSIZE; ! 606: bzero(tbf, i); ! 607: #ifdef RRESTORE ! 608: if (rmtseek(i, 1) < 0) ! 609: #else ! 610: if (lseek(mt, i, 1) == (long)-1) ! 611: #endif ! 612: { ! 613: perror("continuation failed"); ! 614: done(1); ! 615: } ! 616: } ! 617: if (i == 0) { ! 618: if (pipein) { ! 619: bcopy((char *)&endoftapemark, b, ! 620: (long)TP_BSIZE); ! 621: flsht(); ! 622: return; ! 623: } ! 624: newvol = volno + 1; ! 625: volno = 0; ! 626: getvol(newvol); ! 627: readtape(b); ! 628: return; ! 629: } ! 630: } ! 631: bcopy(&tbf[(bct++*TP_BSIZE)], b, (long)TP_BSIZE); ! 632: blksread++; ! 633: } ! 634: ! 635: flsht() ! 636: { ! 637: ! 638: bct = NTREC+1; ! 639: } ! 640: ! 641: closemt() ! 642: { ! 643: if (mt < 0) ! 644: return; ! 645: #ifdef RRESTORE ! 646: rmtclose(); ! 647: #else ! 648: (void) close(mt); ! 649: #endif ! 650: } ! 651: ! 652: checkvol(b, t) ! 653: struct s_spcl *b; ! 654: long t; ! 655: { ! 656: ! 657: if (b->c_volume != t) ! 658: return(FAIL); ! 659: return(GOOD); ! 660: } ! 661: ! 662: readhdr(b) ! 663: struct s_spcl *b; ! 664: { ! 665: ! 666: if (gethead(b) == FAIL) { ! 667: dprintf(stdout, "readhdr fails at %d blocks\n", blksread); ! 668: return(FAIL); ! 669: } ! 670: return(GOOD); ! 671: } ! 672: ! 673: /* ! 674: * read the tape into buf, then return whether or ! 675: * or not it is a header block. ! 676: */ ! 677: gethead(buf) ! 678: struct s_spcl *buf; ! 679: { ! 680: long i; ! 681: union u_ospcl { ! 682: char dummy[TP_BSIZE]; ! 683: struct s_ospcl { ! 684: long c_type; ! 685: long c_date; ! 686: long c_ddate; ! 687: long c_volume; ! 688: long c_tapea; ! 689: u_short c_inumber; ! 690: long c_magic; ! 691: long c_checksum; ! 692: struct odinode { ! 693: unsigned short odi_mode; ! 694: u_short odi_nlink; ! 695: u_short odi_uid; ! 696: u_short odi_gid; ! 697: long odi_size; ! 698: long odi_rdev; ! 699: char odi_addr[36]; ! 700: long odi_atime; ! 701: long odi_mtime; ! 702: long odi_ctime; ! 703: } c_dinode; ! 704: long c_count; ! 705: char c_addr[256]; ! 706: } s_ospcl; ! 707: } u_ospcl; ! 708: ! 709: if (!cvtflag) { ! 710: readtape((char *)buf); ! 711: if (buf->c_magic != NFS_MAGIC || checksum((int *)buf) == FAIL) ! 712: return(FAIL); ! 713: goto good; ! 714: } ! 715: readtape((char *)(&u_ospcl.s_ospcl)); ! 716: bzero((char *)buf, (long)TP_BSIZE); ! 717: buf->c_type = u_ospcl.s_ospcl.c_type; ! 718: buf->c_date = u_ospcl.s_ospcl.c_date; ! 719: buf->c_ddate = u_ospcl.s_ospcl.c_ddate; ! 720: buf->c_volume = u_ospcl.s_ospcl.c_volume; ! 721: buf->c_tapea = u_ospcl.s_ospcl.c_tapea; ! 722: buf->c_inumber = u_ospcl.s_ospcl.c_inumber; ! 723: buf->c_checksum = u_ospcl.s_ospcl.c_checksum; ! 724: buf->c_magic = u_ospcl.s_ospcl.c_magic; ! 725: buf->c_dinode.di_mode = u_ospcl.s_ospcl.c_dinode.odi_mode; ! 726: buf->c_dinode.di_nlink = u_ospcl.s_ospcl.c_dinode.odi_nlink; ! 727: buf->c_dinode.di_uid = u_ospcl.s_ospcl.c_dinode.odi_uid; ! 728: buf->c_dinode.di_gid = u_ospcl.s_ospcl.c_dinode.odi_gid; ! 729: buf->c_dinode.di_size = u_ospcl.s_ospcl.c_dinode.odi_size; ! 730: buf->c_dinode.di_rdev = u_ospcl.s_ospcl.c_dinode.odi_rdev; ! 731: buf->c_dinode.di_atime = u_ospcl.s_ospcl.c_dinode.odi_atime; ! 732: buf->c_dinode.di_mtime = u_ospcl.s_ospcl.c_dinode.odi_mtime; ! 733: buf->c_dinode.di_ctime = u_ospcl.s_ospcl.c_dinode.odi_ctime; ! 734: buf->c_count = u_ospcl.s_ospcl.c_count; ! 735: bcopy(u_ospcl.s_ospcl.c_addr, buf->c_addr, (long)256); ! 736: if (u_ospcl.s_ospcl.c_magic != OFS_MAGIC || ! 737: checksum((int *)(&u_ospcl.s_ospcl)) == FAIL) ! 738: return(FAIL); ! 739: buf->c_magic = NFS_MAGIC; ! 740: ! 741: good: ! 742: switch (buf->c_type) { ! 743: ! 744: case TS_CLRI: ! 745: case TS_BITS: ! 746: /* ! 747: * Have to patch up missing information in bit map headers ! 748: */ ! 749: buf->c_inumber = 0; ! 750: buf->c_dinode.di_size = buf->c_count * TP_BSIZE; ! 751: for (i = 0; i < buf->c_count; i++) ! 752: buf->c_addr[i]++; ! 753: break; ! 754: ! 755: case TS_TAPE: ! 756: case TS_END: ! 757: buf->c_inumber = 0; ! 758: break; ! 759: ! 760: case TS_INODE: ! 761: case TS_ADDR: ! 762: break; ! 763: ! 764: default: ! 765: panic("gethead: unknown inode type %d\n", buf->c_type); ! 766: break; ! 767: } ! 768: if (dflag) ! 769: accthdr(buf); ! 770: return(GOOD); ! 771: } ! 772: ! 773: /* ! 774: * Check that a header is where it belongs and predict the next header ! 775: */ ! 776: accthdr(header) ! 777: struct s_spcl *header; ! 778: { ! 779: static ino_t previno = 0x7fffffff; ! 780: static int prevtype; ! 781: static long predict; ! 782: long blks, i; ! 783: ! 784: if (header->c_type == TS_TAPE) { ! 785: fprintf(stderr, "Volume header\n"); ! 786: return; ! 787: } ! 788: if (previno == 0x7fffffff) ! 789: goto newcalc; ! 790: switch (prevtype) { ! 791: case TS_BITS: ! 792: fprintf(stderr, "Dump mask header"); ! 793: break; ! 794: case TS_CLRI: ! 795: fprintf(stderr, "Remove mask header"); ! 796: break; ! 797: case TS_INODE: ! 798: fprintf(stderr, "File header, ino %d", previno); ! 799: break; ! 800: case TS_ADDR: ! 801: fprintf(stderr, "File continuation header, ino %d", previno); ! 802: break; ! 803: case TS_END: ! 804: fprintf(stderr, "End of tape header"); ! 805: break; ! 806: } ! 807: if (predict != blksread - 1) ! 808: fprintf(stderr, "; predicted %d blocks, got %d blocks", ! 809: predict, blksread - 1); ! 810: fprintf(stderr, "\n"); ! 811: newcalc: ! 812: blks = 0; ! 813: if (header->c_type != TS_END) ! 814: for (i = 0; i < header->c_count; i++) ! 815: if (header->c_addr[i] != 0) ! 816: blks++; ! 817: predict = blks; ! 818: blksread = 0; ! 819: prevtype = header->c_type; ! 820: previno = header->c_inumber; ! 821: } ! 822: ! 823: /* ! 824: * Find an inode header. ! 825: * Complain if had to skip, and complain is set. ! 826: */ ! 827: findinode(header, complain) ! 828: struct s_spcl *header; ! 829: int complain; ! 830: { ! 831: static long skipcnt = 0; ! 832: ! 833: curfile.name = "<name unknown>"; ! 834: curfile.action = UNKNOWN; ! 835: curfile.dip = (struct dinode *)NIL; ! 836: curfile.ino = 0; ! 837: if (ishead(header) == FAIL) { ! 838: skipcnt++; ! 839: while (gethead(header) == FAIL) ! 840: skipcnt++; ! 841: } ! 842: for (;;) { ! 843: if (checktype(header, TS_INODE) == GOOD) { ! 844: curfile.dip = &header->c_dinode; ! 845: curfile.ino = header->c_inumber; ! 846: break; ! 847: } ! 848: if (checktype(header, TS_END) == GOOD) { ! 849: curfile.ino = maxino; ! 850: break; ! 851: } ! 852: if (checktype(header, TS_CLRI) == GOOD) { ! 853: curfile.name = "<file removal list>"; ! 854: break; ! 855: } ! 856: if (checktype(header, TS_BITS) == GOOD) { ! 857: curfile.name = "<file dump list>"; ! 858: break; ! 859: } ! 860: while (gethead(header) == FAIL) ! 861: skipcnt++; ! 862: } ! 863: if (skipcnt > 0 && complain) ! 864: fprintf(stderr, "resync restore, skipped %d blocks\n", skipcnt); ! 865: skipcnt = 0; ! 866: } ! 867: ! 868: /* ! 869: * return whether or not the buffer contains a header block ! 870: */ ! 871: ishead(buf) ! 872: struct s_spcl *buf; ! 873: { ! 874: ! 875: if (buf->c_magic != NFS_MAGIC) ! 876: return(FAIL); ! 877: return(GOOD); ! 878: } ! 879: ! 880: checktype(b, t) ! 881: struct s_spcl *b; ! 882: int t; ! 883: { ! 884: ! 885: if (b->c_type != t) ! 886: return(FAIL); ! 887: return(GOOD); ! 888: } ! 889: ! 890: checksum(b) ! 891: register int *b; ! 892: { ! 893: register int i, j; ! 894: ! 895: j = sizeof(union u_spcl) / sizeof(int); ! 896: i = 0; ! 897: do ! 898: i += *b++; ! 899: while (--j); ! 900: if (i != CHECKSUM) { ! 901: fprintf(stderr, "Checksum error %o, inode %d file %s\n", i, ! 902: curfile.ino, curfile.name); ! 903: return(FAIL); ! 904: } ! 905: return(GOOD); ! 906: } ! 907: ! 908: #ifdef RRESTORE ! 909: /* VARARGS1 */ ! 910: msg(cp, a1, a2, a3) ! 911: char *cp; ! 912: { ! 913: ! 914: fprintf(stderr, cp, a1, a2, a3); ! 915: } ! 916: #endif RRESTORE
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.