Changeset 2725 in MondoRescue for branches/2.2.9/mindi-busybox/libbb/getopt32.c

Timestamp:

Feb 25, 2011, 9:26:54 PM (13 years ago)

Author:

Bruno Cornec

Message:

• Update mindi-busybox to 1.18.3 to avoid problems with the tar command which is now failing on recent versions with busybox 1.7.3

File:

• branches/2.2.9/mindi-busybox/libbb/getopt32.c (modified) (28 diffs)

branches/2.2.9/mindi-busybox/libbb/getopt32.c

@@ -5 +5 @@
  * Copyright (C) 2003-2005  Vladimir Oleynik  <dzo@simtreas.ru>
  *
- * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
 
@@ -31 +31 @@
         "r" will add 1    (bit 0)
         "n" will add 2    (bit 1)
-        "u  will add 4    (bit 2)
+        "u" will add 4    (bit 2)
         "g" will add 8    (bit 3)
 
@@ -73 +73 @@
         Here we want env to process just the '-i', not the '-d'.
 
+ "!"    Report bad option, missing required options,
+        inconsistent options with all-ones return value (instead of abort).
+
 const char *applet_long_options
 
@@ -113 +116 @@
 
  "ww"   Adjacent double options have a counter associated which indicates
-        the number of occurences of the option.
+        the number of occurrences of the option.
         For example the ps applet needs:
         if w is given once, GNU ps sets the width to 132,
         if w is given more than once, it is "unlimited"
 
-        int w_counter = 0;
+        int w_counter = 0; // must be initialized!
         opt_complementary = "ww";
         getopt32(argv, "w", &w_counter);
@@ -138 +141 @@
         f = getopt32(argv, "vb:c", &my_b, &verbose_level);
         if (f & 2)       // -c after -b unsets -b flag
-                while (my_b) { dosomething_with(my_b->data); my_b = my_b->link; }
+                while (my_b) dosomething_with(llist_pop(&my_b));
         if (my_b)        // but llist is stored if -b is specified
                 free_llist(my_b);
@@ -145 +148 @@
 Special characters:
 
- "-"    A dash as the first char in a opt_complementary group forces
-        all arguments to be treated as options, even if they have
-        no leading dashes. Next char in this case can't be a digit (0-9),
-        use ':' or end of line. For example:
-
-        opt_complementary = "-:w-x:x-w";
-        getopt32(argv, "wx");
-
-        Allows any arguments to be given without a dash (./program w x)
+ "-"    A group consisting of just a dash forces all arguments
+        to be treated as options, even if they have no leading dashes.
+        Next char in this case can't be a digit (0-9), use ':' or end of line.
+        Example:
+
+        opt_complementary = "-:w-x:x-w"; // "-w-x:x-w" would also work,
+        getopt32(argv, "wx");            // but is less readable
+
+        This makes it possible to use options without a dash (./program w x)
         as well as with a dash (./program -x).
+
+        NB: getopt32() will leak a small amount of memory if you use
+        this option! Do not use it if there is a possibility of recursive
+        getopt32() calls.
 
  "--"   A double dash at the beginning of opt_complementary means the
@@ -162 +169 @@
         tar xvf foo.tar
 
+        NB: getopt32() will leak a small amount of memory if you use
+        this option! Do not use it if there is a possibility of recursive
+        getopt32() calls.
+
  "-N"   A dash as the first char in a opt_complementary group followed
         by a single digit (0-9) means that at least N non-option
@@ -175 +186 @@
 
  "V-"   An option with dash before colon or end-of-line results in
-        bb_show_usage being called if this option is encountered.
+        bb_show_usage() being called if this option is encountered.
         This is typically used to implement "print verbose usage message
         and exit" option.
 
- "-"    A dash between two options causes the second of the two
+ "a-b"  A dash between two options causes the second of the two
         to be unset (and ignored) if it is given on the command line.
 
@@ -205 +216 @@
                 printf("Detected odd -x usage\n");
 
- "--"   A double dash between two options, or between an option and a group
+ "a--b" A double dash between two options, or between an option and a group
         of options, means that they are mutually exclusive.  Unlike
         the "-" case above, an error will be forced if the options
@@ -221 +232 @@
         at most once.
 
