![[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] / 42BSD / bin|
Return to tar.c CVS log | Up to [CSRG BSD Unix] / 42BSD / bin |
1.1 root 1: #ifndef lint
2: static char *sccsid = "@(#)tar.c 4.19 (Berkeley) 9/22/83";
3: #endif
4:
5: /*
6: * Tape Archival Program
7: */
8: #include <stdio.h>
9: #include <sys/param.h>
10: #include <sys/stat.h>
11: #include <sys/dir.h>
12: #include <sys/ioctl.h>
13: #include <sys/mtio.h>
14: #include <sys/time.h>
15: #include <signal.h>
16: #include <errno.h>
17:
18: #define TBLOCK 512
19: #define NBLOCK 20
20: #define NAMSIZ 100
21:
22: union hblock {
23: char dummy[TBLOCK];
24: struct header {
25: char name[NAMSIZ];
26: char mode[8];
27: char uid[8];
28: char gid[8];
29: char size[12];
30: char mtime[12];
31: char chksum[8];
32: char linkflag;
33: char linkname[NAMSIZ];
34: } dbuf;
35: };
36:
37: struct linkbuf {
38: ino_t inum;
39: dev_t devnum;
40: int count;
41: char pathname[NAMSIZ];
42: struct linkbuf *nextp;
43: };
44:
45: union hblock dblock;
46: union hblock *tbuf;
47: struct linkbuf *ihead;
48: struct stat stbuf;
49:
50: int rflag;
51: int xflag;
52: int vflag;
53: int tflag;
54: int cflag;
55: int mflag;
56: int fflag;
57: int iflag;
58: int oflag;
59: int pflag;
60: int wflag;
61: int hflag;
62: int Bflag;
63: int Fflag;
64:
65: int mt;
66: int term;
67: int chksum;
68: int recno;
69: int first;
70: int linkerrok;
71: int freemem = 1;
72: int nblock = NBLOCK;
73: int onintr();
74: int onquit();
75: int onhup();
76: int onterm();
77:
78: daddr_t low;
79: daddr_t high;
80: daddr_t bsrch();
81:
82: FILE *tfile;
83: char tname[] = "/tmp/tarXXXXXX";
84: char *usefile;
85: char magtape[] = "/dev/rmt8";
86: char *malloc();
87: char *sprintf();
88: char *strcat();
89: char *rindex();
90: char *getcwd();
91: char *getwd();
92:
93: main(argc, argv)
94: int argc;
95: char *argv[];
96: {
97: char *cp;
98:
99: if (argc < 2)
100: usage();
101:
102: tfile = NULL;
103: usefile = magtape;
104: argv[argc] = 0;
105: argv++;
106: for (cp = *argv++; *cp; cp++)
107: switch(*cp) {
108:
109: case 'f':
110: if (*argv == 0) {
111: fprintf(stderr,
112: "tar: tapefile must be specified with 'f' option\n");
113: usage();
114: }
115: usefile = *argv++;
116: fflag++;
117: break;
118:
119: case 'c':
120: cflag++;
121: rflag++;
122: break;
123:
124: case 'o':
125: oflag++;
126: break;
127:
128: case 'p':
129: pflag++;
130: break;
131:
132: case 'u':
133: mktemp(tname);
134: if ((tfile = fopen(tname, "w")) == NULL) {
135: fprintf(stderr,
136: "Tar: cannot create temporary file (%s)\n",
137: tname);
138: done(1);
139: }
140: fprintf(tfile, "!!!!!/!/!/!/!/!/!/! 000\n");
141: /*FALL THRU*/
142:
143: case 'r':
144: rflag++;
145: break;
146:
147: case 'v':
148: vflag++;
149: break;
150:
151: case 'w':
152: wflag++;
153: break;
154:
155: case 'x':
156: xflag++;
157: break;
158:
159: case 't':
160: tflag++;
161: break;
162:
163: case 'm':
164: mflag++;
165: break;
166:
167: case '-':
168: break;
169:
170: case '0':
171: case '1':
172: case '4':
173: case '5':
174: case '7':
175: case '8':
176: magtape[8] = *cp;
177: usefile = magtape;
178: break;
179:
180: case 'b':
181: if (*argv == 0) {
182: fprintf(stderr,
183: "tar: blocksize must be specified with 'b' option\n");
184: usage();
185: }
186: nblock = atoi(*argv);
187: if (nblock <= 0) {
188: fprintf(stderr,
189: "tar: invalid blocksize \"%s\"\n", *argv);
190: done(1);
191: }
192: argv++;
193: break;
194:
195: case 'l':
196: linkerrok++;
197: break;
198:
199: case 'h':
200: hflag++;
201: break;
202:
203: case 'i':
204: iflag++;
205: break;
206:
207: case 'B':
208: Bflag++;
209: break;
210:
211: case 'F':
212: Fflag++;
213: break;
214:
215: default:
216: fprintf(stderr, "tar: %c: unknown option\n", *cp);
217: usage();
218: }
219:
220: if (!rflag && !xflag && !tflag)
221: usage();
222: tbuf = (union hblock *)malloc(nblock*TBLOCK);
223: if (tbuf == NULL) {
224: fprintf(stderr, "tar: blocksize %d too big, can't get memory\n",
225: nblock);
226: done(1);
227: }
228: if (rflag) {
229: if (cflag && tfile != NULL)
230: usage();
231: if (signal(SIGINT, SIG_IGN) != SIG_IGN)
232: signal(SIGINT, onintr);
233: if (signal(SIGHUP, SIG_IGN) != SIG_IGN)
234: signal(SIGHUP, onhup);
235: if (signal(SIGQUIT, SIG_IGN) != SIG_IGN)
236: signal(SIGQUIT, onquit);
237: #ifdef notdef
238: if (signal(SIGTERM, SIG_IGN) != SIG_IGN)
239: signal(SIGTERM, onterm);
240: #endif
241: if (strcmp(usefile, "-") == 0) {
242: if (cflag == 0) {
243: fprintf(stderr,
244: "tar: can only create standard output archives\n");
245: done(1);
246: }
247: mt = dup(1);
248: nblock = 1;
249: } else if ((mt = open(usefile, 2)) < 0) {
250: if (cflag == 0 || (mt = creat(usefile, 0666)) < 0) {
251: fprintf(stderr,
252: "tar: cannot open %s\n", usefile);
253: done(1);
254: }
255: }
256: dorep(argv);
257: done(0);
258: }
259: if (strcmp(usefile, "-") == 0) {
260: mt = dup(0);
261: nblock = 1;
262: } else if ((mt = open(usefile, 0)) < 0) {
263: fprintf(stderr, "tar: cannot open %s\n", usefile);
264: done(1);
265: }
266: if (xflag)
267: doxtract(argv);
268: else
269: dotable();
270: done(0);
271: }
272:
273: usage()
274: {
275: fprintf(stderr,
276: "tar: usage: tar -{txru}[cvfblmhopwBi] [tapefile] [blocksize] file1 file2...\n");
277: done(1);
278: }
279:
280: dorep(argv)
281: char *argv[];
282: {
283: register char *cp, *cp2;
284: char wdir[MAXPATHLEN], tempdir[MAXPATHLEN], *parent;
285:
286: if (!cflag) {
287: getdir();
288: do {
289: passtape();
290: if (term)
291: done(0);
292: getdir();
293: } while (!endtape());
294: backtape();
295: if (tfile != NULL) {
296: char buf[200];
297:
298: sprintf(buf,
299: "sort +0 -1 +1nr %s -o %s; awk '$1 != prev {print; prev=$1}' %s >%sX; mv %sX %s",
300: tname, tname, tname, tname, tname, tname);
301: fflush(tfile);
302: system(buf);
303: freopen(tname, "r", tfile);
304: fstat(fileno(tfile), &stbuf);
305: high = stbuf.st_size;
306: }
307: }
308:
309: (void) getcwd(wdir);
310: while (*argv && ! term) {
311: cp2 = *argv;
312: if (!strcmp(cp2, "-C") && argv[1]) {
313: argv++;
314: if (chdir(*argv) < 0)
315: perror(*argv);
316: else
317: (void) getcwd(wdir);
318: argv++;
319: continue;
320: }
321: parent = wdir;
322: for (cp = *argv; *cp; cp++)
323: if (*cp == '/')
324: cp2 = cp;
325: if (cp2 != *argv) {
326: *cp2 = '\0';
327: if (chdir(*argv) < 0) {
328: perror(*argv);
329: continue;
330: }
331: parent = getcwd(tempdir);
332: *cp2 = '/';
333: cp2++;
334: }
335: putfile(*argv++, cp2, parent);
336: if (chdir(wdir) < 0) {
337: fprintf(stderr, "cannot change back?: ");
338: perror(wdir);
339: }
340: }
341: putempty();
342: putempty();
343: flushtape();
344: if (linkerrok == 0)
345: return;
346: for (; ihead != NULL; ihead = ihead->nextp) {
347: if (ihead->count == 0)
348: continue;
349: fprintf(stderr, "tar: missing links to %s\n", ihead->pathname);
350: }
351: }
352:
353: endtape()
354: {
355: return (dblock.dbuf.name[0] == '\0');
356: }
357:
358: getdir()
359: {
360: register struct stat *sp;
361: int i;
362:
363: top:
364: readtape((char *)&dblock);
365: if (dblock.dbuf.name[0] == '\0')
366: return;
367: sp = &stbuf;
368: sscanf(dblock.dbuf.mode, "%o", &i);
369: sp->st_mode = i;
370: sscanf(dblock.dbuf.uid, "%o", &i);
371: sp->st_uid = i;
372: sscanf(dblock.dbuf.gid, "%o", &i);
373: sp->st_gid = i;
374: sscanf(dblock.dbuf.size, "%lo", &sp->st_size);
375: sscanf(dblock.dbuf.mtime, "%lo", &sp->st_mtime);
376: sscanf(dblock.dbuf.chksum, "%o", &chksum);
377: if (chksum != (i = checksum())) {
378: fprintf(stderr, "tar: directory checksum error (%d != %d)\n",
379: chksum, i);
380: if (iflag)
381: goto top;
382: done(2);
383: }
384: if (tfile != NULL)
385: fprintf(tfile, "%s %s\n", dblock.dbuf.name, dblock.dbuf.mtime);
386: }
387:
388: passtape()
389: {
390: long blocks;
391: char buf[TBLOCK];
392:
393: if (dblock.dbuf.linkflag == '1')
394: return;
395: blocks = stbuf.st_size;
396: blocks += TBLOCK-1;
397: blocks /= TBLOCK;
398:
399: while (blocks-- > 0)
400: readtape(buf);
401: }
402:
403: putfile(longname, shortname, parent)
404: char *longname;
405: char *shortname;
406: char *parent;
407: {
408: int infile = 0;
409: long blocks;
410: char buf[TBLOCK];
411: register char *cp, *cp2;
412: struct direct *dp;
413: DIR *dirp;
414: int i, j;
415: char newparent[NAMSIZ+64];
416: extern int errno;
417:
418: if (!hflag)
419: i = lstat(shortname, &stbuf);
420: else
421: i = stat(shortname, &stbuf);
422: if (i < 0) {
423: switch (errno) {
424: case EACCES:
425: fprintf(stderr, "tar: %s: cannot open file\n", longname);
426: break;
427: case ENOENT:
428: fprintf(stderr, "tar: %s: no such file or directory\n",
429: longname);
430: break;
431: default:
432: fprintf(stderr, "tar: %s: cannot stat file\n", longname);
433: break;
434: }
435: return;
436: }
437: if (tfile != NULL && checkupdate(longname) == 0)
438: return;
439: if (checkw('r', longname) == 0)
440: return;
441: if (Fflag && checkf(shortname, stbuf.st_mode, Fflag) == 0)
442: return;
443:
444: switch (stbuf.st_mode & S_IFMT) {
445: case S_IFDIR:
446: for (i = 0, cp = buf; *cp++ = longname[i++];)
447: ;
448: *--cp = '/';
449: *++cp = 0 ;
450: if (!oflag) {
451: if ((cp - buf) >= NAMSIZ) {
452: fprintf(stderr, "tar: %s: file name too long\n",
453: longname);
454: return;
455: }
456: stbuf.st_size = 0;
457: tomodes(&stbuf);
458: strcpy(dblock.dbuf.name,buf);
459: sprintf(dblock.dbuf.chksum, "%6o", checksum());
460: writetape((char *)&dblock);
461: }
462: sprintf(newparent, "%s/%s", parent, shortname);
463: if (chdir(shortname) < 0) {
464: perror(shortname);
465: return;
466: }
467: if ((dirp = opendir(".")) == NULL) {
468: fprintf(stderr, "tar: %s: directory read error\n",
469: longname);
470: if (chdir(parent) < 0) {
471: fprintf(stderr, "cannot change back?: ");
472: perror(parent);
473: }
474: return;
475: }
476: while ((dp = readdir(dirp)) != NULL && !term) {
477: if (dp->d_ino == 0)
478: continue;
479: if (!strcmp(".", dp->d_name) ||
480: !strcmp("..", dp->d_name))
481: continue;
482: strcpy(cp, dp->d_name);
483: i = telldir(dirp);
484: closedir(dirp);
485: putfile(buf, cp, newparent);
486: dirp = opendir(".");
487: seekdir(dirp, i);
488: }
489: closedir(dirp);
490: if (chdir(parent) < 0) {
491: fprintf(stderr, "cannot change back?: ");
492: perror(parent);
493: }
494: break;
495:
496: case S_IFLNK:
497: tomodes(&stbuf);
498: if (strlen(longname) >= NAMSIZ) {
499: fprintf(stderr, "tar: %s: file name too long\n",
500: longname);
501: return;
502: }
503: strcpy(dblock.dbuf.name, longname);
504: if (stbuf.st_size + 1 >= NAMSIZ) {
505: fprintf(stderr, "tar: %s: symbolic link too long\n",
506: longname);
507: return;
508: }
509: i = readlink(shortname, dblock.dbuf.linkname, NAMSIZ - 1);
510: if (i < 0) {
511: perror(longname);
512: return;
513: }
514: dblock.dbuf.linkname[i] = '\0';
515: dblock.dbuf.linkflag = '2';
516: if (vflag) {
517: fprintf(stderr, "a %s ", longname);
518: fprintf(stderr, "symbolic link to %s\n",
519: dblock.dbuf.linkname);
520: }
521: sprintf(dblock.dbuf.size, "%11lo", 0);
522: sprintf(dblock.dbuf.chksum, "%6o", checksum());
523: writetape((char *)&dblock);
524: break;
525:
526: case S_IFREG:
527: if ((infile = open(shortname, 0)) < 0) {
528: fprintf(stderr, "tar: %s: cannot open file\n", longname);
529: return;
530: }
531: tomodes(&stbuf);
532: if (strlen(longname) >= NAMSIZ) {
533: fprintf(stderr, "tar: %s: file name too long\n",
534: longname);
535: return;
536: }
537: strcpy(dblock.dbuf.name, longname);
538: if (stbuf.st_nlink > 1) {
539: struct linkbuf *lp;
540: int found = 0;
541:
542: for (lp = ihead; lp != NULL; lp = lp->nextp)
543: if (lp->inum == stbuf.st_ino &&
544: lp->devnum == stbuf.st_dev) {
545: found++;
546: break;
547: }
548: if (found) {
549: strcpy(dblock.dbuf.linkname, lp->pathname);
550: dblock.dbuf.linkflag = '1';
551: sprintf(dblock.dbuf.chksum, "%6o", checksum());
552: writetape( (char *) &dblock);
553: if (vflag) {
554: fprintf(stderr, "a %s ", longname);
555: fprintf(stderr, "link to %s\n",
556: lp->pathname);
557: }
558: lp->count--;
559: close(infile);
560: return;
561: }
562: lp = (struct linkbuf *) malloc(sizeof(*lp));
563: if (lp == NULL) {
564: if (freemem) {
565: fprintf(stderr,
566: "tar: out of memory, link information lost\n");
567: freemem = 0;
568: }
569: } else {
570: lp->nextp = ihead;
571: ihead = lp;
572: lp->inum = stbuf.st_ino;
573: lp->devnum = stbuf.st_dev;
574: lp->count = stbuf.st_nlink - 1;
575: strcpy(lp->pathname, longname);
576: }
577: }
578: blocks = (stbuf.st_size + (TBLOCK-1)) / TBLOCK;
579: if (vflag) {
580: fprintf(stderr, "a %s ", longname);
581: fprintf(stderr, "%ld blocks\n", blocks);
582: }
583: sprintf(dblock.dbuf.chksum, "%6o", checksum());
584: writetape((char *)&dblock);
585:
586: while ((i = read(infile, buf, TBLOCK)) > 0 && blocks > 0) {
587: writetape(buf);
588: blocks--;
589: }
590: close(infile);
591: if (blocks != 0 || i != 0)
592: fprintf(stderr, "tar: %s: file changed size\n",
593: longname);
594: while (--blocks >= 0)
595: putempty();
596: break;
597:
598: default:
599: fprintf(stderr, "tar: %s is not a file. Not dumped\n",
600: longname);
601: break;
602: }
603: }
604:
605: doxtract(argv)
606: char *argv[];
607: {
608: long blocks, bytes;
609: char buf[TBLOCK];
610: char **cp;
611: int ofile;
612:
613: for (;;) {
614: getdir();
615: if (endtape())
616: break;
617: if (*argv == 0)
618: goto gotit;
619: for (cp = argv; *cp; cp++)
620: if (prefix(*cp, dblock.dbuf.name))
621: goto gotit;
622: passtape();
623: continue;
624:
625: gotit:
626: if (checkw('x', dblock.dbuf.name) == 0) {
627: passtape();
628: continue;
629: }
630: if (Fflag) {
631: char *s;
632:
633: if ((s = rindex(dblock.dbuf.name, '/')) == 0)
634: s = dblock.dbuf.name;
635: else
636: s++;
637: if (checkf(s, stbuf.st_mode, Fflag) == 0) {
638: passtape();
639: continue;
640: }
641: }
642: if (checkdir(dblock.dbuf.name))
643: continue;
644: if (dblock.dbuf.linkflag == '2') {
645: unlink(dblock.dbuf.name);
646: if (symlink(dblock.dbuf.linkname, dblock.dbuf.name)<0) {
647: fprintf(stderr, "tar: %s: symbolic link failed\n",
648: dblock.dbuf.name);
649: continue;
650: }
651: if (vflag)
652: fprintf(stderr, "x %s symbolic link to %s\n",
653: dblock.dbuf.name, dblock.dbuf.linkname);
654: #ifdef notdef
655: /* ignore alien orders */
656: chown(dblock.dbuf.name, stbuf.st_uid, stbuf.st_gid);
657: if (mflag == 0) {
658: struct timeval tv[2];
659:
660: tv[0].tv_sec = time(0);
661: tv[0].tv_usec = 0;
662: tv[1].tv_sec = stbuf.st_mtime;
663: tv[1].tv_usec = 0;
664: utimes(dblock.dbuf.name, tv);
665: }
666: if (pflag)
667: chmod(dblock.dbuf.name, stbuf.st_mode & 07777);
668: #endif
669: continue;
670: }
671: if (dblock.dbuf.linkflag == '1') {
672: unlink(dblock.dbuf.name);
673: if (link(dblock.dbuf.linkname, dblock.dbuf.name) < 0) {
674: fprintf(stderr, "tar: %s: cannot link\n",
675: dblock.dbuf.name);
676: continue;
677: }
678: if (vflag)
679: fprintf(stderr, "%s linked to %s\n",
680: dblock.dbuf.name, dblock.dbuf.linkname);
681: continue;
682: }
683: if ((ofile = creat(dblock.dbuf.name,stbuf.st_mode&0xfff)) < 0) {
684: fprintf(stderr, "tar: %s - cannot create\n",
685: dblock.dbuf.name);
686: passtape();
687: continue;
688: }
689: chown(dblock.dbuf.name, stbuf.st_uid, stbuf.st_gid);
690: blocks = ((bytes = stbuf.st_size) + TBLOCK-1)/TBLOCK;
691: if (vflag)
692: fprintf(stderr, "x %s, %ld bytes, %ld tape blocks\n",
693: dblock.dbuf.name, bytes, blocks);
694: for (; blocks-- > 0; bytes -= TBLOCK) {
695: readtape(buf);
696: if (bytes > TBLOCK) {
697: if (write(ofile, buf, TBLOCK) < 0) {
698: fprintf(stderr,
699: "tar: %s: HELP - extract write error\n",
700: dblock.dbuf.name);
701: done(2);
702: }
703: continue;
704: }
705: if (write(ofile, buf, (int) bytes) < 0) {
706: fprintf(stderr,
707: "tar: %s: HELP - extract write error\n",
708: dblock.dbuf.name);
709: done(2);
710: }
711: }
712: close(ofile);
713: if (mflag == 0) {
714: struct timeval tv[2];
715:
716: tv[0].tv_sec = time(0);
717: tv[0].tv_usec = 0;
718: tv[1].tv_sec = stbuf.st_mtime;
719: tv[1].tv_usec = 0;
720: utimes(dblock.dbuf.name, tv);
721: }
722: if (pflag)
723: chmod(dblock.dbuf.name, stbuf.st_mode & 07777);
724: }
725: }
726:
727: dotable()
728: {
729: for (;;) {
730: getdir();
731: if (endtape())
732: break;
733: if (vflag)
734: longt(&stbuf);
735: printf("%s", dblock.dbuf.name);
736: if (dblock.dbuf.linkflag == '1')
737: printf(" linked to %s", dblock.dbuf.linkname);
738: if (dblock.dbuf.linkflag == '2')
739: printf(" symbolic link to %s", dblock.dbuf.linkname);
740: printf("\n");
741: passtape();
742: }
743: }
744:
745: putempty()
746: {
747: char buf[TBLOCK];
748:
749: bzero(buf, sizeof (buf));
750: writetape(buf);
751: }
752:
753: longt(st)
754: register struct stat *st;
755: {
756: register char *cp;
757: char *ctime();
758:
759: pmode(st);
760: printf("%3d/%1d", st->st_uid, st->st_gid);
761: printf("%7D", st->st_size);
762: cp = ctime(&st->st_mtime);
763: printf(" %-12.12s %-4.4s ", cp+4, cp+20);
764: }
765:
766: #define SUID 04000
767: #define SGID 02000
768: #define ROWN 0400
769: #define WOWN 0200
770: #define XOWN 0100
771: #define RGRP 040
772: #define WGRP 020
773: #define XGRP 010
774: #define ROTH 04
775: #define WOTH 02
776: #define XOTH 01
777: #define STXT 01000
778: int m1[] = { 1, ROWN, 'r', '-' };
779: int m2[] = { 1, WOWN, 'w', '-' };
780: int m3[] = { 2, SUID, 's', XOWN, 'x', '-' };
781: int m4[] = { 1, RGRP, 'r', '-' };
782: int m5[] = { 1, WGRP, 'w', '-' };
783: int m6[] = { 2, SGID, 's', XGRP, 'x', '-' };
784: int m7[] = { 1, ROTH, 'r', '-' };
785: int m8[] = { 1, WOTH, 'w', '-' };
786: int m9[] = { 2, STXT, 't', XOTH, 'x', '-' };
787:
788: int *m[] = { m1, m2, m3, m4, m5, m6, m7, m8, m9};
789:
790: pmode(st)
791: register struct stat *st;
792: {
793: register int **mp;
794:
795: for (mp = &m[0]; mp < &m[9];)
796: select(*mp++, st);
797: }
798:
799: select(pairp, st)
800: int *pairp;
801: struct stat *st;
802: {
803: register int n, *ap;
804:
805: ap = pairp;
806: n = *ap++;
807: while (--n>=0 && (st->st_mode&*ap++)==0)
808: ap++;
809: printf("%c", *ap);
810: }
811:
812: checkdir(name)
813: register char *name;
814: {
815: register char *cp;
816:
817: /*
818: * Quick check for existance of directory.
819: */
820: if ((cp = rindex(name, '/')) == 0)
821: return (0);
822: *cp = '\0';
823: if (access(name, 0) >= 0) {
824: *cp = '/';
825: return (cp[1] == '\0');
826: }
827: *cp = '/';
828:
829: /*
830: * No luck, try to make all directories in path.
831: */
832: for (cp = name; *cp; cp++) {
833: if (*cp != '/')
834: continue;
835: *cp = '\0';
836: if (access(name, 0) < 0) {
837: if (mkdir(name, 0777) < 0) {
838: perror(name);
839: *cp = '/';
840: return (0);
841: }
842: chown(name, stbuf.st_uid, stbuf.st_gid);
843: if (pflag && cp[1] == '\0')
844: chmod(name, stbuf.st_mode & 0777);
845: }
846: *cp = '/';
847: }
848: return (cp[-1]=='/');
849: }
850:
851: onintr()
852: {
853: signal(SIGINT, SIG_IGN);
854: term++;
855: }
856:
857: onquit()
858: {
859: signal(SIGQUIT, SIG_IGN);
860: term++;
861: }
862:
863: onhup()
864: {
865: signal(SIGHUP, SIG_IGN);
866: term++;
867: }
868:
869: onterm()
870: {
871: signal(SIGTERM, SIG_IGN);
872: term++;
873: }
874:
875: tomodes(sp)
876: register struct stat *sp;
877: {
878: register char *cp;
879:
880: for (cp = dblock.dummy; cp < &dblock.dummy[TBLOCK]; cp++)
881: *cp = '\0';
882: sprintf(dblock.dbuf.mode, "%6o ", sp->st_mode & 07777);
883: sprintf(dblock.dbuf.uid, "%6o ", sp->st_uid);
884: sprintf(dblock.dbuf.gid, "%6o ", sp->st_gid);
885: sprintf(dblock.dbuf.size, "%11lo ", sp->st_size);
886: sprintf(dblock.dbuf.mtime, "%11lo ", sp->st_mtime);
887: }
888:
889: checksum()
890: {
891: register i;
892: register char *cp;
893:
894: for (cp = dblock.dbuf.chksum;
895: cp < &dblock.dbuf.chksum[sizeof(dblock.dbuf.chksum)]; cp++)
896: *cp = ' ';
897: i = 0;
898: for (cp = dblock.dummy; cp < &dblock.dummy[TBLOCK]; cp++)
899: i += *cp;
900: return (i);
901: }
902:
903: checkw(c, name)
904: char *name;
905: {
906: if (!wflag)
907: return (1);
908: printf("%c ", c);
909: if (vflag)
910: longt(&stbuf);
911: printf("%s: ", name);
912: return (response() == 'y');
913: }
914:
915: response()
916: {
917: char c;
918:
919: c = getchar();
920: if (c != '\n')
921: while (getchar() != '\n')
922: ;
923: else
924: c = 'n';
925: return (c);
926: }
927:
928: checkf(name, mode, howmuch)
929: char *name;
930: int mode, howmuch;
931: {
932: int l;
933:
934: if ((mode & S_IFMT) == S_IFDIR)
935: return (strcmp(name, "SCCS") != 0);
936: if ((l = strlen(name)) < 3)
937: return (1);
938: if (howmuch > 1 && name[l-2] == '.' && name[l-1] == 'o')
939: return (0);
940: if (strcmp(name, "core") == 0 ||
941: strcmp(name, "errs") == 0 ||
942: (howmuch > 1 && strcmp(name, "a.out") == 0))
943: return (0);
944: /* SHOULD CHECK IF IT IS EXECUTABLE */
945: return (1);
946: }
947:
948: checkupdate(arg)
949: char *arg;
950: {
951: char name[100];
952: long mtime;
953: daddr_t seekp;
954: daddr_t lookup();
955:
956: rewind(tfile);
957: for (;;) {
958: if ((seekp = lookup(arg)) < 0)
959: return (1);
960: fseek(tfile, seekp, 0);
961: fscanf(tfile, "%s %lo", name, &mtime);
962: return (stbuf.st_mtime > mtime);
963: }
964: }
965:
966: done(n)
967: {
968: unlink(tname);
969: exit(n);
970: }
971:
972: prefix(s1, s2)
973: register char *s1, *s2;
974: {
975: while (*s1)
976: if (*s1++ != *s2++)
977: return (0);
978: if (*s2)
979: return (*s2 == '/');
980: return (1);
981: }
982:
983: #define N 200
984: int njab;
985:
986: daddr_t
987: lookup(s)
988: char *s;
989: {
990: register i;
991: daddr_t a;
992:
993: for(i=0; s[i]; i++)
994: if (s[i] == ' ')
995: break;
996: a = bsrch(s, i, low, high);
997: return (a);
998: }
999:
1000: daddr_t
1001: bsrch(s, n, l, h)
1002: daddr_t l, h;
1003: char *s;
1004: {
1005: register i, j;
1006: char b[N];
1007: daddr_t m, m1;
1008:
1009: njab = 0;
1010:
1011: loop:
1012: if (l >= h)
1013: return (-1L);
1014: m = l + (h-l)/2 - N/2;
1015: if (m < l)
1016: m = l;
1017: fseek(tfile, m, 0);
1018: fread(b, 1, N, tfile);
1019: njab++;
1020: for(i=0; i<N; i++) {
1021: if (b[i] == '\n')
1022: break;
1023: m++;
1024: }
1025: if (m >= h)
1026: return (-1L);
1027: m1 = m;
1028: j = i;
1029: for(i++; i<N; i++) {
1030: m1++;
1031: if (b[i] == '\n')
1032: break;
1033: }
1034: i = cmp(b+j, s, n);
1035: if (i < 0) {
1036: h = m;
1037: goto loop;
1038: }
1039: if (i > 0) {
1040: l = m1;
1041: goto loop;
1042: }
1043: return (m);
1044: }
1045:
1046: cmp(b, s, n)
1047: char *b, *s;
1048: {
1049: register i;
1050:
1051: if (b[0] != '\n')
1052: exit(2);
1053: for(i=0; i<n; i++) {
1054: if (b[i+1] > s[i])
1055: return (-1);
1056: if (b[i+1] < s[i])
1057: return (1);
1058: }
1059: return (b[i+1] == ' '? 0 : -1);
1060: }
1061:
1062: readtape(buffer)
1063: char *buffer;
1064: {
1065: register int i;
1066:
1067: if (recno >= nblock || first == 0) {
1068: if ((i = bread(mt, tbuf, TBLOCK*nblock)) < 0) {
1069: fprintf(stderr, "tar: tape read error\n");
1070: done(3);
1071: }
1072: if (first == 0) {
1073: if ((i % TBLOCK) != 0) {
1074: fprintf(stderr, "tar: tape blocksize error\n");
1075: done(3);
1076: }
1077: i /= TBLOCK;
1078: if (i != nblock) {
1079: fprintf(stderr, "tar: blocksize = %d\n", i);
1080: nblock = i;
1081: }
1082: }
1083: recno = 0;
1084: }
1085: first = 1;
1086: bcopy((char *)&tbuf[recno++], buffer, TBLOCK);
1087: return (TBLOCK);
1088: }
1089:
1090: writetape(buffer)
1091: char *buffer;
1092: {
1093: first = 1;
1094: if (recno >= nblock) {
1095: if (write(mt, tbuf, TBLOCK*nblock) < 0) {
1096: fprintf(stderr, "tar: tape write error\n");
1097: done(2);
1098: }
1099: recno = 0;
1100: }
1101: bcopy(buffer, (char *)&tbuf[recno++], TBLOCK);
1102: if (recno >= nblock) {
1103: if (write(mt, tbuf, TBLOCK*nblock) < 0) {
1104: fprintf(stderr, "tar: tape write error\n");
1105: done(2);
1106: }
1107: recno = 0;
1108: }
1109: return (TBLOCK);
1110: }
1111:
1112: backtape()
1113: {
1114: static int mtdev = 1;
1115: static struct mtop mtop = {MTBSR, 1};
1116: struct mtget mtget;
1117:
1118: if (mtdev == 1)
1119: mtdev = ioctl(mt, MTIOCGET, &mtget);
1120: if (mtdev == 0) {
1121: if (ioctl(mt, MTIOCTOP, &mtop) < 0) {
1122: fprintf(stderr, "tar: tape backspace error\n");
1123: done(4);
1124: }
1125: } else
1126: lseek(mt, (long) -TBLOCK*nblock, 1);
1127: recno--;
1128: }
1129:
1130: flushtape()
1131: {
1132: write(mt, tbuf, TBLOCK*nblock);
1133: }
1134:
1135: bread(fd, buf, size)
1136: int fd;
1137: char *buf;
1138: int size;
1139: {
1140: int count;
1141: static int lastread = 0;
1142:
1143: if (!Bflag)
1144: return (read(fd, buf, size));
1145: for (count = 0; count < size; count += lastread) {
1146: if (lastread < 0) {
1147: if (count > 0)
1148: return (count);
1149: return (lastread);
1150: }
1151: lastread = read(fd, buf, size - count);
1152: buf += lastread;
1153: }
1154: return (count);
1155: }
1156:
1157: char *
1158: getcwd(buf)
1159: char *buf;
1160: {
1161:
1162: if (getwd(buf) == NULL) {
1163: fprintf(stderr, "tar: %s\n", buf);
1164: exit(1);
1165: }
1166: return (buf);
1167: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.