Add getopt_long_only() from OpenBSD and other OpenBSD cleanups

PR:             63173
Submitted by:   Marius Strobl <marius@alchemy.franken.de>

3 files changed, 459 insertions, 299 deletions

diff --git a/lib/libc/stdlib/Makefile.inc b/lib/libc/stdlib/Makefile.inc
index c85c2f9..229a871 100644
--- a/lib/libc/stdlib/Makefile.inc
+++ b/lib/libc/stdlib/Makefile.inc
@@ -27,6 +27,7 @@ MAN+=	abort.3 abs.3 alloca.3 atexit.3 atof.3 atoi.3 atol.3 bsearch.3 \
 MLINKS+=atol.3 atoll.3
 MLINKS+=exit.3 _Exit.3
 MLINKS+=getenv.3 putenv.3 getenv.3 setenv.3 getenv.3 unsetenv.3
+MLINKS+=getopt_long.3 getopt_long_only.3
 MLINKS+=grantpt.3 posix_openpt.3 grantpt.3 ptsname.3 grantpt.3 unlockpt.3
 MLINKS+=hcreate.3 hdestroy.3 hcreate.3 hsearch.3
 MLINKS+=insque.3 remque.3
diff --git a/lib/libc/stdlib/getopt_long.3 b/lib/libc/stdlib/getopt_long.3
index a407571..fcb36b8 100644
--- a/lib/libc/stdlib/getopt_long.3
+++ b/lib/libc/stdlib/getopt_long.3
@@ -1,4 +1,5 @@
-.\"	$NetBSD: getopt_long.3,v 1.8 2002/06/03 12:01:43 wiz Exp $
+.\"	$OpenBSD: getopt_long.3,v 1.10 2004/01/06 23:44:28 fgsch Exp $
+.\"	$NetBSD: getopt_long.3,v 1.14 2003/08/07 16:43:40 agc Exp $
 .\"
 .\" Copyright (c) 1988, 1991, 1993
 .\"	The Regents of the University of California.  All rights reserved.
@@ -11,11 +12,7 @@
 .\" 2. Redistributions in binary form must reproduce the above copyright
 .\"    notice, this list of conditions and the following disclaimer in the
 .\"    documentation and/or other materials provided with the distribution.
-.\" 3. All advertising materials mentioning features or use of this software
-.\"    must display the following acknowledgement:
-.\"	This product includes software developed by the University of
-.\"	California, Berkeley and its contributors.
-.\" 4. Neither the name of the University nor the names of its contributors
+.\" 3. Neither the name of the University nor the names of its contributors
 .\"    may be used to endorse or promote products derived from this software
 .\"    without specific prior written permission.
 .\"
@@ -38,21 +35,27 @@
 .Dt GETOPT_LONG 3
 .Os
 .Sh NAME
-.Nm getopt_long
+.Nm getopt_long ,
+.Nm getopt_long_only
 .Nd get long options from command line argument list
 .Sh LIBRARY
 .Lb libc
 .Sh SYNOPSIS
 .In getopt.h
 .Vt extern char *optarg ;
-.Vt extern int   optind ;
-.Vt extern int   optopt ;
-.Vt extern int   opterr ;
-.Vt extern int   optreset ;
+.Vt extern int optind ;
+.Vt extern int optopt ;
+.Vt extern int opterr ;
+.Vt extern int optreset ;
 .Ft int
 .Fo getopt_long
 .Fa "int argc" "char * const *argv" "const char *optstring"
-.Fa "struct option *long options" "int *index"
+.Fa "const struct option *longopts" "int *longindex"
+.Fc
+.Ft int
+.Fo getopt_long_only
+.Fa "int argc" "char * const *argv" "const char *optstring"
+.Fa "const struct option *longopts" "int *longindex"
 .Fc
 .Sh DESCRIPTION
 The
@@ -158,41 +161,87 @@ and setting
 to the corresponding short option will make this function act just
 like
 .Xr getopt 3 .
