#include "config.h"
#ifdef NEED_GLOB

/*
 * 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.
 * 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. 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * 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.
 */

/* from: static char sccsid[] = "@(#)glob.c	8.3 (Berkeley) 10/13/93"; */

/* 
 * It's not that I dislike the original code, it's just that there really 
 * isn't any other canonical implementation of glob() but the original 
 * BSD one, that was written in C90 and had lots of features I didn't use
 * and made everything crazy complicated and C99 static analyzers had
 * a million complaints...
 * 
 * This is a stripped down version of glob() that only does what i want,
 * that C99 compilers do not complain about.  If you need a real glob()
 * then you should call your system's glob().
 */

/*
 * glob(3) -- a superset of the one defined in POSIX 1003.2.
 * The [!...] convention to negate a range is supported (SysV, Posix, ksh).
 *
 * This is the only truly optional flag
 *  GLOB_INSENSITIVE:
 *	Globbing occurs without regard to case of the letters.
 *
 * The behavior of these flags are always forced, whether you specify
 * them or not:
 *  GLOB_MARK
 *  GLOB_QUOTE:
 *	Escaping convention: \ inhibits any special meaning the following
 *	character might have (except \ at end of string is retained).
 *  GLOB_BRACE:
 *	expand {1,2}{a,b} to 1a 1b 2a 2b 
 *
 * The behavior of these flags is no longer supported, whether you specify
 * them or not:
 *  GLOB_ALTDIRFUNC:
 *	Use alternately specified directory access functions.
 *  GLOB_MAGCHAR:
 *	Set in gl_flags if pattern contained a globbing character.
 *  GLOB_NOMAGIC:
 *	Same as GLOB_NOCHECK, but it will only append pattern if it did
 *	not contain any magic characters.  [Used in csh style globbing]
 *  GLOB_TILDE: (not available)
 *	expand ~user/foo to the /home/dir/of/user/foo
 *  gl_matchc:
 *	Number of matches in the current invocation of glob.
 */

#ifdef HAVE_SYS_PARAM_H
#include <sys/param.h>
#endif
#include <sys/stat.h>
#include <ctype.h>
#include <dirent.h>
#include <errno.h>
#include "glob.h"
#include <pwd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "irc.h"
#include "compat.h"
#ifndef PATH_MAX
# ifndef MAXPATHLEN
#  ifndef PATHSIZE
#   define PATH_MAX 1024
#  else
#   define PATH_MAX PATHSIZE
#  endif
# else
#  define PATH_MAX MAXPATHLEN
# endif
#endif

#undef EOS
#define	DOLLAR		'$'
#define	DOT		'.'
#define	EOS		'\0'
#define	LBRACKET	'['
#define	NOT		'!'
#define	QUESTION	'?'
#define	QUOTE		'\\'
#define	RANGE		'-'
#define	RBRACKET	']'
#define	SEP		'/'
#define	STAR		'*'
#define	UNDERSCORE	'_'
#define	LBRACE		'{'
#define	RBRACE		'}'
#define	SLASH		'/'
#define	COMMA		','

#define	M_QUOTE		0x8000
#define	M_PROTECT	0x4000
#define M_ANYCASE	0x2000		/* EPIC ADD */
#define	M_MASK		0xffff
#define	M_ASCII		0x00ff

#ifdef Char
#undef Char
#endif
typedef unsigned short Char;

#define	CHAR(c)		((Char)((c)&M_ASCII))
#define	META(c)		((Char)((c)|M_QUOTE))
#define	M_ALL		META('*')
#define	M_END		META(']')
#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 void	 	g_Ctoc (const Char *, char *);
static int	 	g_lstat (Char *, Stat *, glob_t *);
static DIR	*	g_opendir (Char *, glob_t *);
static ssize_t		g_strchr (const Char *, int);
static int	 	g_stat (Char *, Stat *, glob_t *);
static int	 	glob0 (const Char *, glob_t *);
static int	 	glob1 (Char *, glob_t *);
static int	 	glob2 (Char *, Char *, Char *, glob_t *);
static int	 	glob3 (Char *, Char *, Char *, Char *, glob_t *);
static int	 	globextend (const Char *, glob_t *);
static int	 	globexp1 (const Char *, glob_t *);
static int	 	globexp2 (const Char *, const Char *, glob_t *, int *);
static int	 	globmatch (Char *, Char *, Char *, int);

