![[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 [CSRG BSD Unix] / 43BSDReno / sbin / restore|
Return to tape.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sbin / restore |
1.1 ! root 1: /* ! 2: * Copyright (c) 1983 The Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution and use in source and binary forms are permitted ! 6: * provided that: (1) source distributions retain this entire copyright ! 7: * notice and comment, and (2) distributions including binaries display ! 8: * the following acknowledgement: ``This product includes software ! 9: * developed by the University of California, Berkeley and its contributors'' ! 10: * in the documentation or other materials provided with the distribution ! 11: * and in all advertising materials mentioning features or use of this ! 12: * software. Neither the name of the University nor the names of its ! 13: * contributors may be used to endorse or promote products derived ! 14: * from this software without specific prior written permission. ! 15: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR ! 16: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED ! 17: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 18: */ ! 19: ! 20: #ifndef lint ! 21: static char sccsid[] = "@(#)tape.c 5.19 (Berkeley) 6/1/90"; ! 22: #endif /* not lint */ ! 23: ! 24: #include "restore.h" ! 25: #include <protocols/dumprestore.h> ! 26: #include <sys/ioctl.h> ! 27: #include <sys/mtio.h> ! 28: #include <sys/file.h> ! 29: #include <setjmp.h> ! 30: #include <sys/stat.h> ! 31: #include "pathnames.h" ! 32: ! 33: static long fssize = MAXBSIZE; ! 34: static int mt = -1; ! 35: static int pipein = 0; ! 36: static char magtape[BUFSIZ]; ! 37: static int bct; ! 38: static char *tbf; ! 39: static union u_spcl endoftapemark; ! 40: static long blksread; ! 41: static long tapesread; ! 42: static jmp_buf restart; ! 43: static int gettingfile = 0; /* restart has a valid frame */ ! 44: ! 45: static int ofile; ! 46: static char *map; ! 47: static char lnkbuf[MAXPATHLEN + 1]; ! 48: static int pathlen; ! 49: ! 50: int Bcvt; /* Swap Bytes (for CCI or sun) */ ! 51: static int Qcvt; /* Swap quads (for sun) */ ! 52: /* ! 53: * Set up an input source ! 54: */ ! 55: setinput(source) ! 56: char *source; ! 57: { ! 58: extern int errno; ! 59: #ifdef RRESTORE ! 60: char *host, *tape; ! 61: #endif RRESTORE ! 62: char *strerror(); ! 63: ! 64: flsht(); ! 65: if (bflag) ! 66: newtapebuf(ntrec); ! 67: else ! 68: newtapebuf(NTREC > HIGHDENSITYTREC ? NTREC : HIGHDENSITYTREC); ! 69: terminal = stdin; ! 70: #ifdef RRESTORE ! 71: host = source; ! 72: tape = index(host, ':'); ! 73: if (tape == 0) { ! 74: nohost: ! 75: msg("need keyletter ``f'' and device ``host:tape''\n"); ! 76: done(1); ! 77: } ! 78: *tape++ = '\0'; ! 79: (void) strcpy(magtape, tape); ! 80: if (rmthost(host) == 0) ! 81: done(1); ! 82: setuid(getuid()); /* no longer need or want root privileges */ ! 83: #else ! 84: if (strcmp(source, "-") == 0) { ! 85: /* ! 86: * Since input is coming from a pipe we must establish ! 87: * our own connection to the terminal. ! 88: */ ! 89: terminal = fopen(_PATH_TTY, "r"); ! 90: if (terminal == NULL) { ! 91: (void)fprintf(stderr, "Cannot open %s: %s\n", ! 92: _PATH_TTY, strerror(errno)); ! 93: terminal = fopen(_PATH_DEVNULL, "r"); ! 94: if (terminal == NULL) { ! 95: (void)fprintf(stderr, "Cannot open %s: %s\n", ! 96: _PATH_DEVNULL, strerror(errno)); ! 97: done(1); ! 98: } ! 99: } ! 100: pipein++; ! 101: } ! 102: (void) strcpy(magtape, source); ! 103: #endif RRESTORE ! 104: } ! 105: ! 106: newtapebuf(size) ! 107: long size; ! 108: { ! 109: static tbfsize = -1; ! 110: ! 111: ntrec = size; ! 112: if (size <= tbfsize) ! 113: return; ! 114: if (tbf != NULL) ! 115: free(tbf); ! 116: tbf = (char *)malloc(size * TP_BSIZE); ! 117: if (tbf == NULL) { ! 118: fprintf(stderr, "Cannot allocate space for tape buffer\n"); ! 119: done(1); ! 120: } ! 121: tbfsize = size; ! 122: } ! 123: ! 124: /* ! 125: * Verify that the tape drive can be accessed and ! 126: * that it actually is a dump tape. ! 127: */ ! 128: setup() ! 129: { ! 130: int i, j, *ip; ! 131: struct stat stbuf; ! 132: extern int xtrmap(), xtrmapskip(); ! 133: ! 134: vprintf(stdout, "Verify tape and initialize maps\n"); ! 135: #ifdef RRESTORE ! 136: if ((mt = rmtopen(magtape, 0)) < 0) ! 137: #else ! 138: if (pipein) ! 139: mt = 0; ! 140: else if ((mt = open(magtape, 0)) < 0) ! 141: #endif ! 142: { ! 143: perror(magtape); ! 144: done(1); ! 145: } ! 146: volno = 1; ! 147: setdumpnum(); ! 148: flsht(); ! 149: if (!pipein && !bflag) ! 150: findtapeblksize(); ! 151: if (gethead(&spcl) == FAIL) { ! 152: bct--; /* push back this block */ ! 153: cvtflag++; ! 154: if (gethead(&spcl) == FAIL) { ! 155: fprintf(stderr, "Tape is not a dump tape\n"); ! 156: done(1); ! 157: } ! 158: fprintf(stderr, "Converting to new file system format.\n"); ! 159: } ! 160: if (pipein) { ! 161: endoftapemark.s_spcl.c_magic = cvtflag ? OFS_MAGIC : NFS_MAGIC; ! 162: endoftapemark.s_spcl.c_type = TS_END; ! 163: ip = (int *)&endoftapemark; ! 164: j = sizeof(union u_spcl) / sizeof(int); ! 165: i = 0; ! 166: do ! 167: i += *ip++; ! 168: while (--j); ! 169: endoftapemark.s_spcl.c_checksum = CHECKSUM - i; ! 170: } ! 171: if (vflag || command == 't') ! 172: printdumpinfo(); ! 173: dumptime = spcl.c_ddate; ! 174: dumpdate = spcl.c_date; ! 175: if (stat(".", &stbuf) < 0) { ! 176: perror("cannot stat ."); ! 177: done(1); ! 178: } ! 179: if (stbuf.st_blksize > 0 && stbuf.st_blksize <= MAXBSIZE) ! 180: fssize = stbuf.st_blksize; ! 181: if (((fssize - 1) & fssize) != 0) { ! 182: fprintf(stderr, "bad block size %d\n", fssize); ! 183: done(1); ! 184: } ! 185: if (checkvol(&spcl, (long)1) == FAIL) { ! 186: fprintf(stderr, "Tape is not volume 1 of the dump\n"); ! 187: done(1); ! 188: } ! 189: if (readhdr(&spcl) == FAIL) ! 190: panic("no header after volume mark!\n"); ! 191: findinode(&spcl); ! 192: if (checktype(&spcl, TS_CLRI) == FAIL) { ! 193: fprintf(stderr, "Cannot find file removal list\n"); ! 194: done(1); ! 195: } ! 196: maxino = (spcl.c_count * TP_BSIZE * NBBY) + 1; ! 197: dprintf(stdout, "maxino = %d\n", maxino); ! 198: map = calloc((unsigned)1, (unsigned)howmany(maxino, NBBY)); ! 199: if (map == (char *)NIL) ! 200: panic("no memory for file removal list\n"); ! 201: clrimap = map; ! 202: curfile.action = USING; ! 203: getfile(xtrmap, xtrmapskip); ! 204: if (checktype(&spcl, TS_BITS) == FAIL) { ! 205: fprintf(stderr, "Cannot find file dump list\n"); ! 206: done(1); ! 207: } ! 208: map = calloc((unsigned)1, (unsigned)howmany(maxino, NBBY)); ! 209: if (map == (char *)NULL) ! 210: panic("no memory for file dump list\n"); ! 211: dumpmap = map; ! 212: curfile.action = USING; ! 213: getfile(xtrmap, xtrmapskip); ! 214: } ! 215: ! 216: /* ! 217: * Prompt user to load a new dump volume. ! 218: * "Nextvol" is the next suggested volume to use. ! 219: * This suggested volume is enforced when doing full ! 220: * or incremental restores, but can be overrridden by ! 221: * the user when only extracting a subset of the files. ! 222: */ ! 223: getvol(nextvol) ! 224: long nextvol; ! 225: { ! 226: long newvol; ! 227: long savecnt, i; ! 228: union u_spcl tmpspcl; ! 229: # define tmpbuf tmpspcl.s_spcl ! 230: char buf[TP_BSIZE]; ! 231: extern char *ctime(); ! 232: ! 233: if (nextvol == 1) { ! 234: tapesread = 0; ! 235: gettingfile = 0; ! 236: } ! 237: if (pipein) { ! 238: if (nextvol != 1) ! 239: panic("Changing volumes on pipe input?\n"); ! 240: if (volno == 1) ! 241: return; ! 242: goto gethdr; ! 243: } ! 244: savecnt = blksread; ! 245: again: ! 246: if (pipein) ! 247: done(1); /* pipes do not get a second chance */ ! 248: if (command == 'R' || command == 'r' || curfile.action != SKIP) ! 249: newvol = nextvol; ! 250: else ! 251: newvol = 0; ! 252: while (newvol <= 0) { ! 253: if (tapesread == 0) { ! 254: fprintf(stderr, "%s%s%s%s%s", ! 255: "You have not read any tapes yet.\n", ! 256: "Unless you know which volume your", ! 257: " file(s) are on you should start\n", ! 258: "with the last volume and work", ! 259: " towards towards the first.\n"); ! 260: } else { ! 261: fprintf(stderr, "You have read volumes"); ! 262: strcpy(tbf, ": "); ! 263: for (i = 1; i < 32; i++) ! 264: if (tapesread & (1 << i)) { ! 265: fprintf(stderr, "%s%d", tbf, i); ! 266: strcpy(tbf, ", "); ! 267: } ! 268: fprintf(stderr, "\n"); ! 269: } ! 270: do { ! 271: fprintf(stderr, "Specify next volume #: "); ! 272: (void) fflush(stderr); ! 273: (void) fgets(tbf, BUFSIZ, terminal); ! 274: } while (!feof(terminal) && tbf[0] == '\n'); ! 275: if (feof(terminal)) ! 276: done(1); ! 277: newvol = atoi(tbf); ! 278: if (newvol <= 0) { ! 279: fprintf(stderr, ! 280: "Volume numbers are positive numerics\n"); ! 281: } ! 282: } ! 283: if (newvol == volno) { ! 284: tapesread |= 1 << volno; ! 285: return; ! 286: } ! 287: closemt(); ! 288: fprintf(stderr, "Mount tape volume %d\n", newvol); ! 289: fprintf(stderr, "Enter ``none'' if there are no more tapes\n"); ! 290: fprintf(stderr, "otherwise enter tape name (default: %s) ", magtape); ! 291: (void) fflush(stderr); ! 292: (void) fgets(tbf, BUFSIZ, terminal); ! 293: if (feof(terminal)) ! 294: done(1); ! 295: if (!strcmp(tbf, "none\n")) { ! 296: curfile.name = "<name unknown>"; ! 297: curfile.action = UNKNOWN; ! 298: curfile.dip = (struct dinode *)NIL; ! 299: curfile.ino = maxino; ! 300: if (gettingfile) { ! 301: gettingfile = 0; ! 302: longjmp(restart, 1); ! 303: } ! 304: } ! 305: if (tbf[0] != '\n') { ! 306: (void) strcpy(magtape, tbf); ! 307: magtape[strlen(magtape) - 1] = '\0'; ! 308: } ! 309: #ifdef RRESTORE ! 310: if ((mt = rmtopen(magtape, 0)) == -1) ! 311: #else ! 312: if ((mt = open(magtape, 0)) == -1) ! 313: #endif ! 314: { ! 315: fprintf(stderr, "Cannot open %s\n", magtape); ! 316: volno = -1; ! 317: goto again; ! 318: } ! 319: gethdr: ! 320: volno = newvol; ! 321: setdumpnum(); ! 322: flsht(); ! 323: if (readhdr(&tmpbuf) == FAIL) { ! 324: fprintf(stderr, "tape is not dump tape\n"); ! 325: volno = 0; ! 326: goto again; ! 327: } ! 328: if (checkvol(&tmpbuf, volno) == FAIL) { ! 329: fprintf(stderr, "Wrong volume (%d)\n", tmpbuf.c_volume); ! 330: volno = 0; ! 331: goto again; ! 332: } ! 333: if (tmpbuf.c_date != dumpdate || tmpbuf.c_ddate != dumptime) { ! 334: fprintf(stderr, "Wrong dump date\n\tgot: %s", ! 335: ctime(&tmpbuf.c_date)); ! 336: fprintf(stderr, "\twanted: %s", ctime(&dumpdate)); ! 337: volno = 0; ! 338: goto again; ! 339: } ! 340: tapesread |= 1 << volno; ! 341: blksread = savecnt; ! 342: if (curfile.action == USING) { ! 343: if (volno == 1) ! 344: panic("active file into volume 1\n"); ! 345: return; ! 346: } ! 347: /* ! 348: * Skip up to the beginning of the next record ! 349: */ ! 350: if (tmpbuf.c_type == TS_TAPE && (tmpbuf.c_flags & DR_NEWHEADER)) ! 351: for (i = tmpbuf.c_count; i > 0; i--) ! 352: readtape(buf); ! 353: (void) gethead(&spcl); ! 354: findinode(&spcl); ! 355: if (gettingfile) { ! 356: gettingfile = 0; ! 357: longjmp(restart, 1); ! 358: } ! 359: } ! 360: ! 361: /* ! 362: * handle multiple dumps per tape by skipping forward to the ! 363: * appropriate one. ! 364: */ ! 365: setdumpnum() ! 366: { ! 367: struct mtop tcom; ! 368: ! 369: if (dumpnum == 1 || volno != 1) ! 370: return; ! 371: if (pipein) { ! 372: fprintf(stderr, "Cannot have multiple dumps on pipe input\n"); ! 373: done(1); ! 374: } ! 375: tcom.mt_op = MTFSF; ! 376: tcom.mt_count = dumpnum - 1; ! 377: #ifdef RRESTORE ! 378: rmtioctl(MTFSF, dumpnum - 1); ! 379: #else ! 380: if (ioctl(mt, (int)MTIOCTOP, (char *)&tcom) < 0) ! 381: perror("ioctl MTFSF"); ! 382: #endif ! 383: } ! 384: ! 385: printdumpinfo() ! 386: { ! 387: extern char *ctime(); ! 388: ! 389: fprintf(stdout, "Dump date: %s", ctime(&spcl.c_date)); ! 390: fprintf(stdout, "Dumped from: %s", ! 391: (spcl.c_ddate == 0) ? "the epoch\n" : ctime(&spcl.c_ddate)); ! 392: if (spcl.c_host[0] == '\0') ! 393: return; ! 394: fprintf(stderr, "Level %d dump of %s on %s:%s\n", ! 395: spcl.c_level, spcl.c_filesys, spcl.c_host, spcl.c_dev); ! 396: fprintf(stderr, "Label: %s\n", spcl.c_label); ! 397: } ! 398: ! 399: extractfile(name) ! 400: char *name; ! 401: { ! 402: int mode; ! 403: struct timeval timep[2]; ! 404: struct entry *ep; ! 405: extern int xtrlnkfile(), xtrlnkskip(); ! 406: extern int xtrfile(), xtrskip(); ! 407: ! 408: curfile.name = name; ! 409: curfile.action = USING; ! 410: timep[0].tv_sec = curfile.dip->di_atime; ! 411: timep[0].tv_usec = 0; ! 412: timep[1].tv_sec = curfile.dip->di_mtime; ! 413: timep[1].tv_usec = 0; ! 414: mode = curfile.dip->di_mode; ! 415: switch (mode & IFMT) { ! 416: ! 417: default: ! 418: fprintf(stderr, "%s: unknown file mode 0%o\n", name, mode); ! 419: skipfile(); ! 420: return (FAIL); ! 421: ! 422: case IFSOCK: ! 423: vprintf(stdout, "skipped socket %s\n", name); ! 424: skipfile(); ! 425: return (GOOD); ! 426: ! 427: case IFDIR: ! 428: if (mflag) { ! 429: ep = lookupname(name); ! 430: if (ep == NIL || ep->e_flags & EXTRACT) ! 431: panic("unextracted directory %s\n", name); ! 432: skipfile(); ! 433: return (GOOD); ! 434: } ! 435: vprintf(stdout, "extract file %s\n", name); ! 436: return (genliteraldir(name, curfile.ino)); ! 437: ! 438: case IFLNK: ! 439: lnkbuf[0] = '\0'; ! 440: pathlen = 0; ! 441: getfile(xtrlnkfile, xtrlnkskip); ! 442: if (pathlen == 0) { ! 443: vprintf(stdout, ! 444: "%s: zero length symbolic link (ignored)\n", name); ! 445: return (GOOD); ! 446: } ! 447: return (linkit(lnkbuf, name, SYMLINK)); ! 448: ! 449: case IFCHR: ! 450: case IFBLK: ! 451: vprintf(stdout, "extract special file %s\n", name); ! 452: if (Nflag) { ! 453: skipfile(); ! 454: return (GOOD); ! 455: } ! 456: if (mknod(name, mode, (int)curfile.dip->di_rdev) < 0) { ! 457: fprintf(stderr, "%s: ", name); ! 458: (void) fflush(stderr); ! 459: perror("cannot create special file"); ! 460: skipfile(); ! 461: return (FAIL); ! 462: } ! 463: (void) chown(name, curfile.dip->di_uid, curfile.dip->di_gid); ! 464: (void) chmod(name, mode); ! 465: skipfile(); ! 466: utimes(name, timep); ! 467: return (GOOD); ! 468: ! 469: case IFREG: ! 470: vprintf(stdout, "extract file %s\n", name); ! 471: if (Nflag) { ! 472: skipfile(); ! 473: return (GOOD); ! 474: } ! 475: if ((ofile = creat(name, 0666)) < 0) { ! 476: fprintf(stderr, "%s: ", name); ! 477: (void) fflush(stderr); ! 478: perror("cannot create file"); ! 479: skipfile(); ! 480: return (FAIL); ! 481: } ! 482: (void) fchown(ofile, curfile.dip->di_uid, curfile.dip->di_gid); ! 483: (void) fchmod(ofile, mode); ! 484: getfile(xtrfile, xtrskip); ! 485: (void) close(ofile); ! 486: utimes(name, timep); ! 487: return (GOOD); ! 488: } ! 489: /* NOTREACHED */ ! 490: } ! 491: ! 492: /* ! 493: * skip over bit maps on the tape ! 494: */ ! 495: skipmaps() ! 496: { ! 497: ! 498: while (checktype(&spcl, TS_CLRI) == GOOD || ! 499: checktype(&spcl, TS_BITS) == GOOD) ! 500: skipfile(); ! 501: } ! 502: ! 503: /* ! 504: * skip over a file on the tape ! 505: */ ! 506: skipfile() ! 507: { ! 508: extern int null(); ! 509: ! 510: curfile.action = SKIP; ! 511: getfile(null, null); ! 512: } ! 513: ! 514: /* ! 515: * Do the file extraction, calling the supplied functions ! 516: * with the blocks ! 517: */ ! 518: getfile(f1, f2) ! 519: int (*f2)(), (*f1)(); ! 520: { ! 521: register int i; ! 522: int curblk = 0; ! 523: off_t size = spcl.c_dinode.di_size; ! 524: static char clearedbuf[MAXBSIZE]; ! 525: char buf[MAXBSIZE / TP_BSIZE][TP_BSIZE]; ! 526: char junk[TP_BSIZE]; ! 527: ! 528: if (checktype(&spcl, TS_END) == GOOD) ! 529: panic("ran off end of tape\n"); ! 530: if (ishead(&spcl) == FAIL) ! 531: panic("not at beginning of a file\n"); ! 532: if (!gettingfile && setjmp(restart) != 0) ! 533: return; ! 534: gettingfile++; ! 535: loop: ! 536: for (i = 0; i < spcl.c_count; i++) { ! 537: if (spcl.c_addr[i]) { ! 538: readtape(&buf[curblk++][0]); ! 539: if (curblk == fssize / TP_BSIZE) { ! 540: (*f1)(buf, size > TP_BSIZE ? ! 541: (long) (fssize) : ! 542: (curblk - 1) * TP_BSIZE + size); ! 543: curblk = 0; ! 544: } ! 545: } else { ! 546: if (curblk > 0) { ! 547: (*f1)(buf, size > TP_BSIZE ? ! 548: (long) (curblk * TP_BSIZE) : ! 549: (curblk - 1) * TP_BSIZE + size); ! 550: curblk = 0; ! 551: } ! 552: (*f2)(clearedbuf, size > TP_BSIZE ? ! 553: (long) TP_BSIZE : size); ! 554: } ! 555: if ((size -= TP_BSIZE) <= 0) { ! 556: for (i++; i < spcl.c_count; i++) ! 557: if (spcl.c_addr[i]) ! 558: readtape(junk); ! 559: break; ! 560: } ! 561: } ! 562: if (readhdr(&spcl) == GOOD && size > 0) { ! 563: if (checktype(&spcl, TS_ADDR) == GOOD) ! 564: goto loop; ! 565: dprintf(stdout, "Missing address (header) block for %s\n", ! 566: curfile.name); ! 567: } ! 568: if (curblk > 0) ! 569: (*f1)(buf, (curblk * TP_BSIZE) + size); ! 570: findinode(&spcl); ! 571: gettingfile = 0; ! 572: } ! 573: ! 574: /* ! 575: * The next routines are called during file extraction to ! 576: * put the data into the right form and place. ! 577: */ ! 578: xtrfile(buf, size) ! 579: char *buf; ! 580: long size; ! 581: { ! 582: ! 583: if (Nflag) ! 584: return; ! 585: if (write(ofile, buf, (int) size) == -1) { ! 586: fprintf(stderr, "write error extracting inode %d, name %s\n", ! 587: curfile.ino, curfile.name); ! 588: perror("write"); ! 589: done(1); ! 590: } ! 591: } ! 592: ! 593: xtrskip(buf, size) ! 594: char *buf; ! 595: long size; ! 596: { ! 597: ! 598: #ifdef lint ! 599: buf = buf; ! 600: #endif ! 601: if (lseek(ofile, size, 1) == (long)-1) { ! 602: fprintf(stderr, "seek error extracting inode %d, name %s\n", ! 603: curfile.ino, curfile.name); ! 604: perror("lseek"); ! 605: done(1); ! 606: } ! 607: } ! 608: ! 609: xtrlnkfile(buf, size) ! 610: char *buf; ! 611: long size; ! 612: { ! 613: ! 614: pathlen += size; ! 615: if (pathlen > MAXPATHLEN) { ! 616: fprintf(stderr, "symbolic link name: %s->%s%s; too long %d\n", ! 617: curfile.name, lnkbuf, buf, pathlen); ! 618: done(1); ! 619: } ! 620: (void) strcat(lnkbuf, buf); ! 621: } ! 622: ! 623: xtrlnkskip(buf, size) ! 624: char *buf; ! 625: long size; ! 626: { ! 627: ! 628: #ifdef lint ! 629: buf = buf, size = size; ! 630: #endif ! 631: fprintf(stderr, "unallocated block in symbolic link %s\n", ! 632: curfile.name); ! 633: done(1); ! 634: } ! 635: ! 636: xtrmap(buf, size) ! 637: char *buf; ! 638: long size; ! 639: { ! 640: ! 641: bcopy(buf, map, size); ! 642: map += size; ! 643: } ! 644: ! 645: xtrmapskip(buf, size) ! 646: char *buf; ! 647: long size; ! 648: { ! 649: ! 650: #ifdef lint ! 651: buf = buf; ! 652: #endif ! 653: panic("hole in map\n"); ! 654: map += size; ! 655: } ! 656: ! 657: null() {;} ! 658: ! 659: /* ! 660: * Do the tape i/o, dealing with volume changes ! 661: * etc.. ! 662: */ ! 663: readtape(b) ! 664: char *b; ! 665: { ! 666: register long i; ! 667: long rd, newvol; ! 668: int cnt; ! 669: ! 670: if (bct < ntrec) { ! 671: bcopy(&tbf[(bct++*TP_BSIZE)], b, (long)TP_BSIZE); ! 672: blksread++; ! 673: return; ! 674: } ! 675: for (i = 0; i < ntrec; i++) ! 676: ((struct s_spcl *)&tbf[i*TP_BSIZE])->c_magic = 0; ! 677: bct = 0; ! 678: cnt = ntrec*TP_BSIZE; ! 679: rd = 0; ! 680: getmore: ! 681: #ifdef RRESTORE ! 682: i = rmtread(&tbf[rd], cnt); ! 683: #else ! 684: i = read(mt, &tbf[rd], cnt); ! 685: #endif ! 686: if (i > 0 && i != ntrec*TP_BSIZE) { ! 687: if (pipein) { ! 688: rd += i; ! 689: cnt -= i; ! 690: if (cnt > 0) ! 691: goto getmore; ! 692: i = rd; ! 693: } else { ! 694: if (i % TP_BSIZE != 0) ! 695: panic("partial block read: %d should be %d\n", ! 696: i, ntrec * TP_BSIZE); ! 697: bcopy((char *)&endoftapemark, &tbf[i], ! 698: (long)TP_BSIZE); ! 699: } ! 700: } ! 701: if (i < 0) { ! 702: fprintf(stderr, "Tape read error while "); ! 703: switch (curfile.action) { ! 704: default: ! 705: fprintf(stderr, "trying to set up tape\n"); ! 706: break; ! 707: case UNKNOWN: ! 708: fprintf(stderr, "trying to resynchronize\n"); ! 709: break; ! 710: case USING: ! 711: fprintf(stderr, "restoring %s\n", curfile.name); ! 712: break; ! 713: case SKIP: ! 714: fprintf(stderr, "skipping over inode %d\n", ! 715: curfile.ino); ! 716: break; ! 717: } ! 718: if (!yflag && !reply("continue")) ! 719: done(1); ! 720: i = ntrec*TP_BSIZE; ! 721: bzero(tbf, i); ! 722: #ifdef RRESTORE ! 723: if (rmtseek(i, 1) < 0) ! 724: #else ! 725: if (lseek(mt, i, 1) == (long)-1) ! 726: #endif ! 727: { ! 728: perror("continuation failed"); ! 729: done(1); ! 730: } ! 731: } ! 732: if (i == 0) { ! 733: if (!pipein) { ! 734: newvol = volno + 1; ! 735: volno = 0; ! 736: getvol(newvol); ! 737: readtape(b); ! 738: return; ! 739: } ! 740: if (rd % TP_BSIZE != 0) ! 741: panic("partial block read: %d should be %d\n", ! 742: rd, ntrec * TP_BSIZE); ! 743: bcopy((char *)&endoftapemark, &tbf[rd], (long)TP_BSIZE); ! 744: } ! 745: bcopy(&tbf[(bct++*TP_BSIZE)], b, (long)TP_BSIZE); ! 746: blksread++; ! 747: } ! 748: ! 749: findtapeblksize() ! 750: { ! 751: register long i; ! 752: ! 753: for (i = 0; i < ntrec; i++) ! 754: ((struct s_spcl *)&tbf[i * TP_BSIZE])->c_magic = 0; ! 755: bct = 0; ! 756: #ifdef RRESTORE ! 757: i = rmtread(tbf, ntrec * TP_BSIZE); ! 758: #else ! 759: i = read(mt, tbf, ntrec * TP_BSIZE); ! 760: #endif ! 761: if (i <= 0) { ! 762: perror("Tape read error"); ! 763: done(1); ! 764: } ! 765: if (i % TP_BSIZE != 0) { ! 766: fprintf(stderr, "Tape block size (%d) %s (%d)\n", ! 767: i, "is not a multiple of dump block size", TP_BSIZE); ! 768: done(1); ! 769: } ! 770: ntrec = i / TP_BSIZE; ! 771: vprintf(stdout, "Tape block size is %d\n", ntrec); ! 772: } ! 773: ! 774: flsht() ! 775: { ! 776: ! 777: bct = ntrec+1; ! 778: } ! 779: ! 780: closemt() ! 781: { ! 782: if (mt < 0) ! 783: return; ! 784: #ifdef RRESTORE ! 785: rmtclose(); ! 786: #else ! 787: (void) close(mt); ! 788: #endif ! 789: } ! 790: ! 791: checkvol(b, t) ! 792: struct s_spcl *b; ! 793: long t; ! 794: { ! 795: ! 796: if (b->c_volume != t) ! 797: return(FAIL); ! 798: return(GOOD); ! 799: } ! 800: ! 801: readhdr(b) ! 802: struct s_spcl *b; ! 803: { ! 804: ! 805: if (gethead(b) == FAIL) { ! 806: dprintf(stdout, "readhdr fails at %d blocks\n", blksread); ! 807: return(FAIL); ! 808: } ! 809: return(GOOD); ! 810: } ! 811: ! 812: /* ! 813: * read the tape into buf, then return whether or ! 814: * or not it is a header block. ! 815: */ ! 816: gethead(buf) ! 817: struct s_spcl *buf; ! 818: { ! 819: long i; ! 820: u_long *j; ! 821: union u_ospcl { ! 822: char dummy[TP_BSIZE]; ! 823: struct s_ospcl { ! 824: long c_type; ! 825: long c_date; ! 826: long c_ddate; ! 827: long c_volume; ! 828: long c_tapea; ! 829: u_short c_inumber; ! 830: long c_magic; ! 831: long c_checksum; ! 832: struct odinode { ! 833: unsigned short odi_mode; ! 834: u_short odi_nlink; ! 835: u_short odi_uid; ! 836: u_short odi_gid; ! 837: long odi_size; ! 838: long odi_rdev; ! 839: char odi_addr[36]; ! 840: long odi_atime; ! 841: long odi_mtime; ! 842: long odi_ctime; ! 843: } c_dinode; ! 844: long c_count; ! 845: char c_addr[256]; ! 846: } s_ospcl; ! 847: } u_ospcl; ! 848: ! 849: if (!cvtflag) { ! 850: readtape((char *)buf); ! 851: if (buf->c_magic != NFS_MAGIC) { ! 852: if (swabl(buf->c_magic) != NFS_MAGIC) ! 853: return (FAIL); ! 854: if (!Bcvt) { ! 855: vprintf(stdout, "Note: Doing Byte swapping\n"); ! 856: Bcvt = 1; ! 857: } ! 858: } ! 859: if (checksum((int *)buf) == FAIL) ! 860: return (FAIL); ! 861: if (Bcvt) ! 862: swabst("8l4s31l", (char *)buf); ! 863: goto good; ! 864: } ! 865: readtape((char *)(&u_ospcl.s_ospcl)); ! 866: bzero((char *)buf, (long)TP_BSIZE); ! 867: buf->c_type = u_ospcl.s_ospcl.c_type; ! 868: buf->c_date = u_ospcl.s_ospcl.c_date; ! 869: buf->c_ddate = u_ospcl.s_ospcl.c_ddate; ! 870: buf->c_volume = u_ospcl.s_ospcl.c_volume; ! 871: buf->c_tapea = u_ospcl.s_ospcl.c_tapea; ! 872: buf->c_inumber = u_ospcl.s_ospcl.c_inumber; ! 873: buf->c_checksum = u_ospcl.s_ospcl.c_checksum; ! 874: buf->c_magic = u_ospcl.s_ospcl.c_magic; ! 875: buf->c_dinode.di_mode = u_ospcl.s_ospcl.c_dinode.odi_mode; ! 876: buf->c_dinode.di_nlink = u_ospcl.s_ospcl.c_dinode.odi_nlink; ! 877: buf->c_dinode.di_uid = u_ospcl.s_ospcl.c_dinode.odi_uid; ! 878: buf->c_dinode.di_gid = u_ospcl.s_ospcl.c_dinode.odi_gid; ! 879: buf->c_dinode.di_size = u_ospcl.s_ospcl.c_dinode.odi_size; ! 880: buf->c_dinode.di_rdev = u_ospcl.s_ospcl.c_dinode.odi_rdev; ! 881: buf->c_dinode.di_atime = u_ospcl.s_ospcl.c_dinode.odi_atime; ! 882: buf->c_dinode.di_mtime = u_ospcl.s_ospcl.c_dinode.odi_mtime; ! 883: buf->c_dinode.di_ctime = u_ospcl.s_ospcl.c_dinode.odi_ctime; ! 884: buf->c_count = u_ospcl.s_ospcl.c_count; ! 885: bcopy(u_ospcl.s_ospcl.c_addr, buf->c_addr, (long)256); ! 886: if (u_ospcl.s_ospcl.c_magic != OFS_MAGIC || ! 887: checksum((int *)(&u_ospcl.s_ospcl)) == FAIL) ! 888: return(FAIL); ! 889: buf->c_magic = NFS_MAGIC; ! 890: ! 891: good: ! 892: j = buf->c_dinode.di_qsize.val; ! 893: i = j[1]; ! 894: if (buf->c_dinode.di_size == 0 && ! 895: (buf->c_dinode.di_mode & IFMT) == IFDIR && Qcvt==0) { ! 896: if (*j || i) { ! 897: printf("Note: Doing Quad swapping\n"); ! 898: Qcvt = 1; ! 899: } ! 900: } ! 901: if (Qcvt) { ! 902: j[1] = *j; *j = i; ! 903: } ! 904: switch (buf->c_type) { ! 905: ! 906: case TS_CLRI: ! 907: case TS_BITS: ! 908: /* ! 909: * Have to patch up missing information in bit map headers ! 910: */ ! 911: buf->c_inumber = 0; ! 912: buf->c_dinode.di_size = buf->c_count * TP_BSIZE; ! 913: for (i = 0; i < buf->c_count; i++) ! 914: buf->c_addr[i]++; ! 915: break; ! 916: ! 917: case TS_TAPE: ! 918: case TS_END: ! 919: buf->c_inumber = 0; ! 920: break; ! 921: ! 922: case TS_INODE: ! 923: case TS_ADDR: ! 924: break; ! 925: ! 926: default: ! 927: panic("gethead: unknown inode type %d\n", buf->c_type); ! 928: break; ! 929: } ! 930: if (dflag) ! 931: accthdr(buf); ! 932: return(GOOD); ! 933: } ! 934: ! 935: /* ! 936: * Check that a header is where it belongs and predict the next header ! 937: */ ! 938: accthdr(header) ! 939: struct s_spcl *header; ! 940: { ! 941: static ino_t previno = 0x7fffffff; ! 942: static int prevtype; ! 943: static long predict; ! 944: long blks, i; ! 945: ! 946: if (header->c_type == TS_TAPE) { ! 947: fprintf(stderr, "Volume header\n"); ! 948: previno = 0x7fffffff; ! 949: return; ! 950: } ! 951: if (previno == 0x7fffffff) ! 952: goto newcalc; ! 953: switch (prevtype) { ! 954: case TS_BITS: ! 955: fprintf(stderr, "Dump mask header"); ! 956: break; ! 957: case TS_CLRI: ! 958: fprintf(stderr, "Remove mask header"); ! 959: break; ! 960: case TS_INODE: ! 961: fprintf(stderr, "File header, ino %d", previno); ! 962: break; ! 963: case TS_ADDR: ! 964: fprintf(stderr, "File continuation header, ino %d", previno); ! 965: break; ! 966: case TS_END: ! 967: fprintf(stderr, "End of tape header"); ! 968: break; ! 969: } ! 970: if (predict != blksread - 1) ! 971: fprintf(stderr, "; predicted %d blocks, got %d blocks", ! 972: predict, blksread - 1); ! 973: fprintf(stderr, "\n"); ! 974: newcalc: ! 975: blks = 0; ! 976: if (header->c_type != TS_END) ! 977: for (i = 0; i < header->c_count; i++) ! 978: if (header->c_addr[i] != 0) ! 979: blks++; ! 980: predict = blks; ! 981: blksread = 0; ! 982: prevtype = header->c_type; ! 983: previno = header->c_inumber; ! 984: } ! 985: ! 986: /* ! 987: * Find an inode header. ! 988: * Complain if had to skip, and complain is set. ! 989: */ ! 990: findinode(header) ! 991: struct s_spcl *header; ! 992: { ! 993: static long skipcnt = 0; ! 994: long i; ! 995: char buf[TP_BSIZE]; ! 996: ! 997: curfile.name = "<name unknown>"; ! 998: curfile.action = UNKNOWN; ! 999: curfile.dip = (struct dinode *)NIL; ! 1000: curfile.ino = 0; ! 1001: if (ishead(header) == FAIL) { ! 1002: skipcnt++; ! 1003: while (gethead(header) == FAIL || header->c_date != dumpdate) ! 1004: skipcnt++; ! 1005: } ! 1006: for (;;) { ! 1007: if (checktype(header, TS_ADDR) == GOOD) { ! 1008: /* ! 1009: * Skip up to the beginning of the next record ! 1010: */ ! 1011: for (i = 0; i < header->c_count; i++) ! 1012: if (header->c_addr[i]) ! 1013: readtape(buf); ! 1014: (void) gethead(header); ! 1015: continue; ! 1016: } ! 1017: if (checktype(header, TS_INODE) == GOOD) { ! 1018: curfile.dip = &header->c_dinode; ! 1019: curfile.ino = header->c_inumber; ! 1020: break; ! 1021: } ! 1022: if (checktype(header, TS_END) == GOOD) { ! 1023: curfile.ino = maxino; ! 1024: break; ! 1025: } ! 1026: if (checktype(header, TS_CLRI) == GOOD) { ! 1027: curfile.name = "<file removal list>"; ! 1028: break; ! 1029: } ! 1030: if (checktype(header, TS_BITS) == GOOD) { ! 1031: curfile.name = "<file dump list>"; ! 1032: break; ! 1033: } ! 1034: while (gethead(header) == FAIL) ! 1035: skipcnt++; ! 1036: } ! 1037: if (skipcnt > 0) ! 1038: fprintf(stderr, "resync restore, skipped %d blocks\n", skipcnt); ! 1039: skipcnt = 0; ! 1040: } ! 1041: ! 1042: /* ! 1043: * return whether or not the buffer contains a header block ! 1044: */ ! 1045: ishead(buf) ! 1046: struct s_spcl *buf; ! 1047: { ! 1048: ! 1049: if (buf->c_magic != NFS_MAGIC) ! 1050: return(FAIL); ! 1051: return(GOOD); ! 1052: } ! 1053: ! 1054: checktype(b, t) ! 1055: struct s_spcl *b; ! 1056: int t; ! 1057: { ! 1058: ! 1059: if (b->c_type != t) ! 1060: return(FAIL); ! 1061: return(GOOD); ! 1062: } ! 1063: ! 1064: checksum(b) ! 1065: register int *b; ! 1066: { ! 1067: register int i, j; ! 1068: ! 1069: j = sizeof(union u_spcl) / sizeof(int); ! 1070: i = 0; ! 1071: if(!Bcvt) { ! 1072: do ! 1073: i += *b++; ! 1074: while (--j); ! 1075: } else { ! 1076: /* What happens if we want to read restore tapes ! 1077: for a 16bit int machine??? */ ! 1078: do ! 1079: i += swabl(*b++); ! 1080: while (--j); ! 1081: } ! 1082: ! 1083: if (i != CHECKSUM) { ! 1084: fprintf(stderr, "Checksum error %o, inode %d file %s\n", i, ! 1085: curfile.ino, curfile.name); ! 1086: return(FAIL); ! 1087: } ! 1088: return(GOOD); ! 1089: } ! 1090: ! 1091: #ifdef RRESTORE ! 1092: /* VARARGS1 */ ! 1093: msg(cp, a1, a2, a3) ! 1094: char *cp; ! 1095: { ! 1096: ! 1097: fprintf(stderr, cp, a1, a2, a3); ! 1098: } ! 1099: #endif RRESTORE ! 1100: ! 1101: swabst(cp, sp) ! 1102: register char *cp, *sp; ! 1103: { ! 1104: int n = 0; ! 1105: char c; ! 1106: while(*cp) { ! 1107: switch (*cp) { ! 1108: case '0': case '1': case '2': case '3': case '4': ! 1109: case '5': case '6': case '7': case '8': case '9': ! 1110: n = (n * 10) + (*cp++ - '0'); ! 1111: continue; ! 1112: ! 1113: case 's': case 'w': case 'h': ! 1114: c = sp[0]; sp[0] = sp[1]; sp[1] = c; ! 1115: sp++; ! 1116: break; ! 1117: ! 1118: case 'l': ! 1119: c = sp[0]; sp[0] = sp[3]; sp[3] = c; ! 1120: c = sp[2]; sp[2] = sp[1]; sp[1] = c; ! 1121: sp += 3; ! 1122: } ! 1123: sp++; /* Any other character, like 'b' counts as byte. */ ! 1124: if (n <= 1) { ! 1125: n = 0; cp++; ! 1126: } else ! 1127: n--; ! 1128: } ! 1129: } ! 1130: swabl(x) { unsigned long l = x; swabst("l", (char *)&l); return l; }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.