 @@ -1,14 +1,14 @@
-/*	$NetBSD: glob.c,v 1.23.4.1 2010/07/19 18:14:08 riz Exp $	*/
+/*	$NetBSD: glob.c,v 1.23.4.1.2.1 2011/04/24 15:41:23 riz Exp $	*/
 /*
  * Copyright (c) 1989, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Guido van Rossum.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -27,27 +27,27 @@
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
 #if defined(LIBC_SCCS) && !defined(lint)
 #if 0
 static char sccsid[] = "@(#)glob.c	8.3 (Berkeley) 10/13/93";
 #else
-__RCSID("$NetBSD: glob.c,v 1.23.4.1 2010/07/19 18:14:08 riz Exp $");
+__RCSID("$NetBSD: glob.c,v 1.23.4.1.2.1 2011/04/24 15:41:23 riz Exp $");
 #endif
 #endif /* LIBC_SCCS and not lint */
 /*
  * glob(3) -- a superset of the one defined in POSIX 1003.2.
+ *
  * The [!...] convention to negate a range is supported (SysV, Posix, ksh).
+ *
  * Optional extra services, controlled by flags not defined by POSIX:
+ *
  * GLOB_MAGCHAR:
  *	Set in gl_flags if pattern contained a globbing character.
  * GLOB_NOMAGIC:
 @@ -77,33 +77,38 @@ __RCSID("$NetBSD: glob.c,v 1.23.4.1 2010
 #include <errno.h>
 #include <glob.h>
 #include <pwd.h>
 #include <stdio.h>
 #include <stddef.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #ifdef HAVE_NBTOOL_CONFIG_H
 #define NO_GETPW_R
 #endif
-#define	GLOB_LIMIT_MALLOC	65536
+#define	GLOB_LIMIT_STRING	65536	/* number of readdirs */
-#define	GLOB_LIMIT_STAT		128
+#define	GLOB_LIMIT_STAT		128	/* number of stat system calls */
-#define	GLOB_LIMIT_READDIR	16384
+#define	GLOB_LIMIT_READDIR	16384	/* total buffer size of path strings */
 #define	GLOB_LIMIT_PATH		1024	/* number of path elements */
-#define	GLOB_INDEX_MALLOC	0
+#define GLOB_LIMIT_BRACE	128	/* Number of brace calls */
 #define	GLOB_INDEX_STAT		1
-#define	GLOB_INDEX_READDIR	2
+struct glob_limit {
 	size_t l_string;
 	size_t l_stat;
 	size_t l_readdir;
 	size_t l_brace;
 };
 /*
  * XXX: For NetBSD 1.4.x compatibility. (kill me l8r)
  */
 #ifndef _DIAGASSERT
 #define _DIAGASSERT(a)
 #endif
 #define	DOLLAR		'$'
 #define	DOT		'.'
 #define	EOS		'\0'
 #define	LBRACKET	'['
 #define	NOT		'!'
 @@ -148,51 +153,50 @@ typedef char Char;
 #define	M_NOT		META('!')
 #define	M_ONE		META('?')
 #define	M_RNG		META('-')
 #define	M_SET		META('[')
 #define	ismeta(c)	(((c)&M_QUOTE) != 0)
 static int	 compare(const void *, const void *);
 static int	 g_Ctoc(const Char *, char *, size_t);
 static int	 g_lstat(Char *, __gl_stat_t  *, glob_t *);
 static DIR	*g_opendir(Char *, glob_t *);
 static Char	*g_strchr(const Char *, int);
 static int	 g_stat(Char *, __gl_stat_t *, glob_t *);
-static int	 glob0(const Char *, glob_t *, size_t *);
+static int	 glob0(const Char *, glob_t *, struct glob_limit *);
-static int	 glob1(Char *, glob_t *, size_t *);
+static int	 glob1(Char *, glob_t *, struct glob_limit *);
-static int	 glob2(Char *, Char *, Char *, Char *, glob_t *,
+static int	 glob2(Char *, Char *, Char *, const Char *, glob_t *,
-    size_t *);
+    struct glob_limit *);
-static int	 glob3(Char *, Char *, Char *, Char *, Char *, glob_t *,
+static int	 glob3(Char *, Char *, Char *, const Char *, const Char *,
-    size_t *);
+    glob_t *, struct glob_limit *);
-static int	 globextend(const Char *, glob_t *, size_t *);
+static int	 globextend(const Char *, glob_t *, struct glob_limit *);
 static const Char *globtilde(const Char *, Char *, size_t, glob_t *);
