![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tar.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / bin|
Return to tar.c CVS log | Up to [CSRG BSD Unix] / 43BSD / bin |
1.1 ! root 1: /* ! 2: * Copyright (c) 1980 Regents of the University of California. ! 3: * All rights reserved. The Berkeley software License Agreement ! 4: * specifies the terms and conditions for redistribution. ! 5: */ ! 6: ! 7: #ifndef lint ! 8: char copyright[] = ! 9: "@(#) Copyright (c) 1980 Regents of the University of California.\n\ ! 10: All rights reserved.\n"; ! 11: #endif not lint ! 12: ! 13: #ifndef lint ! 14: static char sccsid[] = "@(#)tar.c 5.7 (Berkeley) 4/26/86"; ! 15: #endif not lint ! 16: ! 17: /* ! 18: * Tape Archival Program ! 19: */ ! 20: #include <stdio.h> ! 21: #include <sys/param.h> ! 22: #include <sys/stat.h> ! 23: #include <sys/dir.h> ! 24: #include <sys/ioctl.h> ! 25: #include <sys/mtio.h> ! 26: #include <sys/time.h> ! 27: #include <signal.h> ! 28: #include <errno.h> ! 29: #include <fcntl.h> ! 30: ! 31: #define TBLOCK 512 ! 32: #define NBLOCK 20 ! 33: #define NAMSIZ 100 ! 34: ! 35: #define writetape(b) writetbuf(b, 1) ! 36: #define min(a,b) ((a) < (b) ? (a) : (b)) ! 37: #define max(a,b) ((a) > (b) ? (a) : (b)) ! 38: ! 39: union hblock { ! 40: char dummy[TBLOCK]; ! 41: struct header { ! 42: char name[NAMSIZ]; ! 43: char mode[8]; ! 44: char uid[8]; ! 45: char gid[8]; ! 46: char size[12]; ! 47: char mtime[12]; ! 48: char chksum[8]; ! 49: char linkflag; ! 50: char linkname[NAMSIZ]; ! 51: } dbuf; ! 52: }; ! 53: ! 54: struct linkbuf { ! 55: ino_t inum; ! 56: dev_t devnum; ! 57: int count; ! 58: char pathname[NAMSIZ]; ! 59: struct linkbuf *nextp; ! 60: }; ! 61: ! 62: union hblock dblock; ! 63: union hblock *tbuf; ! 64: struct linkbuf *ihead; ! 65: struct stat stbuf; ! 66: ! 67: int rflag; ! 68: int xflag; ! 69: int vflag; ! 70: int tflag; ! 71: int cflag; ! 72: int mflag; ! 73: int fflag; ! 74: int iflag; ! 75: int oflag; ! 76: int pflag; ! 77: int wflag; ! 78: int hflag; ! 79: int Bflag; ! 80: int Fflag; ! 81: ! 82: int mt; ! 83: int term; ! 84: int chksum; ! 85: int recno; ! 86: int first; ! 87: int prtlinkerr; ! 88: int freemem = 1; ! 89: int nblock = 0; ! 90: int onintr(); ! 91: int onquit(); ! 92: int onhup(); ! 93: #ifdef notdef ! 94: int onterm(); ! 95: #endif ! 96: ! 97: daddr_t low; ! 98: daddr_t high; ! 99: daddr_t bsrch(); ! 100: ! 101: FILE *vfile = stdout; ! 102: FILE *tfile; ! 103: char tname[] = "/tmp/tarXXXXXX"; ! 104: char *usefile; ! 105: char magtape[] = "/dev/rmt8"; ! 106: char *malloc(); ! 107: long time(); ! 108: off_t lseek(); ! 109: char *mktemp(); ! 110: char *sprintf(); ! 111: char *strcat(); ! 112: char *strcpy(); ! 113: char *rindex(); ! 114: char *getcwd(); ! 115: char *getwd(); ! 116: char *getmem(); ! 117: ! 118: main(argc, argv) ! 119: int argc; ! 120: char *argv[]; ! 121: { ! 122: char *cp; ! 123: ! 124: if (argc < 2) ! 125: usage(); ! 126: ! 127: tfile = NULL; ! 128: usefile = magtape; ! 129: argv[argc] = 0; ! 130: argv++; ! 131: for (cp = *argv++; *cp; cp++) ! 132: switch(*cp) { ! 133: ! 134: case 'f': ! 135: if (*argv == 0) { ! 136: fprintf(stderr, ! 137: "tar: tapefile must be specified with 'f' option\n"); ! 138: usage(); ! 139: } ! 140: usefile = *argv++; ! 141: fflag++; ! 142: break; ! 143: ! 144: case 'c': ! 145: cflag++; ! 146: rflag++; ! 147: break; ! 148: ! 149: case 'o': ! 150: oflag++; ! 151: break; ! 152: ! 153: case 'p': ! 154: pflag++; ! 155: break; ! 156: ! 157: case 'u': ! 158: mktemp(tname); ! 159: if ((tfile = fopen(tname, "w")) == NULL) { ! 160: fprintf(stderr, ! 161: "tar: cannot create temporary file (%s)\n", ! 162: tname); ! 163: done(1); ! 164: } ! 165: fprintf(tfile, "!!!!!/!/!/!/!/!/!/! 000\n"); ! 166: /*FALL THRU*/ ! 167: ! 168: case 'r': ! 169: rflag++; ! 170: break; ! 171: ! 172: case 'v': ! 173: vflag++; ! 174: break; ! 175: ! 176: case 'w': ! 177: wflag++; ! 178: break; ! 179: ! 180: case 'x': ! 181: xflag++; ! 182: break; ! 183: ! 184: case 't': ! 185: tflag++; ! 186: break; ! 187: ! 188: case 'm': ! 189: mflag++; ! 190: break; ! 191: ! 192: case '-': ! 193: break; ! 194: ! 195: case '0': ! 196: case '1': ! 197: case '4': ! 198: case '5': ! 199: case '7': ! 200: case '8': ! 201: magtape[8] = *cp; ! 202: usefile = magtape; ! 203: break; ! 204: ! 205: case 'b': ! 206: if (*argv == 0) { ! 207: fprintf(stderr, ! 208: "tar: blocksize must be specified with 'b' option\n"); ! 209: usage(); ! 210: } ! 211: nblock = atoi(*argv); ! 212: if (nblock <= 0) { ! 213: fprintf(stderr, ! 214: "tar: invalid blocksize \"%s\"\n", *argv); ! 215: done(1); ! 216: } ! 217: argv++; ! 218: break; ! 219: ! 220: case 'l': ! 221: prtlinkerr++; ! 222: break; ! 223: ! 224: case 'h': ! 225: hflag++; ! 226: break; ! 227: ! 228: case 'i': ! 229: iflag++; ! 230: break; ! 231: ! 232: case 'B': ! 233: Bflag++; ! 234: break; ! 235: ! 236: case 'F': ! 237: Fflag++; ! 238: break; ! 239: ! 240: default: ! 241: fprintf(stderr, "tar: %c: unknown option\n", *cp); ! 242: usage(); ! 243: } ! 244: ! 245: if (!rflag && !xflag && !tflag) ! 246: usage(); ! 247: if (rflag) { ! 248: if (cflag && tfile != NULL) ! 249: usage(); ! 250: if (signal(SIGINT, SIG_IGN) != SIG_IGN) ! 251: (void) signal(SIGINT, onintr); ! 252: if (signal(SIGHUP, SIG_IGN) != SIG_IGN) ! 253: (void) signal(SIGHUP, onhup); ! 254: if (signal(SIGQUIT, SIG_IGN) != SIG_IGN) ! 255: (void) signal(SIGQUIT, onquit); ! 256: #ifdef notdef ! 257: if (signal(SIGTERM, SIG_IGN) != SIG_IGN) ! 258: (void) signal(SIGTERM, onterm); ! 259: #endif ! 260: mt = openmt(usefile, 1); ! 261: dorep(argv); ! 262: done(0); ! 263: } ! 264: mt = openmt(usefile, 0); ! 265: if (xflag) ! 266: doxtract(argv); ! 267: else ! 268: dotable(argv); ! 269: done(0); ! 270: } ! 271: ! 272: usage() ! 273: { ! 274: fprintf(stderr, ! 275: "tar: usage: tar -{txru}[cvfblmhopwBi] [tapefile] [blocksize] file1 file2...\n"); ! 276: done(1); ! 277: } ! 278: ! 279: int ! 280: openmt(tape, writing) ! 281: char *tape; ! 282: int writing; ! 283: { ! 284: ! 285: if (strcmp(tape, "-") == 0) { ! 286: /* ! 287: * Read from standard input or write to standard output. ! 288: */ ! 289: if (writing) { ! 290: if (cflag == 0) { ! 291: fprintf(stderr, ! 292: "tar: can only create standard output archives\n"); ! 293: done(1); ! 294: } ! 295: vfile = stderr; ! 296: setlinebuf(vfile); ! 297: mt = dup(1); ! 298: } else { ! 299: mt = dup(0); ! 300: Bflag++; ! 301: } ! 302: } else { ! 303: /* ! 304: * Use file or tape on local machine. ! 305: */ ! 306: if (writing) { ! 307: if (cflag) ! 308: mt = open(tape, O_RDWR|O_CREAT|O_TRUNC, 0666); ! 309: else ! 310: mt = open(tape, O_RDWR); ! 311: } else ! 312: mt = open(tape, O_RDONLY); ! 313: if (mt < 0) { ! 314: fprintf(stderr, "tar: "); ! 315: perror(tape); ! 316: done(1); ! 317: } ! 318: } ! 319: return(mt); ! 320: } ! 321: ! 322: dorep(argv) ! 323: char *argv[]; ! 324: { ! 325: register char *cp, *cp2; ! 326: char wdir[MAXPATHLEN], tempdir[MAXPATHLEN], *parent; ! 327: ! 328: if (!cflag) { ! 329: getdir(); ! 330: do { ! 331: passtape(); ! 332: if (term) ! 333: done(0); ! 334: getdir(); ! 335: } while (!endtape()); ! 336: backtape(); ! 337: if (tfile != NULL) { ! 338: char buf[200]; ! 339: ! 340: sprintf(buf, ! 341: "sort +0 -1 +1nr %s -o %s; awk '$1 != prev {print; prev=$1}' %s >%sX; mv %sX %s", ! 342: tname, tname, tname, tname, tname, tname); ! 343: fflush(tfile); ! 344: system(buf); ! 345: freopen(tname, "r", tfile); ! 346: fstat(fileno(tfile), &stbuf); ! 347: high = stbuf.st_size; ! 348: } ! 349: } ! 350: ! 351: (void) getcwd(wdir); ! 352: while (*argv && ! term) { ! 353: cp2 = *argv; ! 354: if (!strcmp(cp2, "-C") && argv[1]) { ! 355: argv++; ! 356: if (chdir(*argv) < 0) { ! 357: fprintf(stderr, "tar: can't change directories to "); ! 358: perror(*argv); ! 359: } else ! 360: (void) getcwd(wdir); ! 361: argv++; ! 362: continue; ! 363: } ! 364: parent = wdir; ! 365: for (cp = *argv; *cp; cp++) ! 366: if (*cp == '/') ! 367: cp2 = cp; ! 368: if (cp2 != *argv) { ! 369: *cp2 = '\0'; ! 370: if (chdir(*argv) < 0) { ! 371: fprintf(stderr, "tar: can't change directories to "); ! 372: perror(*argv); ! 373: continue; ! 374: } ! 375: parent = getcwd(tempdir); ! 376: *cp2 = '/'; ! 377: cp2++; ! 378: } ! 379: putfile(*argv++, cp2, parent); ! 380: if (chdir(wdir) < 0) { ! 381: fprintf(stderr, "tar: cannot change back?: "); ! 382: perror(wdir); ! 383: } ! 384: } ! 385: putempty(); ! 386: putempty(); ! 387: flushtape(); ! 388: if (prtlinkerr == 0) ! 389: return; ! 390: for (; ihead != NULL; ihead = ihead->nextp) { ! 391: if (ihead->count == 0) ! 392: continue; ! 393: fprintf(stderr, "tar: missing links to %s\n", ihead->pathname); ! 394: } ! 395: } ! 396: ! 397: endtape() ! 398: { ! 399: return (dblock.dbuf.name[0] == '\0'); ! 400: } ! 401: ! 402: getdir() ! 403: { ! 404: register struct stat *sp; ! 405: int i; ! 406: ! 407: top: ! 408: readtape((char *)&dblock); ! 409: if (dblock.dbuf.name[0] == '\0') ! 410: return; ! 411: sp = &stbuf; ! 412: sscanf(dblock.dbuf.mode, "%o", &i); ! 413: sp->st_mode = i; ! 414: sscanf(dblock.dbuf.uid, "%o", &i); ! 415: sp->st_uid = i; ! 416: sscanf(dblock.dbuf.gid, "%o", &i); ! 417: sp->st_gid = i; ! 418: sscanf(dblock.dbuf.size, "%lo", &sp->st_size); ! 419: sscanf(dblock.dbuf.mtime, "%lo", &sp->st_mtime); ! 420: sscanf(dblock.dbuf.chksum, "%o", &chksum); ! 421: if (chksum != (i = checksum())) { ! 422: fprintf(stderr, "tar: directory checksum error (%d != %d)\n", ! 423: chksum, i); ! 424: if (iflag) ! 425: goto top; ! 426: done(2); ! 427: } ! 428: if (tfile != NULL) ! 429: fprintf(tfile, "%s %s\n", dblock.dbuf.name, dblock.dbuf.mtime); ! 430: } ! 431: ! 432: passtape() ! 433: { ! 434: long blocks; ! 435: char *bufp; ! 436: ! 437: if (dblock.dbuf.linkflag == '1') ! 438: return; ! 439: blocks = stbuf.st_size; ! 440: blocks += TBLOCK-1; ! 441: blocks /= TBLOCK; ! 442: ! 443: while (blocks-- > 0) ! 444: (void) readtbuf(&bufp, TBLOCK); ! 445: } ! 446: ! 447: putfile(longname, shortname, parent) ! 448: char *longname; ! 449: char *shortname; ! 450: char *parent; ! 451: { ! 452: int infile = 0; ! 453: long blocks; ! 454: char buf[TBLOCK]; ! 455: char *bigbuf; ! 456: register char *cp; ! 457: struct direct *dp; ! 458: DIR *dirp; ! 459: register int i; ! 460: long l; ! 461: char newparent[NAMSIZ+64]; ! 462: extern int errno; ! 463: int maxread; ! 464: int hint; /* amount to write to get "in sync" */ ! 465: ! 466: if (!hflag) ! 467: i = lstat(shortname, &stbuf); ! 468: else ! 469: i = stat(shortname, &stbuf); ! 470: if (i < 0) { ! 471: fprintf(stderr, "tar: "); ! 472: perror(longname); ! 473: return; ! 474: } ! 475: if (tfile != NULL && checkupdate(longname) == 0) ! 476: return; ! 477: if (checkw('r', longname) == 0) ! 478: return; ! 479: if (Fflag && checkf(shortname, stbuf.st_mode, Fflag) == 0) ! 480: return; ! 481: ! 482: switch (stbuf.st_mode & S_IFMT) { ! 483: case S_IFDIR: ! 484: for (i = 0, cp = buf; *cp++ = longname[i++];) ! 485: ; ! 486: *--cp = '/'; ! 487: *++cp = 0 ; ! 488: if (!oflag) { ! 489: if ((cp - buf) >= NAMSIZ) { ! 490: fprintf(stderr, "tar: %s: file name too long\n", ! 491: longname); ! 492: return; ! 493: } ! 494: stbuf.st_size = 0; ! 495: tomodes(&stbuf); ! 496: strcpy(dblock.dbuf.name,buf); ! 497: sprintf(dblock.dbuf.chksum, "%6o", checksum()); ! 498: (void) writetape((char *)&dblock); ! 499: } ! 500: sprintf(newparent, "%s/%s", parent, shortname); ! 501: if (chdir(shortname) < 0) { ! 502: perror(shortname); ! 503: return; ! 504: } ! 505: if ((dirp = opendir(".")) == NULL) { ! 506: fprintf(stderr, "tar: %s: directory read error\n", ! 507: longname); ! 508: if (chdir(parent) < 0) { ! 509: fprintf(stderr, "tar: cannot change back?: "); ! 510: perror(parent); ! 511: } ! 512: return; ! 513: } ! 514: while ((dp = readdir(dirp)) != NULL && !term) { ! 515: if (dp->d_ino == 0) ! 516: continue; ! 517: if (!strcmp(".", dp->d_name) || ! 518: !strcmp("..", dp->d_name)) ! 519: continue; ! 520: strcpy(cp, dp->d_name); ! 521: l = telldir(dirp); ! 522: closedir(dirp); ! 523: putfile(buf, cp, newparent); ! 524: dirp = opendir("."); ! 525: seekdir(dirp, l); ! 526: } ! 527: closedir(dirp); ! 528: if (chdir(parent) < 0) { ! 529: fprintf(stderr, "tar: cannot change back?: "); ! 530: perror(parent); ! 531: } ! 532: break; ! 533: ! 534: case S_IFLNK: ! 535: tomodes(&stbuf); ! 536: if (strlen(longname) >= NAMSIZ) { ! 537: fprintf(stderr, "tar: %s: file name too long\n", ! 538: longname); ! 539: return; ! 540: } ! 541: strcpy(dblock.dbuf.name, longname); ! 542: if (stbuf.st_size + 1 >= NAMSIZ) { ! 543: fprintf(stderr, "tar: %s: symbolic link too long\n", ! 544: longname); ! 545: return; ! 546: } ! 547: i = readlink(shortname, dblock.dbuf.linkname, NAMSIZ - 1); ! 548: if (i < 0) { ! 549: fprintf(stderr, "tar: can't read symbolic link "); ! 550: perror(longname); ! 551: return; ! 552: } ! 553: dblock.dbuf.linkname[i] = '\0'; ! 554: dblock.dbuf.linkflag = '2'; ! 555: if (vflag) ! 556: fprintf(vfile, "a %s symbolic link to %s\n", ! 557: longname, dblock.dbuf.linkname); ! 558: sprintf(dblock.dbuf.size, "%11lo", 0); ! 559: sprintf(dblock.dbuf.chksum, "%6o", checksum()); ! 560: (void) writetape((char *)&dblock); ! 561: break; ! 562: ! 563: case S_IFREG: ! 564: if ((infile = open(shortname, 0)) < 0) { ! 565: fprintf(stderr, "tar: "); ! 566: perror(longname); ! 567: return; ! 568: } ! 569: tomodes(&stbuf); ! 570: if (strlen(longname) >= NAMSIZ) { ! 571: fprintf(stderr, "tar: %s: file name too long\n", ! 572: longname); ! 573: close(infile); ! 574: return; ! 575: } ! 576: strcpy(dblock.dbuf.name, longname); ! 577: if (stbuf.st_nlink > 1) { ! 578: struct linkbuf *lp; ! 579: int found = 0; ! 580: ! 581: for (lp = ihead; lp != NULL; lp = lp->nextp) ! 582: if (lp->inum == stbuf.st_ino && ! 583: lp->devnum == stbuf.st_dev) { ! 584: found++; ! 585: break; ! 586: } ! 587: if (found) { ! 588: strcpy(dblock.dbuf.linkname, lp->pathname); ! 589: dblock.dbuf.linkflag = '1'; ! 590: sprintf(dblock.dbuf.chksum, "%6o", checksum()); ! 591: (void) writetape( (char *) &dblock); ! 592: if (vflag) ! 593: fprintf(vfile, "a %s link to %s\n", ! 594: longname, lp->pathname); ! 595: lp->count--; ! 596: close(infile); ! 597: return; ! 598: } ! 599: lp = (struct linkbuf *) getmem(sizeof(*lp)); ! 600: if (lp != NULL) { ! 601: lp->nextp = ihead; ! 602: ihead = lp; ! 603: lp->inum = stbuf.st_ino; ! 604: lp->devnum = stbuf.st_dev; ! 605: lp->count = stbuf.st_nlink - 1; ! 606: strcpy(lp->pathname, longname); ! 607: } ! 608: } ! 609: blocks = (stbuf.st_size + (TBLOCK-1)) / TBLOCK; ! 610: if (vflag) ! 611: fprintf(vfile, "a %s %ld blocks\n", longname, blocks); ! 612: sprintf(dblock.dbuf.chksum, "%6o", checksum()); ! 613: hint = writetape((char *)&dblock); ! 614: maxread = max(stbuf.st_blksize, (nblock * TBLOCK)); ! 615: if ((bigbuf = malloc((unsigned)maxread)) == 0) { ! 616: maxread = TBLOCK; ! 617: bigbuf = buf; ! 618: } ! 619: ! 620: while ((i = read(infile, bigbuf, min((hint*TBLOCK), maxread))) > 0 ! 621: && blocks > 0) { ! 622: register int nblks; ! 623: ! 624: nblks = ((i-1)/TBLOCK)+1; ! 625: if (nblks > blocks) ! 626: nblks = blocks; ! 627: hint = writetbuf(bigbuf, nblks); ! 628: blocks -= nblks; ! 629: } ! 630: close(infile); ! 631: if (bigbuf != buf) ! 632: free(bigbuf); ! 633: if (i < 0) { ! 634: fprintf(stderr, "tar: Read error on "); ! 635: perror(longname); ! 636: } else if (blocks != 0 || i != 0) ! 637: fprintf(stderr, "tar: %s: file changed size\n", ! 638: longname); ! 639: while (--blocks >= 0) ! 640: putempty(); ! 641: break; ! 642: ! 643: default: ! 644: fprintf(stderr, "tar: %s is not a file. Not dumped\n", ! 645: longname); ! 646: break; ! 647: } ! 648: } ! 649: ! 650: doxtract(argv) ! 651: char *argv[]; ! 652: { ! 653: long blocks, bytes; ! 654: int ofile, i; ! 655: ! 656: for (;;) { ! 657: if ((i = wantit(argv)) == 0) ! 658: continue; ! 659: if (i == -1) ! 660: break; /* end of tape */ ! 661: if (checkw('x', dblock.dbuf.name) == 0) { ! 662: passtape(); ! 663: continue; ! 664: } ! 665: if (Fflag) { ! 666: char *s; ! 667: ! 668: if ((s = rindex(dblock.dbuf.name, '/')) == 0) ! 669: s = dblock.dbuf.name; ! 670: else ! 671: s++; ! 672: if (checkf(s, stbuf.st_mode, Fflag) == 0) { ! 673: passtape(); ! 674: continue; ! 675: } ! 676: } ! 677: if (checkdir(dblock.dbuf.name)) { /* have a directory */ ! 678: if (mflag == 0) ! 679: dodirtimes(&dblock); ! 680: continue; ! 681: } ! 682: if (dblock.dbuf.linkflag == '2') { /* symlink */ ! 683: /* ! 684: * only unlink non directories or empty ! 685: * directories ! 686: */ ! 687: if (rmdir(dblock.dbuf.name) < 0) { ! 688: if (errno == ENOTDIR) ! 689: unlink(dblock.dbuf.name); ! 690: } ! 691: if (symlink(dblock.dbuf.linkname, dblock.dbuf.name)<0) { ! 692: fprintf(stderr, "tar: %s: symbolic link failed: ", ! 693: dblock.dbuf.name); ! 694: perror(""); ! 695: continue; ! 696: } ! 697: if (vflag) ! 698: fprintf(vfile, "x %s symbolic link to %s\n", ! 699: dblock.dbuf.name, dblock.dbuf.linkname); ! 700: #ifdef notdef ! 701: /* ignore alien orders */ ! 702: chown(dblock.dbuf.name, stbuf.st_uid, stbuf.st_gid); ! 703: if (mflag == 0) ! 704: setimes(dblock.dbuf.name, stbuf.st_mtime); ! 705: if (pflag) ! 706: chmod(dblock.dbuf.name, stbuf.st_mode & 07777); ! 707: #endif ! 708: continue; ! 709: } ! 710: if (dblock.dbuf.linkflag == '1') { /* regular link */ ! 711: /* ! 712: * only unlink non directories or empty ! 713: * directories ! 714: */ ! 715: if (rmdir(dblock.dbuf.name) < 0) { ! 716: if (errno == ENOTDIR) ! 717: unlink(dblock.dbuf.name); ! 718: } ! 719: if (link(dblock.dbuf.linkname, dblock.dbuf.name) < 0) { ! 720: fprintf(stderr, "tar: can't link %s to %s: ", ! 721: dblock.dbuf.name, dblock.dbuf.linkname); ! 722: perror(""); ! 723: continue; ! 724: } ! 725: if (vflag) ! 726: fprintf(vfile, "%s linked to %s\n", ! 727: dblock.dbuf.name, dblock.dbuf.linkname); ! 728: continue; ! 729: } ! 730: if ((ofile = creat(dblock.dbuf.name,stbuf.st_mode&0xfff)) < 0) { ! 731: fprintf(stderr, "tar: can't create %s: ", ! 732: dblock.dbuf.name); ! 733: perror(""); ! 734: passtape(); ! 735: continue; ! 736: } ! 737: chown(dblock.dbuf.name, stbuf.st_uid, stbuf.st_gid); ! 738: blocks = ((bytes = stbuf.st_size) + TBLOCK-1)/TBLOCK; ! 739: if (vflag) ! 740: fprintf(vfile, "x %s, %ld bytes, %ld tape blocks\n", ! 741: dblock.dbuf.name, bytes, blocks); ! 742: for (; blocks > 0;) { ! 743: register int nread; ! 744: char *bufp; ! 745: register int nwant; ! 746: ! 747: nwant = NBLOCK*TBLOCK; ! 748: if (nwant > (blocks*TBLOCK)) ! 749: nwant = (blocks*TBLOCK); ! 750: nread = readtbuf(&bufp, nwant); ! 751: if (write(ofile, bufp, (int)min(nread, bytes)) < 0) { ! 752: fprintf(stderr, ! 753: "tar: %s: HELP - extract write error", ! 754: dblock.dbuf.name); ! 755: perror(""); ! 756: done(2); ! 757: } ! 758: bytes -= nread; ! 759: blocks -= (((nread-1)/TBLOCK)+1); ! 760: } ! 761: close(ofile); ! 762: if (mflag == 0) ! 763: setimes(dblock.dbuf.name, stbuf.st_mtime); ! 764: if (pflag) ! 765: chmod(dblock.dbuf.name, stbuf.st_mode & 07777); ! 766: } ! 767: if (mflag == 0) { ! 768: dblock.dbuf.name[0] = '\0'; /* process the whole stack */ ! 769: dodirtimes(&dblock); ! 770: } ! 771: } ! 772: ! 773: dotable(argv) ! 774: char *argv[]; ! 775: { ! 776: register int i; ! 777: ! 778: for (;;) { ! 779: if ((i = wantit(argv)) == 0) ! 780: continue; ! 781: if (i == -1) ! 782: break; /* end of tape */ ! 783: if (vflag) ! 784: longt(&stbuf); ! 785: printf("%s", dblock.dbuf.name); ! 786: if (dblock.dbuf.linkflag == '1') ! 787: printf(" linked to %s", dblock.dbuf.linkname); ! 788: if (dblock.dbuf.linkflag == '2') ! 789: printf(" symbolic link to %s", dblock.dbuf.linkname); ! 790: printf("\n"); ! 791: passtape(); ! 792: } ! 793: } ! 794: ! 795: putempty() ! 796: { ! 797: char buf[TBLOCK]; ! 798: ! 799: bzero(buf, sizeof (buf)); ! 800: (void) writetape(buf); ! 801: } ! 802: ! 803: longt(st) ! 804: register struct stat *st; ! 805: { ! 806: register char *cp; ! 807: char *ctime(); ! 808: ! 809: pmode(st); ! 810: printf("%3d/%1d", st->st_uid, st->st_gid); ! 811: printf("%7ld", st->st_size); ! 812: cp = ctime(&st->st_mtime); ! 813: printf(" %-12.12s %-4.4s ", cp+4, cp+20); ! 814: } ! 815: ! 816: #define SUID 04000 ! 817: #define SGID 02000 ! 818: #define ROWN 0400 ! 819: #define WOWN 0200 ! 820: #define XOWN 0100 ! 821: #define RGRP 040 ! 822: #define WGRP 020 ! 823: #define XGRP 010 ! 824: #define ROTH 04 ! 825: #define WOTH 02 ! 826: #define XOTH 01 ! 827: #define STXT 01000 ! 828: int m1[] = { 1, ROWN, 'r', '-' }; ! 829: int m2[] = { 1, WOWN, 'w', '-' }; ! 830: int m3[] = { 2, SUID, 's', XOWN, 'x', '-' }; ! 831: int m4[] = { 1, RGRP, 'r', '-' }; ! 832: int m5[] = { 1, WGRP, 'w', '-' }; ! 833: int m6[] = { 2, SGID, 's', XGRP, 'x', '-' }; ! 834: int m7[] = { 1, ROTH, 'r', '-' }; ! 835: int m8[] = { 1, WOTH, 'w', '-' }; ! 836: int m9[] = { 2, STXT, 't', XOTH, 'x', '-' }; ! 837: ! 838: int *m[] = { m1, m2, m3, m4, m5, m6, m7, m8, m9}; ! 839: ! 840: pmode(st) ! 841: register struct stat *st; ! 842: { ! 843: register int **mp; ! 844: ! 845: for (mp = &m[0]; mp < &m[9];) ! 846: selectbits(*mp++, st); ! 847: } ! 848: ! 849: selectbits(pairp, st) ! 850: int *pairp; ! 851: struct stat *st; ! 852: { ! 853: register int n, *ap; ! 854: ! 855: ap = pairp; ! 856: n = *ap++; ! 857: while (--n>=0 && (st->st_mode&*ap++)==0) ! 858: ap++; ! 859: putchar(*ap); ! 860: } ! 861: ! 862: /* ! 863: * Make all directories needed by `name'. If `name' is itself ! 864: * a directory on the tar tape (indicated by a trailing '/'), ! 865: * return 1; else 0. ! 866: */ ! 867: checkdir(name) ! 868: register char *name; ! 869: { ! 870: register char *cp; ! 871: ! 872: /* ! 873: * Quick check for existence of directory. ! 874: */ ! 875: if ((cp = rindex(name, '/')) == 0) ! 876: return (0); ! 877: *cp = '\0'; ! 878: if (access(name, 0) == 0) { /* already exists */ ! 879: *cp = '/'; ! 880: return (cp[1] == '\0'); /* return (lastchar == '/') */ ! 881: } ! 882: *cp = '/'; ! 883: ! 884: /* ! 885: * No luck, try to make all directories in path. ! 886: */ ! 887: for (cp = name; *cp; cp++) { ! 888: if (*cp != '/') ! 889: continue; ! 890: *cp = '\0'; ! 891: if (access(name, 0) < 0) { ! 892: if (mkdir(name, 0777) < 0) { ! 893: perror(name); ! 894: *cp = '/'; ! 895: return (0); ! 896: } ! 897: chown(name, stbuf.st_uid, stbuf.st_gid); ! 898: if (pflag && cp[1] == '\0') /* dir on the tape */ ! 899: chmod(name, stbuf.st_mode & 07777); ! 900: } ! 901: *cp = '/'; ! 902: } ! 903: return (cp[-1]=='/'); ! 904: } ! 905: ! 906: onintr() ! 907: { ! 908: (void) signal(SIGINT, SIG_IGN); ! 909: term++; ! 910: } ! 911: ! 912: onquit() ! 913: { ! 914: (void) signal(SIGQUIT, SIG_IGN); ! 915: term++; ! 916: } ! 917: ! 918: onhup() ! 919: { ! 920: (void) signal(SIGHUP, SIG_IGN); ! 921: term++; ! 922: } ! 923: ! 924: #ifdef notdef ! 925: onterm() ! 926: { ! 927: (void) signal(SIGTERM, SIG_IGN); ! 928: term++; ! 929: } ! 930: #endif ! 931: ! 932: tomodes(sp) ! 933: register struct stat *sp; ! 934: { ! 935: register char *cp; ! 936: ! 937: for (cp = dblock.dummy; cp < &dblock.dummy[TBLOCK]; cp++) ! 938: *cp = '\0'; ! 939: sprintf(dblock.dbuf.mode, "%6o ", sp->st_mode & 07777); ! 940: sprintf(dblock.dbuf.uid, "%6o ", sp->st_uid); ! 941: sprintf(dblock.dbuf.gid, "%6o ", sp->st_gid); ! 942: sprintf(dblock.dbuf.size, "%11lo ", sp->st_size); ! 943: sprintf(dblock.dbuf.mtime, "%11lo ", sp->st_mtime); ! 944: } ! 945: ! 946: checksum() ! 947: { ! 948: register i; ! 949: register char *cp; ! 950: ! 951: for (cp = dblock.dbuf.chksum; ! 952: cp < &dblock.dbuf.chksum[sizeof(dblock.dbuf.chksum)]; cp++) ! 953: *cp = ' '; ! 954: i = 0; ! 955: for (cp = dblock.dummy; cp < &dblock.dummy[TBLOCK]; cp++) ! 956: i += *cp; ! 957: return (i); ! 958: } ! 959: ! 960: checkw(c, name) ! 961: char *name; ! 962: { ! 963: if (!wflag) ! 964: return (1); ! 965: printf("%c ", c); ! 966: if (vflag) ! 967: longt(&stbuf); ! 968: printf("%s: ", name); ! 969: return (response() == 'y'); ! 970: } ! 971: ! 972: response() ! 973: { ! 974: char c; ! 975: ! 976: c = getchar(); ! 977: if (c != '\n') ! 978: while (getchar() != '\n') ! 979: ; ! 980: else ! 981: c = 'n'; ! 982: return (c); ! 983: } ! 984: ! 985: checkf(name, mode, howmuch) ! 986: char *name; ! 987: int mode, howmuch; ! 988: { ! 989: int l; ! 990: ! 991: if ((mode & S_IFMT) == S_IFDIR){ ! 992: if ((strcmp(name, "SCCS")==0) || (strcmp(name, "RCS")==0)) ! 993: return(0); ! 994: return(1); ! 995: } ! 996: if ((l = strlen(name)) < 3) ! 997: return (1); ! 998: if (howmuch > 1 && name[l-2] == '.' && name[l-1] == 'o') ! 999: return (0); ! 1000: if (strcmp(name, "core") == 0 || ! 1001: strcmp(name, "errs") == 0 || ! 1002: (howmuch > 1 && strcmp(name, "a.out") == 0)) ! 1003: return (0); ! 1004: /* SHOULD CHECK IF IT IS EXECUTABLE */ ! 1005: return (1); ! 1006: } ! 1007: ! 1008: /* Is the current file a new file, or the newest one of the same name? */ ! 1009: checkupdate(arg) ! 1010: char *arg; ! 1011: { ! 1012: char name[100]; ! 1013: long mtime; ! 1014: daddr_t seekp; ! 1015: daddr_t lookup(); ! 1016: ! 1017: rewind(tfile); ! 1018: for (;;) { ! 1019: if ((seekp = lookup(arg)) < 0) ! 1020: return (1); ! 1021: fseek(tfile, seekp, 0); ! 1022: fscanf(tfile, "%s %lo", name, &mtime); ! 1023: return (stbuf.st_mtime > mtime); ! 1024: } ! 1025: } ! 1026: ! 1027: done(n) ! 1028: { ! 1029: unlink(tname); ! 1030: exit(n); ! 1031: } ! 1032: ! 1033: /* ! 1034: * Do we want the next entry on the tape, i.e. is it selected? If ! 1035: * not, skip over the entire entry. Return -1 if reached end of tape. ! 1036: */ ! 1037: wantit(argv) ! 1038: char *argv[]; ! 1039: { ! 1040: register char **cp; ! 1041: ! 1042: getdir(); ! 1043: if (endtape()) ! 1044: return (-1); ! 1045: if (*argv == 0) ! 1046: return (1); ! 1047: for (cp = argv; *cp; cp++) ! 1048: if (prefix(*cp, dblock.dbuf.name)) ! 1049: return (1); ! 1050: passtape(); ! 1051: return (0); ! 1052: } ! 1053: ! 1054: /* ! 1055: * Does s2 begin with the string s1, on a directory boundary? ! 1056: */ ! 1057: prefix(s1, s2) ! 1058: register char *s1, *s2; ! 1059: { ! 1060: while (*s1) ! 1061: if (*s1++ != *s2++) ! 1062: return (0); ! 1063: if (*s2) ! 1064: return (*s2 == '/'); ! 1065: return (1); ! 1066: } ! 1067: ! 1068: #define N 200 ! 1069: int njab; ! 1070: ! 1071: daddr_t ! 1072: lookup(s) ! 1073: char *s; ! 1074: { ! 1075: register i; ! 1076: daddr_t a; ! 1077: ! 1078: for(i=0; s[i]; i++) ! 1079: if (s[i] == ' ') ! 1080: break; ! 1081: a = bsrch(s, i, low, high); ! 1082: return (a); ! 1083: } ! 1084: ! 1085: daddr_t ! 1086: bsrch(s, n, l, h) ! 1087: daddr_t l, h; ! 1088: char *s; ! 1089: { ! 1090: register i, j; ! 1091: char b[N]; ! 1092: daddr_t m, m1; ! 1093: ! 1094: njab = 0; ! 1095: ! 1096: loop: ! 1097: if (l >= h) ! 1098: return ((daddr_t) -1); ! 1099: m = l + (h-l)/2 - N/2; ! 1100: if (m < l) ! 1101: m = l; ! 1102: fseek(tfile, m, 0); ! 1103: fread(b, 1, N, tfile); ! 1104: njab++; ! 1105: for(i=0; i<N; i++) { ! 1106: if (b[i] == '\n') ! 1107: break; ! 1108: m++; ! 1109: } ! 1110: if (m >= h) ! 1111: return ((daddr_t) -1); ! 1112: m1 = m; ! 1113: j = i; ! 1114: for(i++; i<N; i++) { ! 1115: m1++; ! 1116: if (b[i] == '\n') ! 1117: break; ! 1118: } ! 1119: i = cmp(b+j, s, n); ! 1120: if (i < 0) { ! 1121: h = m; ! 1122: goto loop; ! 1123: } ! 1124: if (i > 0) { ! 1125: l = m1; ! 1126: goto loop; ! 1127: } ! 1128: return (m); ! 1129: } ! 1130: ! 1131: cmp(b, s, n) ! 1132: char *b, *s; ! 1133: { ! 1134: register i; ! 1135: ! 1136: if (b[0] != '\n') ! 1137: exit(2); ! 1138: for(i=0; i<n; i++) { ! 1139: if (b[i+1] > s[i]) ! 1140: return (-1); ! 1141: if (b[i+1] < s[i]) ! 1142: return (1); ! 1143: } ! 1144: return (b[i+1] == ' '? 0 : -1); ! 1145: } ! 1146: ! 1147: readtape(buffer) ! 1148: char *buffer; ! 1149: { ! 1150: char *bufp; ! 1151: ! 1152: if (first == 0) ! 1153: getbuf(); ! 1154: (void) readtbuf(&bufp, TBLOCK); ! 1155: bcopy(bufp, buffer, TBLOCK); ! 1156: return(TBLOCK); ! 1157: } ! 1158: ! 1159: readtbuf(bufpp, size) ! 1160: char **bufpp; ! 1161: int size; ! 1162: { ! 1163: register int i; ! 1164: ! 1165: if (recno >= nblock || first == 0) { ! 1166: if ((i = bread(mt, (char *)tbuf, TBLOCK*nblock)) < 0) ! 1167: mterr("read", i, 3); ! 1168: if (first == 0) { ! 1169: if ((i % TBLOCK) != 0) { ! 1170: fprintf(stderr, "tar: tape blocksize error\n"); ! 1171: done(3); ! 1172: } ! 1173: i /= TBLOCK; ! 1174: if (i != nblock) { ! 1175: fprintf(stderr, "tar: blocksize = %d\n", i); ! 1176: nblock = i; ! 1177: } ! 1178: first = 1; ! 1179: } ! 1180: recno = 0; ! 1181: } ! 1182: if (size > ((nblock-recno)*TBLOCK)) ! 1183: size = (nblock-recno)*TBLOCK; ! 1184: *bufpp = (char *)&tbuf[recno]; ! 1185: recno += (size/TBLOCK); ! 1186: return (size); ! 1187: } ! 1188: ! 1189: writetbuf(buffer, n) ! 1190: register char *buffer; ! 1191: register int n; ! 1192: { ! 1193: int i; ! 1194: ! 1195: if (first == 0) { ! 1196: getbuf(); ! 1197: first = 1; ! 1198: } ! 1199: if (recno >= nblock) { ! 1200: i = write(mt, (char *)tbuf, TBLOCK*nblock); ! 1201: if (i != TBLOCK*nblock) ! 1202: mterr("write", i, 2); ! 1203: recno = 0; ! 1204: } ! 1205: ! 1206: /* ! 1207: * Special case: We have an empty tape buffer, and the ! 1208: * users data size is >= the tape block size: Avoid ! 1209: * the bcopy and dma direct to tape. BIG WIN. Add the ! 1210: * residual to the tape buffer. ! 1211: */ ! 1212: while (recno == 0 && n >= nblock) { ! 1213: i = write(mt, buffer, TBLOCK*nblock); ! 1214: if (i != TBLOCK*nblock) ! 1215: mterr("write", i, 2); ! 1216: n -= nblock; ! 1217: buffer += (nblock * TBLOCK); ! 1218: } ! 1219: ! 1220: while (n-- > 0) { ! 1221: bcopy(buffer, (char *)&tbuf[recno++], TBLOCK); ! 1222: buffer += TBLOCK; ! 1223: if (recno >= nblock) { ! 1224: i = write(mt, (char *)tbuf, TBLOCK*nblock); ! 1225: if (i != TBLOCK*nblock) ! 1226: mterr("write", i, 2); ! 1227: recno = 0; ! 1228: } ! 1229: } ! 1230: ! 1231: /* Tell the user how much to write to get in sync */ ! 1232: return (nblock - recno); ! 1233: } ! 1234: ! 1235: backtape() ! 1236: { ! 1237: static int mtdev = 1; ! 1238: static struct mtop mtop = {MTBSR, 1}; ! 1239: struct mtget mtget; ! 1240: ! 1241: if (mtdev == 1) ! 1242: mtdev = ioctl(mt, MTIOCGET, (char *)&mtget); ! 1243: if (mtdev == 0) { ! 1244: if (ioctl(mt, MTIOCTOP, (char *)&mtop) < 0) { ! 1245: fprintf(stderr, "tar: tape backspace error: "); ! 1246: perror(""); ! 1247: done(4); ! 1248: } ! 1249: } else ! 1250: lseek(mt, (daddr_t) -TBLOCK*nblock, 1); ! 1251: recno--; ! 1252: } ! 1253: ! 1254: flushtape() ! 1255: { ! 1256: int i; ! 1257: ! 1258: i = write(mt, (char *)tbuf, TBLOCK*nblock); ! 1259: if (i != TBLOCK*nblock) ! 1260: mterr("write", i, 2); ! 1261: } ! 1262: ! 1263: mterr(operation, i, exitcode) ! 1264: char *operation; ! 1265: int i; ! 1266: { ! 1267: fprintf(stderr, "tar: tape %s error: ", operation); ! 1268: if (i < 0) ! 1269: perror(""); ! 1270: else ! 1271: fprintf(stderr, "unexpected EOF\n"); ! 1272: done(exitcode); ! 1273: } ! 1274: ! 1275: bread(fd, buf, size) ! 1276: int fd; ! 1277: char *buf; ! 1278: int size; ! 1279: { ! 1280: int count; ! 1281: static int lastread = 0; ! 1282: ! 1283: if (!Bflag) ! 1284: return (read(fd, buf, size)); ! 1285: ! 1286: for (count = 0; count < size; count += lastread) { ! 1287: lastread = read(fd, buf, size - count); ! 1288: if (lastread <= 0) { ! 1289: if (count > 0) ! 1290: return (count); ! 1291: return (lastread); ! 1292: } ! 1293: buf += lastread; ! 1294: } ! 1295: return (count); ! 1296: } ! 1297: ! 1298: char * ! 1299: getcwd(buf) ! 1300: char *buf; ! 1301: { ! 1302: if (getwd(buf) == NULL) { ! 1303: fprintf(stderr, "tar: %s\n", buf); ! 1304: exit(1); ! 1305: } ! 1306: return (buf); ! 1307: } ! 1308: ! 1309: getbuf() ! 1310: { ! 1311: ! 1312: if (nblock == 0) { ! 1313: fstat(mt, &stbuf); ! 1314: if ((stbuf.st_mode & S_IFMT) == S_IFCHR) ! 1315: nblock = NBLOCK; ! 1316: else { ! 1317: nblock = stbuf.st_blksize / TBLOCK; ! 1318: if (nblock == 0) ! 1319: nblock = NBLOCK; ! 1320: } ! 1321: } ! 1322: tbuf = (union hblock *)malloc((unsigned)nblock*TBLOCK); ! 1323: if (tbuf == NULL) { ! 1324: fprintf(stderr, "tar: blocksize %d too big, can't get memory\n", ! 1325: nblock); ! 1326: done(1); ! 1327: } ! 1328: } ! 1329: ! 1330: /* ! 1331: * Save this directory and its mtime on the stack, popping and setting ! 1332: * the mtimes of any stacked dirs which aren't parents of this one. ! 1333: * A null directory causes the entire stack to be unwound and set. ! 1334: * ! 1335: * Since all the elements of the directory "stack" share a common ! 1336: * prefix, we can make do with one string. We keep only the current ! 1337: * directory path, with an associated array of mtime's, one for each ! 1338: * '/' in the path. A negative mtime means no mtime. The mtime's are ! 1339: * offset by one (first index 1, not 0) because calling this with a null ! 1340: * directory causes mtime[0] to be set. ! 1341: * ! 1342: * This stack algorithm is not guaranteed to work for tapes created ! 1343: * with the 'r' option, but the vast majority of tapes with ! 1344: * directories are not. This avoids saving every directory record on ! 1345: * the tape and setting all the times at the end. ! 1346: */ ! 1347: char dirstack[NAMSIZ]; ! 1348: #define NTIM (NAMSIZ/2+1) /* a/b/c/d/... */ ! 1349: time_t mtime[NTIM]; ! 1350: ! 1351: dodirtimes(hp) ! 1352: union hblock *hp; ! 1353: { ! 1354: register char *p = dirstack; ! 1355: register char *q = hp->dbuf.name; ! 1356: register int ndir = 0; ! 1357: char *savp; ! 1358: int savndir; ! 1359: ! 1360: /* Find common prefix */ ! 1361: while (*p == *q) { ! 1362: if (*p++ == '/') ! 1363: ++ndir; ! 1364: q++; ! 1365: } ! 1366: ! 1367: savp = p; ! 1368: savndir = ndir; ! 1369: while (*p) { ! 1370: /* ! 1371: * Not a child: unwind the stack, setting the times. ! 1372: * The order we do this doesn't matter, so we go "forward." ! 1373: */ ! 1374: if (*p++ == '/') ! 1375: if (mtime[++ndir] >= 0) { ! 1376: *--p = '\0'; /* zap the slash */ ! 1377: setimes(dirstack, mtime[ndir]); ! 1378: *p++ = '/'; ! 1379: } ! 1380: } ! 1381: p = savp; ! 1382: ndir = savndir; ! 1383: ! 1384: /* Push this one on the "stack" */ ! 1385: while (*p = *q++) /* append the rest of the new dir */ ! 1386: if (*p++ == '/') ! 1387: mtime[++ndir] = -1; ! 1388: mtime[ndir] = stbuf.st_mtime; /* overwrite the last one */ ! 1389: } ! 1390: ! 1391: setimes(path, mt) ! 1392: char *path; ! 1393: time_t mt; ! 1394: { ! 1395: struct timeval tv[2]; ! 1396: ! 1397: tv[0].tv_sec = time((time_t *) 0); ! 1398: tv[1].tv_sec = mt; ! 1399: tv[0].tv_usec = tv[1].tv_usec = 0; ! 1400: if (utimes(path, tv) < 0) { ! 1401: fprintf(stderr, "tar: can't set time on %s: ", path); ! 1402: perror(""); ! 1403: } ! 1404: } ! 1405: ! 1406: char * ! 1407: getmem(size) ! 1408: { ! 1409: char *p = malloc((unsigned) size); ! 1410: ! 1411: if (p == NULL && freemem) { ! 1412: fprintf(stderr, ! 1413: "tar: out of memory, link and directory modtime info lost\n"); ! 1414: freemem = 0; ! 1415: } ! 1416: return (p); ! 1417: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.