937a200089
This is actually a fully functional build except: * All internal shared libraries are static linked to make sure there is no interference with ports (and to reduce build time). * It does not have the python/perl/etc plugin or API support. * By default, it installs as "svnlite" rather than "svn". * If WITH_SVN added in make.conf, you get "svn". * If WITHOUT_SVNLITE is in make.conf, this is completely disabled. To be absolutely clear, this is not intended for any use other than checking out freebsd source and committing, like we once did with cvs. It should be usable for small scale local repositories that don't need the python/perl plugin architecture.
483 lines
17 KiB
C
483 lines
17 KiB
C
/* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|
* this work for additional information regarding copyright ownership.
|
|
* The ASF licenses this file to You under the Apache License, Version 2.0
|
|
* (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
|
|
/* 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').
|
|
*
|
|
* 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 "apr_file_info.h"
|
|
#include "apr_fnmatch.h"
|
|
#include "apr_tables.h"
|
|
#include "apr_lib.h"
|
|
#include "apr_strings.h"
|
|
#include <string.h>
|
|
#if APR_HAVE_CTYPE_H
|
|
# include <ctype.h>
|
|
#endif
|
|
|
|
|
|
/* 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 APR_INLINE int fnmatch_ch(const char **pattern, const char **string, int flags)
|
|
{
|
|
const char * const mismatch = *pattern;
|
|
const int nocase = !!(flags & APR_FNM_CASE_BLIND);
|
|
const int escape = !(flags & APR_FNM_NOESCAPE);
|
|
const int slash = !!(flags & APR_FNM_PATHNAME);
|
|
int result = APR_FNM_NOMATCH;
|
|
const char *startch;
|
|
int negate;
|
|
|
|
if (**pattern == '[')
|
|
{
|
|
++*pattern;
|
|
|
|
/* Handle negation, either leading ! or ^ operators (never both) */
|
|
negate = ((**pattern == '!') || (**pattern == '^'));
|
|
if (negate)
|
|
++*pattern;
|
|
|
|
/* ']' is an ordinary character 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 be terminated with ']', not EOS */
|
|
if (!**pattern)
|
|
break;
|
|
}
|
|
|
|
/* Patterns must be terminated with ']' not '/' */
|
|
if (slash && (**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(**string) || isupper(*startch)
|
|
|| isupper(**pattern))
|
|
&& (tolower(**string) >= tolower(*startch))
|
|
&& (tolower(**string) <= tolower(**pattern)))
|
|
result = 0;
|
|
|
|
++*pattern;
|
|
continue;
|
|
}
|
|
|
|
/* XXX: handle locale/MBCS comparison, advance by MBCS char width */
|
|
if ((**string == **pattern))
|
|
result = 0;
|
|
else if (nocase && (isupper(**string) || isupper(**pattern))
|
|
&& (tolower(**string) == tolower(**pattern)))
|
|
result = 0;
|
|
|
|
++*pattern;
|
|
}
|
|
|
|
/* NOT a properly balanced [expr] pattern; Rewind
|
|
* and reset result to test '[' literal
|
|
*/
|
|
*pattern = mismatch;
|
|
result = APR_FNM_NOMATCH;
|
|
}
|
|
else if (**pattern == '?') {
|
|
/* Optimize '?' match before unescaping **pattern */
|
|
if (!**string || (slash && (**string == '/')))
|
|
return APR_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(**string) || isupper(**pattern))
|
|
&& (tolower(**string) == tolower(**pattern)))
|
|
result = 0;
|
|
|
|
/* Refuse to advance over trailing slash or nulls
|
|
*/
|
|
if (!**string || !**pattern || (slash && ((**string == '/') || (**pattern == '/'))))
|
|
return result;
|
|
|
|
fnmatch_ch_success:
|
|
++*pattern;
|
|
++*string;
|
|
return result;
|
|
}
|
|
|
|
|
|
APR_DECLARE(int) apr_fnmatch(const char *pattern, const char *string, int flags)
|
|
{
|
|
static const char dummystring[2] = {' ', 0};
|
|
const int escape = !(flags & APR_FNM_NOESCAPE);
|
|
const int slash = !!(flags & APR_FNM_PATHNAME);
|
|
const char *strendseg;
|
|
const char *dummyptr;
|
|
const char *matchptr;
|
|
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 & APR_FNM_PERIOD) && (*string == '.'))
|
|
{
|
|
if (*pattern == '.')
|
|
++pattern;
|
|
else if (escape && (*pattern == '\\') && (pattern[1] == '.'))
|
|
pattern += 2;
|
|
else
|
|
return APR_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 APR_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 APR_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 APR_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 APR_FNM_NOMATCH;
|
|
|
|
pattern = mismatch;
|
|
continue;
|
|
}
|
|
else
|
|
return APR_FNM_NOMATCH;
|
|
}
|
|
}
|
|
|
|
if (*string && !(slash && (*string == '/')))
|
|
return APR_FNM_NOMATCH;
|
|
|
|
if (*pattern && !(slash && ((*pattern == '/')
|
|
|| (escape && (*pattern == '\\')
|
|
&& (pattern[1] == '/')))))
|
|
return APR_FNM_NOMATCH;
|
|
}
|
|
|
|
/* 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 APR_FNM_NOMATCH;
|
|
}
|
|
|
|
|
|
/* This function is an Apache addition
|
|
* return non-zero if pattern has any glob chars in it
|
|
* @bug Function does not distinguish for FNM_PATHNAME mode, which renders
|
|
* a false positive for test[/]this (which is not a range, but
|
|
* seperate test[ and ]this segments and no glob.)
|
|
* @bug Function does not distinguish for non-FNM_ESCAPE mode.
|
|
* @bug Function does not parse []] correctly
|
|
* Solution may be to use fnmatch_ch() to walk the patterns?
|
|
*/
|
|
APR_DECLARE(int) apr_fnmatch_test(const char *pattern)
|
|
{
|
|
int nesting;
|
|
|
|
nesting = 0;
|
|
while (*pattern) {
|
|
switch (*pattern) {
|
|
case '?':
|
|
case '*':
|
|
return 1;
|
|
|
|
case '\\':
|
|
if (*++pattern == '\0') {
|
|
return 0;
|
|
}
|
|
break;
|
|
|
|
case '[': /* '[' is only a glob if it has a matching ']' */
|
|
++nesting;
|
|
break;
|
|
|
|
case ']':
|
|
if (nesting) {
|
|
return 1;
|
|
}
|
|
break;
|
|
}
|
|
++pattern; }
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* Find all files matching the specified pattern */
|
|
APR_DECLARE(apr_status_t) apr_match_glob(const char *pattern,
|
|
apr_array_header_t **result,
|
|
apr_pool_t *p)
|
|
{
|
|
apr_dir_t *dir;
|
|
apr_finfo_t finfo;
|
|
apr_status_t rv;
|
|
char *path;
|
|
|
|
/* XXX So, this is kind of bogus. Basically, I need to strip any leading
|
|
* directories off the pattern, but there is no portable way to do that.
|
|
* So, for now we just find the last occurance of '/' and if that doesn't
|
|
* return anything, then we look for '\'. This means that we could
|
|
* screw up on unix if the pattern is something like "foo\.*" That '\'
|
|
* isn't a directory delimiter, it is a part of the filename. To fix this,
|
|
* we really need apr_filepath_basename, which will be coming as soon as
|
|
* I get to it. rbb
|
|
*/
|
|
char *idx = strrchr(pattern, '/');
|
|
|
|
if (idx == NULL) {
|
|
idx = strrchr(pattern, '\\');
|
|
}
|
|
if (idx == NULL) {
|
|
path = ".";
|
|
}
|
|
else {
|
|
path = apr_pstrndup(p, pattern, idx - pattern);
|
|
pattern = idx + 1;
|
|
}
|
|
|
|
*result = apr_array_make(p, 0, sizeof(char *));
|
|
rv = apr_dir_open(&dir, path, p);
|
|
if (rv != APR_SUCCESS) {
|
|
return rv;
|
|
}
|
|
|
|
while (apr_dir_read(&finfo, APR_FINFO_NAME, dir) == APR_SUCCESS) {
|
|
if (apr_fnmatch(pattern, finfo.name, 0) == APR_SUCCESS) {
|
|
*(const char **)apr_array_push(*result) = apr_pstrdup(p, finfo.name);
|
|
}
|
|
}
|
|
apr_dir_close(dir);
|
|
return APR_SUCCESS;
|
|
}
|