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