Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	lib/libc/gen/fnmatch.c	Lines:	0	162	0.0 %
Date:	2017-11-07	Branches:	0	261	0.0 %


/*	$OpenBSD: fnmatch.c,v 1.21 2016/03/01 20:29:03 millert Exp $	*/

/* Copyright (c) 2011, VMware, Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * 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.
 *     * Neither the name of the VMware, Inc. 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 COPYRIGHT HOLDERS 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 VMWARE, INC. 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.
 */

/*
 * Copyright (c) 2008, 2016 Todd C. Miller <millert@openbsd.org>
 *
 * 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.
 */

/* Authored by William A. Rowe Jr. <wrowe; apache.org, vmware.com>, April 2011
 *
 * Derived from The Open Group Base Specifications Issue 7, IEEE Std 1003.1-2008
 * as described in;
 *   http://pubs.opengroup.org/onlinepubs/9699919799/functions/fnmatch.html
 *
 * Filename pattern matches defined in section 2.13, "Pattern Matching Notation"
 * from chapter 2. "Shell Command Language"
 *   http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_13
 * where; 1. A bracket expression starting with an unquoted <circumflex> '^'
 * character CONTINUES to specify a non-matching list; 2. an explicit <period> '.'
 * in a bracket expression matching list, e.g. "[.abc]" does NOT match a leading
 * <period> in a filename; 3. a <left-square-bracket> '[' which does not introduce
 * a valid bracket expression is treated as an ordinary character; 4. a differing
 * number of consecutive slashes within pattern and string will NOT match;
 * 5. a trailing '\' in FNM_ESCAPE mode is treated as an ordinary '\' character.
 *
 * Bracket expansion defined in section 9.3.5, "RE Bracket Expression",
 * from chapter 9, "Regular Expressions"
 *   http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap09.html#tag_09_03_05
 * with no support for collating symbols, equivalence class expressions or
 * character class expressions.  A partial range expression with a leading
 * hyphen following a valid range expression will match only the ordinary
 * <hyphen> and the ending character (e.g. "[a-m-z]" will match characters
 * 'a' through 'm', a <hyphen> '-', or a 'z').
 *
 * Supports BSD extensions FNM_LEADING_DIR to match pattern to the end of one
 * path segment of string, and FNM_CASEFOLD to ignore alpha case.
 *
 * NOTE: Only POSIX/C single byte locales are correctly supported at this time.
 * Notably, non-POSIX locales with FNM_CASEFOLD produce undefined results,
 * particularly in ranges of mixed case (e.g. "[A-z]") or spanning alpha and
 * nonalpha characters within a range.
 *
 * XXX comments below indicate porting required for multi-byte character sets
 * and non-POSIX locale collation orders; requires mbr* APIs to track shift
 * state of pattern and string (rewinding pattern and string repeatedly).
 *
 * Certain parts of the code assume 0x00-0x3F are unique with any MBCS (e.g.
 * UTF-8, SHIFT-JIS, etc).  Any implementation allowing '\' as an alternate
 * path delimiter must be aware that 0x5C is NOT unique within SHIFT-JIS.
 */

#include <fnmatch.h>
#include <string.h>
#include <ctype.h>

#include "charclass.h"

#define	RANGE_MATCH	1
#define	RANGE_NOMATCH	0
#define	RANGE_ERROR	(-1)

static int
classmatch(const char *pattern, char test, int foldcase, const char **ep)
{
	const char * const mismatch = pattern;
	const char *colon;
	struct cclass *cc;
	int rval = RANGE_NOMATCH;
	size_t len;

	if (pattern[0] != '[' || pattern[1] != ':') {
		*ep = mismatch;
		return RANGE_ERROR;
	}
	pattern += 2;

	if ((colon = strchr(pattern, ':')) == NULL || colon[1] != ']') {
		*ep = mismatch;
		return RANGE_ERROR;
	}
	*ep = colon + 2;
	len = (size_t)(colon - pattern);

	if (foldcase && strncmp(pattern, "upper:]", 7) == 0)
		pattern = "lower:]";
	for (cc = cclasses; cc->name != NULL; cc++) {
		if (!strncmp(pattern, cc->name, len) && cc->name[len] == '\0') {
			if (cc->isctype((unsigned char)test))
				rval = RANGE_MATCH;
			break;
		}
	}
	if (cc->name == NULL) {
		/* invalid character class, treat as normal text */
		*ep = mismatch;
		rval = RANGE_ERROR;
	}
	return rval;
}

