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