+.Pp
+If the
+.Fa longindex
+field is not
+.Dv NULL ,
+then the integer pointed to by it will be set to the index of the long
+option relative to
+.Fa longopts .
+.Pp
+The last element of the
+.Fa longopts
+array has to be filled with zeroes.
+.Pp
+The
+.Fn getopt_long_only
+function behaves identically to
+.Fn getopt_long
+with the exception that long options may start with
+.Ql -
+in addition to
+.Ql -- .
+If an option starting with
+.Ql -
+does not match a long option but does match a single-character option,
+the single-character option is returned.
+.Sh RETURN VALUES
+If the
+.Fa flag
+field in
+.Li struct option
+is
+.Dv NULL ,
+.Fn getopt_long
+and
+.Fn getopt_long_only
+return the value specified in the
+.Fa val
+field, which is usually just the corresponding short option.
+If
+.Fa flag
+is not
+.Dv NULL ,
+these functions return 0 and store
+.Fa val
+in the location pointed to by
+.Fa flag .
+These functions return
+.Ql \&:
+if there was a missing option argument,
+.Ql \&?
+if the user specified an unknown or ambiguous option, and
+\-1 when the argument list has been exhausted.
 .Sh EXAMPLES
 .Bd -literal -compact
-extern char *optarg;
-extern int optind;
 int bflag, ch, fd;
 int daggerset;
 
 /* options descriptor */
 static struct option longopts[] = {
-	{ "buffy",	no_argument,		0, 		'b' },
-	{ "floride",	required_argument,	0, 	       	'f' },
+	{ "buffy",	no_argument,		NULL, 		'b' },
+	{ "fluoride",	required_argument,	NULL, 	       	'f' },
 	{ "daggerset",	no_argument,		\*[Am]daggerset,	1 },
-	{ 0, 		0,			0, 		0 }
+	{ NULL,		0,			NULL, 		0 }
 };
 
 bflag = 0;
 while ((ch = getopt_long(argc, argv, "bf:", longopts, NULL)) != -1)
-	switch(ch) {
+	switch (ch) {
 	case 'b':
 		bflag = 1;
 		break;
 	case 'f':
-		if ((fd = open(optarg, O_RDONLY, 0)) \*[Lt] 0) {
-			(void)fprintf(stderr,
-			    "myname: %s: %s\en", optarg, strerror(errno));
-			exit(1);
-		}
+		if ((fd = open(optarg, O_RDONLY, 0)) == -1)
+			err(1, "unable to open %s", optarg);
 		break;
 	case 0:
-		if(daggerset) {
+		if (daggerset) {
 			fprintf(stderr,"Buffy will use her dagger to "
-				       "apply floride to dracula's teeth\en");
+			    "apply fluoride to dracula's teeth\en");
 		}
 		break;
-	case '?':
 	default:
 		usage();
 }
@@ -211,27 +260,50 @@ Handling of
 as first char of option string in presence of
 environment variable
 .Ev POSIXLY_CORRECT :
-.Bl -tag -width ".Nx"
+.Bl -tag -width ".Bx"
 .It Tn GNU
 ignores
 .Ev POSIXLY_CORRECT
 and returns non-options as
 arguments to option '\e1'.
-.It Nx
+.It Bx
 honors
 .Ev POSIXLY_CORRECT
 and stops at the first non-option.
 .El
 .It
 Handling of
+.Ql -
+within the option string (not the first character):
+.Bl -tag -width ".Bx"
+.It Tn GNU
+treats a
+.Ql -
+on the command line as a non-argument.
+.It Bx
+a
+.Ql -
+within the option string matches a
+.Ql -
+(single dash) on the command line.
+This functionality is provided for backward compatibility with
+programs, such as
+.Xr su 1 ,
+that use
+.Ql -
+as an option flag.
+This practice is wrong, and should not be used in any current development.
+.El
+.It
+Handling of
 .Ql ::
 in options string in presence of
 .Ev POSIXLY_CORRECT :
-.Bl -tag -width ".Nx"
+.Bl -tag -width ".Bx"
 .It Both
 .Tn GNU
 and
-.Nx
+.Bx
 ignore
 .Ev POSIXLY_CORRECT
 here and take
@@ -247,15 +319,15 @@ or
 .Ql - )
 in option string is not
 .Ql \&: :
-.Bl -tag -width ".Nx"
+.Bl -tag -width ".Bx"
 .It Tn GNU
 returns
 .Ql \&?
-.It Nx
+.It Bx
 returns
 .Ql \&:
 (since
-.Nx Ns 's
+.Bx Ns 's
 .Fn getopt
 does).
 .El
@@ -263,13 +335,13 @@ does).
 Handling of
 .Ql --a
 in getopt:
-.Bl -tag -width ".Nx"
+.Bl -tag -width ".Bx"
 .It Tn GNU
 parses this as option
 .Ql - ,
 option
 .Ql a .
