// glob.c

/*

 * 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.

 * 4. 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.

 */

/* Portions Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).All rights reserved.  */

#if defined(LIBC_SCCS) && !defined(lint)

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

#endif /* LIBC_SCCS and not lint */

#include <sys/cdefs.h>

__FBSDID("$FreeBSD: src/lib/libc/gen/glob.c,v 1.23 2005/09/14 19:14:32 ache Exp $");

/*

 * 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_QUOTE:

 *	Escaping convention: \ inhibits any special meaning the following

 *	character might have (except \ at end of string is retained).

 * 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_ALTDIRFUNC:

 *	Use alternately specified directory access functions.

 * GLOB_TILDE:

 *	expand ~user/foo to the /home/dir/of/user/foo

 * GLOB_BRACE:

 *	expand {1,2}{a,b} to 1a 1b 2a 2b

 * gl_matchc:

 *	Number of matches in the current invocation of glob.

 */

/*

 * Some notes on multibyte character support:

 * 1. Patterns with illegal byte sequences match nothing - even if

 *    GLOB_NOCHECK is specified.

 * 2. Illegal byte sequences in filenames are handled by treating them as

 *    single-byte characters with a value of the first byte of the sequence

 *    cast to wchar_t.

 * 3. State-dependent encodings are not currently supported.

 */

#include <sys/param.h>

#include <sys/stat.h>

#include <ctype.h>

#include <dirent.h>

#include <errno.h>

#include <glob.h>

#include <limits.h>

#include <pwd.h>

#include <stdint.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <wchar.h>

#include "libc_collate.h"

#if (defined(__SYMBIAN32__) && (defined(__WINSCW__) || defined(__WINS__)))

#include "libc_wsd_defs.h"

#include "reent.h"

#endif	//defined(__SYMBIAN32__) && (defined(__WINSCW__) || defined(__WINS__))

#ifdef __cplusplus

