/src/curl/lib/curl_fnmatch.c

Source (jump to first uncovered line)
/***************************************************************************
 *                                  _   _ ____  _
 *  Project                     ___| | | |  _ \| |
 *                             / __| | | | |_) | |
 *                            | (__| |_| |  _ <| |___
 *                             \___|\___/|_| \_\_____|
 *
 * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
 *
 * This software is licensed as described in the file COPYING, which
 * you should have received as part of this distribution. The terms
 * are also available at https://curl.se/docs/copyright.html.
 *
 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
 * copies of the Software, and permit persons to whom the Software is
 * furnished to do so, under the terms of the COPYING file.
 *
 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
 * KIND, either express or implied.
 *
 * SPDX-License-Identifier: curl
 *
 ***************************************************************************/

#include "curl_setup.h"
#ifndef CURL_DISABLE_FTP
#include <curl/curl.h>

#include "curl_fnmatch.h"
#include "curl_memory.h"

/* The last #include file should be: */
#include "memdebug.h"

#ifndef HAVE_FNMATCH

#define CURLFNM_CHARSET_LEN (sizeof(char) * 256)
#define CURLFNM_CHSET_SIZE (CURLFNM_CHARSET_LEN + 15)

#define CURLFNM_NEGATE  CURLFNM_CHARSET_LEN

#define CURLFNM_ALNUM   (CURLFNM_CHARSET_LEN + 1)
#define CURLFNM_DIGIT   (CURLFNM_CHARSET_LEN + 2)
#define CURLFNM_XDIGIT  (CURLFNM_CHARSET_LEN + 3)
#define CURLFNM_ALPHA   (CURLFNM_CHARSET_LEN + 4)
#define CURLFNM_PRINT   (CURLFNM_CHARSET_LEN + 5)
#define CURLFNM_BLANK   (CURLFNM_CHARSET_LEN + 6)
#define CURLFNM_LOWER   (CURLFNM_CHARSET_LEN + 7)
#define CURLFNM_GRAPH   (CURLFNM_CHARSET_LEN + 8)
#define CURLFNM_SPACE   (CURLFNM_CHARSET_LEN + 9)
#define CURLFNM_UPPER   (CURLFNM_CHARSET_LEN + 10)

typedef enum {
  CURLFNM_SCHS_DEFAULT = 0,
  CURLFNM_SCHS_RIGHTBR,
  CURLFNM_SCHS_RIGHTBRLEFTBR
} setcharset_state;

typedef enum {
  CURLFNM_PKW_INIT = 0,
  CURLFNM_PKW_DDOT
} parsekey_state;

typedef enum {
  CCLASS_OTHER = 0,
  CCLASS_DIGIT,
  CCLASS_UPPER,
  CCLASS_LOWER
} char_class;

#define SETCHARSET_OK     1
#define SETCHARSET_FAIL   0

static int parsekeyword(unsigned char **pattern, unsigned char *charset)
{
  parsekey_state state = CURLFNM_PKW_INIT;
#define KEYLEN 10
  char keyword[KEYLEN] = { 0 };
  int i;
  unsigned char *p = *pattern;
  bool found = FALSE;
  for(i = 0; !found; i++) {
    char c = *p++;
    if(i >= KEYLEN)
      return SETCHARSET_FAIL;
    switch(state) {
    case CURLFNM_PKW_INIT:
      if(ISLOWER(c))
        keyword[i] = c;
      else if(c == ':')
        state = CURLFNM_PKW_DDOT;
      else
        return SETCHARSET_FAIL;
      break;
    case CURLFNM_PKW_DDOT:
      if(c == ']')
        found = TRUE;
      else
        return SETCHARSET_FAIL;
    }
  }
#undef KEYLEN

  *pattern = p; /* move caller's pattern pointer */
  if(strcmp(keyword, "digit") == 0)
    charset[CURLFNM_DIGIT] = 1;
  else if(strcmp(keyword, "alnum") == 0)
    charset[CURLFNM_ALNUM] = 1;
  else if(strcmp(keyword, "alpha") == 0)
    charset[CURLFNM_ALPHA] = 1;
  else if(strcmp(keyword, "xdigit") == 0)
    charset[CURLFNM_XDIGIT] = 1;
  else if(strcmp(keyword, "print") == 0)
    charset[CURLFNM_PRINT] = 1;
  else if(strcmp(keyword, "graph") == 0)
    charset[CURLFNM_GRAPH] = 1;
  else if(strcmp(keyword, "space") == 0)
    charset[CURLFNM_SPACE] = 1;
  else if(strcmp(keyword, "blank") == 0)
    charset[CURLFNM_BLANK] = 1;
  else if(strcmp(keyword, "upper") == 0)
    charset[CURLFNM_UPPER] = 1;
  else if(strcmp(keyword, "lower") == 0)
    charset[CURLFNM_LOWER] = 1;
  else
    return SETCHARSET_FAIL;
  return SETCHARSET_OK;
}