-.It Nx
+.It Bx
 parses this as
 .Ql -- ,
 and returns \-1 (ignoring the
@@ -285,13 +357,13 @@ for long options with
 .Va flag
 !=
 .Dv NULL :
-.Bl -tag -width ".Nx"
+.Bl -tag -width ".Bx"
 .It Tn GNU
 sets
 .Va optopt
 to
 .Va val .
-.It Nx
+.It Bx
 sets
 .Va optopt
 to 0 (since
@@ -302,28 +374,18 @@ would never be returned).
 Handling of
 .Ql -W
 with
-.Ql W ;
+.Ql W;
 in option string in
 .Fn getopt
 (not
 .Fn getopt_long ) :
-.Bl -tag -width ".Nx"
+.Bl -tag -width ".Bx"
 .It Tn GNU
 causes a segfault.
-.It Nx
-returns \-1, with
-.Va optind
-pointing past the argument of
-.Ql -W
-(as if
-.Ql "-W arg"
-were
-.Ql --arg ,
-and thus
-.Ql --
-had been found).
-.\" How should we treat W; in the option string when called via
-.\" getopt?  Ignore the ';' or treat it as a ':'? Issue a warning?
+.It Bx
+no special handling is done;
+.Ql W;
+is interpreted as two separate options, neither of which take an argument.
 .El
 .It
 Setting of
@@ -331,15 +393,15 @@ Setting of
 for long options without an argument that are
 invoked via
 .Ql -W
-.Ql ( W ;
+.Ql ( W;
 in option string):
-.Bl -tag -width ".Nx"
+.Bl -tag -width ".Bx"
 .It Tn GNU
 sets
 .Va optarg
 to the option name (the argument of
 .Ql -W ) .
-.It Nx
+.It Bx
 sets
 .Va optarg
 to
@@ -353,14 +415,14 @@ with an argument that is not (a prefix to) a known
 long option
 .Ql ( W ;
 in option string):
-.Bl -tag -width ".Nx"
+.Bl -tag -width ".Bx"
 .It Tn GNU
 returns
 .Ql -W
 with
 .Va optarg
 set to the unknown option.
-.It Nx
+.It Bx
 treats this as an error (unknown option) and returns
 .Ql \&?
 with
@@ -376,7 +438,7 @@ man page documents).
 .It
 The error messages are different.
 .It
-.Nx
+.Bx
 does not permute the argument vector at the same points in
 the calling sequence as
 .Tn GNU
@@ -388,18 +450,57 @@ relative
 to current positions) are the same, though.
 (We do fewer variable swaps.)
 .El
+.Sh ENVIRONMENT
+.Bl -tag -width POSIXLY_CORRECT
+.It Ev POSIXLY_CORRECT
+If set, option processing stops when the first non-option is found and
+a leading
+.Ql -
+or
+.Ql +
+in the
+.Ar optstring
+is ignored.
+.El
 .Sh SEE ALSO
 .Xr getopt 3
 .Sh HISTORY
 The
 .Fn getopt_long
-function first appeared in
+and
+.Fn getopt_long_only
+functions first appeared in
 .Tn GNU
 libiberty.
 The first
-.Nx
-implementation appeared in 1.5.
+.Bx
+implementation of
+.Fn getopt_long
+appeared in
+.Nx 1.5 ,
+the first
+.Bx
+implementation of
+.Fn getopt_long_only
+in
+.Ox 3.3 .
+.Fx
+first included
+.Fn getopt_long
+in
+.Fx 5.0 ,
+.Fn getopt_long_only
+in
+.Fx 5.2 .
 .Sh BUGS
+The
+.Ar argv
+argument is not really
+.Dv const
+as its elements may be permuted (unless
+.Ev POSIXLY_CORRECT
+is set).
+.Pp
 The implementation can completely replace
 .Xr getopt 3 ,
 but right now we are using separate code.
diff --git a/lib/libc/stdlib/getopt_long.c b/lib/libc/stdlib/getopt_long.c
index ef1d8e9..54427ef 100644
--- a/lib/libc/stdlib/getopt_long.c
+++ b/lib/libc/stdlib/getopt_long.c
@@ -1,6 +1,25 @@
+/*	$OpenBSD: getopt_long.c,v 1.16 2004/02/04 18:17:25 millert Exp $	*/
 /*	$NetBSD: getopt_long.c,v 1.15 2002/01/31 22:43:40 tv Exp $	*/