int bsd_glob		(	const char *pattern,
				int flags, 
				int (*errfunc) (const char *, int),
				glob_t *pglob				)
{
	const unsigned char *patnext;
	int c;
	Char *bufnext, *bufend, patbuf[PATH_MAX+1];

	patnext = (const unsigned char *) pattern;

	/* We always unconditionally replace (no append) */
	pglob->gl_pathc = 0;
	pglob->gl_pathv = NULL;
	pglob->gl_flags = flags;
	pglob->gl_errfunc = errfunc;

	bufnext = patbuf;
	bufend = bufnext + PATH_MAX;

	/* Protect the quoted characters. */
	while (bufnext < bufend && (c = *patnext++) != EOS) 
	{
		if (c == QUOTE) 
		{
			if ((c = *patnext++) == EOS) 
			{
				c = QUOTE;
				--patnext;
			}
			*bufnext++ = c | M_PROTECT;
		}
		else
			*bufnext++ = c;
	}
	*bufnext = EOS;

	return globexp1(patbuf, pglob);
}

/*
 * 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			)
{
	const Char* ptr = pattern;
	int rv;
	ssize_t	span;

	/* Protect a single {}, for find(1), like csh */
	if (pattern[0] == LBRACE && pattern[1] == RBRACE && pattern[2] == EOS)
		return glob0(pattern, pglob);

	while ((span = g_strchr(ptr, LBRACE)) >= 0)
	{
		ptr += span;
		if (!globexp2(ptr, pattern, pglob, &rv))
			return rv;
	}

	return glob0(pattern, pglob);
}


/*
 * 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				)
{
	int     i;
	Char   *lm, *ls;
	const Char *pe, *pm, *pl;
	Char    patbuf[PATH_MAX + 1];

	/* There are bugs in here that I can't get to the bottom of */
	/* This just papers over a string overrun */
	memset(patbuf, 0, PATH_MAX + 1 * sizeof(Char));

	/* copy part up to the brace */
	for (lm = patbuf, pm = pattern; pm != ptr; *lm++ = *pm++)
		continue;
	*lm = EOS;
	ls = lm;

	/* Find the balanced brace */
	for (i = 0, pe = ++ptr; *pe != EOS; pe++)
	{
		if (*pe == LBRACKET) 
		{
			/* Ignore everything between [] */
			for (pm = pe++; *pe != RBRACKET && *pe != EOS; pe++)
				continue;
			if (*pe == EOS) 
			{
				/* 
				 * We could not find a matching RBRACKET.
				 * Ignore and just look for RBRACE
				 */
				pe = pm;
			}
		}
		else if (*pe == LBRACE)
			i++;
		else if (*pe == RBRACE) 
		{
			if (i == 0)
				break;
			i--;
		}
	}

	/* Non matching braces; just glob the pattern */
	if (i != 0 || *pe == EOS) 
	{
		*rv = glob0(patbuf, pglob);
		return 0;
	}

	for (i = 0, pl = pm = ptr; pm <= pe; pm++)
	{
		switch (*pm) 
		{
		case LBRACKET:
			/* Ignore everything between [] */
			for (pl = pm++; *pm != RBRACKET && *pm != EOS; pm++)
				continue;
			if (*pm == EOS) 
			{
				/* 
				 * We could not find a matching RBRACKET.
				 * Ignore and just look for RBRACE
				 */
				pm = pl;
			}
			break;

		case LBRACE:
			i++;
			break;

		case RBRACE:
			if (i) 
			{
			    i--;
			    break;
			}
			/* FALLTHROUGH */
		case COMMA:
			if (i && *pm == COMMA)
				break;
			else 
			{
				/* Append the current string */
				for (lm = ls; (pl < pm); *lm++ = *pl++)
					continue;
				/* 
				 * Append the rest of the pattern after the
				 * closing brace
				 */
				for (pl = pe + 1; (*lm++ = *pl++) != EOS;)
					continue;

				/* Expand the current pattern */
				*rv = globexp1(patbuf, pglob);

				/* move after the comma, to the next string */
				pl = pm + 1;
			}
			break;

		default:
			break;
		}
	}
	*rv = 0;
	return 0;
}