/* Return the character class. */
static char_class charclass(unsigned char c)
{
  if(ISUPPER(c))
    return CCLASS_UPPER;
  if(ISLOWER(c))
    return CCLASS_LOWER;
  if(ISDIGIT(c))
    return CCLASS_DIGIT;
  return CCLASS_OTHER;
}

/* Include a character or a range in set. */
static void setcharorrange(unsigned char **pp, unsigned char *charset)
{
  unsigned char *p = (*pp)++;
  unsigned char c = *p++;

  charset[c] = 1;
  if(ISALNUM(c) && *p++ == '-') {
    char_class cc = charclass(c);
    unsigned char endrange = *p++;

    if(endrange == '\\')
      endrange = *p++;
    if(endrange >= c && charclass(endrange) == cc) {
      while(c++ != endrange)
        if(charclass(c) == cc)  /* Chars in class may be not consecutive. */
          charset[c] = 1;
      *pp = p;
    }
  }
}

/* returns 1 (true) if pattern is OK, 0 if is bad ("p" is pattern pointer) */
static int setcharset(unsigned char **p, unsigned char *charset)
{
  setcharset_state state = CURLFNM_SCHS_DEFAULT;
  bool something_found = FALSE;
  unsigned char c;

  memset(charset, 0, CURLFNM_CHSET_SIZE);
  for(;;) {
    c = **p;
    if(!c)
      return SETCHARSET_FAIL;

    switch(state) {
    case CURLFNM_SCHS_DEFAULT:
      if(c == ']') {
        if(something_found)
          return SETCHARSET_OK;
        something_found = TRUE;
        state = CURLFNM_SCHS_RIGHTBR;
        charset[c] = 1;
        (*p)++;
      }
      else if(c == '[') {
        unsigned char *pp = *p + 1;

        if(*pp++ == ':' && parsekeyword(&pp, charset))
          *p = pp;
        else {
          charset[c] = 1;
          (*p)++;
        }
        something_found = TRUE;
      }
      else if(c == '^' || c == '!') {
        if(!something_found) {
          if(charset[CURLFNM_NEGATE]) {
            charset[c] = 1;
            something_found = TRUE;
          }
          else
            charset[CURLFNM_NEGATE] = 1; /* negate charset */
        }
        else
          charset[c] = 1;
        (*p)++;
      }
      else if(c == '\\') {
        c = *(++(*p));
        if(c)
          setcharorrange(p, charset);
        else
          charset['\\'] = 1;
        something_found = TRUE;
      }
      else {
        setcharorrange(p, charset);
        something_found = TRUE;
      }
      break;
    case CURLFNM_SCHS_RIGHTBR:
      if(c == '[') {
        state = CURLFNM_SCHS_RIGHTBRLEFTBR;
        charset[c] = 1;
        (*p)++;
      }
      else if(c == ']') {
        return SETCHARSET_OK;
      }
      else if(ISPRINT(c)) {
        charset[c] = 1;
        (*p)++;
        state = CURLFNM_SCHS_DEFAULT;
      }
      else
        /* used 'goto fail' instead of 'return SETCHARSET_FAIL' to avoid a
         * nonsense warning 'statement not reached' at end of the fnc when
         * compiling on Solaris */
        goto fail;
      break;
    case CURLFNM_SCHS_RIGHTBRLEFTBR:
      if(c == ']')
        return SETCHARSET_OK;
      state  = CURLFNM_SCHS_DEFAULT;
      charset[c] = 1;
      (*p)++;
      break;
    }
  }
fail:
  return SETCHARSET_FAIL;
}