-/*	$FreeBSD$ */
 
+/*
+ * Copyright (c) 2002 Todd C. Miller <Todd.Miller@courtesan.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Sponsored in part by the Defense Advanced Research Projects
+ * Agency (DARPA) and Air Force Research Laboratory, Air Force
+ * Materiel Command, USAF, under agreement number F39502-99-1-0512.
+ */
 /*-
  * Copyright (c) 2000 The NetBSD Foundation, Inc.
  * All rights reserved.
@@ -37,62 +56,49 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <sys/cdefs.h>
+#if 0
 #if defined(LIBC_SCCS) && !defined(lint)
-__RCSID("$NetBSD: getopt_long.c,v 1.15 2002/01/31 22:43:40 tv Exp $");
+static char *rcsid = "$OpenBSD: getopt_long.c,v 1.16 2004/02/04 18:17:25 millert Exp $";
 #endif /* LIBC_SCCS and not lint */
+#endif
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
 
-#include <assert.h>
 #include <err.h>
 #include <errno.h>
 #include <getopt.h>
 #include <stdlib.h>
 #include <string.h>
 
-/* not part of the original file */
-#ifndef _DIAGASSERT
-#define _DIAGASSERT(X)
-#endif
-
-#if HAVE_CONFIG_H && !HAVE_GETOPT_LONG && !HAVE_DECL_OPTIND
-#define REPLACE_GETOPT
+#ifdef notyet
+#define	REPLACE_GETOPT		/* use this getopt as the system getopt(3) */
 #endif
 
 #ifdef REPLACE_GETOPT
-#ifdef __weak_alias
-__weak_alias(getopt,_getopt)
-#endif
 int	opterr = 1;		/* if error message should be printed */
 int	optind = 1;		/* index into parent argv vector */
 int	optopt = '?';		/* character checked for validity */
 int	optreset;		/* reset getopt */
 char    *optarg;		/* argument associated with option */
-#elif HAVE_CONFIG_H && !HAVE_DECL_OPTRESET
-static int optreset;
 #endif
 
-#ifdef __weak_alias
-__weak_alias(getopt_long,_getopt_long)
-#endif
+#define PRINT_ERROR	((opterr) && (*options != ':'))
 
-#if !HAVE_GETOPT_LONG
-#define IGNORE_FIRST	(*options == '-' || *options == '+')
-#define PRINT_ERROR	((opterr) && ((*options != ':') \
-				      || (IGNORE_FIRST && options[1] != ':')))
-#define IS_POSIXLY_CORRECT (getenv("POSIXLY_CORRECT") != NULL)
-#define PERMUTE         (!IS_POSIXLY_CORRECT && !IGNORE_FIRST)
-/* XXX: GNU ignores PC if *options == '-' */
-#define IN_ORDER        (!IS_POSIXLY_CORRECT && *options == '-')
+#define FLAG_PERMUTE	0x01	/* permute non-options to the end of argv */
+#define FLAG_ALLARGS	0x02	/* treat non-options as args to option "-1" */
+#define FLAG_LONGONLY	0x04	/* operate as getopt_long_only */
 
 /* return values */
-#define	BADCH	(int)'?'
-#define	BADARG		((IGNORE_FIRST && options[1] == ':') \
-			 || (*options == ':') ? (int)':' : (int)'?')
-#define INORDER (int)1
+#define	BADCH		(int)'?'
+#define	BADARG		((*options == ':') ? (int)':' : (int)'?')
+#define	INORDER 	(int)1
 
-#define	EMSG	""
+#define	EMSG		""
 
-static int getopt_internal(int, char * const *, const char *);
+static int getopt_internal(int, char * const *, const char *,
+			   const struct option *, int *, int);
+static int parse_long_options(char * const *, const char *,
+			      const struct option *, int *, int);
 static int gcd(int, int);
 static void permute_args(int, int, int, char * const *);
 
@@ -110,14 +116,11 @@ static const char noarg[] = "option doesn't take an argument -- %.*s";
 static const char illoptchar[] = "unknown option -- %c";
 static const char illoptstring[] = "unknown option -- %s";
 
-
 /*
  * Compute the greatest common divisor of a and b.
  */
 static int
