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