libbb/getopt_ulflags.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * universal getopt_ulflags implementation for busybox
   4  *
   5  * Copyright (C) 2003-2005  Vladimir Oleynik  <dzo@simtreas.ru>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  20  *
  21  */
  22
  23 #include <getopt.h>
  24 #include <string.h>
  25 #include <assert.h>
  26 #include <stdlib.h>
  27 #include "libbb.h"
  28
  29 /*                  Documentation !
  30
  31 unsigned long
  32 bb_getopt_ulflags (int argc, char **argv, const char *applet_opts, ...)
  33
  34         The command line options must be declared in const char
  35         *applet_opts as a string of chars, for example:
  36
  37         flags = bb_getopt_ulflags(argc, argv, "rnug");
  38
  39         If one of the given options is found, a flag value is added to
  40         the return value (an unsigned long).
  41
  42         The flag value is determined by the position of the char in
  43         applet_opts string.  For example, in the above case:
  44
  45         flags = bb_getopt_ulflags(argc, argv, "rnug");
  46
  47         "r" will add 1    (bit 1 : 0x01)
  48         "n" will add 2    (bit 2 : 0x02)
  49         "u  will add 4    (bit 3 : 0x03)
  50         "g" will add 8    (bit 4 : 0x04)
  51
  52          and so on.  You can also look at the return value as a bit
  53          field and each option sets one of bits.
  54
  55  ":"    If one of the options requires an argument, then add a ":"
  56         after the char in applet_opts and provide a pointer to store
  57         the argument.  For example:
  58
  59         char *pointer_to_arg_for_a;
  60         char *pointer_to_arg_for_b;
  61         char *pointer_to_arg_for_c;
  62         char *pointer_to_arg_for_d;
  63
  64         flags = bb_getopt_ulflags(argc, argv, "a:b:c:d:",
  65                          &pointer_to_arg_for_a, &pointer_to_arg_for_b,
  66                          &pointer_to_arg_for_c, &pointer_to_arg_for_d);
  67
  68         The type of the pointer (char* or llist_t *) may be controlled
  69         by the "::" special separator that is set in the external string
  70         bb_opt_complementally (see below for more info).
  71
  72 static const struct option bb_default_long_options[]
  73
  74         This struct allows you to define long options.  The syntax for
  75         declaring the array is just like that of getopt's longopts.
  76         (see getopt(3))
  77
  78         static const struct option applet_long_options[] = {
  79                 { "verbose", 0, 0, v },
  80                 { 0, 0, 0, 0 }
  81         };
  82         bb_applet_long_options = applet_long_options;
  83
  84         The last argument (val) can undefined from applet_opts.
  85         If you use this, then:
  86         - return bit have next position after short options
  87         - if has_arg is not "no_argument", use ptr for arg also
  88         - bb_opt_complementally have effects for this too
  89
  90         Note: a good applet will make long options configurable via the
  91         config process and not a required feature.  The current standard
  92         is to name the config option CONFIG_FEATURE_<applet>_LONG_OPTIONS.
  93
  94 const char *bb_opt_complementally
  95
  96  ":"    The colon (":") is used to separate groups of two or more chars
  97         and/or groups of chars and special characters (stating some
  98         conditions to be checked).
  99
 100  "abc"  If groups of two or more chars are specified, the first char
 101         is the main option and the other chars are secondary options.
 102         Their flags will be turned on if the main option is found even
 103         if they are not specifed on the command line.  For example:
 104
 105         bb_opt_complementally = "abc";
 106
 107         flags = bb_getopt_ulflags(argc, argv, "abcd")
 108
 109         If getopt() finds "-a" on the command line, then
 110         bb_getopt_ulflags's return value will be as if "-a -b -c" were
 111         found.
 112
 113  "ww"   Adjacent double options have a counter associated which indicates
 114         the number of occurances of the option.
 115         For example the ps applet needs:
 116         if w is given once, GNU ps sets the width to 132,
 117         if w is given more than once, it is "unlimited"
 118
 119         int w_counter = 0;
 120         bb_opt_complementally = "ww";
 121         bb_getopt_ulflags(argc, argv, "w", &w_counter);
 122
 123         if(w_counter)
 124                 width = (w_counter == 1) ? 132 : INT_MAX;
 125         else
 126                 get_terminal_width(...&width...);
 127
 128         w_counter is a pointer to an integer. It has to be passed to
 129         bb_getopt_ulflags() after all other option argument sinks.
 130         For example: accept multiple -v to indicate the level of verbosity
 131         and for each -b optarg, add optarg to my_b. Finally, if b is given,
 132         turn off c and vice versa:
 133
 134         llist_t *my_b = NULL;
 135         int verbose_level = 0;
 136         bb_opt_complementally = "vv:b::b-c:c-b";
 137         f = bb_getopt_ulflags(argc, argv, "vb:c", &my_b, &verbose_level);
 138         if((f & 2))     // -c after -b unset this -b flag
 139           while (my_b) { dosomething_with(my_b->data) ; my_b = my_b->link; }
 140         if(my_b)        // but llist stored always if -b found
 141                 free_llist(my_b);
 142         if (verbose_level) bb_printf("verbose level is %d\n", verbose_level);
 143
 144 Special characters:
 145
 146  "-"    A dash between two options causes the second of the two
 147         to be unset (and ignored or triggered) if it is given on
 148         the command line.
 149
 150         For example:
 151         The du applet has the options "-s" and "-d depth".  If
 152         bb_getopt_ulflags finds -s, then -d is unset or if it finds -d
 153         then -s is unset.  (Note:  busybox implements the GNU
 154         "--max-depth" option as "-d".)  To obtain this behavior, you
 155         set bb_opt_complementally = "s-d:d-s".  Only one flag value is
 156         added to bb_getopt_ulflags's return value depending on the
 157         position of the options on the command line.  If one of the
 158         two options requires an argument pointer (":" in applet_opts
 159         as in "d:") optarg is set accordingly.
 160
 161         char *smax_print_depth;
 162
 163         bb_opt_complementally = "s-d:d-s:x-x";
 164         opt = bb_getopt_ulflags(argc, argv, "sd:x", &smax_print_depth);
 165
 166         if (opt & 2) {
 167                  max_print_depth = atoi(smax_print_depth);
 168         }
 169         if(opt & 4)
 170                 printf("Detected odd -x usaging\n");
 171
 172  "-"    A dash as the first char in a bb_opt_complementally group means to
 173         convert the arguments as option. Next char for this case can`t set
 174         [0-9], recomended use ':' or end of line. For example:
 175
 176         bb_opt_complementally = "-:w-x:x-w";
 177         bb_getopt_ulflags(argc, argv, "wx");
 178
 179         Allows any arguments to be given without a dash (./program w x)
 180         as well as with a dash (./program -x). Why unset -w see above.
 181
 182  "-N"   A dash as the first char in a bb_opt_complementally group with
 183         number 0-9 as one char is means check minimal arguments required.
 184
 185  "--"   A double dash between two options, or between an option and a group
 186         of options, means that they are mutually exclusive.  Unlike
 187         the "-" case above, an error will be forced if the options
 188         are used together.
 189
 190         For example:
 191         The cut applet must have only one type of list specified, so
 192         -b, -c and -f are mutally exclusive and should raise an error
 193         if specified together.  In this case you must set
 194         bb_opt_complementally = "b--cf:c--bf:f--bc".  If two of the
 195         mutually exclusive options are found, bb_getopt_ulflags's
 196         return value will have the error flag set (BB_GETOPT_ERROR) so
 197         that we can check for it:
 198
 199         if (flags & BB_GETOPT_ERROR)
 200                 bb_show_usage();
 201
 202  "?"    A "ask" as the first char in a bb_opt_complementally group give:
 203         if previous point set BB_GETOPT_ERROR, don`t return and
 204         call previous example internally. Next char for this case can`t
 205         set to [0-9], recomended use ':' or end of line.
 206
 207  "?N"   A "ask" as the first char in a bb_opt_complementally group with
 208         number 0-9 as one char is means check maximal arguments possible.
 209
 210  "::"   A double colon after a char in bb_opt_complementally means that the
 211         option can occur multiple times:
 212
 213         For example:
 214         The grep applet can have one or more "-e pattern" arguments.
 215         In this case you should use bb_getopt_ulflags() as follows:
 216
 217         llist_t *patterns = NULL;
 218
 219         (this pointer must be initializated to NULL if the list is empty
 220         as required by *llist_add_to(llist_t *old_head, char *new_item).)
 221
 222         bb_opt_complementally = "e::";
 223
 224         bb_getopt_ulflags(argc, argv, "e:", &patterns);
 225         $ grep -e user -e root /etc/passwd
 226         root:x:0:0:root:/root:/bin/bash
 227         user:x:500:500::/home/user:/bin/bash
 228
 229  "--"   A double dash as the first char in a bb_opt_complementally group
 230         means make first argv[1] as option always as may be added -, special
 231         for "ar" and "tar" applets.
 232
 233  "?"    A "ask" between main and group options causes the second of the two
 234         to be depending required as or if first is given on the command line.
 235         For example from "id" applet:
 236
 237         // Don't allow -n -r -rn -ug -rug -nug -rnug
 238         bb_opt_complementally = "r?ug:n?ug:?u--g:g--u";
 239         flags = bb_getopt_ulflags(argc, argv, "rnug");
 240
 241         This example allowed only:
 242         $ id; id -u; id -g; id -ru; id -nu; id -rg; id -ng; id -rnu; id -rng
 243
 244  "X"    A one options in bb_opt_complementally group means
 245         requires this option always with "or" logic if more one specified,
 246         checked after switch off from complementally logic.
 247         For example from "start-stop-daemon" applet:
 248
 249         // Don't allow -KS -SK, but -S or -K required
 250         bb_opt_complementally = "K:S:?K--S:S--K";
 251         flags = bb_getopt_ulflags(argc, argv, "KS...);
 252
 253
 254  "x--x" give error if double or more used -x option
 255
 256  Don`t forget ':' store. For example "?322-22-23X-x-a" interpretet as
 257  "?3:22:-2:2-2:2-3Xa:2--x": max args is 3, count -2 usaged, min args is 2,
 258  -2 option triggered, unset -3 and -X and -a if -2 any usaged, give error if
 259  after -2 the -x option usaged.
 260
 261 */
 262
 263 const char *bb_opt_complementally;
 264
 265 typedef struct {
 266         int opt;
 267         int list_flg;
 268         unsigned long switch_on;
 269         unsigned long switch_off;
 270         unsigned long incongruously;
 271         unsigned long requires;
 272         void **optarg;               /* char **optarg or llist_t **optarg */
 273         int *counter;
 274 } t_complementally;
 275
 276 /* You can set bb_applet_long_options for parse called long options */
 277
 278 static const struct option bb_default_long_options[] = {
 279 /*      { "help", 0, NULL, '?' }, */
 280         { 0, 0, 0, 0 }
 281 };
 282
 283 const struct option *bb_applet_long_options = bb_default_long_options;
 284
 285 unsigned long
 286 bb_getopt_ulflags (int argc, char **argv, const char *applet_opts, ...)
 287 {
 288         unsigned long flags = 0;
 289         unsigned long requires = 0;
 290         t_complementally complementally[sizeof(flags) * 8 + 1];
 291         int c;
 292         const unsigned char *s;
 293         t_complementally *on_off;
 294         va_list p;
 295         const struct option *l_o;
 296         unsigned long trigger;
 297         char **pargv = NULL;
 298         int min_arg = 0;
 299         int max_arg = -1;
 300
 301 #define SHOW_USAGE_IF_ERROR     1
 302 #define ALL_ARGV_IS_OPTS        2
 303 #define FIRST_ARGV_IS_OPT       4
 304 #define FREE_FIRST_ARGV_IS_OPT  8
 305         int spec_flgs = 0;
 306
 307         va_start (p, applet_opts);
 308
 309         c = 0;
 310         on_off = complementally;
 311         memset(on_off, 0, sizeof(complementally));
 312
 313         /* skip GNU extension */
 314         s = (const unsigned char *)applet_opts;
 315         if(*s == '+' || *s == '-')
 316                 s++;
 317         for (; *s; s++) {
 318                 if(c >= (int)(sizeof(flags)*8))
 319                         break;
 320                 on_off->opt = *s;
 321                 on_off->switch_on = (1 << c);
 322                 if (s[1] == ':') {
 323                         on_off->optarg = va_arg (p, void **);
 324                         do
 325                                 s++;
 326                         while (s[1] == ':');
 327                 }
 328                 on_off++;
 329                 c++;
 330         }
 331
 332         for(l_o = bb_applet_long_options; l_o->name; l_o++) {
 333                 if(l_o->flag)
 334                         continue;
 335                 for(on_off = complementally; on_off->opt != 0; on_off++)
 336                         if(on_off->opt == l_o->val)
 337                                 break;
 338                 if(on_off->opt == 0) {
 339                         if(c >= (int)(sizeof(flags)*8))
 340                                 break;
 341                         on_off->opt = l_o->val;
 342                         on_off->switch_on = (1 << c);
 343                         if(l_o->has_arg != no_argument)
 344                                 on_off->optarg = va_arg (p, void **);
 345                         c++;
 346                 }
 347         }
 348         for (s = (const unsigned char *)bb_opt_complementally; s && *s; s++) {
 349                 t_complementally *pair;
 350                 unsigned long *pair_switch;
 351
 352                 if (*s == ':')
 353                         continue;
 354                 c = s[1];
 355                 if(*s == '?') {
 356                         if(c < '0' || c > '9') {
 357                                 spec_flgs |= SHOW_USAGE_IF_ERROR;
 358                         } else {
 359                                 max_arg = c - '0';
 360                                 s++;
 361                         }
 362                         continue;
 363                 }
 364                 if(*s == '-') {
 365                         if(c < '0' || c > '9') {
 366                                 if(c == '-') {
 367                                         spec_flgs |= FIRST_ARGV_IS_OPT;
 368                                         s++;
 369                                 } else
 370                                         spec_flgs |= ALL_ARGV_IS_OPTS;
 371                         } else {
 372                                 min_arg = c - '0';
 373                                 s++;
 374                         }
 375                         continue;
 376                 }
 377                 for (on_off = complementally; on_off->opt; on_off++)
 378                         if (on_off->opt == *s)
 379                                 break;
 380                 if(c == ':' && s[2] == ':') {
 381                         on_off->list_flg++;
 382                         continue;
 383                 }
 384                 if(c == ':' || c == '\0') {
 385                         requires |= on_off->switch_on;
 386                         continue;
 387                 }
 388                 if(c == *s) {
 389                         on_off->counter = va_arg (p, int *);
 390                         s++;
 391                 }
 392                 pair = on_off;
 393                 pair_switch = &(pair->switch_on);
 394                 for(s++; *s && *s != ':'; s++) {
 395                         if(*s == '?') {
 396                                 pair_switch = &(pair->requires);
 397                         } else if (*s == '-') {
 398                                 if(pair_switch == &(pair->switch_off))
 399                                         pair_switch = &(pair->incongruously);
 400                                 else
 401                                         pair_switch = &(pair->switch_off);
 402                         } else {
 403                             for (on_off = complementally; on_off->opt; on_off++)
 404                                 if (on_off->opt == *s) {
 405                                     *pair_switch |= on_off->switch_on;
 406                                     break;
 407                                 }
 408                         }
 409                 }
 410                 s--;
 411         }
 412         va_end (p);
 413
 414 #if defined(CONFIG_AR) || defined(CONFIG_TAR)
 415         if((spec_flgs & FIRST_ARGV_IS_OPT)) {
 416                 if(argv[1] && argv[1][0] != '-' && argv[1][0] != '\0') {
 417                         argv[1] = bb_xasprintf("-%s", argv[1]);
 418                         if(ENABLE_FEATURE_CLEAN_UP)
 419                                 spec_flgs |= FREE_FIRST_ARGV_IS_OPT;
 420                 }
 421         }
 422 #endif
 423         while ((c = getopt_long (argc, argv, applet_opts,
 424                                  bb_applet_long_options, NULL)) >= 0) {
 425 #ifdef CONFIG_PS
 426 loop_arg_is_opt:
 427 #endif
 428                 for (on_off = complementally; on_off->opt != c; on_off++) {
 429                         /* c==0 if long opt have non NULL flag */
 430                         if(on_off->opt == 0 && c != 0)
 431                                 bb_show_usage ();
 432                 }
 433                 if(flags & on_off->incongruously) {
 434                         if((spec_flgs & SHOW_USAGE_IF_ERROR))
 435                                 bb_show_usage ();
 436                         flags |= BB_GETOPT_ERROR;
 437                 }
 438                 trigger = on_off->switch_on & on_off->switch_off;
 439                 flags &= ~(on_off->switch_off ^ trigger);
 440                 flags |= on_off->switch_on ^ trigger;
 441                 flags ^= trigger;
 442                 if(on_off->counter)
 443                         (*(on_off->counter))++;
 444                 if(on_off->list_flg) {
 445                         *(llist_t **)(on_off->optarg) =
 446                           llist_add_to(*(llist_t **)(on_off->optarg), optarg);
 447                 } else if (on_off->optarg) {
 448                         *(char **)(on_off->optarg) = optarg;
 449                 }
 450 #ifdef CONFIG_PS
 451                 if(pargv != NULL)
 452                         break;
 453 #endif
 454         }
 455
 456 #ifdef CONFIG_PS
 457         if((spec_flgs & ALL_ARGV_IS_OPTS)) {
 458                 /* process argv is option, for example "ps" applet */
 459                 if(pargv == NULL)
 460                         pargv = argv + optind;
 461                 while(*pargv) {
 462                         c = **pargv;
 463                         if(c == '\0') {
 464                                 pargv++;
 465                         } else {
 466                                 (*pargv)++;
 467                                 goto loop_arg_is_opt;
 468                         }
 469                 }
 470         }
 471 #endif
 472
 473 #if (defined(CONFIG_AR) || defined(CONFIG_TAR)) && \
 474                                 defined(CONFIG_FEATURE_CLEAN_UP)
 475         if((spec_flgs & FREE_FIRST_ARGV_IS_OPT))
 476                 free(argv[1]);
 477 #endif
 478         /* check depending requires for given options */
 479         for (on_off = complementally; on_off->opt; on_off++) {
 480                 if(on_off->requires && (flags & on_off->switch_on) &&
 481                                         (flags & on_off->requires) == 0)
 482                         bb_show_usage ();
 483         }
 484         if(requires && (flags & requires) == 0)
 485                 bb_show_usage ();
 486         argc -= optind;
 487         if(argc < min_arg || (max_arg >= 0 && argc > max_arg))
 488                 bb_show_usage ();
 489         return flags;
 490 }