extern "C" {

#endif

#ifdef __SYMBIAN32__

extern char LC_COLLATE_LocaleName[30];

#ifdef EMULATOR

char *GET_WSD_VAR_NAME(LC_COLLATE_LocaleName, g)();

#define LC_COLLATE_LocaleName (GET_WSD_VAR_NAME(LC_COLLATE_LocaleName, g)())

#endif 	//EMULATOR

//Declared and defined from libc_collate.h and vfscanf.c

extern int __collate_range_cmp(int , int );

#endif	//__SYMBIAN32__

#define	DOLLAR		'$'

#define	DOT			'.'

#define	EOS			'\0'

#define	LBRACKET	'['

#define	NOT			'!'

#define	QUESTION	'?'

#define	QUOTE		'\\'

#define	RANGE		'-'

#define	RBRACKET	']'

// For Symbian Environment the path is specified using the '\'

// unlike in the Linux where the path seprator '/' is used.

// Since '\\' as path seprator is used the escaping flag 

// 'QUOTE' cannot be used here.

// For e.g. ..\\test\\hollows\\*

#ifdef __SYMBIAN32__

	#define	SEP		'\\'

#else

	#define SEP		'/'

#endif //__SYMBIAN32__

#define	STAR		'*'

#define	TILDE		'~'

#define	UNDERSCORE	'_'

#define	LBRACE		'{'

#define	RBRACE		'}'

#define	SLASH		'/'

#define	COMMA		','

#ifndef __SYMBIAN32__

#ifndef DEBUG

#define	M_QUOTE		0x8000000000ULL

#define	M_PROTECT	0x4000000000ULL

#define	M_MASK		0xffffffffffULL

#define	M_CHAR		0x00ffffffffULL

typedef uint_fast64_t Char;

#else		//DEBUG

#define	M_QUOTE		0x80

#define	M_PROTECT	0x40

#define	M_MASK		0xff

#define	M_CHAR		0x7f

typedef char Char;

#endif 		//DEBUG

#else    	//__SYMBIAN32__

#define	M_QUOTE		0x80

#define	M_PROTECT	0x40

#define	M_MASK		0xff

#define	M_CHAR		0x7f

typedef unsigned char Char;

#endif		//__SYMBIAN32__

#define	CHAR(c)		((Char)((c)&M_CHAR))

#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 int	 g_Ctoc(const Char *, char *, u_int);

static int	 g_lstat(Char *, struct stat *, glob_t *);

static DIR	*g_opendir(Char *, glob_t *);

static Char	*g_strchr(Char *, wchar_t);

#ifdef notdef

static Char	*g_strcat(Char *, const Char *);

#endif

static int	 g_stat(Char *, struct stat *, glob_t *);

static int	 glob0(const Char *, glob_t *, int *);

static int	 glob1(Char *, glob_t *, int *);

static int	 glob2(Char *, Char *, Char *, Char *, glob_t *, int *);

static int	 glob3(Char *, Char *, Char *, Char *, Char *, glob_t *, int *);

static int	 globextend(const Char *, glob_t *, int *);

static const Char *	

		 globtilde(const Char *, Char *, size_t, glob_t *);

static int	 globexp1(const Char *, glob_t *, int *);

static int	 globexp2(const Char *, const Char *, glob_t *, int *, int *);

static int	 match(Char *, Char *, Char *);

#ifdef DEBUG

static void	 qprintf(const char *, Char *);

#endif

// EXTERNAL FUNCTION PROTOTYPES

//--------------------------------------------------------------------------------------------

//Function Name : int glob(glob(const char *, int flags, int (*)(const char *, int), glob_t *)

//Description   : It takes pattern to be searched, flags and the structure of the type glob_t.

//				  It can optionally also take  If errfunc is not NULL, it will be called in 

//				  error with the arguments epath,  a  pointer  to  the case of an path which 

//			      failed

//				  

//Return Value  : If successful returns the pathnames of the searched pattern contained 

//				  in the glob_t structure member reference pointer gl_pathv. In case

//				  failure, gl_pathv is NULL.

//----------------------------------------------------------------------------------------------

EXPORT_C int

glob(pattern, flags, errfunc, pglob)

	const char *pattern;

	int flags, (*errfunc)(const char *, int);

	glob_t *pglob;

{

	const u_char *patnext;

	int limit;

	Char *bufnext, *bufend, patbuf[MAXPATHLEN], prot;

	mbstate_t mbs;

	wchar_t wc;

	size_t clen;

	patnext = (u_char *) pattern;

	// Since we are using '\\' as path seprator, this flag needs to be mentioned

	// by default in Symbian. Instead this can be hardcoded here.

	#ifdef __SYMBIAN32__

		flags = flags | GLOB_NOESCAPE;

	#endif

	if (!(flags & GLOB_APPEND)) {

		pglob->gl_pathc = 0;

		pglob->gl_pathv = NULL;

		if (!(flags & GLOB_DOOFFS))

			pglob->gl_offs = 0;

	}

	if (flags & GLOB_LIMIT) {

		limit = pglob->gl_matchc;

		if (limit == 0)

			limit = ARG_MAX;

	} else

		limit = 0;

	pglob->gl_flags = flags & ~GLOB_MAGCHAR;

	pglob->gl_errfunc = errfunc;

	pglob->gl_matchc = 0;

	bufnext = patbuf;

	bufend = bufnext + MAXPATHLEN - 1;

	if (flags & GLOB_NOESCAPE) {

		memset(&mbs, 0, sizeof(mbs));

		while (bufend - bufnext >= MB_CUR_MAX) {

			clen = mbrtowc(&wc,(char*)patnext, MB_LEN_MAX, &mbs);

			if (clen == (size_t)-1 || clen == (size_t)-2)

				return (GLOB_NOMATCH);

			else if (clen == 0)

				break;

			*bufnext++ = wc;

			patnext += clen;

		}

	} else {

		/* Protect the quoted characters. */

		memset(&mbs, 0, sizeof(mbs));

		while (bufend - bufnext >= MB_CUR_MAX) {

			if (*patnext == QUOTE) {

				if (*++patnext == EOS) {

					*bufnext++ = QUOTE | M_PROTECT;

					continue;

				}

				prot = M_PROTECT;

			} else

				prot = 0;

			clen = mbrtowc(&wc, (char*)patnext, MB_LEN_MAX, &mbs);

			if (clen == (size_t)-1 || clen == (size_t)-2)

				return (GLOB_NOMATCH);

			else if (clen == 0)

				break;

			*bufnext++ = wc | prot;

			patnext += clen;

		}

	}

	*bufnext = EOS;

	if (flags & GLOB_BRACE)

	    return globexp1(patbuf, pglob, &limit);

	else

	    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(pattern, pglob, limit)

	const Char *pattern;

	glob_t *pglob;

	int *limit;

{

	const Char* ptr = pattern;

	int rv;

	/* 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((Char *) 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(ptr, pattern, pglob, rv, limit)

	const Char *ptr, *pattern;

	glob_t *pglob;

	int *rv, *limit;

{

	int     i;

	Char   *lm, *ls;

	const Char *pe, *pm, *pm1, *pl;

	Char    patbuf[MAXPATHLEN];

	/* 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; 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, limit);

		return 0;

	}

	for (i = 0, pl = pm = ptr; pm <= pe; pm++)

		switch (*pm) {

		case LBRACKET:

			/* Ignore everything between [] */

			for (pm1 = pm++; *pm != RBRACKET && *pm != EOS; pm++)

				continue;

			if (*pm == EOS) {

				/*

				 * We could not find a matching RBRACKET.

				 * Ignore and just look for RBRACE

				 */

				pm = pm1;

			}

			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 */

#ifdef DEBUG

				qprintf("globexp2:", patbuf);

#endif

				*rv = globexp1(patbuf, pglob, limit);

				/* move after the comma, to the next string */

				pl = pm + 1;

			}

			break;

		default:

			break;

		}

	*rv = 0;

	return 0;

}

