/src/curl/lib/curl_fnmatch.c

Source
/***************************************************************************
 *                                  _   _ ____  _
 *  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"

#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(const unsigned char **pattern, unsigned char *charset)
{
  parsekey_state state = CURLFNM_PKW_INIT;
  char keyword[10] = { 0 };
  size_t i;
  const unsigned char *p = *pattern;
  bool found = FALSE;
  for(i = 0; !found; i++) {
    char c = (char)*p++;
    if(i >= sizeof(keyword))
      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(const unsigned char **pp, unsigned char *charset)
{
  const 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(const 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 == '[') {
        const 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)
{
  const unsigned char *p = (const unsigned char *)pattern;
  const unsigned char *s = (const unsigned char *)string;
  unsigned char charset[CURLFNM_CHSET_SIZE] = { 0 };

  for(;;) {
    const 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)) {
        bool 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 = ISBLANK(*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((const unsigned char *)pattern,
              (const 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: 2025-12-05 06:38

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