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 character 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 and
 131         for each -b optarg, add optarg to my_b. Finally, if b is given, turn off
 132         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 = bb_xgetularg10_bnd(smax_print_depth,
 168                              0, INT_MAX);
 169         }
 170         if(opt & 4)
 171                 printf("Detected odd -x usaging\n");
 172
 173  "-"    A minus as the first char in a bb_opt_complementally group means to
 174         convert the arguments as option.
 175         For example:
 176
 177         bb_opt_complementally = "-:w-x:x-w";
 178         bb_getopt_ulflags(argc, argv, "wx");
 179
 180         Allows any arguments to be given without a dash (./program w x)
 181         as well as with a dash (./program -x). Why unset -w see above.
 182
 183  "~"    A tilde between two options, or between an option and a group
 184         of options, means that they are mutually exclusive.  Unlike
 185         the "-" case above, an error will be forced if the options
 186         are used together.
 187
 188         For example:
 189         The cut applet must have only one type of list specified, so
 190         -b, -c and -f are mutally exclusive and should raise an error
 191         if specified together.  In this case you must set
 192         bb_opt_complementally = "b~cf:c~bf:f~bc".  If two of the
 193         mutually exclusive options are found, bb_getopt_ulflags's
 194         return value will have the error flag set (BB_GETOPT_ERROR) so
 195         that we can check for it:
 196
 197         if (flags & BB_GETOPT_ERROR)
 198                 bb_show_usage();
 199
 200  "?"    A "ask" as the first char in a bb_opt_complementally group give:
 201         if previous point set BB_GETOPT_ERROR, don`t return and
 202         call previous example internally
 203
 204  "*"    A star after a char in bb_opt_complementally means that the
 205         option can occur multiple times:
 206
 207         For example:
 208         The grep applet can have one or more "-e pattern" arguments.
 209         In this case you should use bb_getopt_ulflags() as follows:
 210
 211         llist_t *patterns = NULL;
 212
 213         (this pointer must be initializated to NULL if the list is empty
 214         as required by *llist_add_to(llist_t *old_head, char *new_item).)
 215
 216         bb_opt_complementally = "e*";
 217
 218         bb_getopt_ulflags(argc, argv, "e:", &patterns);
 219         $ grep -e user -e root /etc/passwd
 220         root:x:0:0:root:/root:/bin/bash
 221         user:x:500:500::/home/user:/bin/bash
 222
 223  "?"    A "ask" between main and group options causes the second of the two
 224         to be depending required if first is given on the command line.
 225         For example from "id" applet:
 226
 227         // Don't allow -n -r -rn -ug -rug -nug -rnug
 228         bb_opt_complementally = "?u~g:g~u:r?ug:n?ug";
 229         flags = bb_getopt_ulflags(argc, argv, "rnug");
 230
 231         This example allowed only:
 232         $ id; id -u; id -g; id -ru; id -nu; id -rg; id -ng; id -rnu; id -rng
 233
 234  "?"    A "ask" between equivalent options in bb_opt_complementally means
 235         requires this option always, checked after switch off from
 236         complementally logic
 237         For example from "start-stop-daemon" applet:
 238
 239         // Don't allow -KS -SK, but -S or -K required
 240         bb_opt_complementally = "?:K?K:S?S:K~S:S~K";
 241         flags = bb_getopt_ulflags(argc, argv, "KS...);
 242
 243 */
 244
 245 const char *bb_opt_complementally;
 246
 247 typedef struct {
 248         int opt;
 249         int list_flg;
 250         unsigned long switch_on;
 251         unsigned long switch_off;
 252         unsigned long incongruously;
 253         unsigned long requires;
 254         void **optarg;               /* char **optarg or llist_t **optarg */
 255         int *counter;
 256 } t_complementally;
 257
 258 /* You can set bb_applet_long_options for parse called long options */
 259
 260 static const struct option bb_default_long_options[] = {
 261 /*      { "help", 0, NULL, '?' }, */
 262         { 0, 0, 0, 0 }
 263 };
 264
 265 const struct option *bb_applet_long_options = bb_default_long_options;
 266
 267 unsigned long
 268 bb_getopt_ulflags (int argc, char **argv, const char *applet_opts, ...)
 269 {
 270         unsigned long flags = 0;
 271         unsigned long requires = 0;
 272         t_complementally complementally[sizeof(flags) * 8 + 1];
 273         int c;
 274         const unsigned char *s;
 275         t_complementally *on_off;
 276         va_list p;
 277         const struct option *l_o;
 278         unsigned long trigger;
 279         char **pargv = NULL;
 280
 281 #define SHOW_USAGE_IF_ERROR 1
 282 #define ARGV_IS_OPTS        2
 283         int spec_flgs = 0;
 284
 285         va_start (p, applet_opts);
 286
 287         /* skip GNU extension */
 288         s = applet_opts;
 289         if(*s == '+' || *s == '-')
 290                 s++;
 291
 292         c = 0;
 293         on_off = complementally;
 294         memset(on_off, 0, sizeof(complementally));
 295
 296         for (; *s; s++) {
 297                 if(c >= (int)(sizeof(flags)*8))
 298                         break;
 299                 on_off->opt = *s;
 300                 on_off->switch_on = (1 << c);
 301                 if (s[1] == ':') {
 302                         on_off->optarg = va_arg (p, void **);
 303                         do
 304                                 s++;
 305                         while (s[1] == ':');
 306                 }
 307                 on_off++;
 308                 c++;
 309         }
 310
 311         for(l_o = bb_applet_long_options; l_o->name; l_o++) {
 312                 if(l_o->flag)
 313                         continue;
 314                 for(on_off = complementally; on_off->opt != 0; on_off++)
 315                         if(on_off->opt == l_o->val)
 316                                 break;
 317                 if(on_off->opt == 0) {
 318                         if(c >= (int)(sizeof(flags)*8))
 319                                 break;
 320                         on_off->opt = l_o->val;
 321                         on_off->switch_on = (1 << c);
 322                         if(l_o->has_arg != no_argument)
 323                                 on_off->optarg = va_arg (p, void **);
 324                         c++;
 325                 }
 326         }
 327         c = 0;
 328         for (s = bb_opt_complementally; s && *s; s++) {
 329                 t_complementally *pair;
 330
 331                 if (*s == ':') {
 332                         c = 0;
 333                         continue;
 334                 }
 335                 if (c)
 336                         continue;
 337                 if(*s == '?') {
 338                         spec_flgs |= SHOW_USAGE_IF_ERROR;
 339                         continue;
 340                 }
 341                 if(*s == '-') {
 342                         spec_flgs |= ARGV_IS_OPTS;
 343                         continue;
 344                 }
 345                 for (on_off = complementally; on_off->opt; on_off++)
 346                         if (on_off->opt == *s)
 347                                 break;
 348                 pair = on_off;
 349                 for(s++; *s && *s != ':'; s++) {
 350                         if (*s == '-' || *s == '~' || *s == '?') {
 351                                 c = *s;
 352                         } else if(*s == '*') {
 353                                 pair->list_flg++;
 354                         } else {
 355                             unsigned long *pair_switch;
 356
 357                             switch(c) {
 358                                 case '-':
 359                                         pair_switch = &(pair->switch_off);
 360                                         break;
 361                                 case '~':
 362                                         pair_switch = &(pair->incongruously);
 363                                         break;
 364                                 case '?':
 365                                         pair_switch = &(pair->requires);
 366                                         break;
 367                                 default:
 368                                         pair_switch = &(pair->switch_on);
 369                             }
 370                             for (on_off = complementally; on_off->opt; on_off++)
 371                                 if (on_off->opt == *s) {
 372                                     if(pair_switch == &(on_off->switch_on))
 373                                         on_off->counter = va_arg (p, int *);
 374                                     else if(pair_switch == &(on_off->requires))
 375                                         requires |= on_off->switch_on;
 376                                     else
 377                                         *pair_switch |= on_off->switch_on;
 378                                     break;
 379                                 }
 380                         }
 381                 }
 382                 s--;
 383         }
 384
 385         while ((c = getopt_long (argc, argv, applet_opts,
 386                                  bb_applet_long_options, NULL)) >= 0) {
 387
 388 loop_arg_is_opt:
 389                 for (on_off = complementally; on_off->opt != c; on_off++) {
 390                         /* c==0 if long opt have non NULL flag */
 391                         if(on_off->opt == 0 && c != 0)
 392                                 bb_show_usage ();
 393                 }
 394                 if(flags & on_off->incongruously) {
 395                         if((spec_flgs & SHOW_USAGE_IF_ERROR))
 396                                 bb_show_usage ();
 397                         flags |= BB_GETOPT_ERROR;
 398                 }
 399                 trigger = on_off->switch_on & on_off->switch_off;
 400                 flags &= ~(on_off->switch_off ^ trigger);
 401                 flags |= on_off->switch_on ^ trigger;
 402                 flags ^= trigger;
 403                 if(on_off->counter)
 404                         (*(on_off->counter))++;
 405                 if(on_off->list_flg) {
 406                         *(llist_t **)(on_off->optarg) =
 407                           llist_add_to(*(llist_t **)(on_off->optarg), optarg);
 408                 } else if (on_off->optarg) {
 409                         *(char **)(on_off->optarg) = optarg;
 410                 }
 411                 if(pargv != NULL)
 412                         break;
 413         }
 414         if((spec_flgs & ARGV_IS_OPTS)) {
 415                 /* process argv is option, for example "ps" applet */
 416                 if(pargv == NULL)
 417                         pargv = argv + optind;
 418                 while(*pargv) {
 419                         c = **pargv;
 420                         if(c == '\0') {
 421                                 pargv++;
 422                         } else {
 423                                 (*pargv)++;
 424                                 goto loop_arg_is_opt;
 425                         }
 426                 }
 427         }
 428         /* check depending requires for given options */
 429         for (on_off = complementally; on_off->opt; on_off++) {
 430                 if(on_off->requires && (flags & on_off->switch_on) &&
 431                                         (flags & on_off->requires) == 0)
 432                         bb_show_usage ();
 433         }
 434         if(requires && (flags & requires) == 0)
 435                 bb_show_usage ();
 436         return flags;
 437 }