static int loop(const unsigned char *pattern, const unsigned char *string,
                int maxstars)
{
  unsigned char *p = (unsigned char *)pattern;
  unsigned char *s = (unsigned char *)string;
  unsigned char charset[CURLFNM_CHSET_SIZE] = { 0 };

  for(;;) {
    unsigned char *pp;

    switch(*p) {
    case '*':
      if(!maxstars)
        return CURL_FNMATCH_NOMATCH;
      /* Regroup consecutive stars and question marks. This can be done because
         '*?*?*' can be expressed as '??*'. */
      for(;;) {
        if(*++p == '\0')
          return CURL_FNMATCH_MATCH;
        if(*p == '?') {
          if(!*s++)
            return CURL_FNMATCH_NOMATCH;
        }
        else if(*p != '*')
          break;
      }
      /* Skip string characters until we find a match with pattern suffix. */
      for(maxstars--; *s; s++) {
        if(loop(p, s, maxstars) == CURL_FNMATCH_MATCH)
          return CURL_FNMATCH_MATCH;
      }
      return CURL_FNMATCH_NOMATCH;
    case '?':
      if(!*s)
        return CURL_FNMATCH_NOMATCH;
      s++;
      p++;
      break;
    case '\0':
      return *s? CURL_FNMATCH_NOMATCH: CURL_FNMATCH_MATCH;
    case '\\':
      if(p[1])
        p++;
      if(*s++ != *p++)
        return CURL_FNMATCH_NOMATCH;
      break;
    case '[':
      pp = p + 1; /* Copy in case of syntax error in set. */
      if(setcharset(&pp, charset)) {
        int found = FALSE;
        if(!*s)
          return CURL_FNMATCH_NOMATCH;
        if(charset[(unsigned int)*s])
          found = TRUE;
        else if(charset[CURLFNM_ALNUM])
          found = ISALNUM(*s);
        else if(charset[CURLFNM_ALPHA])
          found = ISALPHA(*s);
        else if(charset[CURLFNM_DIGIT])
          found = ISDIGIT(*s);
        else if(charset[CURLFNM_XDIGIT])
          found = ISXDIGIT(*s);
        else if(charset[CURLFNM_PRINT])
          found = ISPRINT(*s);
        else if(charset[CURLFNM_SPACE])
          found = ISSPACE(*s);
        else if(charset[CURLFNM_UPPER])
          found = ISUPPER(*s);
        else if(charset[CURLFNM_LOWER])
          found = ISLOWER(*s);
        else if(charset[CURLFNM_BLANK])
          found = ISBLANK(*s);
        else if(charset[CURLFNM_GRAPH])
          found = ISGRAPH(*s);

        if(charset[CURLFNM_NEGATE])
          found = !found;

        if(!found)
          return CURL_FNMATCH_NOMATCH;
        p = pp + 1;
        s++;
        break;
      }
      /* Syntax error in set; mismatch! */
      return CURL_FNMATCH_NOMATCH;

    default:
      if(*p++ != *s++)
        return CURL_FNMATCH_NOMATCH;
      break;
    }
  }
}

/*
 * @unittest: 1307
 */
int Curl_fnmatch(void *ptr, const char *pattern, const char *string)
{
  (void)ptr; /* the argument is specified by the curl_fnmatch_callback
                prototype, but not used by Curl_fnmatch() */
  if(!pattern || !string) {
    return CURL_FNMATCH_FAIL;
  }
  return loop((unsigned char *)pattern, (unsigned char *)string, 2);
}
#else
#include <fnmatch.h>
/*
 * @unittest: 1307
 */
int Curl_fnmatch(void *ptr, const char *pattern, const char *string)
{
  (void)ptr; /* the argument is specified by the curl_fnmatch_callback
                prototype, but not used by Curl_fnmatch() */
  if(!pattern || !string) {
    return CURL_FNMATCH_FAIL;
  }

  switch(fnmatch(pattern, string, 0)) {
  case 0:
    return CURL_FNMATCH_MATCH;
  case FNM_NOMATCH:
    return CURL_FNMATCH_NOMATCH;
  default:
    return CURL_FNMATCH_FAIL;
  }
  /* not reached */
}

#endif

#endif /* if FTP is disabled */

Coverage Report

Created: 2023-06-07 07:02