-static int	 globexp1(const Char *, glob_t *, size_t *);
+static int	 globexp1(const Char *, glob_t *, struct glob_limit *);
 static int	 globexp2(const Char *, const Char *, glob_t *, int *,
-    size_t *);
+    struct glob_limit *);
-static int	 match(Char *, Char *, Char *);
+static int	 match(const Char *, const Char *, const Char *);
 #ifdef DEBUG
 static void	 qprintf(const char *, Char *);
 #endif
 int
 glob(const char *pattern, int flags, int (*errfunc)(const char *, int),
     glob_t *pglob)
+{
 	const u_char *patnext;
 	int c;
 	Char *bufnext, *bufend, patbuf[MAXPATHLEN+1];
-	/* 0 = malloc(), 1 = stat(), 2 = readdir() */
+	struct glob_limit limit = { 0, 0, 0, 0 };
 	size_t limit[] = { 0, 0, 0 };
 	_DIAGASSERT(pattern != NULL);
 	patnext = (const u_char *) pattern;
 	if (!(flags & GLOB_APPEND)) {
 		pglob->gl_pathc = 0;
 		pglob->gl_pathv = NULL;
 		if (!(flags & GLOB_DOOFFS))
 			pglob->gl_offs = 0;
+	}
 	pglob->gl_flags = flags & ~GLOB_MAGCHAR;
 	pglob->gl_errfunc = errfunc;
 	pglob->gl_matchc = 0;
 @@ -208,65 +212,71 @@ glob(const char *pattern, int flags, int
 			if (c == QUOTE) {
 				if ((c = *patnext++) == EOS) {
 					c = QUOTE;
 					--patnext;
+				}
 				*bufnext++ = c | M_PROTECT;
+			}
 			else
 				*bufnext++ = c;
+	}
 	*bufnext = EOS;
 	if (flags & GLOB_BRACE)
-	    return globexp1(patbuf, pglob, limit);
+	    return globexp1(patbuf, pglob, &limit);
 	else
-	    return glob0(patbuf, pglob, limit);
+	    return glob0(patbuf, pglob, &limit);
+}
 /*
  * Expand recursively a glob {} pattern. When there is no more expansion
  * invoke the standard globbing routine to glob the rest of the magic
  * characters
  */
 static int
