Home | History | Annotate | Line # | Download | only in stdlib 
      1 /*	$NetBSD: getopt_long.c,v 1.28 2024/01/19 18:41:38 christos Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 2000 The NetBSD Foundation, Inc.
      5  * All rights reserved.
      6  *
      7  * This code is derived from software contributed to The NetBSD Foundation
      8  * by Dieter Baron and Thomas Klausner.
      9  *
     10  * Redistribution and use in source and binary forms, with or without
     11  * modification, are permitted provided that the following conditions
     12  * are met:
     13  * 1. Redistributions of source code must retain the above copyright
     14  *    notice, this list of conditions and the following disclaimer.
     15  * 2. Redistributions in binary form must reproduce the above copyright
     16  *    notice, this list of conditions and the following disclaimer in the
     17  *    documentation and/or other materials provided with the distribution.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     29  * POSSIBILITY OF SUCH DAMAGE.
     30  */
     31 
     32 #if HAVE_NBTOOL_CONFIG_H
     33 #include "nbtool_config.h"
     34 #endif
     35 
     36 #include <sys/cdefs.h>
     37 __RCSID("$NetBSD: getopt_long.c,v 1.28 2024/01/19 18:41:38 christos Exp $");
     38 
     39 #include "namespace.h"
     40 
     41 #include <assert.h>
     42 #include <err.h>
     43 #include <errno.h>
     44 #if HAVE_NBTOOL_CONFIG_H
     45 #include "compat_getopt.h"
     46 #else
     47 #include <getopt.h>
     48 #endif
     49 #include <stdlib.h>
     50 #include <string.h>
     51 
     52 #if HAVE_NBTOOL_CONFIG_H && !HAVE_GETOPT_LONG && !HAVE_DECL_OPTIND
     53 #define REPLACE_GETOPT
     54 #endif
     55 
     56 #ifdef REPLACE_GETOPT
     57 #ifdef __weak_alias
     58 __weak_alias(getopt,_getopt)
     59 #endif
     60 int	opterr = 1;		/* if error message should be printed */
     61 int	optind = 1;		/* index into parent argv vector */
     62 int	optopt = '?';		/* character checked for validity */
     63 int	optreset;		/* reset getopt */
     64 char    *optarg;		/* argument associated with option */
     65 #elif HAVE_NBTOOL_CONFIG_H && !HAVE_DECL_OPTRESET
     66 static int optreset;
     67 #endif
     68 
     69 #ifdef __weak_alias
     70 __weak_alias(getopt_long,_getopt_long)
     71 #endif
     72 
     73 #define IGNORE_FIRST	(*options == '-' || *options == '+')
     74 #define PRINT_ERROR	((opterr) && ((*options != ':') \
     75 				      || (IGNORE_FIRST && options[1] != ':')))
     76 #define IS_POSIXLY_CORRECT (getenv("POSIXLY_CORRECT") != NULL)
     77 #define PERMUTE         (!IS_POSIXLY_CORRECT && !IGNORE_FIRST)
     78 /* XXX: GNU ignores PC if *options == '-' */
     79 #define IN_ORDER        (!IS_POSIXLY_CORRECT && *options == '-')
     80 
     81 /* return values */
     82 #define	BADCH	(int)'?'
     83 #define	BADARG		((IGNORE_FIRST && options[1] == ':') \
     84 			 || (*options == ':') ? (int)':' : (int)'?')
     85 #define INORDER (int)1
     86 
     87 #define	EMSG	""
     88 
     89 static int getopt_internal(int, char **, const char *);
     90 static int gcd(int, int);
     91 static void permute_args(int, int, int, char **);
     92 
     93 static const char *place = EMSG; /* option letter processing */
     94 
     95 /* XXX: set optreset to 1 rather than these two */
     96 static int nonopt_start = -1; /* first non option argument (for permute) */
     97 static int nonopt_end = -1;   /* first option after non options (for permute) */
     98 
     99 /* Error messages */
    100 static const char recargchar[] = "option requires an argument -- %c";
    101 static const char recargstring[] = "option requires an argument -- %s";
    102 static const char ambig[] = "ambiguous option -- %.*s";
    103 static const char noarg[] = "option doesn't take an argument -- %.*s";
    104 static const char illoptchar[] = "unknown option -- %c";
    105 static const char illoptstring[] = "unknown option -- %s";
    106 
    107 
    108 /*
    109  * Compute the greatest common divisor of a and b.
    110  */
    111 static int
    112 gcd(int a, int b)
    113 {
    114 	int c;
    115 
    116 	c = a % b;
    117 	while (c != 0) {
    118 		a = b;
    119 		b = c;
    120 		c = a % b;
    121 	}
    122 
    123 	return b;
    124 }
    125 
    126 /*
    127  * Exchange the block from nonopt_start to nonopt_end with the block
    128  * from nonopt_end to opt_end (keeping the same order of arguments
    129  * in each block).
    130  */
    131 static void
    132 permute_args(int panonopt_start, int panonopt_end, int opt_end, char **nargv)
    133 {
    134 	int cstart, cyclelen, i, j, ncycle, nnonopts, nopts, pos;
    135 	char *swap;
    136 
    137 	_DIAGASSERT(nargv != NULL);
    138 
    139 	/*
    140 	 * compute lengths of blocks and number and size of cycles
    141 	 */
    142 	nnonopts = panonopt_end - panonopt_start;
    143 	nopts = opt_end - panonopt_end;
    144 	ncycle = gcd(nnonopts, nopts);
    145 	cyclelen = (opt_end - panonopt_start) / ncycle;
    146 
    147 	for (i = 0; i < ncycle; i++) {
    148 		cstart = panonopt_end+i;
    149 		pos = cstart;
    150 		for (j = 0; j < cyclelen; j++) {
    151 			if (pos >= panonopt_end)
    152 				pos -= nnonopts;
    153 			else
    154 				pos += nopts;
    155 			swap = nargv[pos];
    156 			nargv[pos] = nargv[cstart];
    157 			nargv[cstart] = swap;
    158 		}
    159 	}
    160 }
    161 
    162 /*
    163  * getopt_internal --
    164  *	Parse argc/argv argument vector.  Called by user level routines.
    165  *  Returns -2 if -- is found (can be long option or end of options marker).
    166  */
    167 static int
    168 getopt_internal(int nargc, char **nargv, const char *options)
    169 {
    170 	const char *oli;			/* option letter list index */
    171 	int optchar;
    172 
    173 	_DIAGASSERT(nargv != NULL);
    174 	_DIAGASSERT(options != NULL);
    175 
    176 	optarg = NULL;
    177 
    178 	/*
    179 	 * XXX Some programs (like rsyncd) expect to be able to
    180 	 * XXX re-initialize optind to 0 and have getopt_long(3)
    181 	 * XXX properly function again.  Work around this braindamage.
    182 	 */
    183 	if (optind == 0)
    184 		optind = 1;
    185 
    186 	if (optreset)
    187 		nonopt_start = nonopt_end = -1;
    188 start:
    189 	if (optreset || !*place) {		/* update scanning pointer */
    190 		optreset = 0;
    191 		if (optind >= nargc) {          /* end of argument vector */
    192 			place = EMSG;
    193 			if (nonopt_end != -1) {
    194 				/* do permutation, if we have to */
    195 				permute_args(nonopt_start, nonopt_end,
    196 				    optind, nargv);
    197 				optind -= nonopt_end - nonopt_start;
    198 			}
    199 			else if (nonopt_start != -1) {
    200 				/*
    201 				 * If we skipped non-options, set optind
    202 				 * to the first of them.
    203 				 */
    204 				optind = nonopt_start;
    205 			}
    206 			nonopt_start = nonopt_end = -1;
    207 			return -1;
    208 		}
    209 		if ((*(place = nargv[optind]) != '-')
    210 		    || (place[1] == '\0')) {    /* found non-option */
    211 			place = EMSG;
    212 			if (IN_ORDER) {
    213 				/*
    214 				 * GNU extension:
    215 				 * return non-option as argument to option 1
    216 				 */
    217 				optarg = nargv[optind++];
    218 				return INORDER;
    219 			}
    220 			if (!PERMUTE) {
    221 				/*
    222 				 * if no permutation wanted, stop parsing
    223 				 * at first non-option
    224 				 */
    225 				return -1;
    226 			}
    227 			/* do permutation */
    228 			if (nonopt_start == -1)
    229 				nonopt_start = optind;
    230 			else if (nonopt_end != -1) {
    231 				permute_args(nonopt_start, nonopt_end,
    232 				    optind, nargv);
    233 				nonopt_start = optind -
    234 				    (nonopt_end - nonopt_start);
    235 				nonopt_end = -1;
    236 			}
    237 			optind++;
    238 			/* process next argument */
    239 			goto start;
    240 		}
    241 		if (nonopt_start != -1 && nonopt_end == -1)
    242 			nonopt_end = optind;
    243 		if (place[1] && *++place == '-') {	/* found "--" */
    244 			place++;
    245 			return -2;
    246 		}
    247 	}
    248 	if ((optchar = (int)*place++) == (int)':' ||
    249 	    (oli = strchr(options + (IGNORE_FIRST ? 1 : 0), optchar)) == NULL) {
    250 		/* option letter unknown or ':' */
    251 		if (!*place)
    252 			++optind;
    253 		if (PRINT_ERROR)
    254 			warnx(illoptchar, optchar);
    255 		optopt = optchar;
    256 		return BADCH;
    257 	}
    258 	if (optchar == 'W' && oli[1] == ';') {		/* -W long-option */
    259 		/* XXX: what if no long options provided (called by getopt)? */
    260 		if (*place)
    261 			return -2;
    262 
    263 		if (++optind >= nargc) {	/* no arg */
    264 			place = EMSG;
    265 			if (PRINT_ERROR)
    266 				warnx(recargchar, optchar);
    267 			optopt = optchar;
    268 			return BADARG;
    269 		} else				/* white space */
    270 			place = nargv[optind];
    271 		/*
    272 		 * Handle -W arg the same as --arg (which causes getopt to
    273 		 * stop parsing).
    274 		 */
    275 		return -2;
    276 	}
    277 	if (*++oli != ':') {			/* doesn't take argument */
    278 		if (!*place)
    279 			++optind;
    280 	} else {				/* takes (optional) argument */
    281 		optarg = NULL;
    282 		if (*place)			/* no white space */
    283 			optarg = __UNCONST(place);
    284 		/* XXX: disable test for :: if PC? (GNU doesn't) */
    285 		else if (oli[1] != ':') {	/* arg not optional */
    286 			if (++optind >= nargc) {	/* no arg */
    287 				place = EMSG;
    288 				if (PRINT_ERROR)
    289 					warnx(recargchar, optchar);
    290 				optopt = optchar;
    291 				return BADARG;
    292 			} else
    293 				optarg = nargv[optind];
    294 		}
    295 		place = EMSG;
    296 		++optind;
    297 	}
    298 	/* dump back option letter */
    299 	return optchar;
    300 }
    301 
    302 #ifdef REPLACE_GETOPT
    303 /*
    304  * getopt --
    305  *	Parse argc/argv argument vector.
    306  *
    307  * [eventually this will replace the real getopt]
    308  */
    309 int
    310 getopt(int nargc, char * const *nargv, const char *options)
    311 {
    312 	int retval;
    313 
    314 	_DIAGASSERT(nargv != NULL);
    315 	_DIAGASSERT(options != NULL);
    316 
    317 	retval = getopt_internal(nargc, __UNCONST(nargv), options);
    318 	if (retval == -2) {
    319 		++optind;
    320 		/*
    321 		 * We found an option (--), so if we skipped non-options,
    322 		 * we have to permute.
    323 		 */
    324 		if (nonopt_end != -1) {
    325 			permute_args(nonopt_start, nonopt_end, optind,
    326 				       __UNCONST(nargv));
    327 			optind -= nonopt_end - nonopt_start;
    328 		}
    329 		nonopt_start = nonopt_end = -1;
    330 		retval = -1;
    331 	}
    332 	return retval;
    333 }
    334 #endif
    335 
    336 /*
    337  * getopt_long --
    338  *	Parse argc/argv argument vector.
    339  */
    340 int
    341 getopt_long(int nargc, char * const *nargv, const char *options,
    342     const struct option *long_options, int *idx)
    343 {
    344 	int retval;
    345 
    346 #define IDENTICAL_INTERPRETATION(_x, _y)				\
    347 	(long_options[(_x)].has_arg == long_options[(_y)].has_arg &&	\
    348 	 long_options[(_x)].flag == long_options[(_y)].flag &&		\
    349 	 long_options[(_x)].val == long_options[(_y)].val)
    350 
    351 	_DIAGASSERT(nargv != NULL);
    352 	_DIAGASSERT(options != NULL);
    353 	_DIAGASSERT(long_options != NULL);
    354 	/* idx may be NULL */
    355 
    356 	retval = getopt_internal(nargc, __UNCONST(nargv), options);
    357 	if (retval == -2) {
    358 		char *current_argv, *has_equal;
    359 		size_t current_argv_len;
    360 		int i, ambiguous, match;
    361 
    362 		current_argv = __UNCONST(place);
    363 		match = -1;
    364 		ambiguous = 0;
    365 
    366 		optind++;
    367 		place = EMSG;
    368 
    369 		if (*current_argv == '\0') {		/* found "--" */
    370 			/*
    371 			 * We found an option (--), so if we skipped
    372 			 * non-options, we have to permute.
    373 			 */
    374 			if (nonopt_end != -1) {
    375 				permute_args(nonopt_start, nonopt_end,
    376 				    optind, __UNCONST(nargv));
    377 				optind -= nonopt_end - nonopt_start;
    378 			}
    379 			nonopt_start = nonopt_end = -1;
    380 			return -1;
    381 		}
    382 		if ((has_equal = strchr(current_argv, '=')) != NULL) {
    383 			/* argument found (--option=arg) */
    384 			current_argv_len = has_equal - current_argv;
    385 			has_equal++;
    386 		} else
    387 			current_argv_len = strlen(current_argv);
    388 
    389 		for (i = 0; long_options[i].name; i++) {
    390 			/* find matching long option */
    391 			if (strncmp(current_argv, long_options[i].name,
    392 			    current_argv_len))
    393 				continue;
    394 
    395 			if (strlen(long_options[i].name) ==
    396 			    (unsigned)current_argv_len) {
    397 				/* exact match */
    398 				match = i;
    399 				ambiguous = 0;
    400 				break;
    401 			}
    402 			if (match == -1)		/* partial match */
    403 				match = i;
    404 			else if (!IDENTICAL_INTERPRETATION(i, match))
    405 				ambiguous = 1;
    406 		}
    407 		if (ambiguous) {
    408 			/* ambiguous abbreviation */
    409 			if (PRINT_ERROR)
    410 				warnx(ambig, (int)current_argv_len,
    411 				     current_argv);
    412 			optopt = 0;
    413 			return BADCH;
    414 		}
    415 		if (match != -1) {			/* option found */
    416 		        if (long_options[match].has_arg == no_argument
    417 			    && has_equal) {
    418 				if (PRINT_ERROR)
    419 					warnx(noarg, (int)current_argv_len,
    420 					     current_argv);
    421 				/*
    422 				 * XXX: GNU sets optopt to val regardless of
    423 				 * flag
    424 				 */
    425 				if (long_options[match].flag == NULL)
    426 					optopt = long_options[match].val;
    427 				else
    428 					optopt = 0;
    429 				return BADARG;
    430 			}
    431 			if (long_options[match].has_arg == required_argument ||
    432 			    long_options[match].has_arg == optional_argument) {
    433 				if (has_equal)
    434 					optarg = has_equal;
    435 				else if (long_options[match].has_arg ==
    436 				    required_argument) {
    437 					/*
    438 					 * optional argument doesn't use
    439 					 * next nargv
    440 					 */
    441 					optarg = nargv[optind++];
    442 				}
    443 			}
    444 			if ((long_options[match].has_arg == required_argument)
    445 			    && (optarg == NULL)) {
    446 				/*
    447 				 * Missing argument; leading ':'
    448 				 * indicates no error should be generated
    449 				 */
    450 				if (PRINT_ERROR)
    451 					warnx(recargstring, current_argv);
    452 				/*
    453 				 * XXX: GNU sets optopt to val regardless
    454 				 * of flag
    455 				 */
    456 				if (long_options[match].flag == NULL)
    457 					optopt = long_options[match].val;
    458 				else
    459 					optopt = 0;
    460 				--optind;
    461 				return BADARG;
    462 			}
    463 		} else {			/* unknown option */
    464 			if (PRINT_ERROR)
    465 				warnx(illoptstring, current_argv);
    466 			optopt = 0;
    467 			return BADCH;
    468 		}
    469 		if (long_options[match].flag) {
    470 			*long_options[match].flag = long_options[match].val;
    471 			retval = 0;
    472 		} else
    473 			retval = long_options[match].val;
    474 		if (idx)
    475 			*idx = match;
    476 	}
    477 	return retval;
    478 #undef IDENTICAL_INTERPRETATION
    479 }
    480