Line	Count	Source (jump to first uncovered line)
1		/***************************************************************************
2		* _ _ ____ _
3		* Project ___\| \| \| \| _ \\| \|
4		* / __\| \| \| \| \|_) \| \|
5		* \| (__\| \|_\| \| _ <\| \|___
6		* \___\|\___/\|_\| \_\_____\|
7		*
8		* Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
9		*
10		* This software is licensed as described in the file COPYING, which
11		* you should have received as part of this distribution. The terms
12		* are also available at https://curl.se/docs/copyright.html.
13		*
14		* You may opt to use, copy, modify, merge, publish, distribute and/or sell
15		* copies of the Software, and permit persons to whom the Software is
16		* furnished to do so, under the terms of the COPYING file.
17		*
18		* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19		* KIND, either express or implied.
20		*
21		* SPDX-License-Identifier: curl
22		*
23		***************************************************************************/
24
25		#include "curl_setup.h"
26		#ifndef CURL_DISABLE_FTP
27		#include <curl/curl.h>
28
29		#include "curl_fnmatch.h"
30		#include "curl_memory.h"
31
32		/* The last #include file should be: */
33		#include "memdebug.h"
34
35		#ifndef HAVE_FNMATCH
36
37		#define CURLFNM_CHARSET_LEN (sizeof(char) * 256)
38		#define CURLFNM_CHSET_SIZE (CURLFNM_CHARSET_LEN + 15)
39
40		#define CURLFNM_NEGATE CURLFNM_CHARSET_LEN
41
42		#define CURLFNM_ALNUM (CURLFNM_CHARSET_LEN + 1)
43		#define CURLFNM_DIGIT (CURLFNM_CHARSET_LEN + 2)
44		#define CURLFNM_XDIGIT (CURLFNM_CHARSET_LEN + 3)
45		#define CURLFNM_ALPHA (CURLFNM_CHARSET_LEN + 4)
46		#define CURLFNM_PRINT (CURLFNM_CHARSET_LEN + 5)
47		#define CURLFNM_BLANK (CURLFNM_CHARSET_LEN + 6)
48		#define CURLFNM_LOWER (CURLFNM_CHARSET_LEN + 7)
49		#define CURLFNM_GRAPH (CURLFNM_CHARSET_LEN + 8)
50		#define CURLFNM_SPACE (CURLFNM_CHARSET_LEN + 9)
51		#define CURLFNM_UPPER (CURLFNM_CHARSET_LEN + 10)
52
53		typedef enum {
54		CURLFNM_SCHS_DEFAULT = 0,
55		CURLFNM_SCHS_RIGHTBR,
56		CURLFNM_SCHS_RIGHTBRLEFTBR
57		} setcharset_state;
58
59		typedef enum {
60		CURLFNM_PKW_INIT = 0,
61		CURLFNM_PKW_DDOT
62		} parsekey_state;
63
64		typedef enum {
65		CCLASS_OTHER = 0,
66		CCLASS_DIGIT,
67		CCLASS_UPPER,
68		CCLASS_LOWER
69		} char_class;
70
71		#define SETCHARSET_OK 1
72		#define SETCHARSET_FAIL 0
73
74		static int parsekeyword(unsigned char *pattern, unsigned char charset)
75		{
76		parsekey_state state = CURLFNM_PKW_INIT;
77		#define KEYLEN 10
78		char keyword[KEYLEN] = { 0 };
79		int i;
80		unsigned char p = pattern;
81		bool found = FALSE;
82		for(i = 0; !found; i++) {
83		char c = *p++;
84		if(i >= KEYLEN)
85		return SETCHARSET_FAIL;
86		switch(state) {
87		case CURLFNM_PKW_INIT:
88		if(ISLOWER(c))
89		keyword[i] = c;
90		else if(c == ':')
91		state = CURLFNM_PKW_DDOT;
92		else
93		return SETCHARSET_FAIL;
94		break;
95		case CURLFNM_PKW_DDOT:
96		if(c == ']')
97		found = TRUE;
98		else
99		return SETCHARSET_FAIL;
100		}
101		}
102		#undef KEYLEN
103
104		pattern = p; / move caller's pattern pointer */
105		if(strcmp(keyword, "digit") == 0)
106		charset[CURLFNM_DIGIT] = 1;
107		else if(strcmp(keyword, "alnum") == 0)
108		charset[CURLFNM_ALNUM] = 1;
109		else if(strcmp(keyword, "alpha") == 0)
110		charset[CURLFNM_ALPHA] = 1;
111		else if(strcmp(keyword, "xdigit") == 0)
112		charset[CURLFNM_XDIGIT] = 1;
113		else if(strcmp(keyword, "print") == 0)
114		charset[CURLFNM_PRINT] = 1;
115		else if(strcmp(keyword, "graph") == 0)
116		charset[CURLFNM_GRAPH] = 1;
117		else if(strcmp(keyword, "space") == 0)
118		charset[CURLFNM_SPACE] = 1;
119		else if(strcmp(keyword, "blank") == 0)
120		charset[CURLFNM_BLANK] = 1;
121		else if(strcmp(keyword, "upper") == 0)
122		charset[CURLFNM_UPPER] = 1;
123		else if(strcmp(keyword, "lower") == 0)
124		charset[CURLFNM_LOWER] = 1;
125		else
126		return SETCHARSET_FAIL;
127		return SETCHARSET_OK;
128		}
129
130		/* Return the character class. */
131		static char_class charclass(unsigned char c)
132		{
133		if(ISUPPER(c))
134		return CCLASS_UPPER;
135		if(ISLOWER(c))
136		return CCLASS_LOWER;
137		if(ISDIGIT(c))
138		return CCLASS_DIGIT;
139		return CCLASS_OTHER;
140		}
141
142		/* Include a character or a range in set. */
143		static void setcharorrange(unsigned char *pp, unsigned char charset)
144		{
145		unsigned char p = (pp)++;
146		unsigned char c = *p++;
147
148		charset[c] = 1;
149		if(ISALNUM(c) && *p++ == '-') {
150		char_class cc = charclass(c);
151		unsigned char endrange = *p++;
152
153		if(endrange == '\\')
154		endrange = *p++;
155		if(endrange >= c && charclass(endrange) == cc) {
156		while(c++ != endrange)
157		if(charclass(c) == cc) /* Chars in class may be not consecutive. */
158		charset[c] = 1;
159		*pp = p;
160		}
161		}
162		}
163
164		/* returns 1 (true) if pattern is OK, 0 if is bad ("p" is pattern pointer) */
165		static int setcharset(unsigned char *p, unsigned char charset)
166		{
167		setcharset_state state = CURLFNM_SCHS_DEFAULT;
168		bool something_found = FALSE;
169		unsigned char c;
170
171		memset(charset, 0, CURLFNM_CHSET_SIZE);
172		for(;;) {
173		c = **p;
174		if(!c)
175		return SETCHARSET_FAIL;
176
177		switch(state) {
178		case CURLFNM_SCHS_DEFAULT:
179		if(c == ']') {
180		if(something_found)
181		return SETCHARSET_OK;
182		something_found = TRUE;
183		state = CURLFNM_SCHS_RIGHTBR;
184		charset[c] = 1;
185		(*p)++;
186		}
187		else if(c == '[') {
188		unsigned char pp = p + 1;
189
190		if(*pp++ == ':' && parsekeyword(&pp, charset))
191		*p = pp;
192		else {
193		charset[c] = 1;
194		(*p)++;
195		}
196		something_found = TRUE;
197		}
198		else if(c == '^' \|\| c == '!') {
199		if(!something_found) {
200		if(charset[CURLFNM_NEGATE]) {
201		charset[c] = 1;
202		something_found = TRUE;
203		}
204		else
205		charset[CURLFNM_NEGATE] = 1; /* negate charset */
206		}
207		else
208		charset[c] = 1;
209		(*p)++;
210		}
211		else if(c == '\\') {
212		c = (++(p));
213		if(c)
214		setcharorrange(p, charset);
215		else
216		charset['\\'] = 1;
217		something_found = TRUE;
218		}
219		else {
220		setcharorrange(p, charset);
221		something_found = TRUE;
222		}
223		break;
224		case CURLFNM_SCHS_RIGHTBR:
225		if(c == '[') {
226		state = CURLFNM_SCHS_RIGHTBRLEFTBR;
227		charset[c] = 1;
228		(*p)++;
229		}
230		else if(c == ']') {
231		return SETCHARSET_OK;
232		}
233		else if(ISPRINT(c)) {
234		charset[c] = 1;
235		(*p)++;
236		state = CURLFNM_SCHS_DEFAULT;
237		}
238		else
239		/* used 'goto fail' instead of 'return SETCHARSET_FAIL' to avoid a
240		* nonsense warning 'statement not reached' at end of the fnc when
241		* compiling on Solaris */
242		goto fail;
243		break;
244		case CURLFNM_SCHS_RIGHTBRLEFTBR:
245		if(c == ']')
246		return SETCHARSET_OK;
247		state = CURLFNM_SCHS_DEFAULT;
248		charset[c] = 1;
249		(*p)++;
250		break;
251		}
252		}
253		fail:
254		return SETCHARSET_FAIL;
255		}
256
257		static int loop(const unsigned char pattern, const unsigned char string,
258		int maxstars)
259		{
260		unsigned char p = (unsigned char )pattern;
261		unsigned char s = (unsigned char )string;
262		unsigned char charset[CURLFNM_CHSET_SIZE] = { 0 };
263
264		for(;;) {
265		unsigned char *pp;
266
267		switch(*p) {
268		case '*':
269		if(!maxstars)
270		return CURL_FNMATCH_NOMATCH;
271		/* Regroup consecutive stars and question marks. This can be done because
272		'??' can be expressed as '??'. */
273		for(;;) {
274		if(*++p == '\0')
275		return CURL_FNMATCH_MATCH;
276		if(*p == '?') {
277		if(!*s++)
278		return CURL_FNMATCH_NOMATCH;
279		}
280		else if(p != '')
281		break;
282		}
283		/* Skip string characters until we find a match with pattern suffix. */
284		for(maxstars--; *s; s++) {
285		if(loop(p, s, maxstars) == CURL_FNMATCH_MATCH)
286		return CURL_FNMATCH_MATCH;
287		}
288		return CURL_FNMATCH_NOMATCH;
289		case '?':
290		if(!*s)
291		return CURL_FNMATCH_NOMATCH;
292		s++;
293		p++;
294		break;
295		case '\0':
296		return *s? CURL_FNMATCH_NOMATCH: CURL_FNMATCH_MATCH;
297		case '\\':
298		if(p[1])
299		p++;
300		if(s++ != p++)
301		return CURL_FNMATCH_NOMATCH;
302		break;
303		case '[':
304		pp = p + 1; /* Copy in case of syntax error in set. */
305		if(setcharset(&pp, charset)) {
306		int found = FALSE;
307		if(!*s)
308		return CURL_FNMATCH_NOMATCH;
309		if(charset[(unsigned int)*s])
310		found = TRUE;
311		else if(charset[CURLFNM_ALNUM])
312		found = ISALNUM(*s);
313		else if(charset[CURLFNM_ALPHA])
314		found = ISALPHA(*s);
315		else if(charset[CURLFNM_DIGIT])
316		found = ISDIGIT(*s);
317		else if(charset[CURLFNM_XDIGIT])
318		found = ISXDIGIT(*s);
319		else if(charset[CURLFNM_PRINT])
320		found = ISPRINT(*s);
321		else if(charset[CURLFNM_SPACE])
322		found = ISSPACE(*s);
323		else if(charset[CURLFNM_UPPER])
324		found = ISUPPER(*s);
325		else if(charset[CURLFNM_LOWER])
326		found = ISLOWER(*s);
327		else if(charset[CURLFNM_BLANK])
328		found = ISBLANK(*s);
329		else if(charset[CURLFNM_GRAPH])
330		found = ISGRAPH(*s);
331
332		if(charset[CURLFNM_NEGATE])
333		found = !found;
334
335		if(!found)
336		return CURL_FNMATCH_NOMATCH;
337		p = pp + 1;
338		s++;
339		break;
340		}
341		/* Syntax error in set; mismatch! */
342		return CURL_FNMATCH_NOMATCH;
343
344		default:
345		if(p++ != s++)
346		return CURL_FNMATCH_NOMATCH;
347		break;
348		}
349		}
350		}
351
352		/*
353		* @unittest: 1307
354		*/
355		int Curl_fnmatch(void ptr, const char pattern, const char *string)
356		{
357		(void)ptr; /* the argument is specified by the curl_fnmatch_callback
358		prototype, but not used by Curl_fnmatch() */
359		if(!pattern \|\| !string) {
360		return CURL_FNMATCH_FAIL;
361		}
362		return loop((unsigned char )pattern, (unsigned char )string, 2);
363		}
364		#else
365		#include <fnmatch.h>
366		/*
367		* @unittest: 1307
368		*/
369		int Curl_fnmatch(void ptr, const char pattern, const char *string)
370	0	{
371	0	(void)ptr; /* the argument is specified by the curl_fnmatch_callback
372		prototype, but not used by Curl_fnmatch() */
373	0	if(!pattern \|\| !string) {
374	0	return CURL_FNMATCH_FAIL;
375	0	}
376
377	0	switch(fnmatch(pattern, string, 0)) {
378	0	case 0:
379	0	return CURL_FNMATCH_MATCH;
380	0	case FNM_NOMATCH:
381	0	return CURL_FNMATCH_NOMATCH;
382	0	default:
383	0	return CURL_FNMATCH_FAIL;
384	0	}
385		/* not reached */
386	0	}
387
388		#endif
389
390		#endif /* if FTP is disabled */