-gcd(a, b)
-	int a;
-	int b;
+gcd(int a, int b)
 {
 	int c;
 
@@ -127,8 +130,8 @@ gcd(a, b)
 		b = c;
 		c = a % b;
 	}
-	   
-	return b;
+
+	return (b);
 }
 
 /*
@@ -137,17 +140,12 @@ gcd(a, b)
  * in each block).
  */
 static void
-permute_args(panonopt_start, panonopt_end, opt_end, nargv)
-	int panonopt_start;
-	int panonopt_end;
-	int opt_end;
-	char * const *nargv;
+permute_args(int panonopt_start, int panonopt_end, int opt_end,
+	char * const *nargv)
 {
 	int cstart, cyclelen, i, j, ncycle, nnonopts, nopts, pos;
 	char *swap;
 
-	_DIAGASSERT(nargv != NULL);
-
 	/*
 	 * compute lengths of blocks and number and size of cycles
 	 */
@@ -174,32 +172,160 @@ permute_args(panonopt_start, panonopt_end, opt_end, nargv)
 }
 
 /*
+ * parse_long_options --
+ *	Parse long options in argc/argv argument vector.
+ * Returns -1 if short_too is set and the option does not match long_options.
+ */
+static int
+parse_long_options(char * const *nargv, const char *options,
+	const struct option *long_options, int *idx, int short_too)
+{
+	char *current_argv, *has_equal;
+	size_t current_argv_len;
+	int i, match;
+
+	current_argv = place;
+	match = -1;
+
+	optind++;
+
+	if ((has_equal = strchr(current_argv, '=')) != NULL) {
+		/* argument found (--option=arg) */
+		current_argv_len = has_equal - current_argv;
+		has_equal++;
+	} else
+		current_argv_len = strlen(current_argv);
+
+	for (i = 0; long_options[i].name; i++) {
+		/* find matching long option */
+		if (strncmp(current_argv, long_options[i].name,
+		    current_argv_len))
+			continue;
+
+		if (strlen(long_options[i].name) == current_argv_len) {
+			/* exact match */
+			match = i;
+			break;
+		}
+		/*
+		 * If this is a known short option, don't allow
+		 * a partial match of a single character.
+		 */
+		if (short_too && current_argv_len == 1)
+			continue;
+
+		if (match == -1)	/* partial match */
+			match = i;
+		else {
+			/* ambiguous abbreviation */
+			if (PRINT_ERROR)
+				warnx(ambig, (int)current_argv_len,
+				     current_argv);
+			optopt = 0;
+			return (BADCH);
+		}
+	}
+	if (match != -1) {		/* option found */
+		if (long_options[match].has_arg == no_argument
+		    && has_equal) {
+			if (PRINT_ERROR)
+				warnx(noarg, (int)current_argv_len,
+				     current_argv);
+			/*
+			 * XXX: GNU sets optopt to val regardless of flag
+			 */
+			if (long_options[match].flag == NULL)
+				optopt = long_options[match].val;
+			else
+				optopt = 0;
+			return (BADARG);
+		}
+		if (long_options[match].has_arg == required_argument ||
+		    long_options[match].has_arg == optional_argument) {
+			if (has_equal)
+				optarg = has_equal;
+			else if (long_options[match].has_arg ==
+			    required_argument) {
+				/*
+				 * optional argument doesn't use next nargv
+				 */
+				optarg = nargv[optind++];
+			}
+		}
+		if ((long_options[match].has_arg == required_argument)
+		    && (optarg == NULL)) {
+			/*
+			 * Missing argument; leading ':' indicates no error
+			 * should be generated.
+			 */
+			if (PRINT_ERROR)
+				warnx(recargstring,
+				    current_argv);
+			/*
+			 * XXX: GNU sets optopt to val regardless of flag
+			 */
+			if (long_options[match].flag == NULL)
+				optopt = long_options[match].val;
+			else
+				optopt = 0;
+			--optind;
+			return (BADARG);
+		}
+	} else {			/* unknown option */
+		if (short_too) {
+			--optind;
+			return (-1);
+		}
+		if (PRINT_ERROR)
+			warnx(illoptstring, current_argv);
+		optopt = 0;
+		return (BADCH);
+	}
+	if (idx)
+		*idx = match;
+	if (long_options[match].flag) {
+		*long_options[match].flag = long_options[match].val;
+		return (0);
+	} else
+		return (long_options[match].val);
+}
+
+/*
  * getopt_internal --
  *	Parse argc/argv argument vector.  Called by user level routines.
- *  Returns -2 if -- is found (can be long option or end of options marker).
  */
 static int