/*

 * expand tilde from the passwd file.

 */

static const Char *

globtilde(pattern, patbuf, patbuf_len, pglob)

	const Char *pattern;

	Char *patbuf;

	size_t patbuf_len;

	glob_t *pglob;

{

#ifndef  __SYMBIAN32__

	struct passwd *pwd;

#endif

	char *h;

	const Char *p;

	Char *b, *eb;

	if (*pattern != TILDE || !(pglob->gl_flags & GLOB_TILDE))

		return pattern;

	/* 

	 * Copy up to the end of the string or / 

	 */

	eb = &patbuf[patbuf_len - 1];

#ifdef __SYMBIAN32__

	for (p = pattern + 1, h = (char *) patbuf;

	    h < (char *)eb && *p && *p != SEP ; *h++ = *p++)

		continue;

	*h = EOS;

	if (((char *) patbuf)[0] == EOS) {

		/*

		 * handle a plain ~ or ~\\ by getting the

		 * secure Id for this process. It shall 

		 * return the path as C:\\private\\<secureId>

		 * on emulator and Z:\\private\\<secureId>

		 * on hardware

		 */

	    if( NULL == getcwd(h, patbuf_len) )

			return pattern;

	}

	else{

		/*

		 * Its ~<path>\\.. This will not be handled. Returns the

		 * pattern as it is. 

		 */

		return pattern;

	}

#  else

	for (p = pattern + 1, h = (char *) patbuf;

	    h < (char *)eb && *p && *p != SLASH; *h++ = *p++)

		continue;

	*h = EOS;

	if (((char *) patbuf)[0] == EOS) {

		/*

		 * handle a plain ~ or ~/ by expanding $HOME first (iff

		 * we're not running setuid or setgid) and then trying

		 * the password file

		 */

		if (issetugid() != 0 ||

		    (h = getenv("HOME")) == NULL) {

			if (((h = getlogin()) != NULL &&

			     (pwd = getpwnam(h)) != NULL) ||

			    (pwd = getpwuid(getuid())) != NULL)

				h = pwd->pw_dir;

			else

				return pattern;