-globexp1(const Char *pattern, glob_t *pglob, size_t *limit)
+globexp1(const Char *pattern, glob_t *pglob, struct glob_limit *limit)
+{
 	const Char* ptr = pattern;
 	int rv;
 	_DIAGASSERT(pattern != NULL);
 	_DIAGASSERT(pglob != NULL);
 	if ((pglob->gl_flags & GLOB_LIMIT) &&
 	    limit->l_brace++ >= GLOB_LIMIT_BRACE) {
 		errno = 0;
 		return GLOB_NOSPACE;
+	}
 	/* Protect a single {}, for find(1), like csh */
 	if (pattern[0] == LBRACE && pattern[1] == RBRACE && pattern[2] == EOS)
 		return glob0(pattern, pglob, limit);
 	while ((ptr = (const Char *) g_strchr(ptr, LBRACE)) != NULL)
 		if (!globexp2(ptr, pattern, pglob, &rv, limit))
 			return rv;
 	return glob0(pattern, pglob, limit);
+}
 /*
  * Recursive brace globbing helper. Tries to expand a single brace.
  * If it succeeds then it invokes globexp1 with the new pattern.
  * If it fails then it tries to glob the rest of the pattern and returns.
  */
 static int
 globexp2(const Char *ptr, const Char *pattern, glob_t *pglob, int *rv,
-    size_t *limit)
+    struct glob_limit *limit)
+{
 	int     i;
 	Char   *lm, *ls;
 	const Char *pe, *pm, *pl;
 	Char    patbuf[MAXPATHLEN + 1];
 	_DIAGASSERT(ptr != NULL);
 	_DIAGASSERT(pattern != NULL);
 	_DIAGASSERT(pglob != NULL);
 	_DIAGASSERT(rv != NULL);
 	/* copy part up to the brace */
 	for (lm = patbuf, pm = pattern; pm != ptr; *lm++ = *pm++)
 @@ -451,27 +461,27 @@ globtilde(const Char *pattern, Char *pat
 	return patbuf;
+}
 /*
  * The main glob() routine: compiles the pattern (optionally processing
  * quotes), calls glob1() to do the real pattern matching, and finally
  * sorts the list (unless unsorted operation is requested).  Returns 0
  * if things went well, nonzero if errors occurred.  It is not an error
  * to find no matches.
  */
 static int
-glob0(const Char *pattern, glob_t *pglob, size_t *limit)
+glob0(const Char *pattern, glob_t *pglob, struct glob_limit *limit)
+{
 	const Char *qpatnext;
 	int c, error;
 	__gl_size_t oldpathc;
 	Char *bufnext, patbuf[MAXPATHLEN+1];
 	_DIAGASSERT(pattern != NULL);
 	_DIAGASSERT(pglob != NULL);
 	if ((qpatnext = globtilde(pattern, patbuf, sizeof(patbuf),
 	    pglob)) == NULL)
 		return GLOB_ABEND;
 	oldpathc = pglob->gl_pathc;
 @@ -557,77 +567,78 @@ glob0(const Char *pattern, glob_t *pglob
+}
 static int
 compare(const void *p, const void *q)
+{
 	_DIAGASSERT(p != NULL);
 	_DIAGASSERT(q != NULL);
 	return strcoll(*(const char * const *)p, *(const char * const *)q);
+}
 static int
-glob1(Char *pattern, glob_t *pglob, size_t *limit)
+glob1(Char *pattern, glob_t *pglob, struct glob_limit *limit)
+{
 	Char pathbuf[MAXPATHLEN+1];
 	_DIAGASSERT(pattern != NULL);
 	_DIAGASSERT(pglob != NULL);
 	/* A null pathname is invalid -- POSIX 1003.1 sect. 2.4. */
 	if (*pattern == EOS)
 		return 0;
 	/*
 	 * we save one character so that we can use ptr >= limit,
 	 * in the general case when we are appending non nul chars only.
 	 */
 	return glob2(pathbuf, pathbuf,
 	    pathbuf + (sizeof(pathbuf) / sizeof(*pathbuf)) - 1, pattern,
 	    pglob, limit);
+}
 /*
  * The functions glob2 and glob3 are mutually recursive; there is one level
  * of recursion for each segment in the pattern that contains one or more
  * meta characters.
  */
 static int
-glob2(Char *pathbuf, Char *pathend, Char *pathlim, Char *pattern, glob_t *pglob,
+glob2(Char *pathbuf, Char *pathend, Char *pathlim, const Char *pattern,
-    size_t *limit)
+    glob_t *pglob, struct glob_limit *limit)
+{
 	__gl_stat_t sb;
-	Char *p, *q;
+	const Char *p;
 	Char *q;
 	int anymeta;
 	Char *pend;
 	ptrdiff_t diff;
 	_DIAGASSERT(pathbuf != NULL);
 	_DIAGASSERT(pathend != NULL);
 	_DIAGASSERT(pattern != NULL);
 	_DIAGASSERT(pglob != NULL);
 	/*
 	 * Loop over pattern segments until end of pattern or until
 	 * segment with meta character found.
 	 */
 	for (anymeta = 0;;) {
 		if (*pattern == EOS) {		/* End of pattern? */
 			*pathend = EOS;
 			if (g_lstat(pathbuf, &sb, pglob))
 				return 0;
 			if ((pglob->gl_flags & GLOB_LIMIT) &&
-			    limit[GLOB_INDEX_STAT]++ >= GLOB_LIMIT_STAT) {
+			    limit->l_stat++ >= GLOB_LIMIT_STAT) {
 				errno = 0;
 				*pathend++ = SEP;
 				*pathend = EOS;
 				return GLOB_NOSPACE;
+			}
 			if (((pglob->gl_flags & GLOB_MARK) &&
 			    pathend[-1] != SEP) && (S_ISDIR(sb.st_mode) ||
 			    (S_ISLNK(sb.st_mode) &&
 			    (g_stat(pathbuf, &sb, pglob) == 0) &&
 			    S_ISDIR(sb.st_mode)))) {
 				if (pathend >= pathlim)
 					return GLOB_ABORTED;
 				*pathend++ = SEP;
 @@ -673,28 +684,28 @@ glob2(Char *pathbuf, Char *pathend, Char
 			while (*pattern == SEP) {
 				if (pathend >= pathlim)
 					return GLOB_ABORTED;
 				*pathend++ = *pattern++;
+			}
 		} else			/* Need expansion, recurse. */
 			return glob3(pathbuf, pathend, pathlim, pattern, p,
 			    pglob, limit);
+	}
 	/* NOTREACHED */
+}
 static int
-glob3(Char *pathbuf, Char *pathend, Char *pathlim, Char *pattern,
+glob3(Char *pathbuf, Char *pathend, Char *pathlim, const Char *pattern,
-    Char *restpattern, glob_t *pglob, size_t *limit)
+    const Char *restpattern, glob_t *pglob, struct glob_limit *limit)
+{
 	struct dirent *dp;
 	DIR *dirp;
 	int error;
 	char buf[MAXPATHLEN];
 	/*
 	 * The readdirfunc declaration can't be prototyped, because it is
 	 * assigned, below, to two functions which are prototyped in glob.h
 	 * and dirent.h as taking pointers to differently typed opaque
 	 * structures.
 	 */
 	struct dirent *(*readdirfunc)(void *);
 @@ -730,27 +741,27 @@ glob3(Char *pathbuf, Char *pathend, Char
 	error = 0;
 	/* Search directory for matching names. */
 	if (pglob->gl_flags & GLOB_ALTDIRFUNC)
 		readdirfunc = pglob->gl_readdir;
 	else
 		readdirfunc = (struct dirent *(*)__P((void *))) readdir;
 	while ((dp = (*readdirfunc)(dirp)) != NULL) {
 		u_char *sc;
 		Char *dc;
 		if ((pglob->gl_flags & GLOB_LIMIT) &&
-		    limit[GLOB_INDEX_READDIR]++ >= GLOB_LIMIT_READDIR) {
+		    limit->l_readdir++ >= GLOB_LIMIT_READDIR) {
 			errno = 0;
 			*pathend++ = SEP;
 			*pathend = EOS;
 			return GLOB_NOSPACE;
+		}
 		/*
 		 * Initial DOT must be matched literally, unless we have
 		 * GLOB_PERIOD set.
 		 */
 		if ((pglob->gl_flags & GLOB_PERIOD) == 0)
 			if (dp->d_name[0] == DOT && *pattern != DOT)
 				continue;
 @@ -819,79 +830,83 @@ glob3(Char *pathbuf, Char *pathend, Char
  * add the new item, and update gl_pathc.
+ *
  * This assumes the BSD realloc, which only copies the block when its size
  * crosses a power-of-two boundary; for v7 realloc, this would cause quadratic
  * behavior.
+ *
  * Return 0 if new item added, error code if memory couldn't be allocated.
+ *
  * Invariant of the glob_t structure:
  *	Either gl_pathc is zero and gl_pathv is NULL; or gl_pathc > 0 and
  *	gl_pathv points to (gl_offs + gl_pathc + 1) items.
  */
 static int
-globextend(const Char *path, glob_t *pglob, size_t *limit)
+globextend(const Char *path, glob_t *pglob, struct glob_limit *limit)
+{
 	char **pathv;
 	size_t i, newsize, len;
 	char *copy;
 	const Char *p;
 	_DIAGASSERT(path != NULL);
 	_DIAGASSERT(pglob != NULL);
 	newsize = sizeof(*pathv) * (2 + pglob->gl_pathc + pglob->gl_offs);
 	if ((pglob->gl_flags & GLOB_LIMIT) &&
 	    newsize > GLOB_LIMIT_PATH * sizeof(*pathv))
 		goto nospace;
 	pathv = pglob->gl_pathv ? realloc(pglob->gl_pathv, newsize) :
 	    malloc(newsize);
 	if (pathv == NULL)
 		return GLOB_NOSPACE;
 	if (pglob->gl_pathv == NULL && pglob->gl_offs > 0) {
 		/* first time around -- clear initial gl_offs items */
 		pathv += pglob->gl_offs;
 		for (i = pglob->gl_offs + 1; --i > 0; )
 			*--pathv = NULL;
+	}
 	pglob->gl_pathv = pathv;
 	for (p = path; *p++;)
 		continue;
 	len = (size_t)(p - path);
-	limit[GLOB_INDEX_MALLOC] += len;
+	limit->l_string += len;
 	if ((copy = malloc(len)) != NULL) {
 		if (g_Ctoc(path, copy, len)) {
 			free(copy);
 			return GLOB_ABORTED;
+		}
 		pathv[pglob->gl_offs + pglob->gl_pathc++] = copy;
+	}
 	pathv[pglob->gl_offs + pglob->gl_pathc] = NULL;
 	if ((pglob->gl_flags & GLOB_LIMIT) &&
-	    (newsize + limit[GLOB_INDEX_MALLOC]) >= GLOB_LIMIT_MALLOC) {
+	    (newsize + limit->l_string) >= GLOB_LIMIT_STRING)
-		errno = 0;
+		goto nospace;
 		return GLOB_NOSPACE;
 	return copy == NULL ? GLOB_NOSPACE : 0;
 nospace:
 	errno = 0;
 	return GLOB_NOSPACE;
+}
 /*
  * pattern matching function for filenames.  Each occurrence of the *
  * pattern causes a recursion level.
  */
 static int
-match(Char *name, Char *pat, Char *patend)
+match(const Char *name, const Char *pat, const Char *patend)
+{
 	int ok, negate_range;
 	Char c, k;
 	_DIAGASSERT(name != NULL);
 	_DIAGASSERT(pat != NULL);
 	_DIAGASSERT(patend != NULL);
 	while (pat < patend) {
 		c = *pat++;
 		switch (c & M_MASK) {
 		case M_ALL:
 			if (pat == patend)