1 /*-
2 * Copyright (c) 1992 Keith Muller.
3 * Copyright (c) 1992, 1993
4 * The Regents of the University of California. All rights reserved.
5 *
6 * This code is derived from software contributed to Berkeley by
7 * Keith Muller of the University of California, San Diego.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 * 4. Neither the name of the University nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 */
33
34 #if 0
35 #ifndef lint
36 static char sccsid[] = "@(#)options.c 8.2 (Berkeley) 4/18/94";
37 #endif /* not lint */
38 #endif
39
40 #include <sys/cdefs.h>
41 __FBSDID("$FreeBSD$");
42
43 #include <sys/types.h>
44 #include <sys/stat.h>
45 #include <sys/mtio.h>
46 #include <stdio.h>
47 #include <string.h>
48 #include <errno.h>
49 #include <unistd.h>
50 #include <stdlib.h>
51 #include <limits.h>
52 #include <paths.h>
53 #include "pax.h"
54 #include "options.h"
55 #include "cpio.h"
56 #include "tar.h"
57 #include "extern.h"
58
59 /*
60 * Routines which handle command line options
61 */
62
63 static char flgch[] = FLGCH; /* list of all possible flags */
64 static OPLIST *ophead = NULL; /* head for format specific options -x */
65 static OPLIST *optail = NULL; /* option tail */
66
67 static int no_op(void);
68 static void printflg(unsigned int);
69 static int c_frmt(const void *, const void *);
70 static off_t str_offt(char *);
71 static char *getline(FILE *fp);
72 static void pax_options(int, char **);
73 static void pax_usage(void);
74 static void tar_options(int, char **);
75 static void tar_usage(void);
76 static void cpio_options(int, char **);
77 static void cpio_usage(void);
78
79 /* errors from getline */
80 #define GETLINE_FILE_CORRUPT 1
81 #define GETLINE_OUT_OF_MEM 2
82 static int getline_error;
83
84 char *chdname;
85
86 #define GZIP_CMD "gzip" /* command to run as gzip */
87 #define COMPRESS_CMD "compress" /* command to run as compress */
88 #define BZIP2_CMD "bzip2" /* command to run as gzip */
89
90 /*
91 * Format specific routine table - MUST BE IN SORTED ORDER BY NAME
92 * (see pax.h for description of each function)
93 *
94 * name, blksz, hdsz, udev, hlk, blkagn, inhead, id, st_read,
95 * read, end_read, st_write, write, end_write, trail,
96 * rd_data, wr_data, options
97 */
98
99 FSUB fsub[] = {
100 /* 0: OLD BINARY CPIO */
101 {"bcpio", 5120, sizeof(HD_BCPIO), 1, 0, 0, 1, bcpio_id, cpio_strd,
102 bcpio_rd, bcpio_endrd, cpio_stwr, bcpio_wr, cpio_endwr, cpio_trail,
103 NULL, rd_wrfile, wr_rdfile, bad_opt},
104
105 /* 1: OLD OCTAL CHARACTER CPIO */
106 {"cpio", 5120, sizeof(HD_CPIO), 1, 0, 0, 1, cpio_id, cpio_strd,
107 cpio_rd, cpio_endrd, cpio_stwr, cpio_wr, cpio_endwr, cpio_trail,
108 NULL, rd_wrfile, wr_rdfile, bad_opt},
109
110 /* 2: SVR4 HEX CPIO */
111 {"sv4cpio", 5120, sizeof(HD_VCPIO), 1, 0, 0, 1, vcpio_id, cpio_strd,
112 vcpio_rd, vcpio_endrd, cpio_stwr, vcpio_wr, cpio_endwr, cpio_trail,
113 NULL, rd_wrfile, wr_rdfile, bad_opt},
114
115 /* 3: SVR4 HEX CPIO WITH CRC */
116 {"sv4crc", 5120, sizeof(HD_VCPIO), 1, 0, 0, 1, crc_id, crc_strd,
117 vcpio_rd, vcpio_endrd, crc_stwr, vcpio_wr, cpio_endwr, cpio_trail,
118 NULL, rd_wrfile, wr_rdfile, bad_opt},
119
120 /* 4: OLD TAR */
121 {"tar", 10240, BLKMULT, 0, 1, BLKMULT, 0, tar_id, no_op,
122 tar_rd, tar_endrd, no_op, tar_wr, tar_endwr, NULL, tar_trail,
123 rd_wrfile, wr_rdfile, tar_opt},
124
125 /* 5: POSIX USTAR */
126 {"ustar", 10240, BLKMULT, 0, 1, BLKMULT, 0, ustar_id, ustar_strd,
127 ustar_rd, tar_endrd, ustar_stwr, ustar_wr, tar_endwr, NULL, tar_trail,
128 rd_wrfile, wr_rdfile, bad_opt},
129 };
130 #define F_OCPIO 0 /* format when called as cpio -6 */
131 #define F_ACPIO 1 /* format when called as cpio -c */
132 #define F_CPIO 3 /* format when called as cpio */
133 #define F_OTAR 4 /* format when called as tar -o */
134 #define F_TAR 5 /* format when called as tar */
135 #define DEFLT 5 /* default write format from list above */
136
137 /*
138 * ford is the archive search order used by get_arc() to determine what kind
139 * of archive we are dealing with. This helps to properly id archive formats
140 * some formats may be subsets of others....
141 */
142 int ford[] = {5, 4, 3, 2, 1, 0, -1 };
143
144 /*
145 * options()
146 * figure out if we are pax, tar or cpio. Call the appropriate options
147 * parser
148 */
149
150 void
options(int argc,char ** argv)151 options(int argc, char **argv)
152 {
153
154 /*
155 * Are we acting like pax, tar or cpio (based on argv[0])
156 */
157 if ((argv0 = strrchr(argv[0], '/')) != NULL)
158 argv0++;
159 else
160 argv0 = argv[0];
161
162 if (strcmp(NM_TAR, argv0) == 0) {
163 tar_options(argc, argv);
164 return;
165 }
166 else if (strcmp(NM_CPIO, argv0) == 0) {
167 cpio_options(argc, argv);
168 return;
169 }
170 /*
171 * assume pax as the default
172 */
173 argv0 = NM_PAX;
174 pax_options(argc, argv);
175 return;
176 }
177
178 /*
179 * pax_options()
180 * look at the user specified flags. set globals as required and check if
181 * the user specified a legal set of flags. If not, complain and exit
182 */
183
184 static void
pax_options(int argc,char ** argv)185 pax_options(int argc, char **argv)
186 {
187 int c;
188 size_t i;
189 unsigned int flg = 0;
190 unsigned int bflg = 0;
191 char *pt;
192 FSUB tmp;
193
194 /*
195 * process option flags
196 */
197 while ((c=getopt(argc,argv,"ab:cdf:iklno:p:rs:tuvwx:zB:DE:G:HLOPT:U:XYZ"))
198 != -1) {
199 switch (c) {
200 case 'a':
201 /*
202 * append
203 */
204 flg |= AF;
205 break;
206 case 'b':
207 /*
208 * specify blocksize
209 */
210 flg |= BF;
211 if ((wrblksz = (int)str_offt(optarg)) <= 0) {
212 paxwarn(1, "Invalid block size %s", optarg);
213 pax_usage();
214 }
215 break;
216 case 'c':
217 /*
218 * inverse match on patterns
219 */
220 cflag = 1;
221 flg |= CF;
222 break;
223 case 'd':
224 /*
225 * match only dir on extract, not the subtree at dir
226 */
227 dflag = 1;
228 flg |= DF;
229 break;
230 case 'f':
231 /*
232 * filename where the archive is stored
233 */
234 arcname = optarg;
235 flg |= FF;
236 break;
237 case 'i':
238 /*
239 * interactive file rename
240 */
241 iflag = 1;
242 flg |= IF;
243 break;
244 case 'k':
245 /*
246 * do not clobber files that exist
247 */
248 kflag = 1;
249 flg |= KF;
250 break;
251 case 'l':
252 /*
253 * try to link src to dest with copy (-rw)
254 */
255 lflag = 1;
256 flg |= LF;
257 break;
258 case 'n':
259 /*
260 * select first match for a pattern only
261 */
262 nflag = 1;
263 flg |= NF;
264 break;
265 case 'o':
266 /*
267 * pass format specific options
268 */
269 flg |= OF;
270 if (opt_add(optarg) < 0)
271 pax_usage();
272 break;
273 case 'p':
274 /*
275 * specify file characteristic options
276 */
277 for (pt = optarg; *pt != '\0'; ++pt) {
278 switch(*pt) {
279 case 'a':
280 /*
281 * do not preserve access time
282 */
283 patime = 0;
284 break;
285 case 'e':
286 /*
287 * preserve user id, group id, file
288 * mode, access/modification times
289 */
290 pids = 1;
291 pmode = 1;
292 patime = 1;
293 pmtime = 1;
294 break;
295 case 'm':
296 /*
297 * do not preserve modification time
298 */
299 pmtime = 0;
300 break;
301 case 'o':
302 /*
303 * preserve uid/gid
304 */
305 pids = 1;
306 break;
307 case 'p':
308 /*
309 * preserver file mode bits
310 */
311 pmode = 1;
312 break;
313 default:
314 paxwarn(1, "Invalid -p string: %c", *pt);
315 pax_usage();
316 break;
317 }
318 }
319 flg |= PF;
320 break;
321 case 'r':
322 /*
323 * read the archive
324 */
325 flg |= RF;
326 break;
327 case 's':
328 /*
329 * file name substitution name pattern
330 */
331 if (rep_add(optarg) < 0) {
332 pax_usage();
333 break;
334 }
335 flg |= SF;
336 break;
337 case 't':
338 /*
339 * preserve access time on file system nodes we read
340 */
341 tflag = 1;
342 flg |= TF;
343 break;
344 case 'u':
345 /*
346 * ignore those older files
347 */
348 uflag = 1;
349 flg |= UF;
350 break;
351 case 'v':
352 /*
353 * verbose operation mode
354 */
355 vflag = 1;
356 flg |= VF;
357 break;
358 case 'w':
359 /*
360 * write an archive
361 */
362 flg |= WF;
363 break;
364 case 'x':
365 /*
366 * specify an archive format on write
367 */
368 tmp.name = optarg;
369 if ((frmt = (FSUB *)bsearch((void *)&tmp, (void *)fsub,
370 sizeof(fsub)/sizeof(FSUB), sizeof(FSUB), c_frmt)) != NULL) {
371 flg |= XF;
372 break;
373 }
374 paxwarn(1, "Unknown -x format: %s", optarg);
375 (void)fputs("pax: Known -x formats are:", stderr);
376 for (i = 0; i < (sizeof(fsub)/sizeof(FSUB)); ++i)
377 (void)fprintf(stderr, " %s", fsub[i].name);
378 (void)fputs("\n\n", stderr);
379 pax_usage();
380 break;
381 case 'z':
382 /*
383 * use gzip. Non standard option.
384 */
385 gzip_program = GZIP_CMD;
386 break;
387 case 'B':
388 /*
389 * non-standard option on number of bytes written on a
390 * single archive volume.
391 */
392 if ((wrlimit = str_offt(optarg)) <= 0) {
393 paxwarn(1, "Invalid write limit %s", optarg);
394 pax_usage();
395 }
396 if (wrlimit % BLKMULT) {
397 paxwarn(1, "Write limit is not a %d byte multiple",
398 BLKMULT);
399 pax_usage();
400 }
401 flg |= CBF;
402 break;
403 case 'D':
404 /*
405 * On extraction check file inode change time before the
406 * modification of the file name. Non standard option.
407 */
408 Dflag = 1;
409 flg |= CDF;
410 break;
411 case 'E':
412 /*
413 * non-standard limit on read faults
414 * 0 indicates stop after first error, values
415 * indicate a limit, "NONE" try forever
416 */
417 flg |= CEF;
418 if (strcmp(NONE, optarg) == 0)
419 maxflt = -1;
420 else if ((maxflt = atoi(optarg)) < 0) {
421 paxwarn(1, "Error count value must be positive");
422 pax_usage();
423 }
424 break;
425 case 'G':
426 /*
427 * non-standard option for selecting files within an
428 * archive by group (gid or name)
429 */
430 if (grp_add(optarg) < 0) {
431 pax_usage();
432 break;
433 }
434 flg |= CGF;
435 break;
436 case 'H':
437 /*
438 * follow command line symlinks only
439 */
440 Hflag = 1;
441 flg |= CHF;
442 break;
443 case 'L':
444 /*
445 * follow symlinks
446 */
447 Lflag = 1;
448 flg |= CLF;
449 break;
450 case 'O':
451 /*
452 * Force one volume. Non standard option.
453 */
454 Oflag = 1;
455 break;
456 case 'P':
457 /*
458 * do NOT follow symlinks (default)
459 */
460 Lflag = 0;
461 flg |= CPF;
462 break;
463 case 'T':
464 /*
465 * non-standard option for selecting files within an
466 * archive by modification time range (lower,upper)
467 */
468 if (trng_add(optarg) < 0) {
469 pax_usage();
470 break;
471 }
472 flg |= CTF;
473 break;
474 case 'U':
475 /*
476 * non-standard option for selecting files within an
477 * archive by user (uid or name)
478 */
479 if (usr_add(optarg) < 0) {
480 pax_usage();
481 break;
482 }
483 flg |= CUF;
484 break;
485 case 'X':
486 /*
487 * do not pass over mount points in the file system
488 */
489 Xflag = 1;
490 flg |= CXF;
491 break;
492 case 'Y':
493 /*
494 * On extraction check file inode change time after the
495 * modification of the file name. Non standard option.
496 */
497 Yflag = 1;
498 flg |= CYF;
499 break;
500 case 'Z':
501 /*
502 * On extraction check modification time after the
503 * modification of the file name. Non standard option.
504 */
505 Zflag = 1;
506 flg |= CZF;
507 break;
508 default:
509 pax_usage();
510 break;
511 }
512 }
513
514 /*
515 * figure out the operation mode of pax read,write,extract,copy,append
516 * or list. check that we have not been given a bogus set of flags
517 * for the operation mode.
518 */
519 if (ISLIST(flg)) {
520 act = LIST;
521 listf = stdout;
522 bflg = flg & BDLIST;
523 } else if (ISEXTRACT(flg)) {
524 act = EXTRACT;
525 bflg = flg & BDEXTR;
526 } else if (ISARCHIVE(flg)) {
527 act = ARCHIVE;
528 bflg = flg & BDARCH;
529 } else if (ISAPPND(flg)) {
530 act = APPND;
531 bflg = flg & BDARCH;
532 } else if (ISCOPY(flg)) {
533 act = COPY;
534 bflg = flg & BDCOPY;
535 } else
536 pax_usage();
537 if (bflg) {
538 printflg(flg);
539 pax_usage();
540 }
541
542 /*
543 * if we are writing (ARCHIVE) we use the default format if the user
544 * did not specify a format. when we write during an APPEND, we will
545 * adopt the format of the existing archive if none was supplied.
546 */
547 if (!(flg & XF) && (act == ARCHIVE))
548 frmt = &(fsub[DEFLT]);
549
550 /*
551 * process the args as they are interpreted by the operation mode
552 */
553 switch (act) {
554 case LIST:
555 case EXTRACT:
556 for (; optind < argc; optind++)
557 if (pat_add(argv[optind], NULL) < 0)
558 pax_usage();
559 break;
560 case COPY:
561 if (optind >= argc) {
562 paxwarn(0, "Destination directory was not supplied");
563 pax_usage();
564 }
565 --argc;
566 dirptr = argv[argc];
567 /* FALLTHROUGH */
568 case ARCHIVE:
569 case APPND:
570 for (; optind < argc; optind++)
571 if (ftree_add(argv[optind], 0) < 0)
572 pax_usage();
573 /*
574 * no read errors allowed on updates/append operation!
575 */
576 maxflt = 0;
577 break;
578 }
579 }
580
581
582 /*
583 * tar_options()
584 * look at the user specified flags. set globals as required and check if
585 * the user specified a legal set of flags. If not, complain and exit
586 */
587
588 static void
tar_options(int argc,char ** argv)589 tar_options(int argc, char **argv)
590 {
591 int c;
592 int fstdin = 0;
593 int tar_Oflag = 0;
594 int nincfiles = 0;
595 int incfiles_max = 0;
596 struct incfile {
597 char *file;
598 char *dir;
599 };
600 struct incfile *incfiles = NULL;
601
602 /*
603 * Set default values.
604 */
605 rmleadslash = 1;
606
607 /*
608 * process option flags
609 */
610 while ((c = getoldopt(argc, argv,
611 "b:cef:hjmopqruts:vwxyzBC:HI:LOPXZ014578")) != -1) {
612 switch(c) {
613 case 'b':
614 /*
615 * specify blocksize in 512-byte blocks
616 */
617 if ((wrblksz = (int)str_offt(optarg)) <= 0) {
618 paxwarn(1, "Invalid block size %s", optarg);
619 tar_usage();
620 }
621 wrblksz *= 512; /* XXX - check for int oflow */
622 break;
623 case 'c':
624 /*
625 * create an archive
626 */
627 act = ARCHIVE;
628 break;
629 case 'e':
630 /*
631 * stop after first error
632 */
633 maxflt = 0;
634 break;
635 case 'f':
636 /*
637 * filename where the archive is stored
638 */
639 if ((optarg[0] == '-') && (optarg[1]== '\0')) {
640 /*
641 * treat a - as stdin
642 */
643 fstdin = 1;
644 arcname = NULL;
645 break;
646 }
647 fstdin = 0;
648 arcname = optarg;
649 break;
650 case 'h':
651 /*
652 * follow symlinks
653 */
654 Lflag = 1;
655 break;
656 case 'j':
657 case 'y':
658 /*
659 * use bzip2. Non standard option.
660 */
661 gzip_program = BZIP2_CMD;
662 break;
663 case 'm':
664 /*
665 * do not preserve modification time
666 */
667 pmtime = 0;
668 break;
669 case 'o':
670 if (opt_add("write_opt=nodir") < 0)
671 tar_usage();
672 case 'O':
673 tar_Oflag = 1;
674 break;
675 case 'p':
676 /*
677 * preserve uid/gid and file mode, regardless of umask
678 */
679 pmode = 1;
680 pids = 1;
681 break;
682 case 'q':
683 /*
684 * select first match for a pattern only
685 */
686 nflag = 1;
687 break;
688 case 'r':
689 case 'u':
690 /*
691 * append to the archive
692 */
693 act = APPND;
694 break;
695 case 's':
696 /*
697 * file name substitution name pattern
698 */
699 if (rep_add(optarg) < 0) {
700 tar_usage();
701 break;
702 }
703 break;
704 case 't':
705 /*
706 * list contents of the tape
707 */
708 act = LIST;
709 break;
710 case 'v':
711 /*
712 * verbose operation mode
713 */
714 vflag++;
715 break;
716 case 'w':
717 /*
718 * interactive file rename
719 */
720 iflag = 1;
721 break;
722 case 'x':
723 /*
724 * extract an archive, preserving mode,
725 * and mtime if possible.
726 */
727 act = EXTRACT;
728 pmtime = 1;
729 break;
730 case 'z':
731 /*
732 * use gzip. Non standard option.
733 */
734 gzip_program = GZIP_CMD;
735 break;
736 case 'B':
737 /*
738 * Nothing to do here, this is pax default
739 */
740 break;
741 case 'C':
742 chdname = optarg;
743 break;
744 case 'H':
745 /*
746 * follow command line symlinks only
747 */
748 Hflag = 1;
749 break;
750 case 'I':
751 if (++nincfiles > incfiles_max) {
752 incfiles_max = nincfiles + 3;
753 incfiles = realloc(incfiles,
754 sizeof(*incfiles) * incfiles_max);
755 if (incfiles == NULL) {
756 paxwarn(0, "Unable to allocate space "
757 "for option list");
758 exit(1);
759 }
760 }
761 incfiles[nincfiles - 1].file = optarg;
762 incfiles[nincfiles - 1].dir = chdname;
763 break;
764 case 'L':
765 /*
766 * follow symlinks
767 */
768 Lflag = 1;
769 break;
770 case 'P':
771 /*
772 * do not remove leading '/' from pathnames
773 */
774 rmleadslash = 0;
775 break;
776 case 'X':
777 /*
778 * do not pass over mount points in the file system
779 */
780 Xflag = 1;
781 break;
782 case 'Z':
783 /*
784 * use compress.
785 */
786 gzip_program = COMPRESS_CMD;
787 break;
788 case '0':
789 arcname = DEV_0;
790 break;
791 case '1':
792 arcname = DEV_1;
793 break;
794 case '4':
795 arcname = DEV_4;
796 break;
797 case '5':
798 arcname = DEV_5;
799 break;
800 case '7':
801 arcname = DEV_7;
802 break;
803 case '8':
804 arcname = DEV_8;
805 break;
806 default:
807 tar_usage();
808 break;
809 }
810 }
811 argc -= optind;
812 argv += optind;
813
814 /* Traditional tar behaviour (pax uses stderr unless in list mode) */
815 if (fstdin == 1 && act == ARCHIVE)
816 listf = stderr;
817 else
818 listf = stdout;
819
820 /* Traditional tar behaviour (pax wants to read file list from stdin) */
821 if ((act == ARCHIVE || act == APPND) && argc == 0 && nincfiles == 0)
822 exit(0);
823
824 /*
825 * if we are writing (ARCHIVE) specify tar, otherwise run like pax
826 * (unless -o specified)
827 */
828 if (act == ARCHIVE || act == APPND)
829 frmt = &(fsub[tar_Oflag ? F_OTAR : F_TAR]);
830 else if (tar_Oflag) {
831 paxwarn(1, "The -O/-o options are only valid when writing an archive");
832 tar_usage(); /* only valid when writing */
833 }
834
835 /*
836 * process the args as they are interpreted by the operation mode
837 */
838 switch (act) {
839 case LIST:
840 case EXTRACT:
841 default:
842 {
843 int sawpat = 0;
844 char *file, *dir = NULL;
845
846 while (nincfiles || *argv != NULL) {
847 /*
848 * If we queued up any include files,
849 * pull them in now. Otherwise, check
850 * for -I and -C positional flags.
851 * Anything else must be a file to
852 * extract.
853 */
854 if (nincfiles) {
855 file = incfiles->file;
856 dir = incfiles->dir;
857 incfiles++;
858 nincfiles--;
859 } else if (strcmp(*argv, "-I") == 0) {
860 if (*++argv == NULL)
861 break;
862 file = *argv++;
863 dir = chdname;
864 } else
865 file = NULL;
866 if (file != NULL) {
867 FILE *fp;
868 char *str;
869
870 if (strcmp(file, "-") == 0)
871 fp = stdin;
872 else if ((fp = fopen(file, "r")) == NULL) {
873 paxwarn(1, "Unable to open file '%s' for read", file);
874 tar_usage();
875 }
876 while ((str = getline(fp)) != NULL) {
877 if (pat_add(str, dir) < 0)
878 tar_usage();
879 sawpat = 1;
880 }
881 if (strcmp(file, "-") != 0)
882 fclose(fp);
883 if (getline_error) {
884 paxwarn(1, "Problem with file '%s'", file);
885 tar_usage();
886 }
887 } else if (strcmp(*argv, "-C") == 0) {
888 if (*++argv == NULL)
889 break;
890 chdname = *argv++;
891 } else if (pat_add(*argv++, chdname) < 0)
892 tar_usage();
893 else
894 sawpat = 1;
895 }
896 /*
897 * if patterns were added, we are doing chdir()
898 * on a file-by-file basis, else, just one
899 * global chdir (if any) after opening input.
900 */
901 if (sawpat > 0)
902 chdname = NULL;
903 }
904 break;
905 case ARCHIVE:
906 case APPND:
907 if (chdname != NULL) { /* initial chdir() */
908 if (ftree_add(chdname, 1) < 0)
909 tar_usage();
910 }
911
912 while (nincfiles || *argv != NULL) {
913 char *file, *dir = NULL;
914
915 /*
916 * If we queued up any include files, pull them in
917 * now. Otherwise, check for -I and -C positional
918 * flags. Anything else must be a file to include
919 * in the archive.
920 */
921 if (nincfiles) {
922 file = incfiles->file;
923 dir = incfiles->dir;
924 incfiles++;
925 nincfiles--;
926 } else if (strcmp(*argv, "-I") == 0) {
927 if (*++argv == NULL)
928 break;
929 file = *argv++;
930 dir = NULL;
931 } else
932 file = NULL;
933 if (file != NULL) {
934 FILE *fp;
935 char *str;
936
937 /* Set directory if needed */
938 if (dir) {
939 if (ftree_add(dir, 1) < 0)
940 tar_usage();
941 }
942
943 if (strcmp(file, "-") == 0)
944 fp = stdin;
945 else if ((fp = fopen(file, "r")) == NULL) {
946 paxwarn(1, "Unable to open file '%s' for read", file);
947 tar_usage();
948 }
949 while ((str = getline(fp)) != NULL) {
950 if (ftree_add(str, 0) < 0)
951 tar_usage();
952 }
953 if (strcmp(file, "-") != 0)
954 fclose(fp);
955 if (getline_error) {
956 paxwarn(1, "Problem with file '%s'",
957 file);
958 tar_usage();
959 }
960 } else if (strcmp(*argv, "-C") == 0) {
961 if (*++argv == NULL)
962 break;
963 if (ftree_add(*argv++, 1) < 0)
964 tar_usage();
965 } else if (ftree_add(*argv++, 0) < 0)
966 tar_usage();
967 }
968 /*
969 * no read errors allowed on updates/append operation!
970 */
971 maxflt = 0;
972 break;
973 }
974 if (!fstdin && ((arcname == NULL) || (*arcname == '\0'))) {
975 arcname = getenv("TAPE");
976 if ((arcname == NULL) || (*arcname == '\0'))
977 arcname = _PATH_DEFTAPE;
978 }
979 }
980
981 static int
mkpath(char * path)982 mkpath(char *path)
983 {
984 struct stat sb;
985 char *slash;
986 int done = 0;
987
988 slash = path;
989
990 while (!done) {
991 slash += strspn(slash, "/");
992 slash += strcspn(slash, "/");
993
994 done = (*slash == '\0');
995 *slash = '\0';
996
997 if (stat(path, &sb)) {
998 if (errno != ENOENT || mkdir(path, 0777)) {
999 paxwarn(1, "%s", path);
1000 return (-1);
1001 }
1002 } else if (!S_ISDIR(sb.st_mode)) {
1003 syswarn(1, ENOTDIR, "%s", path);
1004 return (-1);
1005 }
1006
1007 if (!done)
1008 *slash = '/';
1009 }
1010
1011 return (0);
1012 }
1013 /*
1014 * cpio_options()
1015 * look at the user specified flags. set globals as required and check if
1016 * the user specified a legal set of flags. If not, complain and exit
1017 */
1018
1019 static void
cpio_options(int argc,char ** argv)1020 cpio_options(int argc, char **argv)
1021 {
1022 int c;
1023 size_t i;
1024 char *str;
1025 FSUB tmp;
1026 FILE *fp;
1027
1028 kflag = 1;
1029 pids = 1;
1030 pmode = 1;
1031 pmtime = 0;
1032 arcname = NULL;
1033 dflag = 1;
1034 act = -1;
1035 nodirs = 1;
1036 while ((c=getopt(argc,argv,"abcdfiklmoprstuvzABC:E:F:H:I:LO:SZ6")) != -1)
1037 switch (c) {
1038 case 'a':
1039 /*
1040 * preserve access time on files read
1041 */
1042 tflag = 1;
1043 break;
1044 case 'b':
1045 /*
1046 * swap bytes and half-words when reading data
1047 */
1048 break;
1049 case 'c':
1050 /*
1051 * ASCII cpio header
1052 */
1053 frmt = &(fsub[F_ACPIO]);
1054 break;
1055 case 'd':
1056 /*
1057 * create directories as needed
1058 */
1059 nodirs = 0;
1060 break;
1061 case 'f':
1062 /*
1063 * invert meaning of pattern list
1064 */
1065 cflag = 1;
1066 break;
1067 case 'i':
1068 /*
1069 * restore an archive
1070 */
1071 act = EXTRACT;
1072 break;
1073 case 'k':
1074 break;
1075 case 'l':
1076 /*
1077 * use links instead of copies when possible
1078 */
1079 lflag = 1;
1080 break;
1081 case 'm':
1082 /*
1083 * preserve modification time
1084 */
1085 pmtime = 1;
1086 break;
1087 case 'o':
1088 /*
1089 * create an archive
1090 */
1091 act = ARCHIVE;
1092 frmt = &(fsub[F_CPIO]);
1093 break;
1094 case 'p':
1095 /*
1096 * copy-pass mode
1097 */
1098 act = COPY;
1099 break;
1100 case 'r':
1101 /*
1102 * interactively rename files
1103 */
1104 iflag = 1;
1105 break;
1106 case 's':
1107 /*
1108 * swap bytes after reading data
1109 */
1110 break;
1111 case 't':
1112 /*
1113 * list contents of archive
1114 */
1115 act = LIST;
1116 listf = stdout;
1117 break;
1118 case 'u':
1119 /*
1120 * replace newer files
1121 */
1122 kflag = 0;
1123 break;
1124 case 'v':
1125 /*
1126 * verbose operation mode
1127 */
1128 vflag = 1;
1129 break;
1130 case 'z':
1131 /*
1132 * use gzip. Non standard option.
1133 */
1134 gzip_program = GZIP_CMD;
1135 break;
1136 case 'A':
1137 /*
1138 * append mode
1139 */
1140 act = APPND;
1141 break;
1142 case 'B':
1143 /*
1144 * Use 5120 byte block size
1145 */
1146 wrblksz = 5120;
1147 break;
1148 case 'C':
1149 /*
1150 * set block size in bytes
1151 */
1152 wrblksz = atoi(optarg);
1153 break;
1154 case 'E':
1155 /*
1156 * file with patterns to extract or list
1157 */
1158 if ((fp = fopen(optarg, "r")) == NULL) {
1159 paxwarn(1, "Unable to open file '%s' for read", optarg);
1160 cpio_usage();
1161 }
1162 while ((str = getline(fp)) != NULL) {
1163 pat_add(str, NULL);
1164 }
1165 fclose(fp);
1166 if (getline_error) {
1167 paxwarn(1, "Problem with file '%s'", optarg);
1168 cpio_usage();
1169 }
1170 break;
1171 case 'F':
1172 case 'I':
1173 case 'O':
1174 /*
1175 * filename where the archive is stored
1176 */
1177 if ((optarg[0] == '-') && (optarg[1]== '\0')) {
1178 /*
1179 * treat a - as stdin
1180 */
1181 arcname = NULL;
1182 break;
1183 }
1184 arcname = optarg;
1185 break;
1186 case 'H':
1187 /*
1188 * specify an archive format on write
1189 */
1190 tmp.name = optarg;
1191 if ((frmt = (FSUB *)bsearch((void *)&tmp, (void *)fsub,
1192 sizeof(fsub)/sizeof(FSUB), sizeof(FSUB), c_frmt)) != NULL)
1193 break;
1194 paxwarn(1, "Unknown -H format: %s", optarg);
1195 (void)fputs("cpio: Known -H formats are:", stderr);
1196 for (i = 0; i < (sizeof(fsub)/sizeof(FSUB)); ++i)
1197 (void)fprintf(stderr, " %s", fsub[i].name);
1198 (void)fputs("\n\n", stderr);
1199 cpio_usage();
1200 break;
1201 case 'L':
1202 /*
1203 * follow symbolic links
1204 */
1205 Lflag = 1;
1206 break;
1207 case 'S':
1208 /*
1209 * swap halfwords after reading data
1210 */
1211 break;
1212 case 'Z':
1213 /*
1214 * use compress. Non standard option.
1215 */
1216 gzip_program = COMPRESS_CMD;
1217 break;
1218 case '6':
1219 /*
1220 * process Version 6 cpio format
1221 */
1222 frmt = &(fsub[F_OCPIO]);
1223 break;
1224 case '?':
1225 default:
1226 cpio_usage();
1227 break;
1228 }
1229 argc -= optind;
1230 argv += optind;
1231
1232 /*
1233 * process the args as they are interpreted by the operation mode
1234 */
1235 switch (act) {
1236 case LIST:
1237 case EXTRACT:
1238 while (*argv != NULL)
1239 if (pat_add(*argv++, NULL) < 0)
1240 cpio_usage();
1241 break;
1242 case COPY:
1243 if (*argv == NULL) {
1244 paxwarn(0, "Destination directory was not supplied");
1245 cpio_usage();
1246 }
1247 dirptr = *argv;
1248 if (mkpath(dirptr) < 0)
1249 cpio_usage();
1250 --argc;
1251 ++argv;
1252 /* FALLTHROUGH */
1253 case ARCHIVE:
1254 case APPND:
1255 if (*argv != NULL)
1256 cpio_usage();
1257 /*
1258 * no read errors allowed on updates/append operation!
1259 */
1260 maxflt = 0;
1261 while ((str = getline(stdin)) != NULL) {
1262 ftree_add(str, 0);
1263 }
1264 if (getline_error) {
1265 paxwarn(1, "Problem while reading stdin");
1266 cpio_usage();
1267 }
1268 break;
1269 default:
1270 cpio_usage();
1271 break;
1272 }
1273 }
1274
1275 /*
1276 * printflg()
1277 * print out those invalid flag sets found to the user
1278 */
1279
1280 static void
printflg(unsigned int flg)1281 printflg(unsigned int flg)
1282 {
1283 int nxt;
1284 int pos = 0;
1285
1286 (void)fprintf(stderr,"%s: Invalid combination of options:", argv0);
1287 while ((nxt = ffs(flg)) != 0) {
1288 flg = flg >> nxt;
1289 pos += nxt;
1290 (void)fprintf(stderr, " -%c", flgch[pos-1]);
1291 }
1292 (void)putc('\n', stderr);
1293 }
1294
1295 /*
1296 * c_frmt()
1297 * comparison routine used by bsearch to find the format specified
1298 * by the user
1299 */
1300
1301 static int
c_frmt(const void * a,const void * b)1302 c_frmt(const void *a, const void *b)
1303 {
1304 return(strcmp(((const FSUB *)a)->name, ((const FSUB *)b)->name));
1305 }
1306
1307 /*
1308 * opt_next()
1309 * called by format specific options routines to get each format specific
1310 * flag and value specified with -o
1311 * Return:
1312 * pointer to next OPLIST entry or NULL (end of list).
1313 */
1314
1315 OPLIST *
opt_next(void)1316 opt_next(void)
1317 {
1318 OPLIST *opt;
1319
1320 if ((opt = ophead) != NULL)
1321 ophead = ophead->fow;
1322 return(opt);
1323 }
1324
1325 /*
1326 * bad_opt()
1327 * generic routine used to complain about a format specific options
1328 * when the format does not support options.
1329 */
1330
1331 int
bad_opt(void)1332 bad_opt(void)
1333 {
1334 OPLIST *opt;
1335
1336 if (ophead == NULL)
1337 return(0);
1338 /*
1339 * print all we were given
1340 */
1341 paxwarn(1,"These format options are not supported");
1342 while ((opt = opt_next()) != NULL)
1343 (void)fprintf(stderr, "\t%s = %s\n", opt->name, opt->value);
1344 pax_usage();
1345 return(0);
1346 }
1347
1348 /*
1349 * opt_add()
1350 * breaks the value supplied to -o into an option name and value. Options
1351 * are given to -o in the form -o name-value,name=value
1352 * multiple -o may be specified.
1353 * Return:
1354 * 0 if format in name=value format, -1 if -o is passed junk.
1355 */
1356
1357 int
opt_add(const char * str)1358 opt_add(const char *str)
1359 {
1360 OPLIST *opt;
1361 char *frpt;
1362 char *pt;
1363 char *endpt;
1364 char *lstr;
1365
1366 if ((str == NULL) || (*str == '\0')) {
1367 paxwarn(0, "Invalid option name");
1368 return(-1);
1369 }
1370 if ((lstr = strdup(str)) == NULL) {
1371 paxwarn(0, "Unable to allocate space for option list");
1372 return(-1);
1373 }
1374 frpt = endpt = lstr;
1375
1376 /*
1377 * break into name and values pieces and stuff each one into a
1378 * OPLIST structure. When we know the format, the format specific
1379 * option function will go through this list
1380 */
1381 while ((frpt != NULL) && (*frpt != '\0')) {
1382 if ((endpt = strchr(frpt, ',')) != NULL)
1383 *endpt = '\0';
1384 if ((pt = strchr(frpt, '=')) == NULL) {
1385 paxwarn(0, "Invalid options format");
1386 free(lstr);
1387 return(-1);
1388 }
1389 if ((opt = (OPLIST *)malloc(sizeof(OPLIST))) == NULL) {
1390 paxwarn(0, "Unable to allocate space for option list");
1391 free(lstr);
1392 return(-1);
1393 }
1394 *pt++ = '\0';
1395 opt->name = frpt;
1396 opt->value = pt;
1397 opt->fow = NULL;
1398 if (endpt != NULL)
1399 frpt = endpt + 1;
1400 else
1401 frpt = NULL;
1402 if (ophead == NULL) {
1403 optail = ophead = opt;
1404 continue;
1405 }
1406 optail->fow = opt;
1407 optail = opt;
1408 }
1409 return(0);
1410 }
1411
1412 /*
1413 * str_offt()
1414 * Convert an expression of the following forms to an off_t > 0.
1415 * 1) A positive decimal number.
1416 * 2) A positive decimal number followed by a b (mult by 512).
1417 * 3) A positive decimal number followed by a k (mult by 1024).
1418 * 4) A positive decimal number followed by a m (mult by 512).
1419 * 5) A positive decimal number followed by a w (mult by sizeof int)
1420 * 6) Two or more positive decimal numbers (with/without k,b or w).
1421 * separated by x (also * for backwards compatibility), specifying
1422 * the product of the indicated values.
1423 * Return:
1424 * 0 for an error, a positive value o.w.
1425 */
1426
1427 static off_t
str_offt(char * val)1428 str_offt(char *val)
1429 {
1430 char *expr;
1431 off_t num, t;
1432
1433 # ifdef NET2_STAT
1434 num = strtol(val, &expr, 0);
1435 if ((num == LONG_MAX) || (num <= 0) || (expr == val))
1436 # else
1437 num = strtoq(val, &expr, 0);
1438 if ((num == QUAD_MAX) || (num <= 0) || (expr == val))
1439 # endif
1440 return(0);
1441
1442 switch(*expr) {
1443 case 'b':
1444 t = num;
1445 num *= 512;
1446 if (t > num)
1447 return(0);
1448 ++expr;
1449 break;
1450 case 'k':
1451 t = num;
1452 num *= 1024;
1453 if (t > num)
1454 return(0);
1455 ++expr;
1456 break;
1457 case 'm':
1458 t = num;
1459 num *= 1048576;
1460 if (t > num)
1461 return(0);
1462 ++expr;
1463 break;
1464 case 'w':
1465 t = num;
1466 num *= sizeof(int);
1467 if (t > num)
1468 return(0);
1469 ++expr;
1470 break;
1471 }
1472
1473 switch(*expr) {
1474 case '\0':
1475 break;
1476 case '*':
1477 case 'x':
1478 t = num;
1479 num *= str_offt(expr + 1);
1480 if (t > num)
1481 return(0);
1482 break;
1483 default:
1484 return(0);
1485 }
1486 return(num);
1487 }
1488
1489 char *
getline(FILE * f)1490 getline(FILE *f)
1491 {
1492 char *name, *temp;
1493 size_t len;
1494
1495 name = fgetln(f, &len);
1496 if (!name) {
1497 getline_error = ferror(f) ? GETLINE_FILE_CORRUPT : 0;
1498 return(0);
1499 }
1500 if (name[len-1] != '\n')
1501 len++;
1502 temp = malloc(len);
1503 if (!temp) {
1504 getline_error = GETLINE_OUT_OF_MEM;
1505 return(0);
1506 }
1507 memcpy(temp, name, len-1);
1508 temp[len-1] = 0;
1509 return(temp);
1510 }
1511
1512 /*
1513 * no_op()
1514 * for those option functions where the archive format has nothing to do.
1515 * Return:
1516 * 0
1517 */
1518
1519 static int
no_op(void)1520 no_op(void)
1521 {
1522 return(0);
1523 }
1524
1525 /*
1526 * pax_usage()
1527 * print the usage summary to the user
1528 */
1529
1530 void
pax_usage(void)1531 pax_usage(void)
1532 {
1533 (void)fputs("usage: pax [-cdnOvz] [-E limit] [-f archive] ", stderr);
1534 (void)fputs("[-s replstr] ... [-U user] ...", stderr);
1535 (void)fputs("\n [-G group] ... ", stderr);
1536 (void)fputs("[-T [from_date][,to_date]] ... ", stderr);
1537 (void)fputs("[pattern ...]\n", stderr);
1538 (void)fputs(" pax -r [-cdiknOuvzDYZ] [-E limit] ", stderr);
1539 (void)fputs("[-f archive] [-o options] ... \n", stderr);
1540 (void)fputs(" [-p string] ... [-s replstr] ... ", stderr);
1541 (void)fputs("[-U user] ... [-G group] ...\n ", stderr);
1542 (void)fputs("[-T [from_date][,to_date]] ... ", stderr);
1543 (void)fputs(" [pattern ...]\n", stderr);
1544 (void)fputs(" pax -w [-dituvzHLOPX] [-b blocksize] ", stderr);
1545 (void)fputs("[ [-a] [-f archive] ] [-x format] \n", stderr);
1546 (void)fputs(" [-B bytes] [-s replstr] ... ", stderr);
1547 (void)fputs("[-o options] ... [-U user] ...", stderr);
1548 (void)fputs("\n [-G group] ... ", stderr);
1549 (void)fputs("[-T [from_date][,to_date][/[c][m]]] ... ", stderr);
1550 (void)fputs("[file ...]\n", stderr);
1551 (void)fputs(" pax -r -w [-diklntuvDHLOPXYZ] ", stderr);
1552 (void)fputs("[-p string] ... [-s replstr] ...", stderr);
1553 (void)fputs("\n [-U user] ... [-G group] ... ", stderr);
1554 (void)fputs("[-T [from_date][,to_date][/[c][m]]] ... ", stderr);
1555 (void)fputs("\n [file ...] directory\n", stderr);
1556 exit(1);
1557 }
1558
1559 /*
1560 * tar_usage()
1561 * print the usage summary to the user
1562 */
1563
1564 void
tar_usage(void)1565 tar_usage(void)
1566 {
1567 (void)fputs("usage: tar [-]{crtux}[-befhjmopqsvwyzHLOPXZ014578] [blocksize] ",
1568 stderr);
1569 (void)fputs("[archive] [replstr] [-C directory] [-I file] [file ...]\n",
1570 stderr);
1571 exit(1);
1572 }
1573
1574 /*
1575 * cpio_usage()
1576 * print the usage summary to the user
1577 */
1578
1579 void
cpio_usage(void)1580 cpio_usage(void)
1581 {
1582 (void)fputs("usage: cpio -o [-aABcLvVzZ] [-C bytes] [-H format] [-O archive]\n", stderr);
1583 (void)fputs(" [-F archive] < name-list [> archive]\n", stderr);
1584 (void)fputs(" cpio -i [-bBcdfmnrsStuvVzZ6] [-C bytes] [-E file] [-H format]\n", stderr);
1585 (void)fputs(" [-I archive] [-F archive] [pattern...] [< archive]\n", stderr);
1586 (void)fputs(" cpio -p [-adlLmuvV] destination-directory < name-list\n", stderr);
1587 exit(1);
1588 }
1589