mirror of
https://git.tartarus.org/simon/putty.git
synced 2025-01-10 01:48:00 +00:00
3396c97da9
Now that the new CMake build system is encouraging us to lay out the code like a set of libraries, it seems like a good idea to make them look more _like_ libraries, by putting things into separate modules as far as possible. This fixes several previous annoyances in which you had to link against some object in order to get a function you needed, but that object also contained other functions you didn't need which included link-time symbol references you didn't want to have to deal with. The usual offender was subsidiary supporting programs including misc.c for some innocuous function and then finding they had to deal with the requirements of buildinfo(). This big reorganisation introduces three new subdirectories called 'utils', one at the top level and one in each platform subdir. In each case, the directory contains basically the same files that were previously placed in the 'utils' build-time library, except that the ones that were extremely miscellaneous (misc.c, utils.c, uxmisc.c, winmisc.c, winmiscs.c, winutils.c) have been split up into much smaller pieces.
487 lines
16 KiB
C
487 lines
16 KiB
C
/*
|
|
* Wildcard matching engine for use with SFTP-based file transfer
|
|
* programs (PSFTP, new-look PSCP): since SFTP has no notion of
|
|
* getting the remote side to do globbing (and rightly so) we have
|
|
* to do it locally, by retrieving all the filenames in a directory
|
|
* and checking each against the wildcard pattern.
|
|
*/
|
|
|
|
#include <assert.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "putty.h"
|
|
|
|
/*
|
|
* Definition of wildcard syntax:
|
|
*
|
|
* - * matches any sequence of characters, including zero.
|
|
* - ? matches exactly one character which can be anything.
|
|
* - [abc] matches exactly one character which is a, b or c.
|
|
* - [a-f] matches anything from a through f.
|
|
* - [^a-f] matches anything _except_ a through f.
|
|
* - [-_] matches - or _; [^-_] matches anything else. (The - is
|
|
* non-special if it occurs immediately after the opening
|
|
* bracket or ^.)
|
|
* - [a^] matches an a or a ^. (The ^ is non-special if it does
|
|
* _not_ occur immediately after the opening bracket.)
|
|
* - \*, \?, \[, \], \\ match the single characters *, ?, [, ], \.
|
|
* - All other characters are non-special and match themselves.
|
|
*/
|
|
|
|
/*
|
|
* Some notes on differences from POSIX globs (IEEE Std 1003.1, 2003 ed.):
|
|
* - backslashes act as escapes even within [] bracket expressions
|
|
* - does not support [!...] for non-matching list (POSIX are weird);
|
|
* NB POSIX allows [^...] as well via "A bracket expression starting
|
|
* with an unquoted circumflex character produces unspecified
|
|
* results". If we wanted to allow [!...] we might want to define
|
|
* [^!] as having its literal meaning (match '^' or '!').
|
|
* - none of the scary [[:class:]] stuff, etc
|
|
*/
|
|
|
|
/*
|
|
* The wildcard matching technique we use is very simple and
|
|
* potentially O(N^2) in running time, but I don't anticipate it
|
|
* being that bad in reality (particularly since N will be the size
|
|
* of a filename, which isn't all that much). Perhaps one day, once
|
|
* PuTTY has grown a regexp matcher for some other reason, I might
|
|
* come back and reimplement wildcards by translating them into
|
|
* regexps or directly into NFAs; but for the moment, in the
|
|
* absence of any other need for the NFA->DFA translation engine,
|
|
* anything more than the simplest possible wildcard matcher is
|
|
* vast code-size overkill.
|
|
*
|
|
* Essentially, these wildcards are much simpler than regexps in
|
|
* that they consist of a sequence of rigid fragments (? and [...]
|
|
* can never match more or less than one character) separated by
|
|
* asterisks. It is therefore extremely simple to look at a rigid
|
|
* fragment and determine whether or not it begins at a particular
|
|
* point in the test string; so we can search along the string
|
|
* until we find each fragment, then search for the next. As long
|
|
* as we find each fragment in the _first_ place it occurs, there
|
|
* will never be a danger of having to backpedal and try to find it
|
|
* again somewhere else.
|
|
*/
|
|
|
|
enum {
|
|
WC_TRAILINGBACKSLASH = 1,
|
|
WC_UNCLOSEDCLASS,
|
|
WC_INVALIDRANGE
|
|
};
|
|
|
|
/*
|
|
* Error reporting is done by returning various negative values
|
|
* from the wildcard routines. Passing any such value to wc_error
|
|
* will give a human-readable message.
|
|
*/
|
|
const char *wc_error(int value)
|
|
{
|
|
value = abs(value);
|
|
switch (value) {
|
|
case WC_TRAILINGBACKSLASH:
|
|
return "'\' occurred at end of string (expected another character)";
|
|
case WC_UNCLOSEDCLASS:
|
|
return "expected ']' to close character class";
|
|
case WC_INVALIDRANGE:
|
|
return "character range was not terminated (']' just after '-')";
|
|
}
|
|
return "INTERNAL ERROR: unrecognised wildcard error number";
|
|
}
|
|
|
|
/*
|
|
* This is the routine that tests a target string to see if an
|
|
* initial substring of it matches a fragment. If successful, it
|
|
* returns 1, and advances both `fragment' and `target' past the
|
|
* fragment and matching substring respectively. If unsuccessful it
|
|
* returns zero. If the wildcard fragment suffers a syntax error,
|
|
* it returns <0 and the precise value indexes into wc_error.
|
|
*/
|
|
static int wc_match_fragment(const char **fragment, const char **target,
|
|
const char *target_end)
|
|
{
|
|
const char *f, *t;
|
|
|
|
f = *fragment;
|
|
t = *target;
|
|
/*
|
|
* The fragment terminates at either the end of the string, or
|
|
* the first (unescaped) *.
|
|
*/
|
|
while (*f && *f != '*' && t < target_end) {
|
|
/*
|
|
* Extract one character from t, and one character's worth
|
|
* of pattern from f, and step along both. Return 0 if they
|
|
* fail to match.
|
|
*/
|
|
if (*f == '\\') {
|
|
/*
|
|
* Backslash, which means f[1] is to be treated as a
|
|
* literal character no matter what it is. It may not
|
|
* be the end of the string.
|
|
*/
|
|
if (!f[1])
|
|
return -WC_TRAILINGBACKSLASH; /* error */
|
|
if (f[1] != *t)
|
|
return 0; /* failed to match */
|
|
f += 2;
|
|
} else if (*f == '?') {
|
|
/*
|
|
* Question mark matches anything.
|
|
*/
|
|
f++;
|
|
} else if (*f == '[') {
|
|
bool invert = false;
|
|
bool matched = false;
|
|
/*
|
|
* Open bracket introduces a character class.
|
|
*/
|
|
f++;
|
|
if (*f == '^') {
|
|
invert = true;
|
|
f++;
|
|
}
|
|
while (*f != ']') {
|
|
if (*f == '\\')
|
|
f++; /* backslashes still work */
|
|
if (!*f)
|
|
return -WC_UNCLOSEDCLASS; /* error again */
|
|
if (f[1] == '-') {
|
|
int lower, upper, ourchr;
|
|
lower = (unsigned char) *f++;
|
|
f++; /* eat the minus */
|
|
if (*f == ']')
|
|
return -WC_INVALIDRANGE; /* different error! */
|
|
if (*f == '\\')
|
|
f++; /* backslashes _still_ work */
|
|
if (!*f)
|
|
return -WC_UNCLOSEDCLASS; /* error again */
|
|
upper = (unsigned char) *f++;
|
|
ourchr = (unsigned char) *t;
|
|
if (lower > upper) {
|
|
int t = lower; lower = upper; upper = t;
|
|
}
|
|
if (ourchr >= lower && ourchr <= upper)
|
|
matched = true;
|
|
} else {
|
|
matched |= (*t == *f++);
|
|
}
|
|
}
|
|
if (invert == matched)
|
|
return 0; /* failed to match character class */
|
|
f++; /* eat the ] */
|
|
} else {
|
|
/*
|
|
* Non-special character matches itself.
|
|
*/
|
|
if (*f != *t)
|
|
return 0;
|
|
f++;
|
|
}
|
|
/*
|
|
* Now we've done that, increment t past the character we
|
|
* matched.
|
|
*/
|
|
t++;
|
|
}
|
|
if (!*f || *f == '*') {
|
|
/*
|
|
* We have reached the end of f without finding a mismatch;
|
|
* so we're done. Update the caller pointers and return 1.
|
|
*/
|
|
*fragment = f;
|
|
*target = t;
|
|
return 1;
|
|
}
|
|
/*
|
|
* Otherwise, we must have reached the end of t before we
|
|
* reached the end of f; so we've failed. Return 0.
|
|
*/
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* This is the real wildcard matching routine. It returns 1 for a
|
|
* successful match, 0 for an unsuccessful match, and <0 for a
|
|
* syntax error in the wildcard.
|
|
*/
|
|
static int wc_match_inner(
|
|
const char *wildcard, const char *target, size_t target_len)
|
|
{
|
|
const char *target_end = target + target_len;
|
|
int ret;
|
|
|
|
/*
|
|
* Every time we see a '*' _followed_ by a fragment, we just
|
|
* search along the string for a location at which the fragment
|
|
* matches. The only special case is when we see a fragment
|
|
* right at the start, in which case we just call the matching
|
|
* routine once and give up if it fails.
|
|
*/
|
|
if (*wildcard != '*') {
|
|
ret = wc_match_fragment(&wildcard, &target, target_end);
|
|
if (ret <= 0)
|
|
return ret; /* pass back failure or error alike */
|
|
}
|
|
|
|
while (*wildcard) {
|
|
assert(*wildcard == '*');
|
|
while (*wildcard == '*')
|
|
wildcard++;
|
|
|
|
/*
|
|
* It's possible we've just hit the end of the wildcard
|
|
* after seeing a *, in which case there's no need to
|
|
* bother searching any more because we've won.
|
|
*/
|
|
if (!*wildcard)
|
|
return 1;
|
|
|
|
/*
|
|
* Now `wildcard' points at the next fragment. So we
|
|
* attempt to match it against `target', and if that fails
|
|
* we increment `target' and try again, and so on. When we
|
|
* find we're about to try matching against the empty
|
|
* string, we give up and return 0.
|
|
*/
|
|
ret = 0;
|
|
while (*target) {
|
|
const char *save_w = wildcard, *save_t = target;
|
|
|
|
ret = wc_match_fragment(&wildcard, &target, target_end);
|
|
|
|
if (ret < 0)
|
|
return ret; /* syntax error */
|
|
|
|
if (ret > 0 && !*wildcard && target != target_end) {
|
|
/*
|
|
* Final special case - literally.
|
|
*
|
|
* This situation arises when we are matching a
|
|
* _terminal_ fragment of the wildcard (that is,
|
|
* there is nothing after it, e.g. "*a"), and it
|
|
* has matched _too early_. For example, matching
|
|
* "*a" against "parka" will match the "a" fragment
|
|
* against the _first_ a, and then (if it weren't
|
|
* for this special case) matching would fail
|
|
* because we're at the end of the wildcard but not
|
|
* at the end of the target string.
|
|
*
|
|
* In this case what we must do is measure the
|
|
* length of the fragment in the target (which is
|
|
* why we saved `target'), jump straight to that
|
|
* distance from the end of the string using
|
|
* strlen, and match the same fragment again there
|
|
* (which is why we saved `wildcard'). Then we
|
|
* return whatever that operation returns.
|
|
*/
|
|
target = target_end - (target - save_t);
|
|
wildcard = save_w;
|
|
return wc_match_fragment(&wildcard, &target, target_end);
|
|
}
|
|
|
|
if (ret > 0)
|
|
break;
|
|
target++;
|
|
}
|
|
if (ret > 0)
|
|
continue;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* If we reach here, it must be because we successfully matched
|
|
* a fragment and then found ourselves right at the end of the
|
|
* wildcard. Hence, we return 1 if and only if we are also
|
|
* right at the end of the target.
|
|
*/
|
|
return target == target_end;
|
|
}
|
|
|
|
int wc_match(const char *wildcard, const char *target)
|
|
{
|
|
return wc_match_inner(wildcard, target, strlen(target));
|
|
}
|
|
|
|
int wc_match_pl(const char *wildcard, ptrlen target)
|
|
{
|
|
return wc_match_inner(wildcard, target.ptr, target.len);
|
|
}
|
|
|
|
/*
|
|
* Another utility routine that translates a non-wildcard string
|
|
* into its raw equivalent by removing any escaping backslashes.
|
|
* Expects a target string buffer of anything up to the length of
|
|
* the original wildcard. You can also pass NULL as the output
|
|
* buffer if you're only interested in the return value.
|
|
*
|
|
* Returns true on success, or false if a wildcard character was
|
|
* encountered. In the latter case the output string MAY not be
|
|
* zero-terminated and you should not use it for anything!
|
|
*/
|
|
bool wc_unescape(char *output, const char *wildcard)
|
|
{
|
|
while (*wildcard) {
|
|
if (*wildcard == '\\') {
|
|
wildcard++;
|
|
/* We are lenient about trailing backslashes in non-wildcards. */
|
|
if (*wildcard) {
|
|
if (output)
|
|
*output++ = *wildcard;
|
|
wildcard++;
|
|
}
|
|
} else if (*wildcard == '*' || *wildcard == '?' ||
|
|
*wildcard == '[' || *wildcard == ']') {
|
|
return false; /* it's a wildcard! */
|
|
} else {
|
|
if (output)
|
|
*output++ = *wildcard;
|
|
wildcard++;
|
|
}
|
|
}
|
|
if (output)
|
|
*output = '\0';
|
|
return true; /* it's clean */
|
|
}
|
|
|
|
#ifdef TESTMODE
|
|
|
|
struct test {
|
|
const char *wildcard;
|
|
const char *target;
|
|
int expected_result;
|
|
};
|
|
|
|
const struct test fragment_tests[] = {
|
|
/*
|
|
* We exhaustively unit-test the fragment matching routine
|
|
* itself, which should save us the need to test all its
|
|
* intricacies during the full wildcard tests.
|
|
*/
|
|
{"abc", "abc", 1},
|
|
{"abc", "abd", 0},
|
|
{"abc", "abcd", 1},
|
|
{"abcd", "abc", 0},
|
|
{"ab[cd]", "abc", 1},
|
|
{"ab[cd]", "abd", 1},
|
|
{"ab[cd]", "abe", 0},
|
|
{"ab[^cd]", "abc", 0},
|
|
{"ab[^cd]", "abd", 0},
|
|
{"ab[^cd]", "abe", 1},
|
|
{"ab\\", "abc", -WC_TRAILINGBACKSLASH},
|
|
{"ab\\*", "ab*", 1},
|
|
{"ab\\?", "ab*", 0},
|
|
{"ab?", "abc", 1},
|
|
{"ab?", "ab", 0},
|
|
{"ab[", "abc", -WC_UNCLOSEDCLASS},
|
|
{"ab[c-", "abb", -WC_UNCLOSEDCLASS},
|
|
{"ab[c-]", "abb", -WC_INVALIDRANGE},
|
|
{"ab[c-e]", "abb", 0},
|
|
{"ab[c-e]", "abc", 1},
|
|
{"ab[c-e]", "abd", 1},
|
|
{"ab[c-e]", "abe", 1},
|
|
{"ab[c-e]", "abf", 0},
|
|
{"ab[e-c]", "abb", 0},
|
|
{"ab[e-c]", "abc", 1},
|
|
{"ab[e-c]", "abd", 1},
|
|
{"ab[e-c]", "abe", 1},
|
|
{"ab[e-c]", "abf", 0},
|
|
{"ab[^c-e]", "abb", 1},
|
|
{"ab[^c-e]", "abc", 0},
|
|
{"ab[^c-e]", "abd", 0},
|
|
{"ab[^c-e]", "abe", 0},
|
|
{"ab[^c-e]", "abf", 1},
|
|
{"ab[^e-c]", "abb", 1},
|
|
{"ab[^e-c]", "abc", 0},
|
|
{"ab[^e-c]", "abd", 0},
|
|
{"ab[^e-c]", "abe", 0},
|
|
{"ab[^e-c]", "abf", 1},
|
|
{"ab[a^]", "aba", 1},
|
|
{"ab[a^]", "ab^", 1},
|
|
{"ab[a^]", "abb", 0},
|
|
{"ab[^a^]", "aba", 0},
|
|
{"ab[^a^]", "ab^", 0},
|
|
{"ab[^a^]", "abb", 1},
|
|
{"ab[-c]", "ab-", 1},
|
|
{"ab[-c]", "abc", 1},
|
|
{"ab[-c]", "abd", 0},
|
|
{"ab[^-c]", "ab-", 0},
|
|
{"ab[^-c]", "abc", 0},
|
|
{"ab[^-c]", "abd", 1},
|
|
{"ab[\\[-\\]]", "abZ", 0},
|
|
{"ab[\\[-\\]]", "ab[", 1},
|
|
{"ab[\\[-\\]]", "ab\\", 1},
|
|
{"ab[\\[-\\]]", "ab]", 1},
|
|
{"ab[\\[-\\]]", "ab^", 0},
|
|
{"ab[^\\[-\\]]", "abZ", 1},
|
|
{"ab[^\\[-\\]]", "ab[", 0},
|
|
{"ab[^\\[-\\]]", "ab\\", 0},
|
|
{"ab[^\\[-\\]]", "ab]", 0},
|
|
{"ab[^\\[-\\]]", "ab^", 1},
|
|
{"ab[a-fA-F]", "aba", 1},
|
|
{"ab[a-fA-F]", "abF", 1},
|
|
{"ab[a-fA-F]", "abZ", 0},
|
|
};
|
|
|
|
const struct test full_tests[] = {
|
|
{"a", "argh", 0},
|
|
{"a", "ba", 0},
|
|
{"a", "a", 1},
|
|
{"a*", "aardvark", 1},
|
|
{"a*", "badger", 0},
|
|
{"*a", "park", 0},
|
|
{"*a", "pArka", 1},
|
|
{"*a", "parka", 1},
|
|
{"*a*", "park", 1},
|
|
{"*a*", "perk", 0},
|
|
{"?b*r?", "abracadabra", 1},
|
|
{"?b*r?", "abracadabr", 0},
|
|
{"?b*r?", "abracadabzr", 0},
|
|
};
|
|
|
|
int main(void)
|
|
{
|
|
int i;
|
|
int fails, passes;
|
|
|
|
fails = passes = 0;
|
|
|
|
for (i = 0; i < sizeof(fragment_tests)/sizeof(*fragment_tests); i++) {
|
|
const char *f, *t;
|
|
int eret, aret;
|
|
f = fragment_tests[i].wildcard;
|
|
t = fragment_tests[i].target;
|
|
eret = fragment_tests[i].expected_result;
|
|
aret = wc_match_fragment(&f, &t, t + strlen(t));
|
|
if (aret != eret) {
|
|
printf("failed test: /%s/ against /%s/ returned %d not %d\n",
|
|
fragment_tests[i].wildcard, fragment_tests[i].target,
|
|
aret, eret);
|
|
fails++;
|
|
} else
|
|
passes++;
|
|
}
|
|
|
|
for (i = 0; i < sizeof(full_tests)/sizeof(*full_tests); i++) {
|
|
const char *f, *t;
|
|
int eret, aret;
|
|
f = full_tests[i].wildcard;
|
|
t = full_tests[i].target;
|
|
eret = full_tests[i].expected_result;
|
|
aret = wc_match(f, t);
|
|
if (aret != eret) {
|
|
printf("failed test: /%s/ against /%s/ returned %d not %d\n",
|
|
full_tests[i].wildcard, full_tests[i].target,
|
|
aret, eret);
|
|
fails++;
|
|
} else
|
|
passes++;
|
|
}
|
|
|
|
printf("passed %d, failed %d\n", passes, fails);
|
|
|
|
return 0;
|
|
}
|
|
|
|
#endif
|