blob: 15b6efc096ba0ef04f409bcd27f37a6bfece232c
1 | /* vi: set sw=4 ts=4: */ |
2 | /* |
3 | * universal getopt32 implementation for busybox |
4 | * |
5 | * Copyright (C) 2003-2005 Vladimir Oleynik <dzo@simtreas.ru> |
6 | * |
7 | * Licensed under GPLv2 or later, see file LICENSE in this source tree. |
8 | */ |
9 | |
10 | #if ENABLE_LONG_OPTS || ENABLE_FEATURE_GETOPT_LONG |
11 | # include <getopt.h> |
12 | #endif |
13 | #include "libbb.h" |
14 | |
15 | /* Documentation |
16 | |
17 | uint32_t |
18 | getopt32(char **argv, const char *applet_opts, ...) |
19 | |
20 | The command line options are passed as the applet_opts string. |
21 | |
22 | If one of the given options is found, a flag value is added to |
23 | the return value. |
24 | |
25 | The flag value is determined by the position of the char in |
26 | applet_opts string. For example: |
27 | |
28 | flags = getopt32(argv, "rnug"); |
29 | |
30 | "r" will set 1 (bit 0) |
31 | "n" will set 2 (bit 1) |
32 | "u" will set 4 (bit 2) |
33 | "g" will set 8 (bit 3) |
34 | |
35 | and so on. You can also look at the return value as a bit |
36 | field and each option sets one bit. |
37 | |
38 | On exit, global variable optind is set so that if you |
39 | will do argc -= optind; argv += optind; then |
40 | argc will be equal to number of remaining non-option |
41 | arguments, first one would be in argv[0], next in argv[1] and so on |
42 | (options and their parameters will be moved into argv[] |
43 | positions prior to argv[optind]). |
44 | |
45 | "o:" If one of the options requires an argument, then add a ":" |
46 | after the char in applet_opts and provide a pointer to store |
47 | the argument. For example: |
48 | |
49 | char *pointer_to_arg_for_a; |
50 | char *pointer_to_arg_for_b; |
51 | char *pointer_to_arg_for_c; |
52 | char *pointer_to_arg_for_d; |
53 | |
54 | flags = getopt32(argv, "a:b:c:d:", |
55 | &pointer_to_arg_for_a, &pointer_to_arg_for_b, |
56 | &pointer_to_arg_for_c, &pointer_to_arg_for_d); |
57 | |
58 | The type of the pointer may be controlled by "o::" or "o+" in |
59 | the external string opt_complementary (see below for more info). |
60 | |
61 | "o::" If option can have an *optional* argument, then add a "::" |
62 | after its char in applet_opts and provide a pointer to store |
63 | the argument. Note that optional arguments _must_ |
64 | immediately follow the option: -oparam, not -o param. |
65 | |
66 | "o:+" This means that the parameter for this option is a nonnegative integer. |
67 | It will be processed with xatoi_positive() - allowed range |
68 | is 0..INT_MAX. |
69 | |
70 | int param; // "unsigned param;" will also work |
71 | getopt32(argv, "p:+", ¶m); |
72 | |
73 | "o:*" This means that the option can occur multiple times. Each occurrence |
74 | will be saved as a llist_t element instead of char*. |
75 | |
76 | For example: |
77 | The grep applet can have one or more "-e pattern" arguments. |
78 | In this case you should use getopt32() as follows: |
79 | |
80 | llist_t *patterns = NULL; |
81 | |
82 | (this pointer must be initializated to NULL if the list is empty |
83 | as required by llist_add_to_end(llist_t **old_head, char *new_item).) |
84 | |
85 | getopt32(argv, "e:*", &patterns); |
86 | |
87 | $ grep -e user -e root /etc/passwd |
88 | root:x:0:0:root:/root:/bin/bash |
89 | user:x:500:500::/home/user:/bin/bash |
90 | |
91 | "+" If the first character in the applet_opts string is a plus, |
92 | then option processing will stop as soon as a non-option is |
93 | encountered in the argv array. Useful for applets like env |
94 | which should not process arguments to subprograms: |
95 | env -i ls -d / |
96 | Here we want env to process just the '-i', not the '-d'. |
97 | |
98 | "!" Report bad option, missing required options, |
99 | inconsistent options with all-ones return value (instead of abort). |
100 | |
101 | const char *applet_long_options |
102 | |
103 | This struct allows you to define long options: |
104 | |
105 | static const char applet_longopts[] ALIGN1 = |
106 | //"name\0" has_arg val |
107 | "verbose\0" No_argument "v" |
108 | ; |
109 | applet_long_options = applet_longopts; |
110 | |
111 | The last member of struct option (val) typically is set to |
112 | matching short option from applet_opts. If there is no matching |
113 | char in applet_opts, then: |
114 | - return bit has next position after short options |
115 | - if has_arg is not "No_argument", use ptr for arg also |
116 | - opt_complementary affects it too |
117 | |
118 | Note: a good applet will make long options configurable via the |
119 | config process and not a required feature. The current standard |
120 | is to name the config option CONFIG_FEATURE_<applet>_LONG_OPTIONS. |
121 | |
122 | const char *opt_complementary |
123 | |
124 | ":" The colon (":") is used to separate groups of two or more chars |
125 | and/or groups of chars and special characters (stating some |
126 | conditions to be checked). |
127 | |
128 | "abc" If groups of two or more chars are specified, the first char |
129 | is the main option and the other chars are secondary options. |
130 | Their flags will be turned on if the main option is found even |
131 | if they are not specifed on the command line. For example: |
132 | |
133 | opt_complementary = "abc"; |
134 | flags = getopt32(argv, "abcd") |
135 | |
136 | If getopt() finds "-a" on the command line, then |
137 | getopt32's return value will be as if "-a -b -c" were |
138 | found. |
139 | |
140 | "ww" Adjacent double options have a counter associated which indicates |
141 | the number of occurrences of the option. |
142 | For example the ps applet needs: |
143 | if w is given once, GNU ps sets the width to 132, |
144 | if w is given more than once, it is "unlimited" |
145 | |
146 | int w_counter = 0; // must be initialized! |
147 | opt_complementary = "ww"; |
148 | getopt32(argv, "w", &w_counter); |
149 | if (w_counter) |
150 | width = (w_counter == 1) ? 132 : INT_MAX; |
151 | else |
152 | get_terminal_width(...&width...); |
153 | |
154 | w_counter is a pointer to an integer. It has to be passed to |
155 | getopt32() after all other option argument sinks. |
156 | |
157 | For example: accept multiple -v to indicate the level of verbosity |
158 | and for each -b optarg, add optarg to my_b. Finally, if b is given, |
159 | turn off c and vice versa: |
160 | |
161 | llist_t *my_b = NULL; |
162 | int verbose_level = 0; |
163 | opt_complementary = "vv:b-c:c-b"; |
164 | f = getopt32(argv, "vb:*c", &my_b, &verbose_level); |
165 | if (f & 2) // -c after -b unsets -b flag |
166 | while (my_b) dosomething_with(llist_pop(&my_b)); |
167 | if (my_b) // but llist is stored if -b is specified |
168 | free_llist(my_b); |
169 | if (verbose_level) printf("verbose level is %d\n", verbose_level); |
170 | |
171 | Special characters: |
172 | |
173 | "-" A group consisting of just a dash forces all arguments |
174 | to be treated as options, even if they have no leading dashes. |
175 | Next char in this case can't be a digit (0-9), use ':' or end of line. |
176 | Example: |
177 | |
178 | opt_complementary = "-:w-x:x-w"; // "-w-x:x-w" would also work, |
179 | getopt32(argv, "wx"); // but is less readable |
180 | |
181 | This makes it possible to use options without a dash (./program w x) |
182 | as well as with a dash (./program -x). |
183 | |
184 | NB: getopt32() will leak a small amount of memory if you use |
185 | this option! Do not use it if there is a possibility of recursive |
186 | getopt32() calls. |
187 | |
188 | "--" A double dash at the beginning of opt_complementary means the |
189 | argv[1] string should always be treated as options, even if it isn't |
190 | prefixed with a "-". This is useful for special syntax in applets |
191 | such as "ar" and "tar": |
192 | tar xvf foo.tar |
193 | |
194 | NB: getopt32() will leak a small amount of memory if you use |
195 | this option! Do not use it if there is a possibility of recursive |
196 | getopt32() calls. |
197 | |
198 | "-N" A dash as the first char in a opt_complementary group followed |
199 | by a single digit (0-9) means that at least N non-option |
200 | arguments must be present on the command line |
201 | |
202 | "=N" An equal sign as the first char in a opt_complementary group followed |
203 | by a single digit (0-9) means that exactly N non-option |
204 | arguments must be present on the command line |
205 | |
206 | "?N" A "?" as the first char in a opt_complementary group followed |
207 | by a single digit (0-9) means that at most N arguments must be present |
208 | on the command line. |
209 | |
210 | "V-" An option with dash before colon or end-of-line results in |
211 | bb_show_usage() being called if this option is encountered. |
212 | This is typically used to implement "print verbose usage message |
213 | and exit" option. |
214 | |
215 | "a-b" A dash between two options causes the second of the two |
216 | to be unset (and ignored) if it is given on the command line. |
217 | |
218 | [FIXME: what if they are the same? like "x-x"? Is it ever useful?] |
219 | |
220 | For example: |
221 | The du applet has the options "-s" and "-d depth". If |
222 | getopt32 finds -s, then -d is unset or if it finds -d |
223 | then -s is unset. (Note: busybox implements the GNU |
224 | "--max-depth" option as "-d".) To obtain this behavior, you |
225 | set opt_complementary = "s-d:d-s". Only one flag value is |
226 | added to getopt32's return value depending on the |
227 | position of the options on the command line. If one of the |
228 | two options requires an argument pointer (":" in applet_opts |
229 | as in "d:") optarg is set accordingly. |
230 | |
231 | char *smax_print_depth; |
232 | |
233 | opt_complementary = "s-d:d-s:x-x"; |
234 | opt = getopt32(argv, "sd:x", &smax_print_depth); |
235 | |
236 | if (opt & 2) |
237 | max_print_depth = atoi(smax_print_depth); |
238 | if (opt & 4) |
239 | printf("Detected odd -x usage\n"); |
240 | |
241 | "a--b" A double dash between two options, or between an option and a group |
242 | of options, means that they are mutually exclusive. Unlike |
243 | the "-" case above, an error will be forced if the options |
244 | are used together. |
245 | |
246 | For example: |
247 | The cut applet must have only one type of list specified, so |
248 | -b, -c and -f are mutually exclusive and should raise an error |
249 | if specified together. In this case you must set |
250 | opt_complementary = "b--cf:c--bf:f--bc". If two of the |
251 | mutually exclusive options are found, getopt32 will call |
252 | bb_show_usage() and die. |
253 | |
254 | "x--x" Variation of the above, it means that -x option should occur |
255 | at most once. |
256 | |
257 | "o+" A plus after a char in opt_complementary means that the parameter |
258 | for this option is a nonnegative integer. It will be processed |
259 | with xatoi_positive() - allowed range is 0..INT_MAX. |
260 | |
261 | int param; // "unsigned param;" will also work |
262 | opt_complementary = "p+"; |
263 | getopt32(argv, "p:", ¶m); |
264 | |
265 | "o::" A double colon after a char in opt_complementary means that the |
266 | option can occur multiple times. Each occurrence will be saved as |
267 | a llist_t element instead of char*. |
268 | |
269 | For example: |
270 | The grep applet can have one or more "-e pattern" arguments. |
271 | In this case you should use getopt32() as follows: |
272 | |
273 | llist_t *patterns = NULL; |
274 | |
275 | (this pointer must be initializated to NULL if the list is empty |
276 | as required by llist_add_to_end(llist_t **old_head, char *new_item).) |
277 | |
278 | opt_complementary = "e::"; |
279 | getopt32(argv, "e:", &patterns); |
280 | |
281 | $ grep -e user -e root /etc/passwd |
282 | root:x:0:0:root:/root:/bin/bash |
283 | user:x:500:500::/home/user:/bin/bash |
284 | |
285 | "o+" and "o::" can be handled by "o:+" and "o:*" specifiers |
286 | in option string (and it is preferred), but this does not work |
287 | for "long options only" cases, such as tar --exclude=PATTERN, |
288 | wget --header=HDR cases. |
289 | |
290 | "a?b" A "?" between an option and a group of options means that |
291 | at least one of them is required to occur if the first option |
292 | occurs in preceding command line arguments. |
293 | |
294 | For example from "id" applet: |
295 | |
296 | // Don't allow -n -r -rn -ug -rug -nug -rnug |
297 | opt_complementary = "r?ug:n?ug:u--g:g--u"; |
298 | flags = getopt32(argv, "rnug"); |
299 | |
300 | This example allowed only: |
301 | $ id; id -u; id -g; id -ru; id -nu; id -rg; id -ng; id -rnu; id -rng |
302 | |
303 | "X" A opt_complementary group with just a single letter means |
304 | that this option is required. If more than one such group exists, |
305 | at least one option is required to occur (not all of them). |
306 | For example from "start-stop-daemon" applet: |
307 | |
308 | // Don't allow -KS -SK, but -S or -K is required |
309 | opt_complementary = "K:S:K--S:S--K"; |
310 | flags = getopt32(argv, "KS...); |
311 | |
312 | |
313 | Don't forget to use ':'. For example, "?322-22-23X-x-a" |
314 | is interpreted as "?3:22:-2:2-2:2-3Xa:2--x" - |
315 | max 3 args; count uses of '-2'; min 2 args; if there is |
316 | a '-2' option then unset '-3', '-X' and '-a'; if there is |
317 | a '-2' and after it a '-x' then error out. |
318 | But it's far too obfuscated. Use ':' to separate groups. |
319 | */ |
320 | |
321 | /* Code here assumes that 'unsigned' is at least 32 bits wide */ |
322 | |
323 | const char *const bb_argv_dash[] = { "-", NULL }; |
324 | |
325 | const char *opt_complementary; |
326 | |
327 | enum { |
328 | PARAM_STRING, |
329 | PARAM_LIST, |
330 | PARAM_INT, |
331 | }; |
332 | |
333 | typedef struct { |
334 | unsigned char opt_char; |
335 | smallint param_type; |
336 | unsigned switch_on; |
337 | unsigned switch_off; |
338 | unsigned incongruously; |
339 | unsigned requires; |
340 | void **optarg; /* char**, llist_t** or int *. */ |
341 | int *counter; |
342 | } t_complementary; |
343 | |
344 | /* You can set applet_long_options for parse called long options */ |
345 | #if ENABLE_LONG_OPTS || ENABLE_FEATURE_GETOPT_LONG |
346 | static const struct option bb_null_long_options[1] = { |
347 | { 0, 0, 0, 0 } |
348 | }; |
349 | const char *applet_long_options; |
350 | #endif |
351 | |
352 | uint32_t option_mask32; |
353 | |
354 | uint32_t FAST_FUNC |
355 | getopt32(char **argv, const char *applet_opts, ...) |
356 | { |
357 | int argc; |
358 | unsigned flags = 0; |
359 | unsigned requires = 0; |
360 | t_complementary complementary[33]; /* last stays zero-filled */ |
361 | char first_char; |
362 | int c; |
363 | const unsigned char *s; |
364 | t_complementary *on_off; |
365 | va_list p; |
366 | #if ENABLE_LONG_OPTS || ENABLE_FEATURE_GETOPT_LONG |
367 | const struct option *l_o; |
368 | struct option *long_options = (struct option *) &bb_null_long_options; |
369 | #endif |
370 | unsigned trigger; |
371 | char **pargv; |
372 | int min_arg = 0; |
373 | int max_arg = -1; |
374 | |
375 | #define SHOW_USAGE_IF_ERROR 1 |
376 | #define ALL_ARGV_IS_OPTS 2 |
377 | #define FIRST_ARGV_IS_OPT 4 |
378 | |
379 | int spec_flgs = 0; |
380 | |
381 | /* skip 0: some applets cheat: they do not actually HAVE argv[0] */ |
382 | argc = 1; |
383 | while (argv[argc]) |
384 | argc++; |
385 | |
386 | va_start(p, applet_opts); |
387 | |
388 | on_off = complementary; |
389 | memset(on_off, 0, sizeof(complementary)); |
390 | |
391 | applet_opts = strcpy(alloca(strlen(applet_opts) + 1), applet_opts); |
392 | |
393 | /* skip bbox extension */ |
394 | first_char = applet_opts[0]; |
395 | if (first_char == '!') |
396 | applet_opts++; |
397 | |
398 | /* skip GNU extension */ |
399 | s = (const unsigned char *)applet_opts; |
400 | if (*s == '+' || *s == '-') |
401 | s++; |
402 | c = 0; |
403 | while (*s) { |
404 | if (c >= 32) |
405 | break; |
406 | on_off->opt_char = *s; |
407 | on_off->switch_on = (1 << c); |
408 | if (*++s == ':') { |
409 | on_off->optarg = va_arg(p, void **); |
410 | if (s[1] == '+' || s[1] == '*') { |
411 | /* 'o:+' or 'o:*' */ |
412 | on_off->param_type = (s[1] == '+') ? |
413 | PARAM_INT : PARAM_LIST; |
414 | overlapping_strcpy((char*)s + 1, (char*)s + 2); |
415 | } |
416 | /* skip possible 'o::' (or 'o:+:' !) */ |
417 | while (*++s == ':') |
418 | continue; |
419 | } |
420 | on_off++; |
421 | c++; |
422 | } |
423 | |
424 | #if ENABLE_LONG_OPTS || ENABLE_FEATURE_GETOPT_LONG |
425 | if (applet_long_options) { |
426 | const char *optstr; |
427 | unsigned i, count; |
428 | |
429 | count = 1; |
430 | optstr = applet_long_options; |
431 | while (optstr[0]) { |
432 | optstr += strlen(optstr) + 3; /* skip NUL, has_arg, val */ |
433 | count++; |
434 | } |
435 | /* count == no. of longopts + 1 */ |
436 | long_options = alloca(count * sizeof(*long_options)); |
437 | memset(long_options, 0, count * sizeof(*long_options)); |
438 | i = 0; |
439 | optstr = applet_long_options; |
440 | while (--count) { |
441 | long_options[i].name = optstr; |
442 | optstr += strlen(optstr) + 1; |
443 | long_options[i].has_arg = (unsigned char)(*optstr++); |
444 | /* long_options[i].flag = NULL; */ |
445 | long_options[i].val = (unsigned char)(*optstr++); |
446 | i++; |
447 | } |
448 | for (l_o = long_options; l_o->name; l_o++) { |
449 | if (l_o->flag) |
450 | continue; |
451 | for (on_off = complementary; on_off->opt_char; on_off++) |
452 | if (on_off->opt_char == l_o->val) |
453 | goto next_long; |
454 | if (c >= 32) |
455 | break; |
456 | on_off->opt_char = l_o->val; |
457 | on_off->switch_on = (1 << c); |
458 | if (l_o->has_arg != no_argument) |
459 | on_off->optarg = va_arg(p, void **); |
460 | c++; |
461 | next_long: ; |
462 | } |
463 | /* Make it unnecessary to clear applet_long_options |
464 | * by hand after each call to getopt32 |
465 | */ |
466 | applet_long_options = NULL; |
467 | } |
468 | #endif /* ENABLE_LONG_OPTS || ENABLE_FEATURE_GETOPT_LONG */ |
469 | |
470 | for (s = (const unsigned char *)opt_complementary; s && *s; s++) { |
471 | t_complementary *pair; |
472 | unsigned *pair_switch; |
473 | |
474 | if (*s == ':') |
475 | continue; |
476 | c = s[1]; |
477 | if (*s == '?') { |
478 | if (c < '0' || c > '9') { |
479 | spec_flgs |= SHOW_USAGE_IF_ERROR; |
480 | } else { |
481 | max_arg = c - '0'; |
482 | s++; |
483 | } |
484 | continue; |
485 | } |
486 | if (*s == '-') { |
487 | if (c < '0' || c > '9') { |
488 | if (c == '-') { |
489 | spec_flgs |= FIRST_ARGV_IS_OPT; |
490 | s++; |
491 | } else |
492 | spec_flgs |= ALL_ARGV_IS_OPTS; |
493 | } else { |
494 | min_arg = c - '0'; |
495 | s++; |
496 | } |
497 | continue; |
498 | } |
499 | if (*s == '=') { |
500 | min_arg = max_arg = c - '0'; |
501 | s++; |
502 | continue; |
503 | } |
504 | for (on_off = complementary; on_off->opt_char; on_off++) |
505 | if (on_off->opt_char == *s) |
506 | goto found_opt; |
507 | /* Without this, diagnostic of such bugs is not easy */ |
508 | bb_error_msg_and_die("NO OPT %c!", *s); |
509 | found_opt: |
510 | if (c == ':' && s[2] == ':') { |
511 | on_off->param_type = PARAM_LIST; |
512 | continue; |
513 | } |
514 | if (c == '+' && (s[2] == ':' || s[2] == '\0')) { |
515 | on_off->param_type = PARAM_INT; |
516 | s++; |
517 | continue; |
518 | } |
519 | if (c == ':' || c == '\0') { |
520 | requires |= on_off->switch_on; |
521 | continue; |
522 | } |
523 | if (c == '-' && (s[2] == ':' || s[2] == '\0')) { |
524 | flags |= on_off->switch_on; |
525 | on_off->incongruously |= on_off->switch_on; |
526 | s++; |
527 | continue; |
528 | } |
529 | if (c == *s) { |
530 | on_off->counter = va_arg(p, int *); |
531 | s++; |
532 | } |
533 | pair = on_off; |
534 | pair_switch = &pair->switch_on; |
535 | for (s++; *s && *s != ':'; s++) { |
536 | if (*s == '?') { |
537 | pair_switch = &pair->requires; |
538 | } else if (*s == '-') { |
539 | if (pair_switch == &pair->switch_off) |
540 | pair_switch = &pair->incongruously; |
541 | else |
542 | pair_switch = &pair->switch_off; |
543 | } else { |
544 | for (on_off = complementary; on_off->opt_char; on_off++) |
545 | if (on_off->opt_char == *s) { |
546 | *pair_switch |= on_off->switch_on; |
547 | break; |
548 | } |
549 | } |
550 | } |
551 | s--; |
552 | } |
553 | opt_complementary = NULL; |
554 | va_end(p); |
555 | |
556 | if (spec_flgs & (FIRST_ARGV_IS_OPT | ALL_ARGV_IS_OPTS)) { |
557 | pargv = argv + 1; |
558 | while (*pargv) { |
559 | if (pargv[0][0] != '-' && pargv[0][0] != '\0') { |
560 | /* Can't use alloca: opts with params will |
561 | * return pointers to stack! |
562 | * NB: we leak these allocations... */ |
563 | char *pp = xmalloc(strlen(*pargv) + 2); |
564 | *pp = '-'; |
565 | strcpy(pp + 1, *pargv); |
566 | *pargv = pp; |
567 | } |
568 | if (!(spec_flgs & ALL_ARGV_IS_OPTS)) |
569 | break; |
570 | pargv++; |
571 | } |
572 | } |
573 | |
574 | /* In case getopt32 was already called: |
575 | * reset the libc getopt() function, which keeps internal state. |
576 | * run_nofork_applet() does this, but we might end up here |
577 | * also via gunzip_main() -> gzip_main(). Play safe. |
578 | */ |
579 | #ifdef __GLIBC__ |
580 | optind = 0; |
581 | #else /* BSD style */ |
582 | optind = 1; |
583 | /* optreset = 1; */ |
584 | #endif |
585 | /* optarg = NULL; opterr = 0; optopt = 0; - do we need this?? */ |
586 | |
587 | /* Note: just "getopt() <= 0" will not work well for |
588 | * "fake" short options, like this one: |
589 | * wget $'-\203' "Test: test" http://kernel.org/ |
590 | * (supposed to act as --header, but doesn't) */ |
591 | #if ENABLE_LONG_OPTS || ENABLE_FEATURE_GETOPT_LONG |
592 | while ((c = getopt_long(argc, argv, applet_opts, |
593 | long_options, NULL)) != -1) { |
594 | #else |
595 | while ((c = getopt(argc, argv, applet_opts)) != -1) { |
596 | #endif |
597 | /* getopt prints "option requires an argument -- X" |
598 | * and returns '?' if an option has no arg, but one is reqd */ |
599 | c &= 0xff; /* fight libc's sign extension */ |
600 | for (on_off = complementary; on_off->opt_char != c; on_off++) { |
601 | /* c can be NUL if long opt has non-NULL ->flag, |
602 | * but we construct long opts so that flag |
603 | * is always NULL (see above) */ |
604 | if (on_off->opt_char == '\0' /* && c != '\0' */) { |
605 | /* c is probably '?' - "bad option" */ |
606 | goto error; |
607 | } |
608 | } |
609 | if (flags & on_off->incongruously) |
610 | goto error; |
611 | trigger = on_off->switch_on & on_off->switch_off; |
612 | flags &= ~(on_off->switch_off ^ trigger); |
613 | flags |= on_off->switch_on ^ trigger; |
614 | flags ^= trigger; |
615 | if (on_off->counter) |
616 | (*(on_off->counter))++; |
617 | if (optarg) { |
618 | if (on_off->param_type == PARAM_LIST) { |
619 | llist_add_to_end((llist_t **)(on_off->optarg), optarg); |
620 | } else if (on_off->param_type == PARAM_INT) { |
621 | //TODO: xatoi_positive indirectly pulls in printf machinery |
622 | *(unsigned*)(on_off->optarg) = xatoi_positive(optarg); |
623 | } else if (on_off->optarg) { |
624 | *(char **)(on_off->optarg) = optarg; |
625 | } |
626 | } |
627 | } |
628 | |
629 | /* check depending requires for given options */ |
630 | for (on_off = complementary; on_off->opt_char; on_off++) { |
631 | if (on_off->requires |
632 | && (flags & on_off->switch_on) |
633 | && (flags & on_off->requires) == 0 |
634 | ) { |
635 | goto error; |
636 | } |
637 | } |
638 | if (requires && (flags & requires) == 0) |
639 | goto error; |
640 | argc -= optind; |
641 | if (argc < min_arg || (max_arg >= 0 && argc > max_arg)) |
642 | goto error; |
643 | |
644 | option_mask32 = flags; |
645 | return flags; |
646 | |
647 | error: |
648 | if (first_char != '!') |
649 | bb_show_usage(); |
650 | return (int32_t)-1; |
651 | } |
652 |