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