/usr.bin/tar/cmdline.c

  1/*-
  2 * Copyright (c) 2003-2008 Tim Kientzle
  3 * All rights reserved.
  4 *
  5 * Redistribution and use in source and binary forms, with or without
  6 * modification, are permitted provided that the following conditions
  7 * are met:
  8 * 1. Redistributions of source code must retain the above copyright
  9 *    notice, this list of conditions and the following disclaimer.
 10 * 2. Redistributions in binary form must reproduce the above copyright
 11 *    notice, this list of conditions and the following disclaimer in the
 12 *    documentation and/or other materials provided with the distribution.
 13 *
 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 17 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 24 */
 25
 26/*
 27 * Command line parser for tar.
 28 */
 29
 30#include "bsdtar_platform.h"
 31__FBSDID("$FreeBSD$");
 32
 33#ifdef HAVE_ERRNO_H
 34#include <errno.h>
 35#endif
 36#ifdef HAVE_STDLIB_H
 37#include <stdlib.h>
 38#endif
 39#ifdef HAVE_STRING_H
 40#include <string.h>
 41#endif
 42
 43#include "bsdtar.h"
 44#include "err.h"
 45
 46/*
 47 * Short options for tar.  Please keep this sorted.
 48 */
 49static const char *short_options
 50	= "Bb:C:cf:HhI:JjkLlmnOoPpqrSs:T:tUuvW:wX:xyZz";
 51
 52/*
 53 * Long options for tar.  Please keep this list sorted.
 54 *
 55 * The symbolic names for options that lack a short equivalent are
 56 * defined in bsdtar.h.  Also note that so far I've found no need
 57 * to support optional arguments to long options.  That would be
 58 * a small change to the code below.
 59 */
 60
 61static struct option {
 62	const char *name;
 63	int required;      /* 1 if this option requires an argument. */
 64	int equivalent;    /* Equivalent short option. */
 65} tar_longopts[] = {
 66	{ "absolute-paths",       0, 'P' },
 67	{ "append",               0, 'r' },
 68	{ "block-size",           1, 'b' },
 69	{ "bunzip2",              0, 'j' },
 70	{ "bzip",                 0, 'j' },
 71	{ "bzip2",                0, 'j' },
 72	{ "cd",                   1, 'C' },
 73	{ "check-links",          0, OPTION_CHECK_LINKS },
 74	{ "chroot",               0, OPTION_CHROOT },
 75	{ "compress",             0, 'Z' },
 76	{ "confirmation",         0, 'w' },
 77	{ "create",               0, 'c' },
 78	{ "dereference",	  0, 'L' },
 79	{ "directory",            1, 'C' },
 80	{ "exclude",              1, OPTION_EXCLUDE },
 81	{ "exclude-from",         1, 'X' },
 82	{ "extract",              0, 'x' },
 83	{ "fast-read",            0, 'q' },
 84	{ "file",                 1, 'f' },
 85	{ "files-from",           1, 'T' },
 86	{ "format",               1, OPTION_FORMAT },
 87	{ "gid",		  1, OPTION_GID },
 88	{ "gname",		  1, OPTION_GNAME },
 89	{ "gunzip",               0, 'z' },
 90	{ "gzip",                 0, 'z' },
 91	{ "help",                 0, OPTION_HELP },
 92	{ "include",              1, OPTION_INCLUDE },
 93	{ "interactive",          0, 'w' },
 94	{ "insecure",             0, 'P' },
 95	{ "keep-newer-files",     0, OPTION_KEEP_NEWER_FILES },
 96	{ "keep-old-files",       0, 'k' },
 97	{ "list",                 0, 't' },
 98	{ "lzma",                 0, OPTION_LZMA },
 99	{ "modification-time",    0, 'm' },
100	{ "newer",		  1, OPTION_NEWER_CTIME },
101	{ "newer-ctime",	  1, OPTION_NEWER_CTIME },
102	{ "newer-ctime-than",	  1, OPTION_NEWER_CTIME_THAN },
103	{ "newer-mtime",	  1, OPTION_NEWER_MTIME },
104	{ "newer-mtime-than",	  1, OPTION_NEWER_MTIME_THAN },
105	{ "newer-than",		  1, OPTION_NEWER_CTIME_THAN },
106	{ "nodump",               0, OPTION_NODUMP },
107	{ "norecurse",            0, 'n' },
108	{ "no-recursion",         0, 'n' },
109	{ "no-same-owner",	  0, OPTION_NO_SAME_OWNER },
110	{ "no-same-permissions",  0, OPTION_NO_SAME_PERMISSIONS },
111	{ "null",		  0, OPTION_NULL },
112	{ "numeric-owner",	  0, OPTION_NUMERIC_OWNER },
113	{ "one-file-system",	  0, OPTION_ONE_FILE_SYSTEM },
114	{ "options",              1, OPTION_OPTIONS },
115	{ "posix",		  0, OPTION_POSIX },
116	{ "preserve-permissions", 0, 'p' },
117	{ "read-full-blocks",	  0, 'B' },
118	{ "same-owner",	          0, OPTION_SAME_OWNER },
119	{ "same-permissions",     0, 'p' },
120	{ "strip-components",	  1, OPTION_STRIP_COMPONENTS },
121	{ "to-stdout",            0, 'O' },
122	{ "totals",		  0, OPTION_TOTALS },
123	{ "uid",		  1, OPTION_UID },
124	{ "uname",		  1, OPTION_UNAME },
125	{ "uncompress",           0, 'Z' },
126	{ "unlink",		  0, 'U' },
127	{ "unlink-first",	  0, 'U' },
128	{ "update",               0, 'u' },
129	{ "use-compress-program", 1, OPTION_USE_COMPRESS_PROGRAM },
130	{ "verbose",              0, 'v' },
131	{ "version",              0, OPTION_VERSION },
132	{ "xz",                   0, 'J' },
133	{ NULL, 0, 0 }
134};
135
136/*
137 * This getopt implementation has two key features that common
138 * getopt_long() implementations lack.  Apart from those, it's a
139 * straightforward option parser, considerably simplified by not
140 * needing to support the wealth of exotic getopt_long() features.  It
141 * has, of course, been shamelessly tailored for bsdtar.  (If you're
142 * looking for a generic getopt_long() implementation for your
143 * project, I recommend Gregory Pietsch's public domain getopt_long()
144 * implementation.)  The two additional features are:
145 *
146 * Old-style tar arguments: The original tar implementation treated
147 * the first argument word as a list of single-character option
148 * letters.  All arguments follow as separate words.  For example,
149 *    tar xbf 32 /dev/tape
150 * Here, the "xbf" is three option letters, "32" is the argument for
151 * "b" and "/dev/tape" is the argument for "f".  We support this usage
152 * if the first command-line argument does not begin with '-'.  We
153 * also allow regular short and long options to follow, e.g.,
154 *    tar xbf 32 /dev/tape -P --format=pax
155 *
156 * -W long options: There's an obscure GNU convention (only rarely
157 * supported even there) that allows "-W option=argument" as an
158 * alternative way to support long options.  This was supported in
159 * early bsdtar as a way to access long options on platforms that did
160 * not support getopt_long() and is preserved here for backwards
161 * compatibility.  (Of course, if I'd started with a custom
162 * command-line parser from the beginning, I would have had normal
163 * long option support on every platform so that hack wouldn't have
164 * been necessary.  Oh, well.  Some mistakes you just have to live
165 * with.)
166 *
167 * TODO: We should be able to use this to pull files and intermingled
168 * options (such as -C) from the command line in write mode.  That
169 * will require a little rethinking of the argument handling in
170 * bsdtar.c.
171 *
172 * TODO: If we want to support arbitrary command-line options from -T
173 * input (as GNU tar does), we may need to extend this to handle option
174 * words from sources other than argv/arc.  I'm not really sure if I
175 * like that feature of GNU tar, so it's certainly not a priority.
176 */
177
178int
179bsdtar_getopt(struct bsdtar *bsdtar)
180{
181	enum { state_start = 0, state_old_tar, state_next_word,
182	       state_short, state_long };
183	static int state = state_start;
184	static char *opt_word;
185
186	const struct option *popt, *match = NULL, *match2 = NULL;
187	const char *p, *long_prefix = "--";
188	size_t optlength;
189	int opt = '?';
190	int required = 0;
191
192	bsdtar->optarg = NULL;
193
194	/* First time through, initialize everything. */
195	if (state == state_start) {
196		/* Skip program name. */
197		++bsdtar->argv;
198		--bsdtar->argc;
199		if (*bsdtar->argv == NULL)
200			return (-1);
201		/* Decide between "new style" and "old style" arguments. */
202		if (bsdtar->argv[0][0] == '-') {
203			state = state_next_word;
204		} else {
205			state = state_old_tar;
206			opt_word = *bsdtar->argv++;
207			--bsdtar->argc;
208		}
209	}
210
211	/*
212	 * We're parsing old-style tar arguments
213	 */
214	if (state == state_old_tar) {
215		/* Get the next option character. */
216		opt = *opt_word++;
217		if (opt == '\0') {
218			/* New-style args can follow old-style. */
219			state = state_next_word;
220		} else {
221			/* See if it takes an argument. */
222			p = strchr(short_options, opt);
223			if (p == NULL)
224				return ('?');
225			if (p[1] == ':') {
226				bsdtar->optarg = *bsdtar->argv;
227				if (bsdtar->optarg == NULL) {
228					lafe_warnc(0,
229					    "Option %c requires an argument",
230					    opt);
231					return ('?');
232				}
233				++bsdtar->argv;
234				--bsdtar->argc;
235			}
236		}
237	}
238
239	/*
240	 * We're ready to look at the next word in argv.
241	 */
242	if (state == state_next_word) {
243		/* No more arguments, so no more options. */
244		if (bsdtar->argv[0] == NULL)
245			return (-1);
246		/* Doesn't start with '-', so no more options. */
247		if (bsdtar->argv[0][0] != '-')
248			return (-1);
249		/* "--" marks end of options; consume it and return. */
250		if (strcmp(bsdtar->argv[0], "--") == 0) {
251			++bsdtar->argv;
252			--bsdtar->argc;
253			return (-1);
254		}
255		/* Get next word for parsing. */
256		opt_word = *bsdtar->argv++;
257		--bsdtar->argc;
258		if (opt_word[1] == '-') {
259			/* Set up long option parser. */
260			state = state_long;
261			opt_word += 2; /* Skip leading '--' */
262		} else {
263			/* Set up short option parser. */
264			state = state_short;
265			++opt_word;  /* Skip leading '-' */
266		}
267	}
268
269	/*
270	 * We're parsing a group of POSIX-style single-character options.
271	 */
272	if (state == state_short) {
273		/* Peel next option off of a group of short options. */
274		opt = *opt_word++;
275		if (opt == '\0') {
276			/* End of this group; recurse to get next option. */
277			state = state_next_word;
278			return bsdtar_getopt(bsdtar);
279		}
280
281		/* Does this option take an argument? */
282		p = strchr(short_options, opt);
283		if (p == NULL)
284			return ('?');
285		if (p[1] == ':')
286			required = 1;
287
288		/* If it takes an argument, parse that. */
289		if (required) {
290			/* If arg is run-in, opt_word already points to it. */
291			if (opt_word[0] == '\0') {
292				/* Otherwise, pick up the next word. */
293				opt_word = *bsdtar->argv;
294				if (opt_word == NULL) {
295					lafe_warnc(0,
296					    "Option -%c requires an argument",
297					    opt);
298					return ('?');
299				}
300				++bsdtar->argv;
301				--bsdtar->argc;
302			}
303			if (opt == 'W') {
304				state = state_long;
305				long_prefix = "-W "; /* For clearer errors. */
306			} else {
307				state = state_next_word;
308				bsdtar->optarg = opt_word;
309			}
310		}
311	}
312
313	/* We're reading a long option, including -W long=arg convention. */
314	if (state == state_long) {
315		/* After this long option, we'll be starting a new word. */
316		state = state_next_word;
317
318		/* Option name ends at '=' if there is one. */
319		p = strchr(opt_word, '=');
320		if (p != NULL) {
321			optlength = (size_t)(p - opt_word);
322			bsdtar->optarg = (char *)(uintptr_t)(p + 1);
323		} else {
324			optlength = strlen(opt_word);
325		}
326
327		/* Search the table for an unambiguous match. */
328		for (popt = tar_longopts; popt->name != NULL; popt++) {
329			/* Short-circuit if first chars don't match. */
330			if (popt->name[0] != opt_word[0])
331				continue;
332			/* If option is a prefix of name in table, record it.*/
333			if (strncmp(opt_word, popt->name, optlength) == 0) {
334				match2 = match; /* Record up to two matches. */
335				match = popt;
336				/* If it's an exact match, we're done. */
337				if (strlen(popt->name) == optlength) {
338					match2 = NULL; /* Forget the others. */
339					break;
340				}
341			}
342		}
343
344		/* Fail if there wasn't a unique match. */
345		if (match == NULL) {
346			lafe_warnc(0,
347			    "Option %s%s is not supported",
348			    long_prefix, opt_word);
349			return ('?');
350		}
351		if (match2 != NULL) {
352			lafe_warnc(0,
353			    "Ambiguous option %s%s (matches --%s and --%s)",
354			    long_prefix, opt_word, match->name, match2->name);
355			return ('?');
356		}
357
358		/* We've found a unique match; does it need an argument? */
359		if (match->required) {
360			/* Argument required: get next word if necessary. */
361			if (bsdtar->optarg == NULL) {
362				bsdtar->optarg = *bsdtar->argv;
363				if (bsdtar->optarg == NULL) {
364					lafe_warnc(0,
365					    "Option %s%s requires an argument",
366					    long_prefix, match->name);
367					return ('?');
368				}
369				++bsdtar->argv;
370				--bsdtar->argc;
371			}
372		} else {
373			/* Argument forbidden: fail if there is one. */
374			if (bsdtar->optarg != NULL) {
375				lafe_warnc(0,
376				    "Option %s%s does not allow an argument",
377				    long_prefix, match->name);
378				return ('?');
379			}
380		}
381		return (match->equivalent);
382	}
383
384	return (opt);
385}