1/* vi: set sw=4 ts=4: */
2/*
3 * getopt.c - Enhanced implementation of BSD getopt(1)
4 *   Copyright (c) 1997, 1998, 1999, 2000  Frodo Looijaard <frodol@dds.nl>
5 *
6 * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
7 */
8
9/*
10 * Version 1.0-b4: Tue Sep 23 1997. First public release.
11 * Version 1.0: Wed Nov 19 1997.
12 *   Bumped up the version number to 1.0
13 *   Fixed minor typo (CSH instead of TCSH)
14 * Version 1.0.1: Tue Jun 3 1998
15 *   Fixed sizeof instead of strlen bug
16 *   Bumped up the version number to 1.0.1
17 * Version 1.0.2: Thu Jun 11 1998 (not present)
18 *   Fixed gcc-2.8.1 warnings
19 *   Fixed --version/-V option (not present)
20 * Version 1.0.5: Tue Jun 22 1999
21 *   Make -u option work (not present)
22 * Version 1.0.6: Tue Jun 27 2000
23 *   No important changes
24 * Version 1.1.0: Tue Jun 30 2000
25 *   Added NLS support (partly written by Arkadiusz Mi<B6>kiewicz
26 *     <misiek@misiek.eu.org>)
27 * Ported to Busybox - Alfred M. Szmidt <ams@trillian.itslinux.org>
28 *  Removed --version/-V and --help/-h in
29 *  Removed parse_error(), using bb_error_msg() from Busybox instead
30 *  Replaced our_malloc with xmalloc and our_realloc with xrealloc
31 *
32 */
33
34#include <getopt.h>
35#include "libbb.h"
36
37/* NON_OPT is the code that is returned when a non-option is found in '+'
38   mode */
39enum {
40	NON_OPT = 1,
41#if ENABLE_GETOPT_LONG
42/* LONG_OPT is the code that is returned when a long option is found. */
43	LONG_OPT = 2
44#endif
45};
46
47/* For finding activated option flags. Must match getopt32 call! */
48enum {
49	OPT_o	= 0x1,	// -o
50	OPT_n	= 0x2,	// -n
51	OPT_q	= 0x4,	// -q
52	OPT_Q	= 0x8,	// -Q
53	OPT_s	= 0x10,	// -s
54	OPT_T	= 0x20,	// -T
55	OPT_u	= 0x40,	// -u
56#if ENABLE_GETOPT_LONG
57	OPT_a	= 0x80,	// -a
58	OPT_l	= 0x100, // -l
59#endif
60	SHELL_IS_TCSH = 0x8000, /* hijack this bit for other purposes */
61};
62
63/* 0 is getopt_long, 1 is getopt_long_only */
64#define alternative  (option_mask32 & OPT_a)
65
66#define quiet_errors (option_mask32 & OPT_q)
67#define quiet_output (option_mask32 & OPT_Q)
68#define quote        (!(option_mask32 & OPT_u))
69#define shell_TCSH   (option_mask32 & SHELL_IS_TCSH)
70
71/*
72 * This function 'normalizes' a single argument: it puts single quotes around
73 * it and escapes other special characters. If quote is false, it just
74 * returns its argument.
75 * Bash only needs special treatment for single quotes; tcsh also recognizes
76 * exclamation marks within single quotes, and nukes whitespace.
77 * This function returns a pointer to a buffer that is overwritten by
78 * each call.
79 */
80static const char *normalize(const char *arg)
81{
82	char *bufptr;
83#if ENABLE_FEATURE_CLEAN_UP
84	static char *BUFFER = NULL;
85	free(BUFFER);
86#else
87	char *BUFFER;
88#endif
89
90	if (!quote) { /* Just copy arg */
91		BUFFER = xstrdup(arg);
92		return BUFFER;
93	}
94
95	/* Each character in arg may take up to four characters in the result:
96	   For a quote we need a closing quote, a backslash, a quote and an
97	   opening quote! We need also the global opening and closing quote,
98	   and one extra character for '\0'. */
99	BUFFER = xmalloc(strlen(arg)*4 + 3);
100
101	bufptr = BUFFER;
102	*bufptr ++= '\'';
103
104	while (*arg) {
105		if (*arg == '\'') {
106			/* Quote: replace it with: '\'' */
107			*bufptr ++= '\'';
108			*bufptr ++= '\\';
109			*bufptr ++= '\'';
110			*bufptr ++= '\'';
111		} else if (shell_TCSH && *arg == '!') {
112			/* Exclamation mark: replace it with: \! */
113			*bufptr ++= '\'';
114			*bufptr ++= '\\';
115			*bufptr ++= '!';
116			*bufptr ++= '\'';
117		} else if (shell_TCSH && *arg == '\n') {
118			/* Newline: replace it with: \n */
119			*bufptr ++= '\\';
120			*bufptr ++= 'n';
121		} else if (shell_TCSH && isspace(*arg)) {
122			/* Non-newline whitespace: replace it with \<ws> */
123			*bufptr ++= '\'';
124			*bufptr ++= '\\';
125			*bufptr ++= *arg;
126			*bufptr ++= '\'';
127		} else
128			/* Just copy */
129			*bufptr ++= *arg;
130		arg++;
131	}
132	*bufptr ++= '\'';
133	*bufptr ++= '\0';
134	return BUFFER;
135}
136
137/*
138 * Generate the output. argv[0] is the program name (used for reporting errors).
139 * argv[1..] contains the options to be parsed. argc must be the number of
140 * elements in argv (ie. 1 if there are no options, only the program name),
141 * optstr must contain the short options, and longopts the long options.
142 * Other settings are found in global variables.
143 */
144#if !ENABLE_GETOPT_LONG
145#define generate_output(argv,argc,optstr,longopts) generate_output(argv,argc,optstr)
146#endif
147static int generate_output(char **argv, int argc, const char *optstr, const struct option *longopts)
148{
149	int exit_code = 0; /* We assume everything will be OK */
150	unsigned opt;
151#if ENABLE_GETOPT_LONG
152	int longindex;
153#endif
154	const char *charptr;
155
156	if (quiet_errors) /* No error reporting from getopt(3) */
157		opterr = 0;
158	optind = 0; /* Reset getopt(3) */
159
160	while (1) {
161		opt =
162#if ENABLE_GETOPT_LONG
163			alternative ?
164			getopt_long_only(argc, argv, optstr, longopts, &longindex) :
165			getopt_long(argc, argv, optstr, longopts, &longindex);
166#else
167			getopt(argc, argv, optstr);
168#endif
169		if (opt == EOF)
170			break;
171		if (opt == '?' || opt == ':' )
172			exit_code = 1;
173		else if (!quiet_output) {
174#if ENABLE_GETOPT_LONG
175			if (opt == LONG_OPT) {
176				printf(" --%s", longopts[longindex].name);
177				if (longopts[longindex].has_arg)
178					printf(" %s",
179						normalize(optarg ? optarg : ""));
180			} else
181#endif
182			if (opt == NON_OPT)
183				printf(" %s", normalize(optarg));
184			else {
185				printf(" -%c", opt);
186				charptr = strchr(optstr,opt);
187				if (charptr != NULL && *++charptr == ':')
188					printf(" %s",
189						normalize(optarg ? optarg : ""));
190			}
191		}
192	}
193
194	if (!quiet_output) {
195		printf(" --");
196		while (optind < argc)
197			printf(" %s", normalize(argv[optind++]));
198		puts("");
199	}
200	return exit_code;
201}
202
203#if ENABLE_GETOPT_LONG
204/*
205 * Register several long options. options is a string of long options,
206 * separated by commas or whitespace.
207 * This nukes options!
208 */
209static struct option *add_long_options(struct option *long_options, char *options)
210{
211	int long_nr = 0;
212	int arg_opt, tlen;
213	char *tokptr = strtok(options, ", \t\n");
214
215	if (long_options)
216		while (long_options[long_nr].name)
217			long_nr++;
218
219	while (tokptr) {
220		arg_opt = no_argument;
221		tlen = strlen(tokptr);
222		if (tlen) {
223			tlen--;
224			if (tokptr[tlen] == ':') {
225				arg_opt = required_argument;
226				if (tlen && tokptr[tlen-1] == ':') {
227					tlen--;
228					arg_opt = optional_argument;
229				}
230				tokptr[tlen] = '\0';
231				if (tlen == 0)
232					bb_error_msg_and_die("empty long option specified");
233			}
234			long_options = xrealloc(long_options,
235					sizeof(long_options[0]) * (long_nr+2));
236			long_options[long_nr].has_arg = arg_opt;
237			long_options[long_nr].flag = NULL;
238			long_options[long_nr].val = LONG_OPT;
239			long_options[long_nr].name = xstrdup(tokptr);
240			long_nr++;
241			memset(&long_options[long_nr], 0, sizeof(long_options[0]));
242		}
243		tokptr = strtok(NULL, ", \t\n");
244	}
245	return long_options;
246}
247#endif
248
249static void set_shell(const char *new_shell)
250{
251	if (!strcmp(new_shell,"bash") || !strcmp(new_shell,"sh"))
252		return;
253	if (!strcmp(new_shell,"tcsh") || !strcmp(new_shell,"csh"))
254		option_mask32 |= SHELL_IS_TCSH;
255	else
256		bb_error_msg("unknown shell '%s', assuming bash", new_shell);
257}
258
259
260/* Exit codes:
261 *   0) No errors, successful operation.
262 *   1) getopt(3) returned an error.
263 *   2) A problem with parameter parsing for getopt(1).
264 *   3) Internal error, out of memory
265 *   4) Returned for -T
266 */
267
268#if ENABLE_GETOPT_LONG
269static const char getopt_longopts[] ALIGN1 =
270	"options\0"      Required_argument "o"
271	"longoptions\0"  Required_argument "l"
272	"quiet\0"        No_argument       "q"
273	"quiet-output\0" No_argument       "Q"
274	"shell\0"        Required_argument "s"
275	"test\0"         No_argument       "T"
276	"unquoted\0"     No_argument       "u"
277	"alternative\0"  No_argument       "a"
278	"name\0"         Required_argument "n"
279	;
280#endif
281
282int getopt_main(int argc, char *argv[]);
283int getopt_main(int argc, char *argv[])
284{
285	char *optstr = NULL;
286	char *name = NULL;
287	unsigned opt;
288	const char *compatible;
289	char *s_arg;
290#if ENABLE_GETOPT_LONG
291	struct option *long_options = NULL;
292	llist_t *l_arg = NULL;
293#endif
294
295	compatible = getenv("GETOPT_COMPATIBLE"); /* used as yes/no flag */
296
297	if (argc == 1) {
298		if (compatible) {
299			/* For some reason, the original getopt gave no error
300			   when there were no arguments. */
301			printf(" --\n");
302			return 0;
303		}
304		bb_error_msg_and_die("missing optstring argument");
305	}
306
307	if (argv[1][0] != '-' || compatible) {
308		char *s;
309
310		option_mask32 |= OPT_u; /* quoting off */
311		s = xstrdup(argv[1] + strspn(argv[1], "-+"));
312		argv[1] = argv[0];
313		return generate_output(argv+1, argc-1, s, long_options);
314	}
315
316#if !ENABLE_GETOPT_LONG
317	opt = getopt32(argv, "+o:n:qQs:Tu", &optstr, &name, &s_arg);
318#else
319	applet_long_options = getopt_longopts;
320	opt_complementary = "l::";
321	opt = getopt32(argv, "+o:n:qQs:Tual:",
322					&optstr, &name, &s_arg, &l_arg);
323	/* Effectuate the read options for the applet itself */
324	while (l_arg) {
325		long_options = add_long_options(long_options, l_arg->data);
326		l_arg = l_arg->link;
327	}
328#endif
329
330	if (opt & OPT_s) {
331		set_shell(s_arg);
332	}
333
334	if (opt & OPT_T) {
335		return 4;
336	}
337
338	/* All options controlling the applet have now been parsed */
339	if (!optstr) {
340		if (optind >= argc)
341			bb_error_msg_and_die("missing optstring argument");
342		optstr = argv[optind++];
343	}
344
345	argv[optind-1] = name ? name : argv[0];
346	return generate_output(argv+optind-1, argc-optind+1, optstr, long_options);
347}
348