source: azure_iot_hub/trunk/curl-7.57.0/src/tool_urlglob.c@ 389

Last change on this file since 389 was 389, checked in by coas-nagasima, 5 years ago

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