/* Most MBCS/collation/case issues handled here.  Wildcard '*' is not handled.
 * EOS '\0' and the FNM_PATHNAME '/' delimiters are not advanced over,
 * however the "\/" sequence is advanced to '/'.
 *
 * Both pattern and string are **char to support pointer increment of arbitrary
 * multibyte characters for the given locale, in a later iteration of this code
 */
static int fnmatch_ch(const char **pattern, const char **string, int flags)
{
	const char * const mismatch = *pattern;
	const int nocase = !!(flags & FNM_CASEFOLD);
	const int escape = !(flags & FNM_NOESCAPE);
	const int slash = !!(flags & FNM_PATHNAME);
	int result = FNM_NOMATCH;
	const char *startch;
	int negate;

	if (**pattern == '[') {
		++*pattern;

		/* Handle negation, either leading ! or ^ operators */
		negate = (**pattern == '!') || (**pattern == '^');
		if (negate)
			++*pattern;

		/* ']' is an ordinary char at the start of the range pattern */
		if (**pattern == ']')
			goto leadingclosebrace;

		while (**pattern) {
			if (**pattern == ']') {
				++*pattern;
				/* XXX: Fix for MBCS character width */
				++*string;
				return (result ^ negate);
			}

			if (escape && (**pattern == '\\')) {
				++*pattern;

				/* Patterns must terminate with ']', not EOS */
				if (!**pattern)
					break;
			}

			/* Patterns must terminate with ']' not '/' */
			if (slash && (**pattern == '/'))
				break;

			/* Match character classes. */
			switch (classmatch(*pattern, **string, nocase, pattern)) {
			case RANGE_MATCH:
				result = 0;
				continue;
			case RANGE_NOMATCH:
				/* Valid character class but no match. */
				continue;
			default:
				/* Not a valid character class. */
				break;
			}
			if (!**pattern)
				break;

leadingclosebrace:
			/* Look at only well-formed range patterns;
			 * "x-]" is not allowed unless escaped ("x-\]")
			 * XXX: Fix for locale/MBCS character width
			 */
			if (((*pattern)[1] == '-') && ((*pattern)[2] != ']')) {
				startch = *pattern;
				*pattern += (escape && ((*pattern)[2] == '\\')) ? 3 : 2;

				/*
				 * NOT a properly balanced [expr] pattern, EOS
				 * terminated or ranges containing a slash in
				 * FNM_PATHNAME mode pattern fall out to to the
				 * rewind and test '[' literal code path.
				 */
				if (!**pattern || (slash && (**pattern == '/')))
					break;

				/* XXX: handle locale/MBCS comparison, advance by MBCS char width */
				if ((**string >= *startch) && (**string <= **pattern))
					result = 0;
				else if (nocase &&
				    (isupper((unsigned char)**string) ||
				     isupper((unsigned char)*startch) ||
				     isupper((unsigned char)**pattern)) &&
				    (tolower((unsigned char)**string) >=
				     tolower((unsigned char)*startch)) &&
				    (tolower((unsigned char)**string) <=
				     tolower((unsigned char)**pattern)))
					result = 0;

				++*pattern;
				continue;
			}

			/* XXX: handle locale/MBCS comparison, advance by MBCS char width */
			if ((**string == **pattern))
				result = 0;
			else if (nocase && (isupper((unsigned char)**string) ||
			    isupper((unsigned char)**pattern)) &&
			    (tolower((unsigned char)**string) ==
			    tolower((unsigned char)**pattern)))
				result = 0;

			++*pattern;
		}
		/*
		 * NOT a properly balanced [expr] pattern;
		 * Rewind and reset result to test '[' literal
		 */
		*pattern = mismatch;
		result = FNM_NOMATCH;
	} else if (**pattern == '?') {
		/* Optimize '?' match before unescaping **pattern */
		if (!**string || (slash && (**string == '/')))
			return FNM_NOMATCH;
		result = 0;
		goto fnmatch_ch_success;
	} else if (escape && (**pattern == '\\') && (*pattern)[1]) {
		++*pattern;
	}

	/* XXX: handle locale/MBCS comparison, advance by the MBCS char width */
	if (**string == **pattern)
		result = 0;
	else if (nocase && (isupper((unsigned char)**string) ||
	    isupper((unsigned char)**pattern)) &&
	    (tolower((unsigned char)**string) ==
	    tolower((unsigned char)**pattern)))
		result = 0;

	/* Refuse to advance over trailing slash or NULs */
	if (**string == '\0' || **pattern == '\0' ||
	    (slash && ((**string == '/') || (**pattern == '/'))))
		return result;

fnmatch_ch_success:
	++*pattern;
	++*string;
	return result;
}


