1: /***************************************************************************
2: * _ _ ____ _
3: * Project ___| | | | _ \| |
4: * / __| | | | |_) | |
5: * | (__| |_| | _ <| |___
6: * \___|\___/|_| \_\_____|
7: *
8: * Copyright (C) 1998 - 2020, 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: #include "tool_setup.h"
23:
24: #define ENABLE_CURLX_PRINTF
25: /* use our own printf() functions */
26: #include "curlx.h"
27: #include "tool_cfgable.h"
28: #include "tool_doswin.h"
29: #include "tool_urlglob.h"
30: #include "tool_vms.h"
31:
32: #include "memdebug.h" /* keep this as LAST include */
33:
34: #define GLOBERROR(string, column, code) \
35: glob->error = string, glob->pos = column, code
36:
37: static CURLcode glob_fixed(URLGlob *glob, char *fixed, size_t len)
38: {
39: URLPattern *pat = &glob->pattern[glob->size];
40: pat->type = UPTSet;
41: pat->content.Set.size = 1;
42: pat->content.Set.ptr_s = 0;
43: pat->globindex = -1;
44:
45: pat->content.Set.elements = malloc(sizeof(char *));
46:
47: if(!pat->content.Set.elements)
48: return GLOBERROR("out of memory", 0, CURLE_OUT_OF_MEMORY);
49:
50: pat->content.Set.elements[0] = malloc(len + 1);
51: if(!pat->content.Set.elements[0])
52: return GLOBERROR("out of memory", 0, CURLE_OUT_OF_MEMORY);
53:
54: memcpy(pat->content.Set.elements[0], fixed, len);
55: pat->content.Set.elements[0][len] = 0;
56:
57: return CURLE_OK;
58: }
59:
60: /* multiply
61: *
62: * Multiplies and checks for overflow.
63: */
64: static int multiply(unsigned long *amount, long with)
65: {
66: unsigned long sum = *amount * with;
67: if(!with) {
68: *amount = 0;
69: return 0;
70: }
71: if(sum/with != *amount)
72: return 1; /* didn't fit, bail out */
73: *amount = sum;
74: return 0;
75: }
76:
77: static CURLcode glob_set(URLGlob *glob, char **patternp,
78: size_t *posp, unsigned long *amount,
79: int globindex)
80: {
81: /* processes a set expression with the point behind the opening '{'
82: ','-separated elements are collected until the next closing '}'
83: */
84: URLPattern *pat;
85: bool done = FALSE;
86: char *buf = glob->glob_buffer;
87: char *pattern = *patternp;
88: char *opattern = pattern;
89: size_t opos = *posp-1;
90:
91: pat = &glob->pattern[glob->size];
92: /* patterns 0,1,2,... correspond to size=1,3,5,... */
93: pat->type = UPTSet;
94: pat->content.Set.size = 0;
95: pat->content.Set.ptr_s = 0;
96: pat->content.Set.elements = NULL;
97: pat->globindex = globindex;
98:
99: while(!done) {
100: switch (*pattern) {
101: case '\0': /* URL ended while set was still open */
102: return GLOBERROR("unmatched brace", opos, CURLE_URL_MALFORMAT);
103:
104: case '{':
105: case '[': /* no nested expressions at this time */
106: return GLOBERROR("nested brace", *posp, CURLE_URL_MALFORMAT);
107:
108: case '}': /* set element completed */
109: if(opattern == pattern)
110: return GLOBERROR("empty string within braces", *posp,
111: CURLE_URL_MALFORMAT);
112:
113: /* add 1 to size since it'll be incremented below */
114: if(multiply(amount, pat->content.Set.size + 1))
115: return GLOBERROR("range overflow", 0, CURLE_URL_MALFORMAT);
116:
117: /* FALLTHROUGH */
118: case ',':
119:
120: *buf = '\0';
121: if(pat->content.Set.elements) {
122: char **new_arr = realloc(pat->content.Set.elements,
123: (pat->content.Set.size + 1) * sizeof(char *));
124: if(!new_arr)
125: return GLOBERROR("out of memory", 0, CURLE_OUT_OF_MEMORY);
126:
127: pat->content.Set.elements = new_arr;
128: }
129: else
130: pat->content.Set.elements = malloc(sizeof(char *));
131:
132: if(!pat->content.Set.elements)
133: return GLOBERROR("out of memory", 0, CURLE_OUT_OF_MEMORY);
134:
135: pat->content.Set.elements[pat->content.Set.size] =
136: strdup(glob->glob_buffer);
137: if(!pat->content.Set.elements[pat->content.Set.size])
138: return GLOBERROR("out of memory", 0, CURLE_OUT_OF_MEMORY);
139: ++pat->content.Set.size;
140:
141: if(*pattern == '}') {
142: pattern++; /* pass the closing brace */
143: done = TRUE;
144: continue;
145: }
146:
147: buf = glob->glob_buffer;
148: ++pattern;
149: ++(*posp);
150: break;
151:
152: case ']': /* illegal closing bracket */
153: return GLOBERROR("unexpected close bracket", *posp, CURLE_URL_MALFORMAT);
154:
155: case '\\': /* escaped character, skip '\' */
156: if(pattern[1]) {
157: ++pattern;
158: ++(*posp);
159: }
160: /* FALLTHROUGH */
161: default:
162: *buf++ = *pattern++; /* copy character to set element */
163: ++(*posp);
164: }
165: }
166:
167: *patternp = pattern; /* return with the new position */
168: return CURLE_OK;
169: }
170:
171: static CURLcode glob_range(URLGlob *glob, char **patternp,
172: size_t *posp, unsigned long *amount,
173: int globindex)
174: {
175: /* processes a range expression with the point behind the opening '['
176: - char range: e.g. "a-z]", "B-Q]"
177: - num range: e.g. "0-9]", "17-2000]"
178: - num range with leading zeros: e.g. "001-999]"
179: expression is checked for well-formedness and collected until the next ']'
180: */
181: URLPattern *pat;
182: int rc;
183: char *pattern = *patternp;
184: char *c;
185:
186: pat = &glob->pattern[glob->size];
187: pat->globindex = globindex;
188:
189: if(ISALPHA(*pattern)) {
190: /* character range detected */
191: char min_c;
192: char max_c;
193: char end_c;
194: unsigned long step = 1;
195:
196: pat->type = UPTCharRange;
197:
198: rc = sscanf(pattern, "%c-%c%c", &min_c, &max_c, &end_c);
199:
200: if(rc == 3) {
201: if(end_c == ':') {
202: char *endp;
203: errno = 0;
204: step = strtoul(&pattern[4], &endp, 10);
205: if(errno || &pattern[4] == endp || *endp != ']')
206: step = 0;
207: else
208: pattern = endp + 1;
209: }
210: else if(end_c != ']')
211: /* then this is wrong */
212: rc = 0;
213: else
214: /* end_c == ']' */
215: pattern += 4;
216: }
217:
218: *posp += (pattern - *patternp);
219:
220: if(rc != 3 || !step || step > (unsigned)INT_MAX ||
221: (min_c == max_c && step != 1) ||
222: (min_c != max_c && (min_c > max_c || step > (unsigned)(max_c - min_c) ||
223: (max_c - min_c) > ('z' - 'a'))))
224: /* the pattern is not well-formed */
225: return GLOBERROR("bad range", *posp, CURLE_URL_MALFORMAT);
226:
227: /* if there was a ":[num]" thing, use that as step or else use 1 */
228: pat->content.CharRange.step = (int)step;
229: pat->content.CharRange.ptr_c = pat->content.CharRange.min_c = min_c;
230: pat->content.CharRange.max_c = max_c;
231:
232: if(multiply(amount, ((pat->content.CharRange.max_c -
233: pat->content.CharRange.min_c) /
234: pat->content.CharRange.step + 1)))
235: return GLOBERROR("range overflow", *posp, CURLE_URL_MALFORMAT);
236: }
237: else if(ISDIGIT(*pattern)) {
238: /* numeric range detected */
239: unsigned long min_n;
240: unsigned long max_n = 0;
241: unsigned long step_n = 0;
242: char *endp;
243:
244: pat->type = UPTNumRange;
245: pat->content.NumRange.padlength = 0;
246:
247: if(*pattern == '0') {
248: /* leading zero specified, count them! */
249: c = pattern;
250: while(ISDIGIT(*c)) {
251: c++;
252: ++pat->content.NumRange.padlength; /* padding length is set for all
253: instances of this pattern */
254: }
255: }
256:
257: errno = 0;
258: min_n = strtoul(pattern, &endp, 10);
259: if(errno || (endp == pattern))
260: endp = NULL;
261: else {
262: if(*endp != '-')
263: endp = NULL;
264: else {
265: pattern = endp + 1;
266: while(*pattern && ISBLANK(*pattern))
267: pattern++;
268: if(!ISDIGIT(*pattern)) {
269: endp = NULL;
270: goto fail;
271: }
272: errno = 0;
273: max_n = strtoul(pattern, &endp, 10);
274: if(errno)
275: /* overflow */
276: endp = NULL;
277: else if(*endp == ':') {
278: pattern = endp + 1;
279: errno = 0;
280: step_n = strtoul(pattern, &endp, 10);
281: if(errno)
282: /* over/underflow situation */
283: endp = NULL;
284: }
285: else
286: step_n = 1;
287: if(endp && (*endp == ']')) {
288: pattern = endp + 1;
289: }
290: else
291: endp = NULL;
292: }
293: }
294:
295: fail:
296: *posp += (pattern - *patternp);
297:
298: if(!endp || !step_n ||
299: (min_n == max_n && step_n != 1) ||
300: (min_n != max_n && (min_n > max_n || step_n > (max_n - min_n))))
301: /* the pattern is not well-formed */
302: return GLOBERROR("bad range", *posp, CURLE_URL_MALFORMAT);
303:
304: /* typecasting to ints are fine here since we make sure above that we
305: are within 31 bits */
306: pat->content.NumRange.ptr_n = pat->content.NumRange.min_n = min_n;
307: pat->content.NumRange.max_n = max_n;
308: pat->content.NumRange.step = step_n;
309:
310: if(multiply(amount, ((pat->content.NumRange.max_n -
311: pat->content.NumRange.min_n) /
312: pat->content.NumRange.step + 1)))
313: return GLOBERROR("range overflow", *posp, CURLE_URL_MALFORMAT);
314: }
315: else
316: return GLOBERROR("bad range specification", *posp, CURLE_URL_MALFORMAT);
317:
318: *patternp = pattern;
319: return CURLE_OK;
320: }
321:
322: static bool peek_ipv6(const char *str, size_t *skip)
323: {
324: /*
325: * Scan for a potential IPv6 literal.
326: * - Valid globs contain a hyphen and <= 1 colon.
327: * - IPv6 literals contain no hyphens and >= 2 colons.
328: */
329: size_t i = 0;
330: size_t colons = 0;
331: if(str[i++] != '[') {
332: return FALSE;
333: }
334: for(;;) {
335: const char c = str[i++];
336: if(ISALNUM(c) || c == '.' || c == '%') {
337: /* ok */
338: }
339: else if(c == ':') {
340: colons++;
341: }
342: else if(c == ']') {
343: *skip = i;
344: return colons >= 2 ? TRUE : FALSE;
345: }
346: else {
347: return FALSE;
348: }
349: }
350: }
351:
352: static CURLcode glob_parse(URLGlob *glob, char *pattern,
353: size_t pos, unsigned long *amount)
354: {
355: /* processes a literal string component of a URL
356: special characters '{' and '[' branch to set/range processing functions
357: */
358: CURLcode res = CURLE_OK;
359: int globindex = 0; /* count "actual" globs */
360:
361: *amount = 1;
362:
363: while(*pattern && !res) {
364: char *buf = glob->glob_buffer;
365: size_t sublen = 0;
366: while(*pattern && *pattern != '{') {
367: if(*pattern == '[') {
368: /* skip over IPv6 literals and [] */
369: size_t skip = 0;
370: if(!peek_ipv6(pattern, &skip) && (pattern[1] == ']'))
371: skip = 2;
372: if(skip) {
373: memcpy(buf, pattern, skip);
374: buf += skip;
375: pattern += skip;
376: sublen += skip;
377: continue;
378: }
379: break;
380: }
381: if(*pattern == '}' || *pattern == ']')
382: return GLOBERROR("unmatched close brace/bracket", pos,
383: CURLE_URL_MALFORMAT);
384:
385: /* only allow \ to escape known "special letters" */
386: if(*pattern == '\\' &&
387: (*(pattern + 1) == '{' || *(pattern + 1) == '[' ||
388: *(pattern + 1) == '}' || *(pattern + 1) == ']') ) {
389:
390: /* escape character, skip '\' */
391: ++pattern;
392: ++pos;
393: }
394: *buf++ = *pattern++; /* copy character to literal */
395: ++pos;
396: sublen++;
397: }
398: if(sublen) {
399: /* we got a literal string, add it as a single-item list */
400: *buf = '\0';
401: res = glob_fixed(glob, glob->glob_buffer, sublen);
402: }
403: else {
404: switch (*pattern) {
405: case '\0': /* done */
406: break;
407:
408: case '{':
409: /* process set pattern */
410: pattern++;
411: pos++;
412: res = glob_set(glob, &pattern, &pos, amount, globindex++);
413: break;
414:
415: case '[':
416: /* process range pattern */
417: pattern++;
418: pos++;
419: res = glob_range(glob, &pattern, &pos, amount, globindex++);
420: break;
421: }
422: }
423:
424: if(++glob->size >= GLOB_PATTERN_NUM)
425: return GLOBERROR("too many globs", pos, CURLE_URL_MALFORMAT);
426: }
427: return res;
428: }
429:
430: CURLcode glob_url(URLGlob **glob, char *url, unsigned long *urlnum,
431: FILE *error)
432: {
433: /*
434: * We can deal with any-size, just make a buffer with the same length
435: * as the specified URL!
436: */
437: URLGlob *glob_expand;
438: unsigned long amount = 0;
439: char *glob_buffer;
440: CURLcode res;
441:
442: *glob = NULL;
443:
444: glob_buffer = malloc(strlen(url) + 1);
445: if(!glob_buffer)
446: return CURLE_OUT_OF_MEMORY;
447: glob_buffer[0] = 0;
448:
449: glob_expand = calloc(1, sizeof(URLGlob));
450: if(!glob_expand) {
451: Curl_safefree(glob_buffer);
452: return CURLE_OUT_OF_MEMORY;
453: }
454: glob_expand->urllen = strlen(url);
455: glob_expand->glob_buffer = glob_buffer;
456:
457: res = glob_parse(glob_expand, url, 1, &amount);
458: if(!res)
459: *urlnum = amount;
460: else {
461: if(error && glob_expand->error) {
462: char text[512];
463: const char *t;
464: if(glob_expand->pos) {
465: msnprintf(text, sizeof(text), "%s in URL position %zu:\n%s\n%*s^",
466: glob_expand->error,
467: glob_expand->pos, url, glob_expand->pos - 1, " ");
468: t = text;
469: }
470: else
471: t = glob_expand->error;
472:
473: /* send error description to the error-stream */
474: fprintf(error, "curl: (%d) %s\n", res, t);
475: }
476: /* it failed, we cleanup */
477: glob_cleanup(glob_expand);
478: *urlnum = 1;
479: return res;
480: }
481:
482: *glob = glob_expand;
483: return CURLE_OK;
484: }
485:
486: void glob_cleanup(URLGlob* glob)
487: {
488: size_t i;
489: int elem;
490:
491: if(!glob)
492: return;
493:
494: for(i = 0; i < glob->size; i++) {
495: if((glob->pattern[i].type == UPTSet) &&
496: (glob->pattern[i].content.Set.elements)) {
497: for(elem = glob->pattern[i].content.Set.size - 1;
498: elem >= 0;
499: --elem) {
500: Curl_safefree(glob->pattern[i].content.Set.elements[elem]);
501: }
502: Curl_safefree(glob->pattern[i].content.Set.elements);
503: }
504: }
505: Curl_safefree(glob->glob_buffer);
506: Curl_safefree(glob);
507: }
508:
509: CURLcode glob_next_url(char **globbed, URLGlob *glob)
510: {
511: URLPattern *pat;
512: size_t i;
513: size_t len;
514: size_t buflen = glob->urllen + 1;
515: char *buf = glob->glob_buffer;
516:
517: *globbed = NULL;
518:
519: if(!glob->beenhere)
520: glob->beenhere = 1;
521: else {
522: bool carry = TRUE;
523:
524: /* implement a counter over the index ranges of all patterns, starting
525: with the rightmost pattern */
526: for(i = 0; carry && (i < glob->size); i++) {
527: carry = FALSE;
528: pat = &glob->pattern[glob->size - 1 - i];
529: switch(pat->type) {
530: case UPTSet:
531: if((pat->content.Set.elements) &&
532: (++pat->content.Set.ptr_s == pat->content.Set.size)) {
533: pat->content.Set.ptr_s = 0;
534: carry = TRUE;
535: }
536: break;
537: case UPTCharRange:
538: pat->content.CharRange.ptr_c =
539: (char)(pat->content.CharRange.step +
540: (int)((unsigned char)pat->content.CharRange.ptr_c));
541: if(pat->content.CharRange.ptr_c > pat->content.CharRange.max_c) {
542: pat->content.CharRange.ptr_c = pat->content.CharRange.min_c;
543: carry = TRUE;
544: }
545: break;
546: case UPTNumRange:
547: pat->content.NumRange.ptr_n += pat->content.NumRange.step;
548: if(pat->content.NumRange.ptr_n > pat->content.NumRange.max_n) {
549: pat->content.NumRange.ptr_n = pat->content.NumRange.min_n;
550: carry = TRUE;
551: }
552: break;
553: default:
554: printf("internal error: invalid pattern type (%d)\n", (int)pat->type);
555: return CURLE_FAILED_INIT;
556: }
557: }
558: if(carry) { /* first pattern ptr has run into overflow, done! */
559: return CURLE_OK;
560: }
561: }
562:
563: for(i = 0; i < glob->size; ++i) {
564: pat = &glob->pattern[i];
565: switch(pat->type) {
566: case UPTSet:
567: if(pat->content.Set.elements) {
568: msnprintf(buf, buflen, "%s",
569: pat->content.Set.elements[pat->content.Set.ptr_s]);
570: len = strlen(buf);
571: buf += len;
572: buflen -= len;
573: }
574: break;
575: case UPTCharRange:
576: if(buflen) {
577: *buf++ = pat->content.CharRange.ptr_c;
578: *buf = '\0';
579: buflen--;
580: }
581: break;
582: case UPTNumRange:
583: msnprintf(buf, buflen, "%0*lu",
584: pat->content.NumRange.padlength,
585: pat->content.NumRange.ptr_n);
586: len = strlen(buf);
587: buf += len;
588: buflen -= len;
589: break;
590: default:
591: printf("internal error: invalid pattern type (%d)\n", (int)pat->type);
592: return CURLE_FAILED_INIT;
593: }
594: }
595:
596: *globbed = strdup(glob->glob_buffer);
597: if(!*globbed)
598: return CURLE_OUT_OF_MEMORY;
599:
600: return CURLE_OK;
601: }
602:
603: CURLcode glob_match_url(char **result, char *filename, URLGlob *glob)
604: {
605: char *target;
606: size_t allocsize;
607: char numbuf[18];
608: char *appendthis = (char *)"";
609: size_t appendlen = 0;
610: size_t stringlen = 0;
611:
612: *result = NULL;
613:
614: /* We cannot use the glob_buffer for storage here since the filename may
615: * be longer than the URL we use. We allocate a good start size, then
616: * we need to realloc in case of need.
617: */
618: allocsize = strlen(filename) + 1; /* make it at least one byte to store the
619: trailing zero */
620: target = malloc(allocsize);
621: if(!target)
622: return CURLE_OUT_OF_MEMORY;
623:
624: while(*filename) {
625: if(*filename == '#' && ISDIGIT(filename[1])) {
626: char *ptr = filename;
627: unsigned long num = strtoul(&filename[1], &filename, 10);
628: URLPattern *pat = NULL;
629:
630: if(num && (num < glob->size)) {
631: unsigned long i;
632: num--; /* make it zero based */
633: /* find the correct glob entry */
634: for(i = 0; i<glob->size; i++) {
635: if(glob->pattern[i].globindex == (int)num) {
636: pat = &glob->pattern[i];
637: break;
638: }
639: }
640: }
641:
642: if(pat) {
643: switch(pat->type) {
644: case UPTSet:
645: if(pat->content.Set.elements) {
646: appendthis = pat->content.Set.elements[pat->content.Set.ptr_s];
647: appendlen =
648: strlen(pat->content.Set.elements[pat->content.Set.ptr_s]);
649: }
650: break;
651: case UPTCharRange:
652: numbuf[0] = pat->content.CharRange.ptr_c;
653: numbuf[1] = 0;
654: appendthis = numbuf;
655: appendlen = 1;
656: break;
657: case UPTNumRange:
658: msnprintf(numbuf, sizeof(numbuf), "%0*lu",
659: pat->content.NumRange.padlength,
660: pat->content.NumRange.ptr_n);
661: appendthis = numbuf;
662: appendlen = strlen(numbuf);
663: break;
664: default:
665: fprintf(stderr, "internal error: invalid pattern type (%d)\n",
666: (int)pat->type);
667: Curl_safefree(target);
668: return CURLE_FAILED_INIT;
669: }
670: }
671: else {
672: /* #[num] out of range, use the #[num] in the output */
673: filename = ptr;
674: appendthis = filename++;
675: appendlen = 1;
676: }
677: }
678: else {
679: appendthis = filename++;
680: appendlen = 1;
681: }
682: if(appendlen + stringlen >= allocsize) {
683: char *newstr;
684: /* we append a single byte to allow for the trailing byte to be appended
685: at the end of this function outside the while() loop */
686: allocsize = (appendlen + stringlen) * 2;
687: newstr = realloc(target, allocsize + 1);
688: if(!newstr) {
689: Curl_safefree(target);
690: return CURLE_OUT_OF_MEMORY;
691: }
692: target = newstr;
693: }
694: memcpy(&target[stringlen], appendthis, appendlen);
695: stringlen += appendlen;
696: }
697: target[stringlen]= '\0';
698:
699: #if defined(MSDOS) || defined(WIN32)
700: {
701: char *sanitized;
702: SANITIZEcode sc = sanitize_file_name(&sanitized, target,
703: (SANITIZE_ALLOW_PATH |
704: SANITIZE_ALLOW_RESERVED));
705: Curl_safefree(target);
706: if(sc)
707: return CURLE_URL_MALFORMAT;
708: target = sanitized;
709: }
710: #endif /* MSDOS || WIN32 */
711:
712: *result = target;
713: return CURLE_OK;
714: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to tool_urlglob.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 / src