-getopt_internal(nargc, nargv, options)
-	int nargc;
-	char * const *nargv;
-	const char *options;
+getopt_internal(int nargc, char * const *nargv, const char *options,
+	const struct option *long_options, int *idx, int flags)
 {
 	char *oli;				/* option letter list index */
-	int optchar;
+	int optchar, short_too;
+	static int posixly_correct = -1;
 
-	_DIAGASSERT(nargv != NULL);
-	_DIAGASSERT(options != NULL);
+	if (options == NULL)
+		return (-1);
 
-	optarg = NULL;
+	/*
+	 * Disable GNU extensions if POSIXLY_CORRECT is set or options
+	 * string begins with a '+'.
+	 */
+	if (posixly_correct == -1)
+		posixly_correct = (getenv("POSIXLY_CORRECT") != NULL);
+	if (posixly_correct || *options == '+')
+		flags &= ~FLAG_PERMUTE;
+	else if (*options == '-')
+		flags |= FLAG_ALLARGS;
+	if (*options == '+' || *options == '-')
+		options++;
 
 	/*
-	 * XXX Some programs (like rsyncd) expect to be able to
-	 * XXX re-initialize optind to 0 and have getopt_long(3)
-	 * XXX properly function again.  Work around this braindamage.
+	 * XXX Some GNU programs (like cvs) set optind to 0 instead of
+	 * XXX using optreset.  Work around this braindamage.
 	 */
 	if (optind == 0)
-		optind = 1;
+		optind = optreset = 1;
 
+	optarg = NULL;
 	if (optreset)
 		nonopt_start = nonopt_end = -1;
 start:
@@ -221,25 +347,25 @@ start:
 				optind = nonopt_start;
 			}
 			nonopt_start = nonopt_end = -1;
-			return -1;
+			return (-1);
 		}