int fnmatch(const char *pattern, const char *string, int flags)
{
	static const char dummystring[2] = {' ', 0};
	const int escape = !(flags & FNM_NOESCAPE);
	const int slash = !!(flags & FNM_PATHNAME);
	const int leading_dir = !!(flags & FNM_LEADING_DIR);
	const char *dummyptr, *matchptr, *strendseg;
	int wild;
	/* For '*' wild processing only; surpress 'used before initialization'
	 * warnings with dummy initialization values;
	 */
	const char *strstartseg = NULL;
	const char *mismatch = NULL;
	int matchlen = 0;

	if (*pattern == '*')
		goto firstsegment;

	while (*pattern && *string) {
		/*
		 * Pre-decode "\/" which has no special significance, and
		 * match balanced slashes, starting a new segment pattern.
		 */
		if (slash && escape && (*pattern == '\\') && (pattern[1] == '/'))
			++pattern;
		if (slash && (*pattern == '/') && (*string == '/')) {
			++pattern;
			++string;
		}

firstsegment:
		/*
		 * At the beginning of each segment, validate leading period
		 * behavior.
		 */
		if ((flags & FNM_PERIOD) && (*string == '.')) {
		    if (*pattern == '.')
			    ++pattern;
		    else if (escape && (*pattern == '\\') && (pattern[1] == '.'))
			    pattern += 2;
		    else
			    return FNM_NOMATCH;
		    ++string;
		}

		/*
		 * Determine the end of string segment.  Presumes '/'
		 * character is unique, not composite in any MBCS encoding
		 */
		if (slash) {
			strendseg = strchr(string, '/');
			if (!strendseg)
				strendseg = strchr(string, '\0');
		} else {
			strendseg = strchr(string, '\0');
		}

		/*
		 * Allow pattern '*' to be consumed even with no remaining
		 * string to match.
		 */
		while (*pattern) {
			if ((string > strendseg) ||
			    ((string == strendseg) && (*pattern != '*')))
				break;

			if (slash && ((*pattern == '/') ||
			    (escape && (*pattern == '\\') && (pattern[1] == '/'))))
				break;

			/*
			 * Reduce groups of '*' and '?' to n '?' matches
			 * followed by one '*' test for simplicity.
			 */
			for (wild = 0; (*pattern == '*') || (*pattern == '?'); ++pattern) {
				if (*pattern == '*') {
					wild = 1;
				} else if (string < strendseg) {  /* && (*pattern == '?') */
					/* XXX: Advance 1 char for MBCS locale */
					++string;
				}
				else {  /* (string >= strendseg) && (*pattern == '?') */
					return FNM_NOMATCH;
				}
			}

			if (wild) {
				strstartseg = string;
				mismatch = pattern;

				/*
				 * Count fixed (non '*') char matches remaining
				 * in pattern * excluding '/' (or "\/") and '*'.
				 */
				for (matchptr = pattern, matchlen = 0; 1; ++matchlen) {
					if ((*matchptr == '\0') ||
					    (slash && ((*matchptr == '/') ||
					    (escape && (*matchptr == '\\') &&
					    (matchptr[1] == '/'))))) {
						/* Compare precisely this many
						 * trailing string chars, the
						 * resulting match needs no
						 * wildcard loop.
						 */
						/* XXX: Adjust for MBCS */
						if (string + matchlen > strendseg)
							return FNM_NOMATCH;

						string = strendseg - matchlen;
						wild = 0;
						break;
					}

					if (*matchptr == '*') {
						/*
						 * Ensure at least this many
						 * trailing string chars remain
						 * for the first comparison.
						 */
						/* XXX: Adjust for MBCS */
						if (string + matchlen > strendseg)
							return FNM_NOMATCH;

						/*
						 * Begin first wild comparison
						 * at the current position.
						 */
						break;
					}

					/*
					 * Skip forward in pattern by a single
					 * character match Use a dummy
					 * fnmatch_ch() test to count one
					 * "[range]" escape.
					 */
					/* XXX: Adjust for MBCS */
					if (escape && (*matchptr == '\\') &&
					    matchptr[1]) {
						matchptr += 2;
					} else if (*matchptr == '[') {
						dummyptr = dummystring;
						fnmatch_ch(&matchptr, &dummyptr,
						    flags);
					} else {
						++matchptr;
					}
				}
			}

			/* Incrementally match string against the pattern. */
			while (*pattern && (string < strendseg)) {
				/* Success; begin a new wild pattern search. */
				if (*pattern == '*')
					break;

				if (slash && ((*string == '/') ||
				    (*pattern == '/') || (escape &&
				    (*pattern == '\\') && (pattern[1] == '/'))))
					break;

				/*
				 * Compare ch's (the pattern is advanced over
				 * "\/" to the '/', but slashes will mismatch,
				 * and are not consumed).
				 */
				if (!fnmatch_ch(&pattern, &string, flags))
					continue;

				/*
				 * Failed to match, loop against next char
				 * offset of string segment until not enough
				 * string chars remain to match the fixed
				 * pattern.
				 */
				if (wild) {
					/* XXX: Advance 1 char for MBCS locale */
					string = ++strstartseg;
					if (string + matchlen > strendseg)
						return FNM_NOMATCH;

					pattern = mismatch;
					continue;
				} else
					return FNM_NOMATCH;
			}
		}

		if (*string && !((slash || leading_dir) && (*string == '/')))
			return FNM_NOMATCH;

		if (*pattern && !(slash && ((*pattern == '/') ||
		    (escape && (*pattern == '\\') && (pattern[1] == '/')))))
			return FNM_NOMATCH;

		if (leading_dir && !*pattern && *string == '/')
			return 0;
	}

	/* Where both pattern and string are at EOS, declare success.  */
	if (!*string && !*pattern)
		return 0;

	/* Pattern didn't match to the end of string. */
	return FNM_NOMATCH;
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: fnmatch.c,v 1.21 2016/03/01 20:29:03 millert Exp $ */
2
3			/* Copyright (c) 2011, VMware, Inc.
4			* All rights reserved.
5			*
6			* Redistribution and use in source and binary forms, with or without
7			* modification, are permitted provided that the following conditions are met:
8			* * Redistributions of source code must retain the above copyright
9			* notice, this list of conditions and the following disclaimer.
10			* * Redistributions in binary form must reproduce the above copyright
11			* notice, this list of conditions and the following disclaimer in the
12			* documentation and/or other materials provided with the distribution.
13			* * Neither the name of the VMware, Inc. nor the names of its contributors
14			* may be used to endorse or promote products derived from this software
15			* without specific prior written permission.
16			*
17			* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
18			* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20			* ARE DISCLAIMED. IN NO EVENT SHALL VMWARE, INC. OR CONTRIBUTORS BE LIABLE FOR
21			* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22			* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23			* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24			* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25			* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26			* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27			*/
28
29			/*
30			* Copyright (c) 2008, 2016 Todd C. Miller <millert@openbsd.org>
31			*
32			* Permission to use, copy, modify, and distribute this software for any
33			* purpose with or without fee is hereby granted, provided that the above
34			* copyright notice and this permission notice appear in all copies.
35			*
36			* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
37			* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
38			* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
39			* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
40			* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
41			* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
42			* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
43			*/
44
45			/* Authored by William A. Rowe Jr. <wrowe; apache.org, vmware.com>, April 2011
46			*
47			* Derived from The Open Group Base Specifications Issue 7, IEEE Std 1003.1-2008
48			* as described in;
49			* http://pubs.opengroup.org/onlinepubs/9699919799/functions/fnmatch.html
50			*
51			* Filename pattern matches defined in section 2.13, "Pattern Matching Notation"
52			* from chapter 2. "Shell Command Language"
53			* http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_13
54			* where; 1. A bracket expression starting with an unquoted <circumflex> '^'
55			* character CONTINUES to specify a non-matching list; 2. an explicit <period> '.'
56			* in a bracket expression matching list, e.g. "[.abc]" does NOT match a leading
57			* <period> in a filename; 3. a <left-square-bracket> '[' which does not introduce
58			* a valid bracket expression is treated as an ordinary character; 4. a differing
59			* number of consecutive slashes within pattern and string will NOT match;
60			* 5. a trailing '\' in FNM_ESCAPE mode is treated as an ordinary '\' character.
61			*
62			* Bracket expansion defined in section 9.3.5, "RE Bracket Expression",
63			* from chapter 9, "Regular Expressions"
64			* http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap09.html#tag_09_03_05
65			* with no support for collating symbols, equivalence class expressions or
66			* character class expressions. A partial range expression with a leading
67			* hyphen following a valid range expression will match only the ordinary
68			* <hyphen> and the ending character (e.g. "[a-m-z]" will match characters
69			* 'a' through 'm', a <hyphen> '-', or a 'z').
70			*
71			* Supports BSD extensions FNM_LEADING_DIR to match pattern to the end of one
72			* path segment of string, and FNM_CASEFOLD to ignore alpha case.
73			*
74			* NOTE: Only POSIX/C single byte locales are correctly supported at this time.
75			* Notably, non-POSIX locales with FNM_CASEFOLD produce undefined results,
76			* particularly in ranges of mixed case (e.g. "[A-z]") or spanning alpha and
77			* nonalpha characters within a range.
78			*
79			* XXX comments below indicate porting required for multi-byte character sets
80			* and non-POSIX locale collation orders; requires mbr* APIs to track shift
81			* state of pattern and string (rewinding pattern and string repeatedly).
82			*
83			* Certain parts of the code assume 0x00-0x3F are unique with any MBCS (e.g.
84			* UTF-8, SHIFT-JIS, etc). Any implementation allowing '\' as an alternate
85			* path delimiter must be aware that 0x5C is NOT unique within SHIFT-JIS.
86			*/
87
88			#include <fnmatch.h>
89			#include <string.h>
90			#include <ctype.h>
91
92			#include "charclass.h"
93
94			#define RANGE_MATCH 1
95			#define RANGE_NOMATCH 0
96			#define RANGE_ERROR (-1)
97
98			static int
99			classmatch(const char pattern, char test, int foldcase, const char *ep)
100			{
101			const char * const mismatch = pattern;
102			const char *colon;
103			struct cclass *cc;
104			int rval = RANGE_NOMATCH;
105			size_t len;
106
107			if (pattern[0] != '[' \|\| pattern[1] != ':') {
108			*ep = mismatch;
109			return RANGE_ERROR;
110			}
111			pattern += 2;
112
113			if ((colon = strchr(pattern, ':')) == NULL \|\| colon[1] != ']') {
114			*ep = mismatch;
115			return RANGE_ERROR;
116			}
117			*ep = colon + 2;
118			len = (size_t)(colon - pattern);
119
120			if (foldcase && strncmp(pattern, "upper:]", 7) == 0)
121			pattern = "lower:]";
122			for (cc = cclasses; cc->name != NULL; cc++) {
123			if (!strncmp(pattern, cc->name, len) && cc->name[len] == '\0') {
124			if (cc->isctype((unsigned char)test))
125			rval = RANGE_MATCH;
126			break;
127			}
128			}
129			if (cc->name == NULL) {
130			/* invalid character class, treat as normal text */
131			*ep = mismatch;
132			rval = RANGE_ERROR;
133			}
134			return rval;
135			}
136
137			/* Most MBCS/collation/case issues handled here. Wildcard '*' is not handled.
138			* EOS '\0' and the FNM_PATHNAME '/' delimiters are not advanced over,
139			* however the "\/" sequence is advanced to '/'.
140			*
141			* Both pattern and string are **char to support pointer increment of arbitrary
142			* multibyte characters for the given locale, in a later iteration of this code
143			*/
144			static int fnmatch_ch(const char pattern, const char string, int flags)
145			{
146			const char * const mismatch = *pattern;
147			const int nocase = !!(flags & FNM_CASEFOLD);
148			const int escape = !(flags & FNM_NOESCAPE);
149			const int slash = !!(flags & FNM_PATHNAME);
150			int result = FNM_NOMATCH;
151			const char *startch;
152			int negate;
153
154			if (**pattern == '[') {
155			++*pattern;
156
157			/* Handle negation, either leading ! or ^ operators */
158			negate = (pattern == '!') \|\| (pattern == '^');
159			if (negate)
160			++*pattern;
161
162			/* ']' is an ordinary char at the start of the range pattern */
163			if (**pattern == ']')
164			goto leadingclosebrace;
165
166			while (**pattern) {
167			if (**pattern == ']') {
168			++*pattern;
169			/* XXX: Fix for MBCS character width */
170			++*string;
171			return (result ^ negate);
172			}
173
174			if (escape && (**pattern == '\\')) {
175			++*pattern;
176
177			/* Patterns must terminate with ']', not EOS */
178			if (!**pattern)
179			break;
180			}
181
182			/* Patterns must terminate with ']' not '/' */
183			if (slash && (**pattern == '/'))
184			break;
185
186			/* Match character classes. */
187			switch (classmatch(pattern, *string, nocase, pattern)) {
188			case RANGE_MATCH:
189			result = 0;
190			continue;
191			case RANGE_NOMATCH:
192			/* Valid character class but no match. */
193			continue;
194			default:
195			/* Not a valid character class. */
196			break;
197			}
198			if (!**pattern)
199			break;
200
201			leadingclosebrace:
202			/* Look at only well-formed range patterns;
203			* "x-]" is not allowed unless escaped ("x-\]")
204			* XXX: Fix for locale/MBCS character width
205			*/
206			if (((pattern)[1] == '-') && ((pattern)[2] != ']')) {
207			startch = *pattern;
208			pattern += (escape && ((pattern)[2] == '\\')) ? 3 : 2;
209
210			/*
211			* NOT a properly balanced [expr] pattern, EOS
212			* terminated or ranges containing a slash in
213			* FNM_PATHNAME mode pattern fall out to to the
214			* rewind and test '[' literal code path.
215			*/
216			if (!pattern \|\| (slash && (pattern == '/')))
217			break;
218
219			/* XXX: handle locale/MBCS comparison, advance by MBCS char width */
220			if ((*string >= startch) && (string <= pattern))
221			result = 0;
222			else if (nocase &&
223			(isupper((unsigned char)**string) \|\|
224			isupper((unsigned char)*startch) \|\|
225			isupper((unsigned char)**pattern)) &&
226			(tolower((unsigned char)**string) >=
227			tolower((unsigned char)*startch)) &&
228			(tolower((unsigned char)**string) <=
229			tolower((unsigned char)**pattern)))
230			result = 0;
231
232			++*pattern;
233			continue;
234			}
235
236			/* XXX: handle locale/MBCS comparison, advance by MBCS char width */
237			if ((string == pattern))
238			result = 0;
239			else if (nocase && (isupper((unsigned char)**string) \|\|
240			isupper((unsigned char)**pattern)) &&
241			(tolower((unsigned char)**string) ==
242			tolower((unsigned char)**pattern)))
243			result = 0;
244
245			++*pattern;
246			}
247			/*
248			* NOT a properly balanced [expr] pattern;
249			* Rewind and reset result to test '[' literal
250			*/
251			*pattern = mismatch;
252			result = FNM_NOMATCH;
253			} else if (**pattern == '?') {
254			/* Optimize '?' match before unescaping *pattern /
255			if (!string \|\| (slash && (string == '/')))
256			return FNM_NOMATCH;
257			result = 0;
258			goto fnmatch_ch_success;
259			} else if (escape && (*pattern == '\\') && (pattern)[1]) {
260			++*pattern;
261			}
262
263			/* XXX: handle locale/MBCS comparison, advance by the MBCS char width */
264			if (string == pattern)
265			result = 0;
266			else if (nocase && (isupper((unsigned char)**string) \|\|
267			isupper((unsigned char)**pattern)) &&
268			(tolower((unsigned char)**string) ==
269			tolower((unsigned char)**pattern)))
270			result = 0;
271
272			/* Refuse to advance over trailing slash or NULs */
273			if (string == '\0' \|\| pattern == '\0' \|\|
274			(slash && ((string == '/') \|\| (pattern == '/'))))
275			return result;
276
277			fnmatch_ch_success:
278			++*pattern;
279			++*string;
280			return result;
281			}
282
283
284			int fnmatch(const char pattern, const char string, int flags)
285			{
286			static const char dummystring[2] = {' ', 0};
287			const int escape = !(flags & FNM_NOESCAPE);
288			const int slash = !!(flags & FNM_PATHNAME);
289			const int leading_dir = !!(flags & FNM_LEADING_DIR);
290			const char dummyptr, matchptr, *strendseg;
291			int wild;
292			/* For '*' wild processing only; surpress 'used before initialization'
293			* warnings with dummy initialization values;
294			*/
295			const char *strstartseg = NULL;
296			const char *mismatch = NULL;
297			int matchlen = 0;
298
299			if (pattern == '')
300			goto firstsegment;
301
302			while (pattern && string) {
303			/*
304			* Pre-decode "\/" which has no special significance, and
305			* match balanced slashes, starting a new segment pattern.
306			*/
307			if (slash && escape && (*pattern == '\\') && (pattern[1] == '/'))
308			++pattern;
309			if (slash && (pattern == '/') && (string == '/')) {
310			++pattern;
311			++string;
312			}
313
314			firstsegment:
315			/*
316			* At the beginning of each segment, validate leading period
317			* behavior.
318			*/
319			if ((flags & FNM_PERIOD) && (*string == '.')) {
320			if (*pattern == '.')
321			++pattern;
322			else if (escape && (*pattern == '\\') && (pattern[1] == '.'))
323			pattern += 2;
324			else
325			return FNM_NOMATCH;
326			++string;
327			}
328
329			/*
330			* Determine the end of string segment. Presumes '/'
331			* character is unique, not composite in any MBCS encoding
332			*/
333			if (slash) {
334			strendseg = strchr(string, '/');
335			if (!strendseg)
336			strendseg = strchr(string, '\0');
337			} else {
338			strendseg = strchr(string, '\0');
339			}
340
341			/*
342			* Allow pattern '*' to be consumed even with no remaining
343			* string to match.
344			*/
345			while (*pattern) {
346			if ((string > strendseg) \|\|
347			((string == strendseg) && (pattern != '')))
348			break;
349
350			if (slash && ((*pattern == '/') \|\|
351			(escape && (*pattern == '\\') && (pattern[1] == '/'))))
352			break;
353
354			/*
355			* Reduce groups of '*' and '?' to n '?' matches
356			* followed by one '*' test for simplicity.
357			*/
358			for (wild = 0; (pattern == '') \|\| (*pattern == '?'); ++pattern) {
359			if (pattern == '') {
360			wild = 1;
361			} else if (string < strendseg) { /* && (pattern == '?') /
362			/* XXX: Advance 1 char for MBCS locale */
363			++string;
364			}
365			else { /* (string >= strendseg) && (pattern == '?') /
366			return FNM_NOMATCH;
367			}
368			}
369
370			if (wild) {
371			strstartseg = string;
372			mismatch = pattern;
373
374			/*
375			* Count fixed (non '*') char matches remaining
376			* in pattern * excluding '/' (or "\/") and '*'.
377			*/
378			for (matchptr = pattern, matchlen = 0; 1; ++matchlen) {
379			if ((*matchptr == '\0') \|\|
380			(slash && ((*matchptr == '/') \|\|
381			(escape && (*matchptr == '\\') &&
382			(matchptr[1] == '/'))))) {
383			/* Compare precisely this many
384			* trailing string chars, the
385			* resulting match needs no
386			* wildcard loop.
387			*/
388			/* XXX: Adjust for MBCS */
389			if (string + matchlen > strendseg)
390			return FNM_NOMATCH;
391
392			string = strendseg - matchlen;
393			wild = 0;
394			break;
395			}
396
397			if (matchptr == '') {
398			/*
399			* Ensure at least this many
400			* trailing string chars remain
401			* for the first comparison.
402			*/
403			/* XXX: Adjust for MBCS */
404			if (string + matchlen > strendseg)
405			return FNM_NOMATCH;
406
407			/*
408			* Begin first wild comparison
409			* at the current position.
410			*/
411			break;
412			}
413
414			/*
415			* Skip forward in pattern by a single
416			* character match Use a dummy
417			* fnmatch_ch() test to count one
418			* "[range]" escape.
419			*/
420			/* XXX: Adjust for MBCS */
421			if (escape && (*matchptr == '\\') &&
422			matchptr[1]) {
423			matchptr += 2;
424			} else if (*matchptr == '[') {
425			dummyptr = dummystring;
426			fnmatch_ch(&matchptr, &dummyptr,
427			flags);
428			} else {
429			++matchptr;
430			}
431			}
432			}
433
434			/* Incrementally match string against the pattern. */
435			while (*pattern && (string < strendseg)) {
436			/* Success; begin a new wild pattern search. */
437			if (pattern == '')
438			break;
439
440			if (slash && ((*string == '/') \|\|
441			(*pattern == '/') \|\| (escape &&
442			(*pattern == '\\') && (pattern[1] == '/'))))
443			break;
444
445			/*
446			* Compare ch's (the pattern is advanced over
447			* "\/" to the '/', but slashes will mismatch,
448			* and are not consumed).
449			*/
450			if (!fnmatch_ch(&pattern, &string, flags))
451			continue;
452
453			/*
454			* Failed to match, loop against next char
455			* offset of string segment until not enough
456			* string chars remain to match the fixed
457			* pattern.
458			*/
459			if (wild) {
460			/* XXX: Advance 1 char for MBCS locale */
461			string = ++strstartseg;
462			if (string + matchlen > strendseg)
463			return FNM_NOMATCH;
464
465			pattern = mismatch;
466			continue;
467			} else
468			return FNM_NOMATCH;
469			}
470			}
471
472			if (string && !((slash \|\| leading_dir) && (string == '/')))
473			return FNM_NOMATCH;
474
475			if (pattern && !(slash && ((pattern == '/') \|\|
476			(escape && (*pattern == '\\') && (pattern[1] == '/')))))
477			return FNM_NOMATCH;
478
479			if (leading_dir && !pattern && string == '/')
480			return 0;
481			}
482
483			/* Where both pattern and string are at EOS, declare success. */
484			if (!string && !pattern)
485			return 0;
486
487			/* Pattern didn't match to the end of string. */
488			return FNM_NOMATCH;
489			}