From 60b6415214b5debc00909482a0c9d01dffe3f06a Mon Sep 17 00:00:00 2001 From: Stephen Heumann Date: Tue, 18 Nov 2014 20:51:04 -0600 Subject: [PATCH] Add our own implementation of fnmatch (taken from NetBSD), because the one in GNO 2.0.6's libc is broken. The version in libc both matches things it shouldn't and doesn't match things it should, in (at least) cases where a pattern includes additional stuff beyond a *. --- Makefile | 11 ++- Makefile.gmake | 1 + shell/fnmatch.c | 238 ++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 245 insertions(+), 5 deletions(-) create mode 100644 shell/fnmatch.c diff --git a/Makefile b/Makefile index 913b96c46..ab1ad5305 100644 --- a/Makefile +++ b/Makefile @@ -8,7 +8,8 @@ SHELL_OTHER_SRC = \ shell/math.c \ shell/random.c \ shell/shell.common.c \ - shell/glob.c + shell/glob.c \ + shell/fnmatch.c COREUTILS_SRC = \ coreutils/echo.c \ @@ -89,10 +90,10 @@ LIBBB_D_SEG = -SLIBBB_C___ INCLUDES = -I include -I shell -I libbb DEFINES = -Dhush_main=main -DNDEBUG -// This should be the ltermcap from GNO 2.0.4. The one from 2.0.6 is broken -// (links to unimplemented functions), so don't use it. -// The 2.0.4 version is in the "lib.shk" file within -// ftp://ftp.gno.org/pub/apple2/gs.specific/gno/base/v204/gnodisk1.sdk +# This should be the ltermcap from GNO 2.0.4. The one from 2.0.6 is broken +# (links to unimplemented functions), so don't use it. +# The 2.0.4 version is in the "lib.shk" file within +# ftp://ftp.gno.org/pub/apple2/gs.specific/gno/base/v204/gnodisk1.sdk LIBS = -l/usr/lib/libtermcap.204 # Hack to effectively disable close_on_exec_on method for now. diff --git a/Makefile.gmake b/Makefile.gmake index 744872fac..144c5d227 100644 --- a/Makefile.gmake +++ b/Makefile.gmake @@ -5,6 +5,7 @@ SRCS = \ shell/random.c \ shell/shell.common.c \ shell/glob.c \ + shell/fnmatch.c \ coreutils/echo.c \ coreutils/test.c \ coreutils/test.ptr.hack.c \ diff --git a/shell/fnmatch.c b/shell/fnmatch.c new file mode 100644 index 000000000..5fe929057 --- /dev/null +++ b/shell/fnmatch.c @@ -0,0 +1,238 @@ +/* $NetBSD: fnmatch.c,v 1.26 2014/10/12 22:32:33 christos Exp $ */ + +/* + * Copyright (c) 1989, 1993, 1994 + * 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. + */ + +#include +#if defined(LIBC_SCCS) && !defined(lint) +#if 0 +static char sccsid[] = "@(#)fnmatch.c 8.2 (Berkeley) 4/16/94"; +#else +__RCSID("$NetBSD: fnmatch.c,v 1.26 2014/10/12 22:32:33 christos Exp $"); +#endif +#endif /* LIBC_SCCS and not lint */ + +/* + * Function fnmatch() as specified in POSIX 1003.2-1992, section B.6. + * Compares a filename or pathname to a pattern. + */ + +#include +#include +#include +#include + +#ifndef _DIAGASSERT +# define _DIAGASSERT(x) +#endif + +#ifndef FNM_NORES +# define FNM_NORES 3 /* Error return code: Out of resources */ +#endif + +#if defined(__GNO__) && !defined(FNM_LEADING_DIR) +# define FNM_LEADING_DIR (FNM_CASEFOLD << 1) /* Flag: Ignore / after Imatch. */ +#endif + +#ifndef __GNO__ +# define FNMATCH_RECURSION_LIMIT 64 +#else +# define FNMATCH_RECURSION_LIMIT 10 +#endif + +#ifdef __weak_alias +__weak_alias(fnmatch,_fnmatch) +#endif + +#define EOS '\0' + +static int +foldcase(int ch, int flags) +{ + + if ((flags & FNM_CASEFOLD) != 0 && isupper(ch)) + return tolower(ch); + return ch; +} + +#define FOLDCASE(ch, flags) foldcase((unsigned char)(ch), (flags)) + +static const char * +rangematch(const char *pattern, int test, int flags) +{ + int negate, ok, need; + char c, c2; + + _DIAGASSERT(pattern != NULL); + + /* + * A bracket expression starting with an unquoted circumflex + * character produces unspecified results (IEEE 1003.2-1992, + * 3.13.2). This implementation treats it like '!', for + * consistency with the regular expression syntax. + * J.T. Conklin (conklin@ngai.kaleida.com) + */ + if ((negate = (*pattern == '!' || *pattern == '^')) != 0) + ++pattern; + + need = 1; + for (ok = 0; (c = FOLDCASE(*pattern++, flags)) != ']' || need;) { + need = 0; + if (c == '/') + return (void *)-1; + if (c == '\\' && !(flags & FNM_NOESCAPE)) + c = FOLDCASE(*pattern++, flags); + if (c == EOS) + return NULL; + if (*pattern == '-' + && (c2 = FOLDCASE(*(pattern + 1), flags)) != EOS && + c2 != ']') { + pattern += 2; + if (c2 == '\\' && !(flags & FNM_NOESCAPE)) + c2 = FOLDCASE(*pattern++, flags); + if (c2 == EOS) + return NULL; + if (c <= test && test <= c2) + ok = 1; + } else if (c == test) + ok = 1; + } + return ok == negate ? NULL : pattern; +} + + +static int +fnmatchx(const char *pattern, const char *string, int flags, size_t recursion) +{ + const char *stringstart, *r; + char c, test; + + _DIAGASSERT(pattern != NULL); + _DIAGASSERT(string != NULL); + + if (recursion-- == 0) + return FNM_NORES; + + for (stringstart = string;;) { + switch (c = FOLDCASE(*pattern++, flags)) { + case EOS: + if ((flags & FNM_LEADING_DIR) && *string == '/') + return 0; + return *string == EOS ? 0 : FNM_NOMATCH; + case '?': + if (*string == EOS) + return FNM_NOMATCH; + if (*string == '/' && (flags & FNM_PATHNAME)) + return FNM_NOMATCH; + if (*string == '.' && (flags & FNM_PERIOD) && + (string == stringstart || + ((flags & FNM_PATHNAME) && *(string - 1) == '/'))) + return FNM_NOMATCH; + ++string; + break; + case '*': + c = FOLDCASE(*pattern, flags); + /* Collapse multiple stars. */ + while (c == '*') + c = FOLDCASE(*++pattern, flags); + + if (*string == '.' && (flags & FNM_PERIOD) && + (string == stringstart || + ((flags & FNM_PATHNAME) && *(string - 1) == '/'))) + return FNM_NOMATCH; + + /* Optimize for pattern with * at end or before /. */ + if (c == EOS) { + if (flags & FNM_PATHNAME) + return (flags & FNM_LEADING_DIR) || + strchr(string, '/') == NULL ? + 0 : FNM_NOMATCH; + else + return 0; + } else if (c == '/' && flags & FNM_PATHNAME) { + if ((string = strchr(string, '/')) == NULL) + return FNM_NOMATCH; + break; + } + + /* General case, use recursion. */ + while ((test = FOLDCASE(*string, flags)) != EOS) { + int e; + switch ((e = fnmatchx(pattern, string, + flags & ~FNM_PERIOD, recursion))) { + case FNM_NOMATCH: + break; + default: + return e; + } + if (test == '/' && flags & FNM_PATHNAME) + break; + ++string; + } + return FNM_NOMATCH; + case '[': + if (*string == EOS) + return FNM_NOMATCH; + if (*string == '/' && flags & FNM_PATHNAME) + return FNM_NOMATCH; + if ((r = rangematch(pattern, + FOLDCASE(*string, flags), flags)) == NULL) + return FNM_NOMATCH; + if (r == (void *)-1) { + if (*string != '[') + return FNM_NOMATCH; + } else + pattern = r; + ++string; + break; + case '\\': + if (!(flags & FNM_NOESCAPE)) { + if ((c = FOLDCASE(*pattern++, flags)) == EOS) { + c = '\0'; + --pattern; + } + } + /* FALLTHROUGH */ + default: + if (c != FOLDCASE(*string++, flags)) + return FNM_NOMATCH; + break; + } + } + /* NOTREACHED */ +} + +int +fnmatch(const char *pattern, const char *string, int flags) +{ + return fnmatchx(pattern, string, flags, FNMATCH_RECURSION_LIMIT); +}