-		if ((*(place = nargv[optind]) != '-')
-		    || (place[1] == '\0')) {    /* found non-option */
-			place = EMSG;
-			if (IN_ORDER) {
+		if (*(place = nargv[optind]) != '-' ||
+		    (place[1] == '\0' && strchr(options, '-') == NULL)) {
+			place = EMSG;		/* found non-option */
+			if (flags & FLAG_ALLARGS) {
 				/*
-				 * GNU extension: 
+				 * GNU extension:
 				 * return non-option as argument to option 1
 				 */
 				optarg = nargv[optind++];
-				return INORDER;
+				return (INORDER);
 			}
-			if (!PERMUTE) {
+			if (!(flags & FLAG_PERMUTE)) {
 				/*
-				 * if no permutation wanted, stop parsing
-				 * at first non-option
+				 * If no permutation wanted, stop parsing
+				 * at first non-option.
 				 */
-				return -1;
+				return (-1);
 			}
 			/* do permutation */
 			if (nonopt_start == -1)
@@ -257,39 +383,82 @@ start:
 		}
 		if (nonopt_start != -1 && nonopt_end == -1)
 			nonopt_end = optind;
-		if (place[1] && *++place == '-') {	/* found "--" */
-			place++;
-			return -2;
+
+		/*
+		 * If we have "-" do nothing, if "--" we are done.
+		 */
+		if (place[1] != '\0' && *++place == '-' && place[1] == '\0') {
+			optind++;
+			place = EMSG;
+			/*
+			 * We found an option (--), so if we skipped
+			 * non-options, we have to permute.
+			 */
+			if (nonopt_end != -1) {
+				permute_args(nonopt_start, nonopt_end,
+				    optind, nargv);
+				optind -= nonopt_end - nonopt_start;
+			}
+			nonopt_start = nonopt_end = -1;
+			return (-1);
+		}
+	}
+
+	/*
+	 * Check long options if:
+	 *  1) we were passed some
+	 *  2) the arg is not just "-"
+	 *  3) either the arg starts with -- we are getopt_long_only()
+	 */
+	if (long_options != NULL && place != nargv[optind] &&
+	    (*place == '-' || (flags & FLAG_LONGONLY))) {
+		short_too = 0;
+		if (*place == '-')
+			place++;		/* --foo long option */
+		else if (*place != ':' && strchr(options, *place) != NULL)
+			short_too = 1;		/* could be short option too */
+
+		optchar = parse_long_options(nargv, options, long_options,
+		    idx, short_too);
+		if (optchar != -1) {
+			place = EMSG;
+			return (optchar);
 		}
 	}
+
 	if ((optchar = (int)*place++) == (int)':' ||
-	    (oli = strchr(options + (IGNORE_FIRST ? 1 : 0), optchar)) == NULL) {
-		/* option letter unknown or ':' */
+	    (optchar == (int)'-' && *place != '\0') ||
+	    (oli = strchr(options, optchar)) == NULL) {
+		/*
+		 * If the user specified "-" and  '-' isn't listed in
+		 * options, return -1 (non-option) as per POSIX.
+		 * Otherwise, it is an unknown option character (or ':').
+		 */
+		if (optchar == (int)'-' && *place == '\0')
+			return (-1);
 		if (!*place)
 			++optind;
 		if (PRINT_ERROR)
 			warnx(illoptchar, optchar);
 		optopt = optchar;
-		return BADCH;
+		return (BADCH);
 	}
-	if (optchar == 'W' && oli[1] == ';') {		/* -W long-option */
-		/* XXX: what if no long options provided (called by getopt)? */
-		if (*place) 
-			return -2;
-
-		if (++optind >= nargc) {	/* no arg */
+	if (long_options != NULL && optchar == 'W' && oli[1] == ';') {
+		/* -W long-option */
+		if (*place)			/* no space */
+			/* NOTHING */;
+		else if (++optind >= nargc) {	/* no arg */
 			place = EMSG;
 			if (PRINT_ERROR)
 				warnx(recargchar, optchar);
 			optopt = optchar;
-			return BADARG;
+			return (BADARG);
 		} else				/* white space */
 			place = nargv[optind];
-		/*
-		 * Handle -W arg the same as --arg (which causes getopt to
-		 * stop parsing).
-		 */
-		return -2;
+		optchar = parse_long_options(nargv, options, long_options,
+		    idx, 0);
+		place = EMSG;
+		return (optchar);
 	}
 	if (*++oli != ':') {			/* doesn't take argument */
 		if (!*place)
@@ -305,15 +474,22 @@ start:
 				if (PRINT_ERROR)
 					warnx(recargchar, optchar);
 				optopt = optchar;
-				return BADARG;
+				return (BADARG);
 			} else
 				optarg = nargv[optind];
+		} else if (!(flags & FLAG_PERMUTE)) {
+			/*
+			 * If permutation is disabled, we can accept an
+			 * optional arg separated by whitespace.
+			 */
+			if (optind + 1 < nargc)
+				optarg = nargv[++optind];
 		}
 		place = EMSG;
 		++optind;
 	}
 	/* dump back option letter */
-	return optchar;
+	return (optchar);
 }
 
 #ifdef REPLACE_GETOPT
@@ -321,36 +497,23 @@ start:
  * getopt --
  *	Parse argc/argv argument vector.
  *
- * [eventually this will replace the real getopt]
+ * [eventually this will replace the BSD getopt]
  */
 int
-getopt(nargc, nargv, options)
-	int nargc;
-	char * const *nargv;
-	const char *options;
+getopt(int nargc, char * const *nargv, const char *options)
 {
-	int retval;
 
-	_DIAGASSERT(nargv != NULL);
-	_DIAGASSERT(options != NULL);
-
-	if ((retval = getopt_internal(nargc, nargv, options)) == -2) {
-		++optind;
-		/*
-		 * We found an option (--), so if we skipped non-options,
-		 * we have to permute.
-		 */
-		if (nonopt_end != -1) {
-			permute_args(nonopt_start, nonopt_end, optind,
-				       nargv);
-			optind -= nonopt_end - nonopt_start;
-		}
-		nonopt_start = nonopt_end = -1;
-		retval = -1;
-	}
-	return retval;
+	/*
+	 * We don't pass FLAG_PERMUTE to getopt_internal() since
+	 * the BSD getopt(3) (unlike GNU) has never done this.
+	 *
+	 * Furthermore, since many privileged programs call getopt()
+	 * before dropping privileges it makes sense to keep things
+	 * as simple (and bug-free) as possible.
+	 */
+	return (getopt_internal(nargc, nargv, options, NULL, NULL, 0));
 }
-#endif
+#endif /* REPLACE_GETOPT */
 
 /*
  * getopt_long --
@@ -364,129 +527,24 @@ getopt_long(nargc, nargv, options, long_options, idx)
 	const struct option *long_options;
 	int *idx;
 {
-	int retval;
-
-	_DIAGASSERT(nargv != NULL);
-	_DIAGASSERT(options != NULL);
-	_DIAGASSERT(long_options != NULL);
-	/* idx may be NULL */
-
-	if ((retval = getopt_internal(nargc, nargv, options)) == -2) {
-		char *current_argv, *has_equal;
-		size_t current_argv_len;
-		int i, match;
 
-		current_argv = place;
-		match = -1;
+	return (getopt_internal(nargc, nargv, options, long_options, idx,
+	    FLAG_PERMUTE));
+}
 
-		optind++;
-		place = EMSG;
+/*
+ * getopt_long_only --
+ *	Parse argc/argv argument vector.
+ */
+int
+getopt_long_only(nargc, nargv, options, long_options, idx)
+	int nargc;
+	char * const *nargv;
+	const char *options;
+	const struct option *long_options;
+	int *idx;
+{
 
-		if (*current_argv == '\0') {		/* found "--" */
-			/*
-			 * We found an option (--), so if we skipped
-			 * non-options, we have to permute.
-			 */
-			if (nonopt_end != -1) {
-				permute_args(nonopt_start, nonopt_end,
-				    optind, nargv);
-				optind -= nonopt_end - nonopt_start;
-			}
-			nonopt_start = nonopt_end = -1;
-			return -1;
-		}
-		if ((has_equal = strchr(current_argv, '=')) != NULL) {
-			/* argument found (--option=arg) */
-			current_argv_len = has_equal - current_argv;
-			has_equal++;
-		} else
-			current_argv_len = strlen(current_argv);
-	    
-		for (i = 0; long_options[i].name; i++) {
-			/* find matching long option */
-			if (strncmp(current_argv, long_options[i].name,
-			    current_argv_len))
-				continue;
-
-			if (strlen(long_options[i].name) ==
-			    (unsigned)current_argv_len) {
-				/* exact match */
-				match = i;
-				break;
-			}
-			if (match == -1)		/* partial match */
-				match = i;
-			else {
-				/* ambiguous abbreviation */
-				if (PRINT_ERROR)
-					warnx(ambig, (int)current_argv_len,
-					     current_argv);
-				optopt = 0;
-				return BADCH;
-			}
-		}
-		if (match != -1) {			/* option found */
-		        if (long_options[match].has_arg == no_argument
-			    && has_equal) {
-				if (PRINT_ERROR)
-					warnx(noarg, (int)current_argv_len,
-					     current_argv);
-				/*
-				 * XXX: GNU sets optopt to val regardless of
-				 * flag
-				 */
-				if (long_options[match].flag == NULL)
-					optopt = long_options[match].val;
-				else
-					optopt = 0;
-				return BADARG;
-			}
-			if (long_options[match].has_arg == required_argument ||
-			    long_options[match].has_arg == optional_argument) {
-				if (has_equal)
-					optarg = has_equal;
-				else if (long_options[match].has_arg ==
-				    required_argument) {
-					/*
-					 * optional argument doesn't use
-					 * next nargv
-					 */
-					optarg = nargv[optind++];
-				}
-			}
-			if ((long_options[match].has_arg == required_argument)
-			    && (optarg == NULL)) {
-				/*
-				 * Missing argument; leading ':'
-				 * indicates no error should be generated
-				 */
-				if (PRINT_ERROR)
-					warnx(recargstring, current_argv);
-				/*
-				 * XXX: GNU sets optopt to val regardless
-				 * of flag
-				 */
-				if (long_options[match].flag == NULL)
-					optopt = long_options[match].val;
-				else
-					optopt = 0;
-				--optind;
-				return BADARG;
-			}
-		} else {			/* unknown option */
-			if (PRINT_ERROR)
-				warnx(illoptstring, current_argv);
-			optopt = 0;
-			return BADCH;
-		}
-		if (long_options[match].flag) {
-			*long_options[match].flag = long_options[match].val;
-			retval = 0;
-		} else 
-			retval = long_options[match].val;
-		if (idx)
-			*idx = match;
-	}
-	return retval;
+	return (getopt_internal(nargc, nargv, options, long_options, idx,
+	    FLAG_PERMUTE|FLAG_LONGONLY));
 }
-#endif /* !GETOPT_LONG */