/*
 * 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		)
{
	const Char *	qpatnext;
	int 		c;
	int		err;
	int		oldpathc;
	Char *		bufnext;
	Char		patbuf[PATH_MAX+1];

	qpatnext = pattern;
	if (qpatnext == NULL) 
	{
		errno = E2BIG;
		return (GLOB_NOSPACE);
	}
	oldpathc = pglob->gl_pathc;
	bufnext = patbuf;

	/* We don't need to check for buffer overflow any more. */
	while ((c = *qpatnext++) != EOS) 
	{
		switch (c) 
		{
		case LBRACKET:
			c = *qpatnext;
			if (c == NOT)
				++qpatnext;
			if (*qpatnext == EOS || 
			    g_strchr(qpatnext+1, RBRACKET) < 0)
			{
				*bufnext++ = LBRACKET;
				if (c == NOT)
					--qpatnext;
				break;
			}
			*bufnext++ = M_SET;
			if (c == NOT)
				*bufnext++ = M_NOT;
			c = *qpatnext++;
			do 
			{
				*bufnext++ = CHAR(c);
				if (*qpatnext == RANGE && 
				    (c = qpatnext[1]) != RBRACKET) 
				{
					*bufnext++ = M_RNG;
					*bufnext++ = CHAR(c);
					qpatnext += 2;
				}
			} 
			while ((c = *qpatnext++), (c && c != RBRACKET));

			*bufnext++ = M_END;
			break;
		case QUESTION:
			*bufnext++ = M_ONE;
			break;
		case STAR:
			/* 
			 * collapse adjacent stars to one, 
			 * to avoid exponential behavior
			 */
			if (bufnext == patbuf || bufnext[-1] != M_ALL)
			    *bufnext++ = M_ALL;
			break;
		default:
			*bufnext++ = CHAR(c);
			break;
		}
	}
	*bufnext = EOS;

	if ((err = glob1(patbuf, pglob)) != 0)
		return(err);

	if (pglob->gl_pathv)
		qsort(pglob->gl_pathv + oldpathc, 
		      pglob->gl_pathc - oldpathc, 
		      sizeof(char *), compare);

	return(0);
}

static int compare		(	const void *p,
					const void *q		)
{
	return (strcmp(*(const char * const *)p, *(const char * const *)q));
}

static int glob1		(	Char *pattern,
					glob_t *pglob		)
{
	Char pathbuf[PATH_MAX+1];

	/* A null pathname is invalid -- POSIX 1003.1 sect. 2.4. */
	if (*pattern == EOS)
		return(0);
	return(glob2(pathbuf, pathbuf, pattern, pglob));
}

/*
 * 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 *pattern,
					glob_t *pglob		)
{
	Stat sb;
	Char *p, *q;
	int anymeta;

	/*
	 * 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 ( (pathend[-1] != SEP) && 
                             (S_ISDIR(sb.st_mode) || 
			      (S_ISLNK(sb.st_mode) && (g_stat(pathbuf, &sb, pglob) == 0)
			                           && S_ISDIR(sb.st_mode))
			     )
			   )
			{
				*pathend++ = SEP;
				*pathend = EOS;
			}
			return(globextend(pathbuf, pglob));
		}

		/* Find end of next segment, copy tentatively to pathend. */
		q = pathend;
		p = pattern;
		while (*p != EOS && *p != SEP) 
		{
			if (ismeta(*p))
				anymeta = 1;
			*q++ = *p++;
		}

		if (!anymeta)		/* No expansion, do next segment. */
		{
			pathend = q;
			pattern = p;
			while (*pattern == SEP)
				*pathend++ = *pattern++;
		} else			/* Need expansion, recurse. */
			return(glob3(pathbuf, pathend, pattern, p, pglob));
	}
	/* NOTREACHED */
}

static int glob3		(	Char *pathbuf,
					Char *pathend,
					Char *pattern,
					Char *restpattern,
					glob_t *pglob			)
{
	struct dirent *dp;
	DIR *dirp;
	int err;

	*pathend = EOS;
	errno = 0;

	if ((dirp = g_opendir(pathbuf, pglob)) == NULL)
		return(0);

	err = 0;

	while ((dp = readdir(dirp)))
	{
		unsigned char *sc;
		Char *dc;
		int	nocase = 0;

		/* Initial DOT must be matched literally. */
		if (dp->d_name[0] == DOT && *pattern != DOT)
			continue;
		for (sc = (unsigned char *) dp->d_name, dc = pathend; 
		     (*dc++ = *sc++) != EOS;)
			continue;


		if (pglob->gl_flags & GLOB_INSENSITIVE)
			nocase = 1;

		if (!globmatch(pathend, pattern, restpattern, nocase)) 
		{
			*pathend = EOS;
			continue;
		}
		err = glob2(pathbuf, --dc, restpattern, pglob);
		if (err)
			break;
	}

	closedir(dirp);
	return(err);
}


