/* Prepend '-' to the first argument if required */
opt_complementary = "--:p:t:x:-1:p--tx:t--px:x--pt";
- opt = getopt32(argc, argv, "ptxovcr");
+ opt = getopt32(argv, "ptxovcr");
if (opt & AR_CTX_PRINT) {
archive_handle->action_data = data_extract_to_stdout;
int bunzip2_main(int argc, char **argv);
int bunzip2_main(int argc, char **argv)
{
- getopt32(argc, argv, "cf");
+ getopt32(argv, "cf");
argv += optind;
if (applet_name[2] == 'c')
option_mask32 |= OPT_STDOUT;
int gunzip_main(int argc, char **argv);
int gunzip_main(int argc, char **argv)
{
- getopt32(argc, argv, "cfvdt");
+ getopt32(argv, "cfvdt");
argv += optind;
/* if called as zcat */
if (applet_name[1] == 'c')
int unlzma_main(int argc, char **argv);
int unlzma_main(int argc, char **argv)
{
- getopt32(argc, argv, "c");
+ getopt32(argv, "c");
argv += optind;
/* lzmacat? */
if (applet_name[4] == 'c')
int uncompress_main(int argc, char **argv);
int uncompress_main(int argc, char **argv)
{
- getopt32(argc, argv, "cf");
+ getopt32(argv, "cf");
argv += optind;
return bbunpack(argv, make_new_name_uncompress, unpack_uncompress);
archive_handle->seek = seek_by_read;
archive_handle->flags = ARCHIVE_EXTRACT_NEWER | ARCHIVE_PRESERVE_DATE;
- opt = getopt32(argc, argv, "ituvF:dm", &cpio_filename);
+ opt = getopt32(argv, "ituvF:dm", &cpio_filename);
/* One of either extract or test options must be given */
if ((opt & (CPIO_OPT_TEST | CPIO_OPT_EXTRACT)) == 0) {
OPT_unpack = 0x40,
};
- opt = getopt32(argc, argv, "CF:ilPru", &str_f);
+ opt = getopt32(argv, "CF:ilPru", &str_f);
//if (opt & OPT_configure) ... // -C
if (opt & OPT_force_ignore_depends) { // -F (--force in official dpkg)
if (strcmp(str_f, "depends"))
#endif
opt_complementary = "?c--efXx:e--cfXx:f--ceXx:X--cefx:x--cefX";
- opt = getopt32(argc, argv, "cefXx");
+ opt = getopt32(argv, "cefXx");
if (opt & DPKG_DEB_OPT_CONTENTS) {
tar_archive->action_header = header_verbose_list;
unsigned opt;
/* Must match bbunzip's constants OPT_STDOUT, OPT_FORCE! */
- opt = getopt32(argc, argv, "cfv" USE_GUNZIP("d") "q123456789" );
+ opt = getopt32(argv, "cfv" USE_GUNZIP("d") "q123456789" );
option_mask32 &= 0x7; /* Clear -d, ignore -q, -0..9 */
//if (opt & 0x1) // -c
//if (opt & 0x2) // -f
#if ENABLE_FEATURE_TAR_LONG_OPTIONS
applet_long_options = tar_longopts;
#endif
- opt = getopt32(argc, argv,
+ opt = getopt32(argv,
"txC:f:Opvk"
USE_FEATURE_TAR_CREATE( "ch" )
USE_FEATURE_TAR_BZIP2( "j" )
#if ENABLE_FEATURE_SETCONSOLE_LONG_OPTIONS
applet_long_options = setconsole_longopts;
#endif
- flags = getopt32(argc, argv, "r");
+ flags = getopt32(argv, "r");
if (argc - optind > 1)
bb_show_usage();
char day_headings[28]; /* 28 for julian, 21 for nonjulian */
char buf[40];
- flags = getopt32(argc, argv, "jy");
+ flags = getopt32(argv, "jy");
julian = flags & 1;
month = 0;
argv += optind;
int cat_main(int argc, char **argv);
int cat_main(int argc, char **argv)
{
- getopt32(argc, argv, "u");
+ getopt32(argv, "u");
argv += optind;
return bb_cat(argv);
}
int fd;
unsigned flags;
- flags = getopt32(argc, argv, "etv");
+ flags = getopt32(argv, "etv");
#define CATV_OPT_e (1<<0)
#define CATV_OPT_t (1<<1)
#define CATV_OPT_v (1<<2)
/* Parse options */
opt_complementary = "-2";
- getopt32(argc, argv, ("-"OPT_STR) + 1); /* Reuse string */
+ getopt32(argv, ("-"OPT_STR) + 1); /* Reuse string */
argv += optind;
/* Restore option-like mode if needed */
chown_fptr chown_func;
opt_complementary = "-2";
- getopt32(argc, argv, OPT_STR);
+ getopt32(argv, OPT_STR);
argv += optind;
/* This matches coreutils behavior (almost - see below) */
unsigned flags;
opt_complementary = "=2";
- flags = getopt32(argc, argv, "123");
+ flags = getopt32(argv, "123");
argv += optind;
for (i = 0; i < 2; ++i) {
// -r and -R are the same
// -a = -pdR
opt_complementary = "l--s:s--l:Pd:rR:apdR";
- flags = getopt32(argc, argv, FILEUTILS_CP_OPTSTR "arPHL");
+ flags = getopt32(argv, FILEUTILS_CP_OPTSTR "arPHL");
/* Default behavior of cp is to dereference, so we don't have to do
* anything special when we are given -L.
* The behavior of -H is *almost* like -L, but not quite, so let's
char *sopt, *ltok;
opt_complementary = "b--bcf:c--bcf:f--bcf";
- getopt32(argc, argv, optstring, &sopt, &sopt, &sopt, <ok);
+ getopt32(argv, optstring, &sopt, &sopt, &sopt, <ok);
// argc -= optind;
argv += optind;
if (!(option_mask32 & (CUT_OPT_BYTE_FLGS | CUT_OPT_CHAR_FLGS | CUT_OPT_FIELDS_FLGS)))
opt_complementary = "d--s:s--d"
USE_FEATURE_DATE_ISOFMT(":R--I:I--R");
- opt = getopt32(argc, argv, "Rs:ud:r:"
+ opt = getopt32(argv, "Rs:ud:r:"
USE_FEATURE_DATE_ISOFMT("I::D:"),
&date_str, &date_str, &filename
USE_FEATURE_DATE_ISOFMT(, &isofmt_arg, &hintfmt_arg));
#if ENABLE_FEATURE_HUMAN_READABLE
opt_complementary = "h-km:k-hm:m-hk";
- opt = getopt32(argc, argv, "hmk");
+ opt = getopt32(argv, "hmk");
if (opt & 1) {
df_disp_hr = 0;
disp_units_hdr = " Size";
disp_units_hdr = "1M-blocks";
}
#else
- opt = getopt32(argc, argv, "k");
+ opt = getopt32(argv, "k");
#endif
printf("Filesystem%11s%-15sUsed Available Use%% Mounted on\n",
/* -u convert to unix, -d convert to dos */
opt_complementary = "u--d:d--u"; /* mutually exclusive */
- o = getopt32(argc, argv, "du");
+ o = getopt32(argv, "du");
/* Do the conversion requested by an argument else do the default
* conversion depending on our name. */
*/
#if ENABLE_FEATURE_HUMAN_READABLE
opt_complementary = "h-km:k-hm:m-hk:H-L:L-H:s-d:d-s";
- opt = getopt32(argc, argv, "aHkLsx" "d:" "lc" "hm", &smax_print_depth);
+ opt = getopt32(argv, "aHkLsx" "d:" "lc" "hm", &smax_print_depth);
if (opt & (1 << 9)) {
/* -h opt */
disp_hr = 0;
}
#else
opt_complementary = "H-L:L-H:s-d:d-s";
- opt = getopt32(argc, argv, "aHkLsx" "d:" "lc", &smax_print_depth);
+ opt = getopt32(argv, "aHkLsx" "d:" "lc", &smax_print_depth);
#if !ENABLE_FEATURE_DU_DEFAULT_BLOCKSIZE_1K
if (opt & (1 << 2)) {
/* -k opt */
#if ENABLE_FEATURE_ENV_LONG_OPTIONS
applet_long_options = env_longopts;
#endif
- opt = getopt32(argc, argv, "+iu:", &unset_env);
+ opt = getopt32(argv, "+iu:", &unset_env);
argv += optind;
if (*argv && LONE_DASH(argv[0])) {
opt |= 1;
if (ENABLE_EXPAND && (!ENABLE_UNEXPAND || applet_name[0] == 'e')) {
USE_FEATURE_EXPAND_LONG_OPTIONS(applet_long_options = expand_longopts);
- opt = getopt32(argc, argv, "it:", &opt_t);
+ opt = getopt32(argv, "it:", &opt_t);
} else if (ENABLE_UNEXPAND) {
USE_FEATURE_UNEXPAND_LONG_OPTIONS(applet_long_options = unexpand_longopts);
/* -t NUM sets also -a */
opt_complementary = "ta";
- opt = getopt32(argc, argv, "ft:a", &opt_t);
+ opt = getopt32(argv, "ft:a", &opt_t);
/* -f --first-only is the default */
if (!(opt & OPT_ALL)) opt |= OPT_INITIAL;
}
}
}
- flags = getopt32(argc, argv, "bsw:", &w_opt);
+ flags = getopt32(argv, "bsw:", &w_opt);
if (flags & FLAG_WIDTH)
width = xatoul_range(w_opt, 1, 10000);
/* Don't allow -n -r -nr -ug -rug -nug -rnug */
/* Don't allow more than one username */
opt_complementary = "?1:u--g:g--u:r?ug:n?ug" USE_SELINUX(":u--Z:Z--u:g--Z:Z--g");
- flags = getopt32(argc, argv, "rnug" USE_SELINUX("Z"));
+ flags = getopt32(argv, "rnug" USE_SELINUX("Z"));
/* This values could be overwritten later */
uid = geteuid();
opt_complementary = "s--d:d--s" USE_SELINUX(":Z--\xff:\xff--Z");
/* -c exists for backwards compatibility, it's needed */
- flags = getopt32(argc, argv, "cdpsg:m:o:" USE_SELINUX("Z:"),
+ flags = getopt32(argv, "cdpsg:m:o:" USE_SELINUX("Z:"),
&gid_str, &mode_str, &uid_str USE_SELINUX(, &scontext));
#if ENABLE_SELINUX
security_context_t scontext;
#endif
int opt;
- opt = getopt32(argc, argv, "m:" USE_SELINUX("Z:"), &smode USE_SELINUX(,&scontext));
+ opt = getopt32(argv, "m:" USE_SELINUX("Z:"), &smode USE_SELINUX(,&scontext));
if (opt & 1) {
if (bb_parse_mode(smode, &mode))
umask(0);
struct stat statbuf;
int (*link_func)(const char *, const char *);
- flag = getopt32(argc, argv, "sfnbS:", &suffix);
+ flag = getopt32(argv, "sfnbS:", &suffix);
if (argc == optind) {
bb_show_usage();
/* process options */
USE_FEATURE_LS_COLOR(applet_long_options = ls_color_opt;)
#if ENABLE_FEATURE_AUTOWIDTH
- opt = getopt32(argc, argv, ls_options, &tabstops_str, &terminal_width_str
+ opt = getopt32(argv, ls_options, &tabstops_str, &terminal_width_str
USE_FEATURE_LS_COLOR(, &color_opt));
if (tabstops_str)
tabstops = xatou(tabstops_str);
if (terminal_width_str)
terminal_width = xatou(terminal_width_str);
#else
- opt = getopt32(argc, argv, ls_options USE_FEATURE_LS_COLOR(, &color_opt));
+ opt = getopt32(argv, ls_options USE_FEATURE_LS_COLOR(, &color_opt));
#endif
for (i = 0; opt_flags[i] != (1U<<31); i++) {
if (opt & (1 << i)) {
: HASH_SHA1;
if (ENABLE_FEATURE_MD5_SHA1_SUM_CHECK)
- flags = getopt32(argc, argv, "scw");
+ flags = getopt32(argv, "scw");
else optind = 1;
if (ENABLE_FEATURE_MD5_SHA1_SUM_CHECK && !(flags & FLAG_CHECK)) {
#if ENABLE_FEATURE_MKDIR_LONG_OPTIONS
applet_long_options = mkdir_longopts;
#endif
- opt = getopt32(argc, argv, "m:p" USE_SELINUX("Z:"), &smode USE_SELINUX(,&scontext));
+ opt = getopt32(argv, "m:p" USE_SELINUX("Z:"), &smode USE_SELINUX(,&scontext));
if (opt & 1) {
mode = 0777;
if (!bb_parse_mode(smode, &mode)) {
applet_long_options = mv_longopts;
#endif
opt_complementary = "f-i:i-f";
- flags = getopt32(argc, argv, "fi");
+ flags = getopt32(argv, "fi");
if (optind + 2 > argc) {
bb_show_usage();
}
#if ENABLE_GETOPT_LONG
applet_long_options = od_longopts;
#endif
- opt = getopt32(argc, argv, "A:N:abcdfhij:lot:vxsS:"
+ opt = getopt32(argv, "A:N:abcdfhij:lot:vxsS:"
"w::", // -w with optional param
// -S was -s and also had optional parameter
// but in coreutils 6.3 it was renamed and now has
unsigned opt;
/* We need exactly one non-option argument. */
opt_complementary = "=1";
- opt = getopt32(argc, argv, "f");
+ opt = getopt32(argv, "f");
fname = argv[optind];
)
SKIP_FEATURE_READLINK_FOLLOW(
unsigned opt;
opt_complementary = "f-i:i-f";
- opt = getopt32(argc, argv, "fiRr");
+ opt = getopt32(argv, "fiRr");
argv += optind;
if (opt & 1)
flags |= FILEUTILS_FORCE;
int do_dot;
char *path;
- flags = getopt32(argc, argv, "p");
+ flags = getopt32(argv, "p");
argv += optind;
if (!*argv) {
/* -o and -t can be given at most once */
opt_complementary = "o--o:t--t:" /* -t, -o: maximum one of each */
"k::"; /* -k takes list */
- getopt32(argc, argv, OPT_STR, &str_ignored, &str_ignored, &str_o, &lst_k, &str_t);
+ getopt32(argv, OPT_STR, &str_ignored, &str_ignored, &str_o, &lst_k, &str_t);
#if ENABLE_FEATURE_SORT_BIG
if (option_mask32 & FLAG_o) outfile = xfopen(str_o, "w");
if (option_mask32 & FLAG_t) {
char *src;
opt_complementary = "?2";
- opt = getopt32(argc, argv, "l:b:a:", &count_p, &count_p, &sfx);
+ opt = getopt32(argv, "l:b:a:", &count_p, &count_p, &sfx);
if (opt & SPLIT_OPT_l)
cnt = xatoul(count_p);
int ok = 1;
bool (*statfunc)(char const *, char const *) = do_stat;
- getopt32(argc, argv, "ftL"
+ getopt32(argv, "ftL"
USE_SELINUX("Z")
USE_FEATURE_STAT_FORMAT("c:", &format)
);
unsigned n;
unsigned type = SUM_BSD;
- n = getopt32(argc, argv, "sr");
+ n = getopt32(argv, "sr");
if (n & 1) type = SUM_SYSV;
/* give the bsd priority over sysv func */
if (n & 2) type = SUM_BSD;
}
#endif
- opt = getopt32(argc, argv, "fc:n:" USE_FEATURE_FANCY_TAIL("qs:v"),
+ opt = getopt32(argv, "fc:n:" USE_FEATURE_FANCY_TAIL("qs:v"),
&str_c, &str_n USE_FEATURE_FANCY_TAIL(,&str_s));
#define FOLLOW (opt & 0x1)
#define COUNT_BYTES (opt & 0x2)
#else
int c;
#endif
- retval = getopt32(argc, argv, "ia"); /* 'a' must be 2nd */
+ retval = getopt32(argv, "ia"); /* 'a' must be 2nd */
argc -= optind;
argv += optind;
{
int fd;
int status = EXIT_SUCCESS;
- int flags = getopt32(argc, argv, "c");
+ int flags = getopt32(argv, "c");
argv += optind;
xfunc_error_retval = 2; /* SUSv3 requires > 1 for error. */
- USE_INCLUDE_SUSv2(silent = getopt32(argc, argv, "s");)
+ USE_INCLUDE_SUSv2(silent = getopt32(argv, "s");)
/* gnu tty outputs a warning that it is ignoring all args. */
bb_warn_ignoring_args(argc - optind);
const unsigned short int *delta;
char toprint;
- toprint = getopt32(argc, argv, options);
+ toprint = getopt32(argv, options);
if (argc != optind) {
bb_show_usage();
skip_fields = skip_chars = 0;
- opt = getopt32(argc, argv, "cduf:s:", &s0, &s1);
+ opt = getopt32(argv, "cduf:s:", &s0, &s1);
if (opt & OPT_f)
skip_fields = xatoul(s0);
if (opt & OPT_s)
char *line;
opt_complementary = "?1"; /* 1 argument max */
- getopt32(argc, argv, "o:", &outname);
+ getopt32(argv, "o:", &outname);
argv += optind;
if (argv[0])
tbl = bb_uuenc_tbl_std;
mode = 0666 & ~umask(0666);
opt_complementary = "-1:?2"; /* must have 1 or 2 args */
- if (getopt32(argc, argv, "m")) {
+ if (getopt32(argv, "m")) {
tbl = bb_uuenc_tbl_base64;
}
argv += optind;
smallint in_word;
unsigned print_type;
- print_type = getopt32(argc, argv, "lwcL");
+ print_type = getopt32(argv, "lwcL");
if (print_type == 0) {
print_type = (1 << WC_LINES) | (1 << WC_WORDS) | (1 << WC_CHARS);
int mktemp_main(int argc, char **argv);
int mktemp_main(int argc, char **argv)
{
- unsigned long flags = getopt32(argc, argv, "dqt");
+ unsigned long flags = getopt32(argv, "dqt");
char *chp;
if (optind + 1 != argc)
#if ENABLE_FEATURE_RUN_PARTS_LONG_OPTIONS
applet_long_options = runparts_longopts;
#endif
- tmp = getopt32(argc, argv, "a:u:t"USE_FEATURE_RUN_PARTS_FANCY("l"), &arg_list, &umask_p);
+ tmp = getopt32(argv, "a:u:t"USE_FEATURE_RUN_PARTS_FANCY("l"), &arg_list, &umask_p);
G.mode = tmp &~ (RUN_PARTS_OPT_a|RUN_PARTS_OPT_u);
if (tmp & RUN_PARTS_OPT_u) {
/* Check and set the umask of the program executed.
/* Check required one context option was given */
opt_complementary = "K:S:K--S:S--K:m?p:K?xpun:S?xa";
- opt = getopt32(argc, argv, "KSbqma:n:s:u:c:x:p:"
+ opt = getopt32(argv, "KSbqma:n:s:u:c:x:p:"
USE_FEATURE_START_STOP_DAEMON_FANCY("ovN:"),
// USE_FEATURE_START_STOP_DAEMON_FANCY("ovN:R:"),
&startas, &cmdname, &signame, &userspec, &chuid, &execname, &pidfile
int lsattr_main(int argc, char **argv);
int lsattr_main(int argc, char **argv)
{
- getopt32(argc, argv, "Radlv");
+ getopt32(argv, "Radlv");
argv += optind;
if (!*argv)
{
int i;
- flags = getopt32(argc, argv, "Radlv");
+ flags = getopt32(argv, "Radlv");
if (optind > argc - 1)
lsattr_args(".");
}
}
opt_complementary = "v::";
- opt = getopt32(argc, argv, "F:v:f:W:", &opt_F, &opt_v, &g_progname, &opt_W);
+ opt = getopt32(argv, "F:v:f:W:", &opt_F, &opt_v, &g_progname, &opt_W);
argv += optind;
argc -= optind;
if (opt & 0x1)
USE_DESKTOP(":?4")
SKIP_DESKTOP(":?2")
":l--s:s--l";
- opt = getopt32(argc, argv, opt_chars);
+ opt = getopt32(argv, opt_chars);
argv += optind;
filename1 = *argv;
/* exactly 2 params; collect multiple -L <label> */
opt_complementary = "=2:L::";
- getopt32(argc, argv, "abdiL:NqrsS:tTU:wu"
+ getopt32(argv, "abdiL:NqrsS:tTU:wu"
"p" /* ignored (for compatibility) */,
&L_arg, &start, &U_opt);
/*argc -= optind;*/
{
char *p, *i;
- ret = getopt32(argc, argv, "p:i:", &p, &i);
+ ret = getopt32(argv, "p:i:", &p, &i);
if (ret & 1)
patch_level = xatol_range(p, -1, USHRT_MAX);
if (ret & 2) {
opt_e = opt_f = NULL;
opt_complementary = "e::f::" /* can occur multiple times */
"nn"; /* count -n */
- opt = getopt32(argc, argv, "irne:f:", &opt_e, &opt_f,
+ opt = getopt32(argv, "irne:f:", &opt_e, &opt_f,
&G.be_quiet); /* counter for -n */
argc -= optind;
argv += optind;
char *Copt;
opt_complementary = "H-h:e::f::C-AB";
- getopt32(argc, argv,
+ getopt32(argv,
OPTSTR_GREP,
&pattern_head, &fopt, &mopt,
&slines_after, &slines_before, &Copt);
#else
/* with auto sanity checks */
opt_complementary = "H-h:e::f::c-n:q-n:l-n";
- getopt32(argc, argv, OPTSTR_GREP,
+ getopt32(argv, OPTSTR_GREP,
&pattern_head, &fopt, &mopt);
#endif
if (option_mask32 & OPT_m) {
#define read_args process_stdin
#endif
- opt = getopt32(argc, argv, OPTION_STR, &max_args, &max_chars, &eof_str);
+ opt = getopt32(argv, OPTION_STR, &max_args, &max_chars, &eof_str);
if (opt & OPT_ZEROTERM)
USE_FEATURE_XARGS_SUPPORT_ZERO_TERM(read_args = process0_stdin);
for (which = 0; "hpr"[which] != *applet_name; which++);
/* Parse and handle arguments */
- flags = getopt32(argc, argv, "d:nf", &delay);
+ flags = getopt32(argv, "d:nf", &delay);
if (flags & 1) sleep(xatou(delay));
if (!(flags & 2)) sync();
/* 3+ args, -i at most once, -p implies -h, -v is counter */
opt_complementary = "-3:i--i:ph:vv";
#ifdef SSLSVD
- getopt32(argc, argv, "+c:C:i:x:u:l:Eb:hpt:vU:/:Z:K:",
+ getopt32(argv, "+c:C:i:x:u:l:Eb:hpt:vU:/:Z:K:",
&str_c, &str_C, &instructs, &instructs, &user, &local_hostname,
&str_b, &str_t, &ssluser, &root, &cert, &key, &verbose
);
#else
- getopt32(argc, argv, "+c:C:i:x:u:l:Eb:hpt:v",
+ getopt32(argv, "+c:C:i:x:u:l:Eb:hpt:v",
&str_c, &str_C, &instructs, &instructs, &user, &local_hostname,
&str_b, &str_t, &verbose
);
/* Documentation
uint32_t
-getopt32(int argc, char **argv, const char *applet_opts, ...)
+getopt32(char **argv, const char *applet_opts, ...)
The command line options must be declared in const char
*applet_opts as a string of chars, for example:
- flags = getopt32(argc, argv, "rnug");
+ flags = getopt32(argv, "rnug");
If one of the given options is found, a flag value is added to
the return value (an unsigned long).
The flag value is determined by the position of the char in
applet_opts string. For example, in the above case:
- flags = getopt32(argc, argv, "rnug");
+ flags = getopt32(argv, "rnug");
"r" will add 1 (bit 0)
"n" will add 2 (bit 1)
char *pointer_to_arg_for_c;
char *pointer_to_arg_for_d;
- flags = getopt32(argc, argv, "a:b:c:d:",
+ flags = getopt32(argv, "a:b:c:d:",
&pointer_to_arg_for_a, &pointer_to_arg_for_b,
&pointer_to_arg_for_c, &pointer_to_arg_for_d);
if they are not specifed on the command line. For example:
opt_complementary = "abc";
- flags = getopt32(argc, argv, "abcd")
+ flags = getopt32(argv, "abcd")
If getopt() finds "-a" on the command line, then
getopt32's return value will be as if "-a -b -c" were
int w_counter = 0;
opt_complementary = "ww";
- getopt32(argc, argv, "w", &w_counter);
+ getopt32(argv, "w", &w_counter);
if (w_counter)
width = (w_counter == 1) ? 132 : INT_MAX;
else
llist_t *my_b = NULL;
int verbose_level = 0;
opt_complementary = "vv:b::b-c:c-b";
- f = getopt32(argc, argv, "vb:c", &my_b, &verbose_level);
+ 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; }
if (my_b) // but llist is stored if -b is specified
use ':' or end of line. For example:
opt_complementary = "-:w-x:x-w";
- getopt32(argc, argv, "wx");
+ getopt32(argv, "wx");
Allows any arguments to be given without a dash (./program w x)
as well as with a dash (./program -x).
char *smax_print_depth;
opt_complementary = "s-d:d-s:x-x";
- opt = getopt32(argc, argv, "sd:x", &smax_print_depth);
+ opt = getopt32(argv, "sd:x", &smax_print_depth);
if (opt & 2)
max_print_depth = atoi(smax_print_depth);
opt_complementary = "e::";
- getopt32(argc, argv, "e:", &patterns);
+ getopt32(argv, "e:", &patterns);
$ grep -e user -e root /etc/passwd
root:x:0:0:root:/root:/bin/bash
user:x:500:500::/home/user:/bin/bash
// Don't allow -n -r -rn -ug -rug -nug -rnug
opt_complementary = "r?ug:n?ug:?u--g:g--u";
- flags = getopt32(argc, argv, "rnug");
+ flags = getopt32(argv, "rnug");
This example allowed only:
$ id; id -u; id -g; id -ru; id -nu; id -rg; id -ng; id -rnu; id -rng
// Don't allow -KS -SK, but -S or -K is required
opt_complementary = "K:S:?K--S:S--K";
- flags = getopt32(argc, argv, "KS...);
+ flags = getopt32(argv, "KS...);
Don't forget to use ':'. For example, "?322-22-23X-x-a"
uint32_t option_mask32;
uint32_t
-getopt32(int argc, char **argv, const char *applet_opts, ...)
+getopt32(char **argv, const char *applet_opts, ...)
{
+ int argc;
unsigned flags = 0;
unsigned requires = 0;
t_complementary complementary[33];
#define FREE_FIRST_ARGV_IS_OPT 8
int spec_flgs = 0;
+ argc = 0;
+ while (argv[argc])
+ argc++;
+
va_start(p, applet_opts);
c = 0;
* addgroup user group
* Check for min, max and missing args */
opt_complementary = "-1:?2";
- if (getopt32(argc, argv, "g:", &group)) {
+ if (getopt32(argv, "g:", &group)) {
gid = xatoul_range(group, 0, ((unsigned long)(gid_t)ULONG_MAX) >> 1);
}
/* move past the commandline options */
/* exactly one non-option arg */
opt_complementary = "=1";
- getopt32(argc, argv, "h:g:s:G:DSH", &pw.pw_dir, &pw.pw_gecos, &pw.pw_shell, &usegroup);
+ getopt32(argv, "h:g:s:G:DSH", &pw.pw_dir, &pw.pw_gecos, &pw.pw_shell, &usegroup);
argv += optind;
/* create a passwd struct */
opt_complementary = "m--e:e--m";
USE_GETOPT_LONG(applet_long_options = chpasswd_longopts;)
- opt = getopt32(argc, argv, "em");
+ opt = getopt32(argv, "em");
while ((name = xmalloc_getline(stdin)) != NULL) {
pass = strchr(name, ':');
{
char salt[sizeof("$N$XXXXXXXX")];
- if (!getopt32(argc, argv, "a:", NULL) || argv[optind - 1][0] != 'd') {
+ if (!getopt32(argv, "a:", NULL) || argv[optind - 1][0] != 'd') {
strcpy(salt, "$1$");
/* Too ugly, and needs even more magic to handle endianness: */
//((uint32_t*)&salt)[0] = '$' + '1'*0x100 + '$'*0x10000;
{
char *ts;
- op->flags = getopt32(argc, argv, opt_string,
+ op->flags = getopt32(argv, opt_string,
&(op->initstring), &fakehost, &(op->issue),
&(op->login), &ts);
if (op->flags & F_INITSTRING) {
* (The name of the function is misleading. Not daemonizing here.) */
bb_daemonize_or_rexec(DAEMON_ONLY_SANITIZE | DAEMON_CLOSE_EXTRA_FDS, NULL);
- opt = getopt32(argc, argv, "f:h:p", &opt_user, &opt_host);
+ opt = getopt32(argv, "f:h:p", &opt_user, &opt_host);
if (opt & LOGIN_OPT_f) {
if (!amroot)
bb_error_msg_and_die("-f is for root only");
logmode = LOGMODE_BOTH;
openlog(applet_name, LOG_NOWAIT, LOG_AUTH);
- opt = getopt32(argc, argv, "a:lud", &opt_a);
+ opt = getopt32(argv, "a:lud", &opt_a);
//argc -= optind;
argv += optind;
const char *tty;
char *old_user;
- flags = getopt32(argc, argv, "mplc:s:", &opt_command, &opt_shell);
+ flags = getopt32(argv, "mplc:s:", &opt_command, &opt_shell);
argc -= optind;
argv += optind;
logmode = LOGMODE_BOTH;
openlog(applet_name, 0, LOG_AUTH);
- if (getopt32(argc, argv, "t:", &timeout_arg)) {
+ if (getopt32(argv, "t:", &timeout_arg)) {
timeout = xatoi_u(timeout_arg);
}
bb_show_usage();
}
- o_lock_all = getopt32(argc, argv, "a");
+ o_lock_all = getopt32(argv, "a");
vfd = xopen(CURRENT_TTY, O_RDWR);
const char *descript;
txc.modes=0;
- opt = getopt32(argc, argv, "qo:f:p:t:",
+ opt = getopt32(argv, "qo:f:p:t:",
&opt_o, &opt_f, &opt_p, &opt_t);
//if (opt & 0x1) // -q
if (opt & 0x2) { // -o
int prio = 0, policy = SCHED_RR;
opt_complementary = "r--fo:f--ro:r--fo"; /* only one policy accepted */
- opt = getopt32(argc, argv, "+mp:rfo", &p_opt);
+ opt = getopt32(argv, "+mp:rfo", &p_opt);
if (opt & OPT_r)
policy = SCHED_RR;
if (opt & OPT_f)
int dev, cmd;
opt_complementary = "?1:t--T:T--t";
- flags = getopt32(argc, argv, "tT");
+ flags = getopt32(argv, "tT");
device = argv[optind] ? : "/dev/cdrom";
// We used to do "umount <device>" here, but it was buggy
/* TODO: -x: do not interpret backspace, -xx: tab also */
/* -xxx: newline also */
/* -w N: assume width N (-xxx -w 32: hex viewer of sorts) */
- getopt32(argc, argv, "EMmN~");
+ getopt32(argv, "EMmN~");
argc -= optind;
argv += optind;
num_files = argc;
int linenum = 0;
int ret = EXIT_SUCCESS;
- getopt32(argc, argv, "d:", &line);
+ getopt32(argv, "d:", &line);
if (line)
table = xfopen(line, "r");
{
struct stat st;
char *arg;
- int opt = getopt32(argc, argv, "qdx");
+ int opt = getopt32(argv, "qdx");
#define OPT_q (1)
#define OPT_d (2)
#define OPT_x (4)
const char *fmt = "%s: ";
const char *n_arg = "4";
- opt = getopt32(argc, argv, "afon:", &n_arg);
+ opt = getopt32(argv, "afon:", &n_arg);
/* -a is our default behaviour */
/*argc -= optind;*/
argv += optind;
const char *state = "current\0new";
char *p_opt = NULL, *aff = NULL;
- opt = getopt32(argc, argv, "+p:", &p_opt);
+ opt = getopt32(argv, "+p:", &p_opt);
if (opt & OPT_p) {
if (argc == optind+1) { /* -p <aff> <pid> */
char *t_arg;
opt_complementary = "=1"; /* must have 1 argument */
- opts = getopt32(argc, argv, "Ft:", &t_arg);
+ opts = getopt32(argv, "Ft:", &t_arg);
if (opts & OPT_TIMER)
timer_duration = xatou(t_arg);
struct utsname myuname;
/* Parse any options */
- getopt32(argc, argv, OPTION_STR, &opt_o);
+ getopt32(argv, OPTION_STR, &opt_o);
arg1 = argv[optind];
if (option_mask32 & OPT_o) { // -o /* name the output module */
free(m_name);
char *unused;
opt_complementary = "?V-:q-v:v-q";
- main_opts = getopt32(argc, argv, "acdklnqrst:vVC:",
+ main_opts = getopt32(argv, "acdklnqrst:vVC:",
&unused, &unused);
if (main_opts & (DUMP_CONF_EXIT | LIST_ALL))
return EXIT_SUCCESS;
#define misc_buf bb_common_bufsiz1
/* Parse command line. */
- n = getopt32(argc, argv, "wfa");
+ n = getopt32(argv, "wfa");
if (n & 1) // --wait
flags &= ~O_NONBLOCK;
if (n & 2) // --force
if (!ap)
bb_error_msg_and_die("%s: %s not supported", DFLT_AF, "address family");
- getopt32(argc, argv, "A:p:H:t:i:adnDsv", &protocol, &protocol,
+ getopt32(argv, "A:p:H:t:i:adnDsv", &protocol, &protocol,
&hw_type, &hw_type, &device);
argv += optind;
if (option_mask32 & ARP_OPT_A || option_mask32 & ARP_OPT_p) {
* Advert also sets unsolicited.
*/
opt_complementary = "=1:Df:AU";
- opt = getopt32(argc, argv, "DUAqfbc:w:I:s:",
+ opt = getopt32(argv, "DUAqfbc:w:I:s:",
&str_count, &str_timeout, &device, &source);
if (opt & 0x40) /* -c: count */
count = xatou(str_count);
uint16_t port = 53;
uint8_t buf[MAX_PACK_LEN];
- getopt32(argc, argv, "i:c:t:p:dv", &listen_interface, &fileconf, &sttl, &sport);
+ getopt32(argv, "i:c:t:p:dv", &listen_interface, &fileconf, &sttl, &sport);
//if (option_mask32 & 0x1) // -i
//if (option_mask32 & 0x2) // -c
if (option_mask32 & 0x4) // -t
/* handle misc user options */
opt_complementary = "=1";
- flags = getopt32(argc, argv, "bi:p:", &ifname, &pass);
+ flags = getopt32(argv, "bi:p:", &ifname, &pass);
if (flags & 4) /* -p */
wol_passwd_sz = get_wol_pw(pass, wol_passwd);
flags &= 1; /* we further interested only in -b [bcast] flag */
applet_long_options = ftpgetput_longopts;
#endif
opt_complementary = "=3"; /* must have 3 params */
- opt = getopt32(argc, argv, "cvu:p:P:", &server->user, &server->password, &port);
+ opt = getopt32(argv, "cvu:p:P:", &server->user, &server->password, &port);
argv += optind;
/* Process the non-option command line arguments */
if (argc < 1)
bb_show_usage();
- getopt32(argc, argv, "dfisF:", &hostname_str);
+ getopt32(argv, "dfisF:", &hostname_str);
/* Output in desired format */
if (option_mask32 & OPT_dfis) {
/* We do not "absolutize" path given by -h (home) opt.
* If user gives relative path in -h, $SCRIPT_FILENAME can end up
* relative too. */
- opt = getopt32(argc, argv, "c:d:h:"
+ opt = getopt32(argv, "c:d:h:"
USE_FEATURE_HTTPD_ENCODE_URL_STR("e:")
USE_FEATURE_HTTPD_BASIC_AUTH("r:")
USE_FEATURE_HTTPD_AUTH_MD5("m:")
cmds = iface_up;
}
- getopt32(argc, argv, OPTION_STR, &interfaces);
+ getopt32(argv, OPTION_STR, &interfaces);
if (argc - optind > 0) {
if (DO_ALL) bb_show_usage();
} else {
if (uid != 0)
config_filename = NULL;
- opt = getopt32(argc, argv, "R:f", &stoomany);
+ opt = getopt32(argv, "R:f", &stoomany);
if (opt & 1)
toomany = xatoi_u(stoomany);
argv += optind;
#if ENABLE_FEATURE_IPCALC_LONG_OPTIONS
applet_long_options = ipcalc_longopts;
#endif
- opt = getopt32(argc, argv, "mbn" USE_FEATURE_IPCALC_FANCY("phs"));
+ opt = getopt32(argv, "mbn" USE_FEATURE_IPCALC_FANCY("phs"));
argc -= optind;
argv += optind;
if (opt & (BROADCAST | NETWORK | NETPREFIX)) {
unsigned opt;
int fd;
- opt = getopt32(argc, argv, "fiwb:", &bind_address);
+ opt = getopt32(argv, "fiwb:", &bind_address);
strcpy(bogouser, "nobody");
if (argv[optind])
strncpy(bogouser, argv[optind], sizeof(bogouser));
int if_index = 1;
mactable_t *ch;
- if (1 & getopt32(argc, argv, "sc:", &fname)) {
+ if (1 & getopt32(argv, "sc:", &fname)) {
openlog(applet_name, 0, LOG_LOCAL0);
logmode = LOGMODE_SYSLOG;
}
// -g -G -t -r deleted, unimplemented -a deleted too
opt_complementary = "?2:vv"; /* max 2 params, -v is a counter */
- getopt32(argc, argv, "hnp:s:uvw:" USE_NC_SERVER("l")
+ getopt32(argv, "hnp:s:uvw:" USE_NC_SERVER("l")
USE_NC_EXTRA("i:o:z"),
&str_p, &str_s, &str_w
USE_NC_EXTRA(, &str_i, &str_o, &o_verbose));
#endif
/* Option string must match NETSTAT_xxx constants */
- opt = getopt32(argc, argv, NETSTAT_OPTS);
+ opt = getopt32(argv, NETSTAT_OPTS);
if (opt & 0x1) { // -l
flags &= ~NETSTAT_CONNECTED;
flags |= NETSTAT_LISTENING;
/* exactly one argument needed, -v and -q don't mix */
opt_complementary = "=1:q--v:v--q";
- getopt32(argc, argv, OPT_STRING, &opt_c, &opt_s, &opt_I);
+ getopt32(argv, OPT_STRING, &opt_c, &opt_s, &opt_I);
if (option_mask32 & OPT_c) pingcount = xatoul(opt_c); // -c
if (option_mask32 & OPT_s) datalen = xatou16(opt_s); // -s
if (option_mask32 & OPT_I) { // -I
unsigned start;
opt_complementary = "=1"; /* exactly one non-option */
- getopt32(argc, argv, "p:P:t:T:", &opt_min_port, &opt_max_port, &opt_timeout, &opt_min_rtt);
+ getopt32(argv, "p:P:t:T:", &opt_min_port, &opt_max_port, &opt_timeout, &opt_min_rtt);
argv += optind;
max_port = xatou_range(opt_max_port, 1, 65535);
port = xatou_range(opt_min_port, 1, max_port);
}
}
- opt = getopt32(argc, argv, "A:ne", &family);
+ opt = getopt32(argv, "A:ne", &family);
if ((opt & ROUTE_OPT_A) && strcmp(family, "inet") != 0) {
#if ENABLE_FEATURE_IPV6
INIT_G();
/* Parse command line options */
- opt = getopt32(argc, argv, "p:s:c:ehmLF", &proto, &baud_str, &extcmd);
+ opt = getopt32(argv, "p:s:c:ehmLF", &proto, &baud_str, &extcmd);
/*argc -= optind;*/
argv += optind;
bb_show_usage();
#if ENABLE_FEATURE_TELNET_AUTOLOGIN
- if (1 & getopt32(argc, argv, "al:", &G.autologin))
+ if (1 & getopt32(argv, "al:", &G.autologin))
G.autologin = getenv("USER");
argv += optind;
#else
OPT_INETD = 0x20 * ENABLE_FEATURE_TELNETD_STANDALONE,
};
- opt = getopt32(argc, argv, "f:l:" USE_FEATURE_TELNETD_STANDALONE("p:b:Fi"),
+ opt = getopt32(argv, "f:l:" USE_FEATURE_TELNETD_STANDALONE("p:b:Fi"),
&issuefile, &loginpath
USE_FEATURE_TELNETD_STANDALONE(, &opt_portnbr, &opt_bindaddr));
/* Redirect log to syslog early, if needed */
opt_complementary = "" USE_FEATURE_TFTP_GET("g:") USE_FEATURE_TFTP_PUT("p:")
USE_GETPUT("?g--p:p--g");
- USE_GETPUT(cmd =) getopt32(argc, argv,
+ USE_GETPUT(cmd =) getopt32(argv,
USE_FEATURE_TFTP_GET("g") USE_FEATURE_TFTP_PUT("p")
"l:r:" USE_FEATURE_TFTP_BLOCKSIZE("b:"),
&localfile, &remotefile
opt_complementary = "x-x";
#endif
- op = getopt32(argc, argv, "FIlnrdvxt:i:m:p:q:s:w:z:f:"
+ op = getopt32(argv, "FIlnrdvxt:i:m:p:q:s:w:z:f:"
#if ENABLE_FEATURE_TRACEROUTE_SOURCE_ROUTE
"g:"
#endif
#if ENABLE_GETOPT_LONG
applet_long_options = udhcpc_longopts;
#endif
- opt = getopt32(argc, argv, "c:CV:fbH:h:F:i:np:qRr:s:T:t:vS",
+ opt = getopt32(argv, "c:CV:fbH:h:F:i:np:qRr:s:T:t:vS",
&str_c, &str_V, &str_h, &str_h, &str_F,
&client_config.interface, &client_config.pidfile, &str_r,
&client_config.script, &str_T, &str_t
struct option_set *option;
struct dhcpOfferedAddr *lease, static_lease;
- opt = getopt32(argc, argv, "fS");
+ opt = getopt32(argv, "fS");
argv += optind;
if (!(opt & 1)) { /* no -f */
applet_long_options = dumpleases_longopts;
#endif
opt_complementary = "=0:a--r:r--a";
- opt = getopt32(argc, argv, "arf:", &file);
+ opt = getopt32(argv, "arf:", &file);
fd = xopen(file, O_RDONLY);
#endif
/* server.allocated = target.allocated = NULL; */
opt_complementary = "-1" USE_FEATURE_WGET_LONG_OPTIONS(":\xfe::");
- opt = getopt32(argc, argv, "csqO:P:Y:U:",
+ opt = getopt32(argv, "csqO:P:Y:U:",
&fname_out, &dir_prefix,
&proxy_flag, &user_agent
USE_FEATURE_WGET_LONG_OPTIONS(, &headers_llist)
// parse commandline: prog [options] ifname script
// exactly 2 args; -v accumulates and implies -f
opt_complementary = "=2:vv:vf";
- opts = getopt32(argc, argv, "fqr:v", &r_opt, &verbose);
+ opts = getopt32(argv, "fqr:v", &r_opt, &verbose);
if (!FOREGROUND) {
/* Do it early, before all bb_xx_msg calls */
openlog(applet_name, 0, LOG_DAEMON);
#endif
/* do unconditional option parsing */
- opt = getopt32(argc, argv, ""
+ opt = getopt32(argv, ""
USE_FEATURE_PIDOF_SINGLE ("s")
USE_FEATURE_PIDOF_OMIT("o:", &omits));
// Select which columns to display
/* We allow (and ignore) most of the above. FIXME */
opt_complementary = "o::";
- USE_SELINUX(opt =) getopt32(argc, argv, "Zo:aAdefl", &opt_o);
+ USE_SELINUX(opt =) getopt32(argv, "Zo:aAdefl", &opt_o);
if (opt_o) {
do {
parse_o(opt_o->data);
#if ENABLE_FEATURE_PS_WIDE || ENABLE_SELINUX
#if ENABLE_FEATURE_PS_WIDE
opt_complementary = "-:ww";
- USE_SELINUX(i =) getopt32(argc, argv, USE_SELINUX("Z") "w", &w_count);
+ USE_SELINUX(i =) getopt32(argv, USE_SELINUX("Z") "w", &w_count);
/* if w is given once, GNU ps sets the width to 132,
* if w is given more than once, it is "unlimited"
*/
terminal_width = MAX_WIDTH;
}
#else /* only ENABLE_SELINUX */
- i = getopt32(argc, argv, "Z");
+ i = getopt32(argv, "Z");
#endif
#if ENABLE_SELINUX
if ((i & 1) && is_selinux_enabled())
/* do normal option parsing */
opt_complementary = "-";
- getopt32(argc, argv, "d:n:b", &sinterval, &siterations);
+ getopt32(argv, "d:n:b", &sinterval, &siterations);
if (option_mask32 & 0x1) interval = xatou(sinterval); // -d
if (option_mask32 & 0x2) iterations = xatou(siterations); // -n
//if (option_mask32 & 0x4) // -b
char **p;
opt_complementary = "-1"; // at least one param please
- opt = getopt32(argc, argv, "+dtn:", &tmp);
+ opt = getopt32(argv, "+dtn:", &tmp);
//if (opt & 0x1) // -d (ignore)
//if (opt & 0x2) // -t
if (opt & 0x4) period = xatou(tmp);
{
char *m,*d,*o,*p,*f,*c,*r,*t,*n;
- getopt32(argc, argv, "+u:U:e:m:d:o:p:f:c:r:t:/:n:vP012",
+ getopt32(argv, "+u:U:e:m:d:o:p:f:c:r:t:/:n:vP012",
&set_user,&env_user,&env_dir,
&m,&d,&o,&p,&f,&c,&r,&t,&root,&n);
// if (option_mask32 & 0x1) // -u
static void softlimit(int argc, char **argv)
{
char *a,*c,*d,*f,*l,*m,*o,*p,*r,*s,*t;
- getopt32(argc, argv, "+a:c:d:f:l:m:o:p:r:s:t:",
+ getopt32(argv, "+a:c:d:f:l:m:o:p:r:s:t:",
&a,&c,&d,&f,&l,&m,&o,&p,&r,&s,&t);
if (option_mask32 & 0x001) limita = xatoul(a); // -a
if (option_mask32 & 0x002) limitc = xatoul(c); // -c
x = getenv("SVWAIT");
if (x) waitsec = xatoul(x);
- opt = getopt32(argc, argv, "w:v", &x);
+ opt = getopt32(argv, "w:v", &x);
if (opt & 1) waitsec = xatoul(x); // -w
if (opt & 2) verbose = 1; // -v
argc -= optind;
#define line bb_common_bufsiz1
opt_complementary = "tt:vv";
- opt = getopt32(argc, argv, "r:R:l:b:tv",
+ opt = getopt32(argv, "r:R:l:b:tv",
&r, &replace, &l, &b, ×tamp, &verbose);
if (opt & 1) { // -r
repl = r[0];
":\xff--urtl:u--\xff:r--\xff:t--\xff:l--\xff"
#endif
":f--v:v--f"; /* 'verbose' and 'quiet' are exclusive */
- getopt32(argc, argv, "Rchf:u:r:t:l:v",
+ getopt32(argv, "Rchf:u:r:t:l:v",
&user, &role, &type, &range, &reference_file);
argv += optind;
unsigned opt;
selinux_or_die();
- opt = getopt32(argc, argv, "a");
+ opt = getopt32(argv, "a");
if (opt) { /* -a */
if (argc > 2)
opt_complementary = "-1" /* at least one param reqd */
":?:f--p:p--f"; /* mutually exclusive */
- opts = getopt32(argc, argv, "nNf:p:V", &fcontext, &prefix);
+ opts = getopt32(argv, "nNf:p:V", &fcontext, &prefix);
argv += optind;
if (opts & OPT_NOT_TRANS) {
applet_long_options = runcon_longopts;
#endif
opt_complementary = "-1";
- opts = getopt32(argc, argv, "r:t:u:l:ch", &role, &type, &user, &range);
+ opts = getopt32(argv, "r:t:u:l:ch", &role, &type, &user, &range);
argv += optind;
if (!(opts & OPTS_CONTEXT_COMPONENT)) {
opt_complementary = "e::vv:v--p:p--v:v--q:q--v";
/* Option order must match OPT_x definitions! */
if (applet_name[0] == 'r') { /* restorecon */
- flags = getopt32(argc, argv, "de:f:ilnpqrsvo:FWR",
+ flags = getopt32(argv, "de:f:ilnpqrsvo:FWR",
&exclude_dir, &input_filename, &out_filename, &verbose);
} else { /* setfiles */
- flags = getopt32(argc, argv, "de:f:ilnpqr:svo:FW"
+ flags = getopt32(argv, "de:f:ilnpqr:svo:FW"
USE_FEATURE_SETFILES_CHECK_OPTION("c:"),
&exclude_dir, &input_filename, &rootpath, &out_filename,
USE_FEATURE_SETFILES_CHECK_OPTION(&policyfile,)
char *command=NULL;
FILE *f;
- getopt32(argc, argv, "c:", &command);
+ getopt32(argv, "c:", &command);
f = argv[optind] ? xfopen(argv[optind],"r") : NULL;
if (command) handle(command);
char *start;
/* do normal option parsing */
- getopt32(argc, argv, "c:n", &start);
+ getopt32(argv, "c:n", &start);
if (option_mask32 & OPT_LEVEL) {
/* Valid levels are between 1 and 8 */
str_t = name;
/* Parse any options */
- getopt32(argc, argv, "p:st:", &str_p, &str_t);
+ getopt32(argv, "p:st:", &str_p, &str_t);
if (option_mask32 & 0x2) /* -s */
i |= LOG_PERROR;
int cur;
int log_semid; /* ipc semaphore id */
int log_shmid; /* ipc shared memory id */
- smallint follow = getopt32(argc, argv, "f");
+ smallint follow = getopt32(argv, "f");
log_shmid = shmget(KEY_ID, 0, 0);
if (log_shmid == -1)
/* do normal option parsing */
opt_complementary = "=0"; /* no non-option params */
- getopt32(argc, argv, OPTION_STR, OPTION_PARAM);
+ getopt32(argv, OPTION_STR, OPTION_PARAM);
#ifdef SYSLOGD_MARK
if (option_mask32 & OPT_mark) // -m
G.markInterval = xatou_range(opt_m, 0, INT_MAX/60) * 60;
int dmesg_main(int argc, char **argv)
{
char *size, *level;
- int flags = getopt32(argc, argv, "cs:n:", &size, &level);
+ int flags = getopt32(argv, "cs:n:", &size, &level);
if (flags & 4) {
if (klogctl(8, NULL, xatoul_range(level, 0, 10)))
if (argc < 2) {
bb_show_usage();
}
- verify = !getopt32(argc, argv, "n");
+ verify = !getopt32(argv, "n");
argv += optind;
xstat(*argv, &st);
PTR_TO_GLOBALS = xzalloc(sizeof(G));
- opt = getopt32(argc, argv, "b:C:H:lS:u" USE_FEATURE_FDISK_BLKSIZE("s"),
+ opt = getopt32(argv, "b:C:H:lS:u" USE_FEATURE_FDISK_BLKSIZE("s"),
&str_b, &str_C, &str_H, &str_S);
argc -= optind;
argv += optind;
}
#if !ENABLE_GETOPT_LONG
- opt = getopt32(argc, argv, "+o:n:qQs:Tu", &optstr, &name, &s_arg);
+ opt = getopt32(argv, "+o:n:qQs:Tu", &optstr, &name, &s_arg);
#else
applet_long_options = getopt_longopts;
opt_complementary = "l::";
- opt = getopt32(argc, argv, "+o:n:qQs:Tual:",
+ opt = getopt32(argv, "+o:n:qQs:Tual:",
&optstr, &name, &s_arg, &l_arg);
/* Effectuate the read options for the applet itself */
while (l_arg) {
applet_long_options = hwclock_longopts;
#endif
opt_complementary = "r--ws:w--rs:s--wr:l--u:u--l";
- opt = getopt32(argc, argv, "lurswf:", &rtcname);
+ opt = getopt32(argv, "lurswf:", &rtcname);
/* If -u or -l wasn't given check if we are using utc */
if (opt & (HWCLOCK_OPT_UTC | HWCLOCK_OPT_LOCALTIME))
#define flag_sem (1<<2)
#define flag_shm (1<<3)
- opt = getopt32(argc, argv, "i:aqsmtcplu", &opt_i);
+ opt = getopt32(argv, "i:aqsmtcplu", &opt_i);
if (opt & 0x1) { // -i
id = xatoi(opt_i);
flags |= flag_print;
char *opt_o;
unsigned long long offset = 0;
- opt = getopt32(argc, argv, "do:", &opt_o);
+ opt = getopt32(argv, "do:", &opt_o);
argc -= optind;
argv += optind;
bb_error_msg_and_die("bad inode size");
#endif
- opt = getopt32(argc, argv, "ci:l:n:v", &str_i, &listfile, &str_n);
+ opt = getopt32(argv, "ci:l:n:v", &str_i, &listfile, &str_n);
argv += optind;
//if (opt & 1) -c
if (opt & 2) G.req_nr_inodes = xatoul(str_i); // -i
// Parse remaining options
- opt = getopt32(argc, argv, "o:t:rwanfvs", &opt_o, &fstype);
+ opt = getopt32(argv, "o:t:rwanfvs", &opt_o, &fstype);
if (opt & 0x1) append_mount_options(&cmdopts, opt_o); // -o
//if (opt & 0x2) // -t
if (opt & 0x4) append_mount_options(&cmdopts, "ro"); // -r
unsigned long flags;
opt_complementary = "-1";
- flags = getopt32(argc, argv, "sp");
+ flags = getopt32(argv, "sp");
remote_time = askremotedate(argv[optind]);
mapFile = defaultmap;
opt_complementary = "nn:aa:bb:ss:ii:rr:vv";
- getopt32(argc, argv, "M:m:p:nabsirv",
+ getopt32(argv, "M:m:p:nabsirv",
&mult, &mapFile, &proFile,
&optNative, &optAll, &optBins, &optSub,
&optInfo, &optReset, &optVerbose);
if (argc == 1)
bb_show_usage();
- ret = getopt32(argc, argv, "a");
+ ret = getopt32(argv, "a");
if (ret)
return do_em_all();
// Parse args (-c console)
opt_complementary = "-2";
- getopt32(argc, argv, "c:", &console);
+ getopt32(argv, "c:", &console);
argv += optind;
// Change to new root directory and verify it's a different fs.
/* Parse any options */
- opt = getopt32(argc, argv, OPTION_STRING, &fstype);
+ opt = getopt32(argv, OPTION_STRING, &fstype);
argc -= optind;
argv += optind;
projects / oweals / busybox.git / commitdiff