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