/*
 * Extend the gl_pathv member of a glob_t structure to accomodate a new item,
 * 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_pathc + 1) items.
 */
static int globextend		(	const Char *path,
					glob_t *pglob			)
{
	char **pathv;
	unsigned newsize;
	char *copy;
	const Char *p;

	newsize = sizeof(*pathv) * (2 + pglob->gl_pathc);
	pathv = pglob->gl_pathv ? 
		    (char **)realloc((char *)pglob->gl_pathv, newsize) :
		    (char **)malloc(newsize);
	if (pathv == NULL)
		return(GLOB_NOSPACE);

	pglob->gl_pathv = pathv;

	for (p = path; *p++;)
		continue;
	if ((copy = malloc(p - path)) != NULL) 
	{
		g_Ctoc(path, copy);
		pathv[pglob->gl_pathc++] = copy;
	}
	pathv[pglob->gl_pathc] = NULL;
	return(copy == NULL ? GLOB_NOSPACE : 0);
}


/*
 * pattern matching function for filenames.  
 *
 * note:
 * The original version got complaints from static analyzers about 
 * infinite recursion.  I noticed FreeBSD reimplemented it to be 
 * non-recursive, so I switched to that algorithm.
 */
static int globmatch		(	Char *name,
					Char *pat,
					Char *patend, int nocase )
{
	int ok, negate_range;
	Char c, k, *nextp, *nextn;

	nextn = NULL;
	nextp = NULL;

	for (;;) 
	{
		while (pat < patend) 
		{
			c = *pat++;
			switch (c & M_MASK) 
			{
			    case M_ALL:
				if (pat == patend)
					return(1);
				if (*name == EOS)
					return 0;
				nextn = name + 1;
				nextp = pat - 1;
				break;

			    case M_ONE:
				if (*name++ == EOS)
					goto fail;
				break;

			    case M_SET:
				ok = 0;
				if ((k = *name++) == EOS)
					goto fail;
				negate_range = ((*pat & M_MASK) == M_NOT);
				if (negate_range != 0)
					++pat;
				while (((c = *pat++) & M_MASK) != M_END)
				{
					if ((*pat & M_MASK) == M_RNG) 
					{
						if (c <= k && k <= pat[1])
							ok = 1;
						pat += 2;
					} else if (c == k)
						ok = 1;
				}
				if (ok == negate_range)
					goto fail;
				break;

			    default:
			    {
				Char	namex = *name;
				name++;

				if (nocase)
				{
					if (toupper((int)CHAR(namex)) != toupper((int)CHAR(c)))
						goto fail;
				}
				else
				{
					if (namex != c)
						goto fail;
				}
				break;
			    }
			}
		}

		if (*name == EOS)
			return 1;

	fail:
		if (nextn == NULL)
			break;
		pat = nextp;
		name = nextn;
	}

	return 0;
}

/* Free allocated data belonging to a glob_t structure. */
void bsd_globfree 		(	glob_t *pglob			)
{
	int i;
	char **pp;

	if (pglob->gl_pathv != NULL) {
		pp = pglob->gl_pathv;
		for (i = pglob->gl_pathc; i--; ++pp)
			if (*pp)
				free(*pp);
		free(pglob->gl_pathv);
	}
}

static DIR *g_opendir		(	Char *str,
					glob_t *pglob			)
{
	char buf[PATH_MAX];

	if (!*str)
		strlcpy(buf, ".", sizeof buf);
	else
		g_Ctoc(str, buf);

	return(opendir(buf));
}

static int g_lstat		(	Char *fn,
					Stat *sb,
					glob_t *pglob			)
{
	char buf[PATH_MAX];

	g_Ctoc(fn, buf);
	return(lstat(buf, sb));
}

static int g_stat		(	Char *fn,
					Stat *sb,
					glob_t *pglob			)
{
	char buf[PATH_MAX];

	g_Ctoc(fn, buf);
	return(stat(buf, sb));
}

static ssize_t	g_strchr	(	const Char *str, 
					int ch				)
{
	const Char *start = str;
	do {
		if (*str == ch)
			return str - start;
	} while (*str++);
	return -1;
}

static void g_Ctoc		(	const Char *str,
					char *buf			)
{
	char *dc;

	for (dc = buf; (*dc++ = *str++) != EOS;)
		continue;
}
#endif