Home | History | Annotate | Download | only in src 
      1 /***************************************************************************
      2  *                                  _   _ ____  _
      3  *  Project                     ___| | | |  _ \| |
      4  *                             / __| | | | |_) | |
      5  *                            | (__| |_| |  _ <| |___
      6  *                             \___|\___/|_| \_\_____|
      7  *
      8  * Copyright (C) 1998 - 2017, Daniel Stenberg, <daniel (at) 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 void glob_cleanup(URLGlob* glob);
     38 
     39 static 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  */
     66 static 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 
     79 static 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 
    173 static 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 
    324 static 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 
    354 static 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 
    432 CURLcode 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 
    487 void 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 
    507 CURLcode 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 
    602 CURLcode 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 }
    714