src/text/url.c

   1 /*****************************************************************************
   2  * url.c: URL related functions
   3  *****************************************************************************
   4  * Copyright (C) 2006 VLC authors and VideoLAN
   5  * Copyright (C) 2008-2012 Rémi Denis-Courmont
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU Lesser General Public License as published by
   9  * the Free Software Foundation; either version 2.1 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15  * GNU Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public License
  18  * along with this program; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  20  *****************************************************************************/
  21
  22 #ifdef HAVE_CONFIG_H
  23 # include "config.h"
  24 #endif
  25
  26 #include <errno.h>
  27 #include <limits.h>
  28 #include <stdint.h>
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <assert.h>
  33 #ifdef _WIN32
  34 # include <io.h>
  35 #endif
  36
  37 #include <vlc_common.h>
  38 #include <vlc_memstream.h>
  39 #include <vlc_url.h>
  40 #include <vlc_fs.h>
  41 #include <ctype.h>
  42
  43 char *vlc_uri_decode_duplicate (const char *str)
  44 {
  45     char *buf = strdup (str);
  46     if (vlc_uri_decode (buf) == NULL)
  47     {
  48         free (buf);
  49         buf = NULL;
  50     }
  51     return buf;
  52 }
  53
  54 char *vlc_uri_decode (char *str)
  55 {
  56     char *in = str, *out = str;
  57     if (in == NULL)
  58         return NULL;
  59
  60     char c;
  61     while ((c = *(in++)) != '\0')
  62     {
  63         if (c == '%')
  64         {
  65             char hex[3];
  66
  67             if (!(hex[0] = *(in++)) || !(hex[1] = *(in++)))
  68                 return NULL;
  69             hex[2] = '\0';
  70             *(out++) = strtoul (hex, NULL, 0x10);
  71         }
  72         else
  73             *(out++) = c;
  74     }
  75     *out = '\0';
  76     return str;
  77 }
  78
  79 static bool isurisafe (int c)
  80 {
  81     /* These are the _unreserved_ URI characters (RFC3986 §2.3) */
  82     return ((unsigned char)(c - 'a') < 26)
  83         || ((unsigned char)(c - 'A') < 26)
  84         || ((unsigned char)(c - '0') < 10)
  85         || (strchr ("-._~", c) != NULL);
  86 }
  87
  88 static bool isurisubdelim(int c)
  89 {
  90     return strchr("!$&'()*+,;=", c) != NULL;
  91 }
  92
  93 static bool isurihex(int c)
  94 {   /* Same as isxdigit() but does not depend on locale and unsignedness */
  95     return ((unsigned char)(c - '0') < 10)
  96         || ((unsigned char)(c - 'A') < 6)
  97         || ((unsigned char)(c - 'a') < 6);
  98 }
  99
 100 static const char urihex[] = "0123456789ABCDEF";
 101
 102 static char *encode_URI_bytes (const char *str, size_t *restrict lenp)
 103 {
 104     char *buf = malloc (3 * *lenp + 1);
 105     if (unlikely(buf == NULL))
 106         return NULL;
 107
 108     char *out = buf;
 109     for (size_t i = 0; i < *lenp; i++)
 110     {
 111         unsigned char c = str[i];
 112
 113         if (isurisafe (c))
 114             *(out++) = c;
 115         /* This is URI encoding, not HTTP forms:
 116          * Space is encoded as '%20', not '+'. */
 117         else
 118         {
 119             *(out++) = '%';
 120             *(out++) = urihex[c >> 4];
 121             *(out++) = urihex[c & 0xf];
 122         }
 123     }
 124
 125     *lenp = out - buf;
 126     out = realloc (buf, *lenp + 1);
 127     return likely(out != NULL) ? out : buf;
 128 }
 129
 130 char *vlc_uri_encode (const char *str)
 131 {
 132     size_t len = strlen (str);
 133     char *ret = encode_URI_bytes (str, &len);
 134     if (likely(ret != NULL))
 135         ret[len] = '\0';
 136     return ret;
 137 }
 138
 139 char *vlc_path2uri (const char *path, const char *scheme)
 140 {
 141     if (path == NULL)
 142     {
 143         errno = EINVAL;
 144         return NULL;
 145     }
 146     if (scheme == NULL && !strcmp (path, "-"))
 147         return strdup ("fd://0"); // standard input
 148     /* Note: VLC cannot handle URI schemes without double slash after the
 149      * scheme name (such as mailto: or news:). */
 150
 151     char *buf;
 152
 153 #ifdef __OS2__
 154     char p[strlen (path) + 1];
 155
 156     for (buf = p; *path; buf++, path++)
 157         *buf = (*path == '/') ? DIR_SEP_CHAR : *path;
 158     *buf = '\0';
 159
 160     path = p;
 161 #endif
 162
 163 #if defined (_WIN32) || defined (__OS2__)
 164     /* Drive letter */
 165     if (isalpha ((unsigned char)path[0]) && (path[1] == ':'))
 166     {
 167         if (asprintf (&buf, "%s:///%c:", scheme ? scheme : "file",
 168                       path[0]) == -1)
 169             buf = NULL;
 170         path += 2;
 171 # warning Drive letter-relative path not implemented!
 172         if (path[0] != DIR_SEP_CHAR)
 173         {
 174             errno = ENOTSUP;
 175             return NULL;
 176         }
 177     }
 178     else
 179     if (!strncmp (path, "\\\\", 2))
 180     {   /* Windows UNC paths */
 181         /* \\host\share\path -> file://host/share/path */
 182         int hostlen = strcspn (path + 2, DIR_SEP);
 183
 184         if (asprintf (&buf, "file://%.*s", hostlen, path + 2) == -1)
 185             buf = NULL;
 186         path += 2 + hostlen;
 187
 188         if (path[0] == '\0')
 189             return buf; /* Hostname without path */
 190     }
 191     else
 192 #endif
 193     if (path[0] != DIR_SEP_CHAR)
 194     {   /* Relative path: prepend the current working directory */
 195         char *cwd, *ret;
 196
 197         if ((cwd = vlc_getcwd ()) == NULL)
 198             return NULL;
 199         if (asprintf (&buf, "%s"DIR_SEP"%s", cwd, path) == -1)
 200             buf = NULL;
 201
 202         free (cwd);
 203         ret = (buf != NULL) ? vlc_path2uri (buf, scheme) : NULL;
 204         free (buf);
 205         return ret;
 206     }
 207     else
 208     if (asprintf (&buf, "%s://", scheme ? scheme : "file") == -1)
 209         buf = NULL;
 210     if (buf == NULL)
 211         return NULL;
 212
 213     /* Absolute file path */
 214     assert (path[0] == DIR_SEP_CHAR);
 215     do
 216     {
 217         size_t len = strcspn (++path, DIR_SEP);
 218         path += len;
 219
 220         char *component = encode_URI_bytes (path - len, &len);
 221         if (unlikely(component == NULL))
 222         {
 223             free (buf);
 224             return NULL;
 225         }
 226         component[len] = '\0';
 227
 228         char *uri;
 229         int val = asprintf (&uri, "%s/%s", buf, component);
 230         free (component);
 231         free (buf);
 232         if (unlikely(val == -1))
 233             return NULL;
 234         buf = uri;
 235     }
 236     while (*path);
 237
 238     return buf;
 239 }
 240
 241 char *vlc_uri2path (const char *url)
 242 {
 243     char *ret = NULL;
 244     char *end;
 245
 246     char *path = strstr (url, "://");
 247     if (path == NULL)
 248         return NULL; /* unsupported scheme or invalid syntax */
 249
 250     end = memchr (url, '/', path - url);
 251     size_t schemelen = ((end != NULL) ? end : path) - url;
 252     path += 3; /* skip "://" */
 253
 254     /* Remove request parameters and/or HTML anchor if present */
 255     end = path + strcspn (path, "?#");
 256     path = strndup (path, end - path);
 257     if (unlikely(path == NULL))
 258         return NULL; /* boom! */
 259
 260     /* Decode path */
 261     vlc_uri_decode (path);
 262
 263     if (schemelen == 4 && !strncasecmp (url, "file", 4))
 264     {
 265 #if !defined (_WIN32) && !defined (__OS2__)
 266         /* Leading slash => local path */
 267         if (*path == '/')
 268             return path;
 269         /* Local path disguised as a remote one */
 270         if (!strncasecmp (path, "localhost/", 10))
 271             return memmove (path, path + 9, strlen (path + 9) + 1);
 272 #else
 273         /* cannot start with a space */
 274         if (*path == ' ')
 275             goto out;
 276         for (char *p = strchr (path, '/'); p; p = strchr (p + 1, '/'))
 277             *p = '\\';
 278
 279         /* Leading backslash => local path */
 280         if (*path == '\\')
 281             return memmove (path, path + 1, strlen (path + 1) + 1);
 282         /* Local path disguised as a remote one */
 283         if (!strncasecmp (path, "localhost\\", 10))
 284             return memmove (path, path + 10, strlen (path + 10) + 1);
 285         /* UNC path */
 286         if (*path && asprintf (&ret, "\\\\%s", path) == -1)
 287             ret = NULL;
 288 #endif
 289         /* non-local path :-( */
 290     }
 291     else
 292     if (schemelen == 2 && !strncasecmp (url, "fd", 2))
 293     {
 294         int fd = strtol (path, &end, 0);
 295
 296         if (*end)
 297             goto out;
 298
 299 #if !defined( _WIN32 ) && !defined( __OS2__ )
 300         switch (fd)
 301         {
 302             case 0:
 303                 ret = strdup ("/dev/stdin");
 304                 break;
 305             case 1:
 306                 ret = strdup ("/dev/stdout");
 307                 break;
 308             case 2:
 309                 ret = strdup ("/dev/stderr");
 310                 break;
 311             default:
 312                 if (asprintf (&ret, "/dev/fd/%d", fd) == -1)
 313                     ret = NULL;
 314         }
 315 #else
 316         /* XXX: Does this work on WinCE? */
 317         if (fd < 2)
 318             ret = strdup ("CON");
 319 #endif
 320     }
 321
 322 out:
 323     free (path);
 324     return ret; /* unknown scheme */
 325 }
 326
 327 static char *vlc_idna_to_ascii (const char *);
 328
 329 /* RFC3987 §3.1 */
 330 static char *vlc_iri2uri(const char *iri)
 331 {
 332     size_t a = 0, u = 0;
 333
 334     for (size_t i = 0; iri[i] != '\0'; i++)
 335     {
 336         unsigned char c = iri[i];
 337
 338         if (c < 128)
 339             a++;
 340         else
 341             u++;
 342     }
 343
 344     if (unlikely((a + u) > (SIZE_MAX / 4)))
 345     {
 346         errno = ENOMEM;
 347         return NULL;
 348     }
 349
 350     char *uri = malloc(a + 3 * u + 1), *p;
 351     if (unlikely(uri == NULL))
 352         return NULL;
 353
 354     for (p = uri; *iri != '\0'; iri++)
 355     {
 356         unsigned char c = *iri;
 357
 358         if (c < 128)
 359             *(p++) = c;
 360         else
 361         {
 362             *(p++) = '%';
 363             *(p++) = urihex[c >> 4];
 364             *(p++) = urihex[c & 0xf];
 365         }
 366     }
 367
 368     *p = '\0';
 369     return uri;
 370 }
 371
 372 static bool vlc_uri_component_validate(const char *str, const char *extras)
 373 {
 374     assert(str != NULL);
 375
 376     for (size_t i = 0; str[i] != '\0'; i++)
 377     {
 378         int c = str[i];
 379
 380         if (isurisafe(c) || isurisubdelim(c))
 381             continue;
 382         if (strchr(extras, c) != NULL)
 383             continue;
 384         if (c == '%' && isurihex(str[i + 1]) && isurihex(str[i + 2]))
 385         {
 386             i += 2;
 387             continue;
 388         }
 389         return false;
 390     }
 391     return true;
 392 }
 393
 394 static bool vlc_uri_host_validate(const char *str)
 395 {
 396     return vlc_uri_component_validate(str, ":");
 397 }
 398
 399 static bool vlc_uri_path_validate(const char *str)
 400 {
 401     return vlc_uri_component_validate(str, "/@:");
 402 }
 403
 404 int vlc_UrlParse(vlc_url_t *restrict url, const char *str)
 405 {
 406     url->psz_protocol = NULL;
 407     url->psz_username = NULL;
 408     url->psz_password = NULL;
 409     url->psz_host = NULL;
 410     url->i_port = 0;
 411     url->psz_path = NULL;
 412     url->psz_option = NULL;
 413     url->psz_buffer = NULL;
 414
 415     if (str == NULL)
 416     {
 417         errno = EINVAL;
 418         return -1;
 419     }
 420
 421     char *buf = vlc_iri2uri(str);
 422     if (unlikely(buf == NULL))
 423         return -1;
 424     url->psz_buffer = buf;
 425
 426     char *cur = buf, *next;
 427     int ret = 0;
 428
 429     /* URI scheme */
 430     next = buf;
 431     while ((*next >= 'A' && *next <= 'Z') || (*next >= 'a' && *next <= 'z')
 432         || (*next >= '0' && *next <= '9') || memchr ("+-.", *next, 3) != NULL)
 433         next++;
 434
 435     if (*next == ':')
 436     {
 437         *(next++) = '\0';
 438         url->psz_protocol = cur;
 439         cur = next;
 440     }
 441
 442     /* Fragment */
 443     next = strchr(cur, '#');
 444     if (next != NULL)
 445     {
 446 #if 0  /* TODO */
 447        *(next++) = '\0';
 448        url->psz_fragment = next;
 449 #else
 450        *next = '\0';
 451 #endif
 452     }
 453
 454     /* Query parameters */
 455     next = strchr(cur, '?');
 456     if (next != NULL)
 457     {
 458         *(next++) = '\0';
 459         url->psz_option = next;
 460     }
 461
 462     /* Authority */
 463     if (strncmp(cur, "//", 2) == 0)
 464     {
 465         cur += 2;
 466
 467         /* Path */
 468         next = strchr(cur, '/');
 469         if (next != NULL)
 470         {
 471             *next = '\0'; /* temporary nul, reset to slash later */
 472             url->psz_path = next;
 473         }
 474         /*else
 475             url->psz_path = "/";*/
 476
 477         /* User name */
 478         next = strrchr(cur, '@');
 479         if (next != NULL)
 480         {
 481             *(next++) = '\0';
 482             url->psz_username = cur;
 483             cur = next;
 484
 485             /* Password (obsolete) */
 486             next = strchr(url->psz_username, ':');
 487             if (next != NULL)
 488             {
 489                 *(next++) = '\0';
 490                 url->psz_password = next;
 491                 vlc_uri_decode(url->psz_password);
 492             }
 493             vlc_uri_decode(url->psz_username);
 494         }
 495
 496         /* Host name */
 497         if (*cur == '[' && (next = strrchr(cur, ']')) != NULL)
 498         {   /* Try IPv6 numeral within brackets */
 499             *(next++) = '\0';
 500             url->psz_host = strdup(cur + 1);
 501
 502             if (*next == ':')
 503                 next++;
 504             else
 505                 next = NULL;
 506         }
 507         else
 508         {
 509             next = strchr(cur, ':');
 510             if (next != NULL)
 511                 *(next++) = '\0';
 512
 513             url->psz_host = vlc_idna_to_ascii(vlc_uri_decode(cur));
 514         }
 515
 516         if (url->psz_host == NULL)
 517             ret = -1;
 518         else
 519         if (!vlc_uri_host_validate(url->psz_host))
 520         {
 521             free(url->psz_host);
 522             url->psz_host = NULL;
 523             errno = EINVAL;
 524             ret = -1;
 525         }
 526
 527         /* Port number */
 528         if (next != NULL && *next)
 529         {
 530             char* end;
 531             unsigned long port = strtoul(next, &end, 10);
 532
 533             if (strchr("0123456789", *next) == NULL || *end || port > UINT_MAX)
 534             {
 535                 errno = EINVAL;
 536                 ret = -1;
 537             }
 538
 539             url->i_port = port;
 540         }
 541
 542         if (url->psz_path != NULL)
 543             *url->psz_path = '/'; /* restore leading slash */
 544     }
 545     else
 546     {
 547         url->psz_path = cur;
 548     }
 549
 550     if (url->psz_path != NULL && !vlc_uri_path_validate(url->psz_path))
 551     {
 552         url->psz_path = NULL;
 553         errno = EINVAL;
 554         ret = -1;
 555     }
 556
 557     return ret;
 558 }
 559
 560 void vlc_UrlClean (vlc_url_t *restrict url)
 561 {
 562     free (url->psz_host);
 563     free (url->psz_buffer);
 564 }
 565
 566 /**
 567  * Merge paths
 568  *
 569  * See IETF RFC3986 section 5.2.3 for details.
 570  */
 571 static char *vlc_uri_merge_paths(const char *base, const char *ref)
 572 {
 573     char *str;
 574     int len;
 575
 576     if (base == NULL)
 577         len = asprintf(&str, "/%s", ref);
 578     else
 579     {
 580         const char *end = strrchr(base, '/');
 581
 582         if (end != NULL)
 583             end++;
 584         else
 585             end = base;
 586
 587         len = asprintf(&str, "%.*s%s", (int)(end - base), base, ref);
 588     }
 589
 590     if (unlikely(len == -1))
 591         str = NULL;
 592     return str;
 593 }
 594
 595 /**
 596  * Remove dot segments
 597  *
 598  * See IETF RFC3986 section 5.2.4 for details.
 599  */
 600 static char *vlc_uri_remove_dot_segments(char *str)
 601 {
 602     char *input = str, *output = str;
 603
 604     while (input[0] != '\0')
 605     {
 606         assert(output <= input);
 607
 608         if (strncmp(input, "../", 3) == 0)
 609         {
 610             input += 3;
 611             continue;
 612         }
 613         if (strncmp(input, "./", 2) == 0)
 614         {
 615             input += 2;
 616             continue;
 617         }
 618         if (strncmp(input, "/./", 3) == 0)
 619         {
 620             input += 2;
 621             continue;
 622         }
 623         if (strcmp(input, "/.") == 0)
 624         {
 625             input[1] = '\0';
 626             continue;
 627         }
 628         if (strncmp(input, "/../", 4) == 0)
 629         {
 630             input += 3;
 631             output = memrchr(str, '/', output - str);
 632             if (output == NULL)
 633                 output = str;
 634             continue;
 635         }
 636         if (strcmp(input, "/..") == 0)
 637         {
 638             input[1] = '\0';
 639             output = memrchr(str, '/', output - str);
 640             if (output == NULL)
 641                 output = str;
 642             continue;
 643         }
 644         if (strcmp(input, ".") == 0)
 645         {
 646             input++;
 647             continue;
 648         }
 649         if (strcmp(input, "..") == 0)
 650         {
 651             input += 2;
 652             continue;
 653         }
 654
 655         if (input[0] == '/')
 656             *(output++) = *(input++);
 657
 658         size_t len = strcspn(input, "/");
 659
 660         if (input != output)
 661             memmove(output, input, len);
 662
 663         input += len;
 664         output += len;
 665     }
 666
 667     output[0] = '\0';
 668     return str;
 669 }
 670
 671 char *vlc_uri_compose(const vlc_url_t *uri)
 672 {
 673     struct vlc_memstream stream;
 674     char *enc;
 675
 676     vlc_memstream_open(&stream);
 677
 678     if (uri->psz_protocol != NULL)
 679         vlc_memstream_printf(&stream, "%s:", uri->psz_protocol);
 680
 681     if (uri->psz_host != NULL)
 682     {
 683         vlc_memstream_write(&stream, "//", 2);
 684
 685         if (uri->psz_username != NULL)
 686         {
 687             enc = vlc_uri_encode(uri->psz_username);
 688             if (enc == NULL)
 689                 goto error;
 690
 691             vlc_memstream_puts(&stream, enc);
 692             free(enc);
 693
 694             if (uri->psz_password != NULL)
 695             {
 696                 enc = vlc_uri_encode(uri->psz_password);
 697                 if (unlikely(enc == NULL))
 698                     goto error;
 699
 700                 vlc_memstream_printf(&stream, ":%s", enc);
 701                 free(enc);
 702             }
 703             vlc_memstream_putc(&stream, '@');
 704         }
 705
 706         const char *fmt;
 707
 708         if (strchr(uri->psz_host, ':') != NULL)
 709             fmt = (uri->i_port != 0) ? "[%s]:%d" : "[%s]";
 710         else
 711             fmt = (uri->i_port != 0) ? "%s:%d" : "%s";
 712         /* No IDNA decoding here. Seems unnecessary, dangerous even. */
 713         vlc_memstream_printf(&stream, fmt, uri->psz_host, uri->i_port);
 714     }
 715
 716     if (uri->psz_path != NULL)
 717         vlc_memstream_puts(&stream, uri->psz_path);
 718     if (uri->psz_option != NULL)
 719         vlc_memstream_printf(&stream, "?%s", uri->psz_option);
 720     /* NOTE: fragment not handled currently */
 721
 722     if (vlc_memstream_close(&stream))
 723         return NULL;
 724     return stream.ptr;
 725
 726 error:
 727     if (vlc_memstream_close(&stream) == 0)
 728         free(stream.ptr);
 729     return NULL;
 730 }
 731
 732 char *vlc_uri_resolve(const char *base, const char *ref)
 733 {
 734     vlc_url_t base_uri, rel_uri;
 735     vlc_url_t tgt_uri;
 736     char *pathbuf = NULL, *ret = NULL;
 737
 738     if (vlc_UrlParse(&rel_uri, ref))
 739     {
 740         vlc_UrlClean(&rel_uri);
 741         return NULL;
 742     }
 743
 744     if (rel_uri.psz_protocol != NULL)
 745     {   /* Short circuit in case of absolute URI */
 746         vlc_UrlClean(&rel_uri);
 747         return strdup(ref);
 748     }
 749
 750     vlc_UrlParse(&base_uri, base);
 751
 752     /* RFC3986 section 5.2.2 */
 753     do
 754     {
 755         tgt_uri = rel_uri;
 756         tgt_uri.psz_protocol = base_uri.psz_protocol;
 757
 758         if (rel_uri.psz_host != NULL)
 759             break;
 760
 761         tgt_uri.psz_username = base_uri.psz_username;
 762         tgt_uri.psz_password = base_uri.psz_password;
 763         tgt_uri.psz_host = base_uri.psz_host;
 764         tgt_uri.i_port = base_uri.i_port;
 765
 766         if (rel_uri.psz_path == NULL || rel_uri.psz_path[0] == '\0')
 767         {
 768             tgt_uri.psz_path = base_uri.psz_path;
 769             if (rel_uri.psz_option == NULL)
 770                 tgt_uri.psz_option = base_uri.psz_option;
 771             break;
 772         }
 773
 774         if (rel_uri.psz_path[0] == '/')
 775             break;
 776
 777         pathbuf = vlc_uri_merge_paths(base_uri.psz_path, rel_uri.psz_path);
 778         if (unlikely(pathbuf == NULL))
 779             goto error;
 780
 781         tgt_uri.psz_path = pathbuf;
 782     }
 783     while (0);
 784
 785     if (tgt_uri.psz_path != NULL)
 786         vlc_uri_remove_dot_segments(tgt_uri.psz_path);
 787
 788     ret = vlc_uri_compose(&tgt_uri);
 789 error:
 790     free(pathbuf);
 791     vlc_UrlClean(&base_uri);
 792     vlc_UrlClean(&rel_uri);
 793     return ret;
 794 }
 795
 796 char *vlc_uri_fixup(const char *str)
 797 {
 798     /* Rule number one is do not change a (potentially) valid URI */
 799     if (vlc_uri_component_validate(str, ":/?#[]@"))
 800         return strdup(str);
 801
 802     bool encode_percent = false;
 803     for (size_t i = 0; str[i] != '\0'; i++)
 804         if (str[i] == '%' && !(isurihex(str[i+1]) && isurihex(str[i+2])))
 805         {
 806             encode_percent = true;
 807             break;
 808         }
 809
 810     struct vlc_memstream stream;
 811
 812     vlc_memstream_open(&stream);
 813
 814     for (size_t i = 0; str[i] != '\0'; i++)
 815     {
 816         unsigned char c = str[i];
 817
 818         if (isurisafe(c) || isurisubdelim(c) || (strchr(":/?#[]@", c) != NULL)
 819          || (c == '%' && !encode_percent))
 820             vlc_memstream_putc(&stream, c);
 821         else
 822             vlc_memstream_printf(&stream, "%%%02hhX", c);
 823     }
 824
 825     if (vlc_memstream_close(&stream))
 826         return NULL;
 827     return stream.ptr;
 828 }
 829
 830 #if defined (HAVE_IDN)
 831 # include <idna.h>
 832 #elif defined (_WIN32)
 833 # include <windows.h>
 834 # include <vlc_charset.h>
 835
 836 # if (_WIN32_WINNT < _WIN32_WINNT_VISTA)
 837 #  define IDN_ALLOW_UNASSIGNED 0x01
 838 static int IdnToAscii(DWORD flags, LPCWSTR str, int len, LPWSTR buf, int size)
 839 {
 840     HMODULE h = LoadLibrary(_T("Normaliz.dll"));
 841     if (h == NULL)
 842     {
 843         errno = ENOSYS;
 844         return 0;
 845     }
 846
 847     int (WINAPI *IdnToAsciiReal)(DWORD, LPCWSTR, int, LPWSTR, int);
 848     int ret = 0;
 849
 850     IdnToAsciiReal = GetProcAddress(h, "IdnToAscii");
 851     if (IdnToAsciiReal != NULL)
 852         ret = IdnToAsciiReal(flags, str, len, buf, size);
 853     else
 854         errno = ENOSYS;
 855     FreeLibrary(h);
 856     return ret;
 857 }
 858 # endif
 859 #endif
 860
 861 /**
 862  * Converts a UTF-8 nul-terminated IDN to nul-terminated ASCII domain name.
 863  * \param idn UTF-8 Internationalized Domain Name to convert
 864  * \return a heap-allocated string or NULL on error.
 865  */
 866 static char *vlc_idna_to_ascii (const char *idn)
 867 {
 868 #if defined (HAVE_IDN)
 869     char *adn;
 870
 871     switch (idna_to_ascii_8z(idn, &adn, IDNA_ALLOW_UNASSIGNED))
 872     {
 873         case IDNA_SUCCESS:
 874             return adn;
 875         case IDNA_MALLOC_ERROR:
 876             errno = ENOMEM;
 877             return NULL;
 878         case IDNA_DLOPEN_ERROR:
 879             errno = ENOSYS;
 880             return NULL;
 881         default:
 882             errno = EINVAL;
 883             return NULL;
 884     }
 885
 886 #elif defined (_WIN32)
 887     char *ret = NULL;
 888
 889     if (idn[0] == '\0')
 890         return strdup("");
 891
 892     wchar_t *wide = ToWide (idn);
 893     if (wide == NULL)
 894         return NULL;
 895
 896     int len = IdnToAscii (IDN_ALLOW_UNASSIGNED, wide, -1, NULL, 0);
 897     if (len == 0)
 898     {
 899         errno = EINVAL;
 900         goto error;
 901     }
 902
 903     wchar_t *buf = malloc (sizeof (*buf) * len);
 904     if (unlikely(buf == NULL))
 905         goto error;
 906     if (!IdnToAscii (IDN_ALLOW_UNASSIGNED, wide, -1, buf, len))
 907     {
 908         free (buf);
 909         errno = EINVAL;
 910         goto error;
 911     }
 912     ret = FromWide (buf);
 913     free (buf);
 914 error:
 915     free (wide);
 916     return ret;
 917
 918 #else
 919     /* No IDN support, filter out non-ASCII domain names */
 920     for (const char *p = idn; *p; p++)
 921         if (((unsigned char)*p) >= 0x80)
 922         {
 923             errno = ENOSYS;
 924             return NULL;
 925         }
 926
 927     return strdup (idn);
 928
 929 #endif
 930 }