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  "V-"   A option with dash before colon or end line indicate: call
 186         bb_show_usage if this option give, for example verbose
 187         usage option.
 188
 189  "--"   A double dash between two options, or between an option and a group
 190         of options, means that they are mutually exclusive.  Unlike
 191         the "-" case above, an error will be forced if the options
 192         are used together.
 193
 194         For example:
 195         The cut applet must have only one type of list specified, so
 196         -b, -c and -f are mutally exclusive and should raise an error
 197         if specified together.  In this case you must set
 198         bb_opt_complementally = "b--cf:c--bf:f--bc".  If two of the
 199         mutually exclusive options are found, bb_getopt_ulflags's
 200         return value will have the error flag set (BB_GETOPT_ERROR) so
 201         that we can check for it:
 202
 203         if (flags & BB_GETOPT_ERROR)
 204                 bb_show_usage();
 205
 206  "?"    A "ask" as the first char in a bb_opt_complementally group give:
 207         if previous point set BB_GETOPT_ERROR, don`t return and
 208         call previous example internally. Next char for this case can`t
 209         set to [0-9], recomended use ':' or end of line.
 210
 211  "?N"   A "ask" as the first char in a bb_opt_complementally group with
 212         number 0-9 as one char is means check maximal arguments possible.
 213
 214  "::"   A double colon after a char in bb_opt_complementally means that the
 215         option can occur multiple times:
 216
 217         For example:
 218         The grep applet can have one or more "-e pattern" arguments.
 219         In this case you should use bb_getopt_ulflags() as follows:
 220
 221         llist_t *patterns = NULL;
 222
 223         (this pointer must be initializated to NULL if the list is empty
 224         as required by *llist_add_to(llist_t *old_head, char *new_item).)
 225
 226         bb_opt_complementally = "e::";
 227
 228         bb_getopt_ulflags(argc, argv, "e:", &patterns);
 229         $ grep -e user -e root /etc/passwd
 230         root:x:0:0:root:/root:/bin/bash
 231         user:x:500:500::/home/user:/bin/bash
 232
 233  "--"   A double dash as the first char in a bb_opt_complementally group
 234         means make first argv[1] as option always as may be added -, special
 235         for "ar" and "tar" applets.
 236
 237  "?"    A "ask" between main and group options causes the second of the two
 238         to be depending required as or if first is given on the command line.
 239         For example from "id" applet:
 240
 241         // Don't allow -n -r -rn -ug -rug -nug -rnug
 242         bb_opt_complementally = "r?ug:n?ug:?u--g:g--u";
 243         flags = bb_getopt_ulflags(argc, argv, "rnug");
 244
 245         This example allowed only:
 246         $ id; id -u; id -g; id -ru; id -nu; id -rg; id -ng; id -rnu; id -rng
 247
 248  "X"    A one options in bb_opt_complementally group means
 249         requires this option always with "or" logic if more one specified,
 250         checked after switch off from complementally logic.
 251         For example from "start-stop-daemon" applet:
 252
 253         // Don't allow -KS -SK, but -S or -K required
 254         bb_opt_complementally = "K:S:?K--S:S--K";
 255         flags = bb_getopt_ulflags(argc, argv, "KS...);
 256
 257
 258  "x--x" give error if double or more used -x option
 259
 260  Don`t forget ':' store. For example "?322-22-23X-x-a" interpretet as
 261  "?3:22:-2:2-2:2-3Xa:2--x": max args is 3, count -2 usaged, min args is 2,
 262  -2 option triggered, unset -3 and -X and -a if -2 any usaged, give error if
 263  after -2 the -x option usaged.
 264
 265 */
 266
 267 const char *bb_opt_complementally;
 268
 269 typedef struct {
 270         int opt;
 271         int list_flg;
 272         unsigned long switch_on;
 273         unsigned long switch_off;
 274         unsigned long incongruously;
 275         unsigned long requires;
 276         void **optarg;               /* char **optarg or llist_t **optarg */
 277         int *counter;
 278 } t_complementally;
 279
 280 /* You can set bb_applet_long_options for parse called long options */
 281
 282 static const struct option bb_default_long_options[] = {
 283 /*      { "help", 0, NULL, '?' }, */
 284         { 0, 0, 0, 0 }
 285 };
 286
 287 const struct option *bb_applet_long_options = bb_default_long_options;
 288
 289 unsigned long
 290 bb_getopt_ulflags (int argc, char **argv, const char *applet_opts, ...)
 291 {
 292         unsigned long flags = 0;
 293         unsigned long requires = 0;
 294         t_complementally complementally[sizeof(flags) * 8 + 1];
 295         int c;
 296         const unsigned char *s;
 297         t_complementally *on_off;
 298         va_list p;
 299         const struct option *l_o;
 300         unsigned long trigger;
 301 #ifdef CONFIG_PS
 302         char **pargv = NULL;
 303 #endif
 304         int min_arg = 0;
 305         int max_arg = -1;
 306
 307 #define SHOW_USAGE_IF_ERROR     1
 308 #define ALL_ARGV_IS_OPTS        2
 309 #define FIRST_ARGV_IS_OPT       4
 310 #define FREE_FIRST_ARGV_IS_OPT  8
 311         int spec_flgs = 0;
 312
 313         va_start (p, applet_opts);
 314
 315         c = 0;
 316         on_off = complementally;
 317         memset(on_off, 0, sizeof(complementally));
 318
 319         /* skip GNU extension */
 320         s = (const unsigned char *)applet_opts;
 321         if(*s == '+' || *s == '-')
 322                 s++;
 323         for (; *s; s++) {
 324                 if(c >= (int)(sizeof(flags)*8))
 325                         break;
 326                 on_off->opt = *s;
 327                 on_off->switch_on = (1 << c);
 328                 if (s[1] == ':') {
 329                         on_off->optarg = va_arg (p, void **);
 330                         do
 331                                 s++;
 332                         while (s[1] == ':');
 333                 }
 334                 on_off++;
 335                 c++;
 336         }
 337
 338         for(l_o = bb_applet_long_options; l_o->name; l_o++) {
 339                 if(l_o->flag)
 340                         continue;
 341                 for(on_off = complementally; on_off->opt != 0; on_off++)
 342                         if(on_off->opt == l_o->val)
 343                                 break;
 344                 if(on_off->opt == 0) {
 345                         if(c >= (int)(sizeof(flags)*8))
 346                                 break;
 347                         on_off->opt = l_o->val;
 348                         on_off->switch_on = (1 << c);
 349                         if(l_o->has_arg != no_argument)
 350                                 on_off->optarg = va_arg (p, void **);
 351                         c++;
 352                 }
 353         }
 354         for (s = (const unsigned char *)bb_opt_complementally; s && *s; s++) {
 355                 t_complementally *pair;
 356                 unsigned long *pair_switch;
 357
 358                 if (*s == ':')
 359                         continue;
 360                 c = s[1];
 361                 if(*s == '?') {
 362                         if(c < '0' || c > '9') {
 363                                 spec_flgs |= SHOW_USAGE_IF_ERROR;
 364                         } else {
 365                                 max_arg = c - '0';
 366                                 s++;
 367                         }
 368                         continue;
 369                 }
 370                 if(*s == '-') {
 371                         if(c < '0' || c > '9') {
 372                                 if(c == '-') {
 373                                         spec_flgs |= FIRST_ARGV_IS_OPT;
 374                                         s++;
 375                                 } else
 376                                         spec_flgs |= ALL_ARGV_IS_OPTS;
 377                         } else {
 378                                 min_arg = c - '0';
 379                                 s++;
 380                         }
 381                         continue;
 382                 }
 383                 for (on_off = complementally; on_off->opt; on_off++)
 384                         if (on_off->opt == *s)
 385                                 break;
 386                 if(c == ':' && s[2] == ':') {
 387                         on_off->list_flg++;
 388                         continue;
 389                 }
 390                 if(c == ':' || c == '\0') {
 391                         requires |= on_off->switch_on;
 392                         continue;
 393                 }
 394                 if(c == '-' && (s[2] == ':' || s[2] == '\0')) {
 395                         flags |= on_off->switch_on;
 396                         on_off->incongruously |= on_off->switch_on;
 397                         s++;
 398                         continue;
 399                 }
 400                 if(c == *s) {
 401                         on_off->counter = va_arg (p, int *);
 402                         s++;
 403                 }
 404                 pair = on_off;
 405                 pair_switch = &(pair->switch_on);
 406                 for(s++; *s && *s != ':'; s++) {
 407                         if(*s == '?') {
 408                                 pair_switch = &(pair->requires);
 409                         } else if (*s == '-') {
 410                                 if(pair_switch == &(pair->switch_off))
 411                                         pair_switch = &(pair->incongruously);
 412                                 else
 413                                         pair_switch = &(pair->switch_off);
 414                         } else {
 415                             for (on_off = complementally; on_off->opt; on_off++)
 416                                 if (on_off->opt == *s) {
 417                                     *pair_switch |= on_off->switch_on;
 418                                     break;
 419                                 }
 420                         }
 421                 }
 422                 s--;
 423         }
 424         va_end (p);
 425
 426 #if defined(CONFIG_AR) || defined(CONFIG_TAR)
 427         if((spec_flgs & FIRST_ARGV_IS_OPT)) {
 428                 if(argv[1] && argv[1][0] != '-' && argv[1][0] != '\0') {
 429                         argv[1] = bb_xasprintf("-%s", argv[1]);
 430                         if(ENABLE_FEATURE_CLEAN_UP)
 431                                 spec_flgs |= FREE_FIRST_ARGV_IS_OPT;
 432                 }
 433         }
 434 #endif
 435         while ((c = getopt_long (argc, argv, applet_opts,
 436                                  bb_applet_long_options, NULL)) >= 0) {
 437 #ifdef CONFIG_PS
 438 loop_arg_is_opt:
 439 #endif
 440                 for (on_off = complementally; on_off->opt != c; on_off++) {
 441                         /* c==0 if long opt have non NULL flag */
 442                         if(on_off->opt == 0 && c != 0)
 443                                 bb_show_usage ();
 444                 }
 445                 if(flags & on_off->incongruously) {
 446                         if((spec_flgs & SHOW_USAGE_IF_ERROR))
 447                                 bb_show_usage ();
 448                         flags |= BB_GETOPT_ERROR;
 449                 }
 450                 trigger = on_off->switch_on & on_off->switch_off;
 451                 flags &= ~(on_off->switch_off ^ trigger);
 452                 flags |= on_off->switch_on ^ trigger;
 453                 flags ^= trigger;
 454                 if(on_off->counter)
 455                         (*(on_off->counter))++;
 456                 if(on_off->list_flg) {
 457                         *(llist_t **)(on_off->optarg) =
 458                           llist_add_to(*(llist_t **)(on_off->optarg), optarg);
 459                 } else if (on_off->optarg) {
 460                         *(char **)(on_off->optarg) = optarg;
 461                 }
 462 #ifdef CONFIG_PS
 463                 if(pargv != NULL)
 464                         break;
 465 #endif
 466         }
 467
 468 #ifdef CONFIG_PS
 469         if((spec_flgs & ALL_ARGV_IS_OPTS)) {
 470                 /* process argv is option, for example "ps" applet */
 471                 if(pargv == NULL)
 472                         pargv = argv + optind;
 473                 while(*pargv) {
 474                         c = **pargv;
 475                         if(c == '\0') {
 476                                 pargv++;
 477                         } else {
 478                                 (*pargv)++;
 479                                 goto loop_arg_is_opt;
 480                         }
 481                 }
 482         }
 483 #endif
 484
 485 #if (defined(CONFIG_AR) || defined(CONFIG_TAR)) && \
 486                                 defined(CONFIG_FEATURE_CLEAN_UP)
 487         if((spec_flgs & FREE_FIRST_ARGV_IS_OPT))
 488                 free(argv[1]);
 489 #endif
 490         /* check depending requires for given options */
 491         for (on_off = complementally; on_off->opt; on_off++) {
 492                 if(on_off->requires && (flags & on_off->switch_on) &&
 493                                         (flags & on_off->requires) == 0)
 494                         bb_show_usage ();
 495         }
 496         if(requires && (flags & requires) == 0)
 497                 bb_show_usage ();
 498         argc -= optind;
 499         if(argc < min_arg || (max_arg >= 0 && argc > max_arg))
 500                 bb_show_usage ();
 501         return flags;
 502 }