- "::"   A double colon after a char in opt_complementary means that the
+ "a+"   A plus after a char in opt_complementary means that the parameter
+        for this option is a nonnegative integer. It will be processed
+        with xatoi_positive() - allowed range is 0..INT_MAX.
+
+        int param;  // "unsigned param;" will also work
+        opt_complementary = "p+";
+        getopt32(argv, "p:", &param);
+
+ "a::"  A double colon after a char in opt_complementary means that the
         option can occur multiple times. Each occurrence will be saved as
         a llist_t element instead of char*.
@@ -241 +260 @@
         user:x:500:500::/home/user:/bin/bash
 
- "?"    An "?" between an option and a group of options means that
+ "a?b"  A "?" between an option and a group of options means that
         at least one of them is required to occur if the first option
         occurs in preceding command line arguments.
@@ -248 +267 @@
 
         // Don't allow -n -r -rn -ug -rug -nug -rnug
-        opt_complementary = "r?ug:n?ug:?u--g:g--u";
+        opt_complementary = "r?ug:n?ug:u--g:g--u";
         flags = getopt32(argv, "rnug");
 
@@ -260 +279 @@
 
         // Don't allow -KS -SK, but -S or -K is required
-        opt_complementary = "K:S:?K--S:S--K";
+        opt_complementary = "K:S:K--S:S--K";
         flags = getopt32(argv, "KS...);
 
@@ -269 +288 @@
         a '-2' option then unset '-3', '-X' and '-a'; if there is
         a '-2' and after it a '-x' then error out.
+        But it's far too obfuscated. Use ':' to separate groups.
 */
 
 /* Code here assumes that 'unsigned' is at least 32 bits wide */
 
+const char *const bb_argv_dash[] = { "-", NULL };
+
 const char *opt_complementary;
 
+enum {
+    PARAM_STRING,
+    PARAM_LIST,
+    PARAM_INT,
+};
+
 typedef struct {
-    int opt;
-    int list_flg;
+    unsigned char opt_char;
+    smallint param_type;
     unsigned switch_on;
     unsigned switch_off;
     unsigned incongruously;
     unsigned requires;
-    void **optarg;               /* char **optarg or llist_t **optarg */
+    void **optarg;  /* char**, llist_t** or int *. */
     int *counter;
 } t_complementary;
 
 /* You can set applet_long_options for parse called long options */
-#if ENABLE_GETOPT_LONG
+#if ENABLE_LONG_OPTS || ENABLE_FEATURE_GETOPT_LONG
 static const struct option bb_null_long_options[1] = {
     { 0, 0, 0, 0 }
@@ -296 +324 @@
 uint32_t option_mask32;
 
-uint32_t
+uint32_t FAST_FUNC
 getopt32(char **argv, const char *applet_opts, ...)
 {
@@ -302 +330 @@
     unsigned flags = 0;
     unsigned requires = 0;
-    t_complementary complementary[33];
+    t_complementary complementary[33]; /* last stays zero-filled */
+    char first_char;
     int c;
     const unsigned char *s;
     t_complementary *on_off;
     va_list p;
-#if ENABLE_GETOPT_LONG
+#if ENABLE_LONG_OPTS || ENABLE_FEATURE_GETOPT_LONG
     const struct option *l_o;
     struct option *long_options = (struct option *) &bb_null_long_options;
 #endif
     unsigned trigger;
-    char **pargv = NULL;
+    char **pargv;
     int min_arg = 0;
     int max_arg = -1;
@@ -319 +348 @@
 #define ALL_ARGV_IS_OPTS        2
 #define FIRST_ARGV_IS_OPT       4
-#define FREE_FIRST_ARGV_IS_OPT  8
+
     int spec_flgs = 0;
 
-    argc = 0;
+    /* skip 0: some applets cheat: they do not actually HAVE argv[0] */
+    argc = 1;
     while (argv[argc])
         argc++;
@@ -331 +361 @@
     on_off = complementary;
     memset(on_off, 0, sizeof(complementary));
+
+    /* skip bbox extension */
+    first_char = applet_opts[0];
+    if (first_char == '!')
+        applet_opts++;
 
     /* skip GNU extension */
@@ -337 +372 @@
         s++;
     while (*s) {
-        if (c >= 32) break;
-        on_off->opt = *s;
+        if (c >= 32)
+            break;
+        on_off->opt_char = *s;
         on_off->switch_on = (1 << c);
         if (*++s == ':') {
             on_off->optarg = va_arg(p, void **);
-            while (*++s == ':') /* skip */;
+            while (*++s == ':')
+                continue;
         }
         on_off++;
@@ -348 +385 @@
     }
 
-#if ENABLE_GETOPT_LONG
+#if ENABLE_LONG_OPTS || ENABLE_FEATURE_GETOPT_LONG
     if (applet_long_options) {
         const char *optstr;
@@ -375 +412 @@
             if (l_o->flag)
                 continue;
-            for (on_off = complementary; on_off->opt != 0; on_off++)
-                if (on_off->opt == l_o->val)
+            for (on_off = complementary; on_off->opt_char; on_off++)
+                if (on_off->opt_char == l_o->val)
                     goto next_long;
-            if (c >= 32) break;
-            on_off->opt = l_o->val;
+            if (c >= 32)
+                break;
+            on_off->opt_char = l_o->val;
             on_off->switch_on = (1 << c);
             if (l_o->has_arg != no_argument)
@@ -386 +424 @@
  next_long: ;
         }
+        /* Make it unnecessary to clear applet_long_options
+         * by hand after each call to getopt32
+         */
+        applet_long_options = NULL;
     }
-#endif /* ENABLE_GETOPT_LONG */
+#endif /* ENABLE_LONG_OPTS || ENABLE_FEATURE_GETOPT_LONG */
     for (s = (const unsigned char *)opt_complementary; s && *s; s++) {
         t_complementary *pair;
@@ -422 +464 @@
             continue;
         }
-        for (on_off = complementary; on_off->opt; on_off++)
-            if (on_off->opt == *s)
+        for (on_off = complementary; on_off->opt_char; on_off++)
+            if (on_off->opt_char == *s)
                 break;
         if (c == ':' && s[2] == ':') {
-            on_off->list_flg++;
+            on_off->param_type = PARAM_LIST;
+            continue;
+        }
+        if (c == '+' && (s[2] == ':' || s[2] == '\0')) {
+            on_off->param_type = PARAM_INT;
             continue;
         }
@@ -444 +490 @@
         }
         pair = on_off;
-        pair_switch = &(pair->switch_on);
+        pair_switch = &pair->switch_on;
         for (s++; *s && *s != ':'; s++) {
             if (*s == '?') {
-                pair_switch = &(pair->requires);
+                pair_switch = &pair->requires;
             } else if (*s == '-') {
-                if (pair_switch == &(pair->switch_off))
-                    pair_switch = &(pair->incongruously);
+                if (pair_switch == &pair->switch_off)
+                    pair_switch = &pair->incongruously;
                 else
-                    pair_switch = &(pair->switch_off);
+                    pair_switch = &pair->switch_off;
             } else {
-                for (on_off = complementary; on_off->opt; on_off++)
-                    if (on_off->opt == *s) {
+                for (on_off = complementary; on_off->opt_char; on_off++)
+                    if (on_off->opt_char == *s) {
                         *pair_switch |= on_off->switch_on;
                         break;
@@ -463 +509 @@
         s--;
     }
+    opt_complementary = NULL;
     va_end(p);
 
-    if (spec_flgs & FIRST_ARGV_IS_OPT) {
-        if (argv[1] && argv[1][0] != '-' && argv[1][0] != '\0') {
-            argv[1] = xasprintf("-%s", argv[1]);
-            if (ENABLE_FEATURE_CLEAN_UP)
-                spec_flgs |= FREE_FIRST_ARGV_IS_OPT;
+    if (spec_flgs & (FIRST_ARGV_IS_OPT | ALL_ARGV_IS_OPTS)) {
+        pargv = argv + 1;
+        while (*pargv) {
+            if (pargv[0][0] != '-' && pargv[0][0] != '\0') {
+                /* Can't use alloca: opts with params will
+                 * return pointers to stack!
+                 * NB: we leak these allocations... */
+                char *pp = xmalloc(strlen(*pargv) + 2);
+                *pp = '-';
+                strcpy(pp + 1, *pargv);
+                *pargv = pp;
+            }
+            if (!(spec_flgs & ALL_ARGV_IS_OPTS))
+                break;
+            pargv++;
         }
     }
 
-    /* In case getopt32 was already called, reinit some state */
+    /* In case getopt32 was already called:
+     * reset the libc getopt() function, which keeps internal state.
+     * run_nofork_applet_prime() does this, but we might end up here
+     * also via gunzip_main() -> gzip_main(). Play safe.
+     */
+#ifdef __GLIBC__
+    optind = 0;
+#else /* BSD style */
     optind = 1;
-    /* optarg = NULL; opterr = 0; optopt = 0; ?? */
-
-    /* Note: just "getopt() <= 0" will not work good for
+    /* optreset = 1; */
+#endif
+    /* optarg = NULL; opterr = 0; optopt = 0; - do we need this?? */
+
+    pargv = NULL;
+
+    /* Note: just "getopt() <= 0" will not work well for
      * "fake" short options, like this one:
      * wget $'-\203' "Test: test" http://kernel.org/
      * (supposed to act as --header, but doesn't) */
-#if ENABLE_GETOPT_LONG
+#if ENABLE_LONG_OPTS || ENABLE_FEATURE_GETOPT_LONG
     while ((c = getopt_long(argc, argv, applet_opts,
             long_options, NULL)) != -1) {
@@ -487 +555 @@
     while ((c = getopt(argc, argv, applet_opts)) != -1) {
 #endif
-        c &= 0xff; /* fight libc's sign extends */
- loop_arg_is_opt:
-        for (on_off = complementary; on_off->opt != c; on_off++) {
-            /* c==0 if long opt have non NULL flag */
-            if (on_off->opt == 0 && c != 0)
-                bb_show_usage();
+        /* getopt prints "option requires an argument -- X"
+         * and returns '?' if an option has no arg, but one is reqd */
+        c &= 0xff; /* fight libc's sign extension */
+        for (on_off = complementary; on_off->opt_char != c; on_off++) {
+            /* c can be NUL if long opt has non-NULL ->flag,
+             * but we construct long opts so that flag
+             * is always NULL (see above) */
+            if (on_off->opt_char == '\0' /* && c != '\0' */) {
+                /* c is probably '?' - "bad option" */
+                goto error;
+            }
         }
         if (flags & on_off->incongruously)
-            bb_show_usage();
+            goto error;
         trigger = on_off->switch_on & on_off->switch_off;
         flags &= ~(on_off->switch_off ^ trigger);
@@ -502 +575 @@
         if (on_off->counter)
             (*(on_off->counter))++;
-        if (on_off->list_flg) {
-            llist_add_to_end((llist_t **)(on_off->optarg), optarg);
+        if (on_off->param_type == PARAM_LIST) {
+            if (optarg)
+                llist_add_to_end((llist_t **)(on_off->optarg), optarg);
+        } else if (on_off->param_type == PARAM_INT) {
+            if (optarg)
+//TODO: xatoi_positive indirectly pulls in printf machinery
+                *(unsigned*)(on_off->optarg) = xatoi_positive(optarg);
         } else if (on_off->optarg) {
-            *(char **)(on_off->optarg) = optarg;
+            if (optarg)
+                *(char **)(on_off->optarg) = optarg;
         }
         if (pargv != NULL)
@@ -511 +590 @@
     }
 
-    if (spec_flgs & ALL_ARGV_IS_OPTS) {
-        /* process argv is option, for example "ps" applet */
-        if (pargv == NULL)
-            pargv = argv + optind;
-        while (*pargv) {
-            c = **pargv;
-            if (c == '\0') {
-                pargv++;
-            } else {
-                (*pargv)++;
-                goto loop_arg_is_opt;
-            }
-        }
-    }
-
-#if (ENABLE_AR || ENABLE_TAR) && ENABLE_FEATURE_CLEAN_UP
-    if (spec_flgs & FREE_FIRST_ARGV_IS_OPT)
-        free(argv[1]);
-#endif
     /* check depending requires for given options */
-    for (on_off = complementary; on_off->opt; on_off++) {
-        if (on_off->requires && (flags & on_off->switch_on) &&
-                    (flags & on_off->requires) == 0)
-            bb_show_usage();
+    for (on_off = complementary; on_off->opt_char; on_off++) {
+        if (on_off->requires
+         && (flags & on_off->switch_on)
+         && (flags & on_off->requires) == 0
+        ) {
+            goto error;
+        }
     }
     if (requires && (flags & requires) == 0)
-        bb_show_usage();
+        goto error;
     argc -= optind;
     if (argc < min_arg || (max_arg >= 0 && argc > max_arg))
-        bb_show_usage();
+        goto error;
 
     option_mask32 = flags;
     return flags;
+
+ error:
+    if (first_char != '!')
+        bb_show_usage();
+    return (int32_t)-1;
 }