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