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 static int vlc_UrlParseInner(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     url->psz_pathbuffer = NULL;
 415
 416     if (str == NULL)
 417     {
 418         errno = EINVAL;
 419         return -1;
 420     }
 421
 422     char *buf = vlc_iri2uri(str);
 423     if (unlikely(buf == NULL))
 424         return -1;
 425     url->psz_buffer = buf;
 426
 427     char *cur = buf, *next;
 428     int ret = 0;
 429
 430     /* URI scheme */
 431     next = buf;
 432     while ((*next >= 'A' && *next <= 'Z') || (*next >= 'a' && *next <= 'z')
 433         || (*next >= '0' && *next <= '9') || memchr ("+-.", *next, 3) != NULL)
 434         next++;
 435
 436     if (*next == ':')
 437     {
 438         *(next++) = '\0';
 439         url->psz_protocol = cur;
 440         cur = next;
 441     }
 442
 443     /* Fragment */
 444     next = strchr(cur, '#');
 445     if (next != NULL)
 446     {
 447 #if 0  /* TODO */
 448        *(next++) = '\0';
 449        url->psz_fragment = next;
 450 #else
 451        *next = '\0';
 452 #endif
 453     }
 454
 455     /* Query parameters */
 456     next = strchr(cur, '?');
 457     if (next != NULL)
 458     {
 459         *(next++) = '\0';
 460         url->psz_option = next;
 461     }
 462
 463     /* Authority */
 464     if (strncmp(cur, "//", 2) == 0)
 465     {
 466         cur += 2;
 467
 468         /* Path */
 469         next = strchr(cur, '/');
 470         if (next != NULL)
 471         {
 472             *next = '\0'; /* temporary nul, reset to slash later */
 473             url->psz_path = next;
 474         }
 475         /*else
 476             url->psz_path = "/";*/
 477
 478         /* User name */
 479         next = strrchr(cur, '@');
 480         if (next != NULL)
 481         {
 482             *(next++) = '\0';
 483             url->psz_username = cur;
 484             cur = next;
 485
 486             /* Password (obsolete) */
 487             next = strchr(url->psz_username, ':');
 488             if (next != NULL)
 489             {
 490                 *(next++) = '\0';
 491                 url->psz_password = next;
 492                 vlc_uri_decode(url->psz_password);
 493             }
 494             vlc_uri_decode(url->psz_username);
 495         }
 496
 497         /* Host name */
 498         if (*cur == '[' && (next = strrchr(cur, ']')) != NULL)
 499         {   /* Try IPv6 numeral within brackets */
 500             *(next++) = '\0';
 501             url->psz_host = strdup(cur + 1);
 502
 503             if (*next == ':')
 504                 next++;
 505             else
 506                 next = NULL;
 507         }
 508         else
 509         {
 510             next = strchr(cur, ':');
 511             if (next != NULL)
 512                 *(next++) = '\0';
 513
 514             url->psz_host = vlc_idna_to_ascii(vlc_uri_decode(cur));
 515         }
 516
 517         if (url->psz_host == NULL)
 518             ret = -1;
 519         else
 520         if (!vlc_uri_host_validate(url->psz_host))
 521         {
 522             free(url->psz_host);
 523             url->psz_host = NULL;
 524             errno = EINVAL;
 525             ret = -1;
 526         }
 527
 528         /* Port number */
 529         if (next != NULL && *next)
 530         {
 531             char* end;
 532             unsigned long port = strtoul(next, &end, 10);
 533
 534             if (strchr("0123456789", *next) == NULL || *end || port > UINT_MAX)
 535             {
 536                 errno = EINVAL;
 537                 ret = -1;
 538             }
 539
 540             url->i_port = port;
 541         }
 542
 543         if (url->psz_path != NULL)
 544             *url->psz_path = '/'; /* restore leading slash */
 545     }
 546     else
 547     {
 548         url->psz_path = cur;
 549     }
 550
 551     return ret;
 552 }
 553
 554 int vlc_UrlParse(vlc_url_t *url, const char *str)
 555 {
 556     int ret = vlc_UrlParseInner(url, str);
 557
 558     if (url->psz_path != NULL && !vlc_uri_path_validate(url->psz_path))
 559     {
 560         url->psz_path = NULL;
 561         errno = EINVAL;
 562         ret = -1;
 563     }
 564     return ret;
 565 }
 566
 567 static char *vlc_uri_fixup_inner(const char *str, const char *extras);
 568
 569 int vlc_UrlParseFixup(vlc_url_t *url, const char *str)
 570 {
 571     int ret = vlc_UrlParseInner(url, str);
 572
 573     static const char pathextras[] = "/@:";
 574
 575     if (url->psz_path != NULL
 576      && !vlc_uri_component_validate(url->psz_path, pathextras))
 577     {
 578         url->psz_pathbuffer = vlc_uri_fixup_inner(url->psz_path, pathextras);
 579         if (url->psz_pathbuffer == NULL)
 580         {
 581             url->psz_path = NULL;
 582             errno = ENOMEM;
 583             ret = -1;
 584         }
 585         else
 586         {
 587             url->psz_path = url->psz_pathbuffer;
 588             assert(vlc_uri_path_validate(url->psz_path));
 589         }
 590     }
 591     return ret;
 592 }
 593
 594 void vlc_UrlClean (vlc_url_t *restrict url)
 595 {
 596     free (url->psz_host);
 597     free (url->psz_buffer);
 598     free (url->psz_pathbuffer);
 599 }
 600
 601 /**
 602  * Merge paths
 603  *
 604  * See IETF RFC3986 section 5.2.3 for details.
 605  */
 606 static char *vlc_uri_merge_paths(const char *base, const char *ref)
 607 {
 608     char *str;
 609     int len;
 610
 611     if (base == NULL)
 612         len = asprintf(&str, "/%s", ref);
 613     else
 614     {
 615         const char *end = strrchr(base, '/');
 616
 617         if (end != NULL)
 618             end++;
 619         else
 620             end = base;
 621
 622         len = asprintf(&str, "%.*s%s", (int)(end - base), base, ref);
 623     }
 624
 625     if (unlikely(len == -1))
 626         str = NULL;
 627     return str;
 628 }
 629
 630 /**
 631  * Remove dot segments
 632  *
 633  * See IETF RFC3986 section 5.2.4 for details.
 634  */
 635 static char *vlc_uri_remove_dot_segments(char *str)
 636 {
 637     char *input = str, *output = str;
 638
 639     while (input[0] != '\0')
 640     {
 641         assert(output <= input);
 642
 643         if (strncmp(input, "../", 3) == 0)
 644         {
 645             input += 3;
 646             continue;
 647         }
 648         if (strncmp(input, "./", 2) == 0)
 649         {
 650             input += 2;
 651             continue;
 652         }
 653         if (strncmp(input, "/./", 3) == 0)
 654         {
 655             input += 2;
 656             continue;
 657         }
 658         if (strcmp(input, "/.") == 0)
 659         {
 660             input[1] = '\0';
 661             continue;
 662         }
 663         if (strncmp(input, "/../", 4) == 0)
 664         {
 665             input += 3;
 666             output = memrchr(str, '/', output - str);
 667             if (output == NULL)
 668                 output = str;
 669             continue;
 670         }
 671         if (strcmp(input, "/..") == 0)
 672         {
 673             input[1] = '\0';
 674             output = memrchr(str, '/', output - str);
 675             if (output == NULL)
 676                 output = str;
 677             continue;
 678         }
 679         if (strcmp(input, ".") == 0)
 680         {
 681             input++;
 682             continue;
 683         }
 684         if (strcmp(input, "..") == 0)
 685         {
 686             input += 2;
 687             continue;
 688         }
 689
 690         if (input[0] == '/')
 691             *(output++) = *(input++);
 692
 693         size_t len = strcspn(input, "/");
 694
 695         if (input != output)
 696             memmove(output, input, len);
 697
 698         input += len;
 699         output += len;
 700     }
 701
 702     output[0] = '\0';
 703     return str;
 704 }
 705
 706 char *vlc_uri_compose(const vlc_url_t *uri)
 707 {
 708     struct vlc_memstream stream;
 709     char *enc;
 710
 711     vlc_memstream_open(&stream);
 712
 713     if (uri->psz_protocol != NULL)
 714         vlc_memstream_printf(&stream, "%s:", uri->psz_protocol);
 715
 716     if (uri->psz_host != NULL)
 717     {
 718         vlc_memstream_write(&stream, "//", 2);
 719
 720         if (uri->psz_username != NULL)
 721         {
 722             enc = vlc_uri_encode(uri->psz_username);
 723             if (enc == NULL)
 724                 goto error;
 725
 726             vlc_memstream_puts(&stream, enc);
 727             free(enc);
 728
 729             if (uri->psz_password != NULL)
 730             {
 731                 enc = vlc_uri_encode(uri->psz_password);
 732                 if (unlikely(enc == NULL))
 733                     goto error;
 734
 735                 vlc_memstream_printf(&stream, ":%s", enc);
 736                 free(enc);
 737             }
 738             vlc_memstream_putc(&stream, '@');
 739         }
 740
 741         const char *fmt;
 742
 743         if (strchr(uri->psz_host, ':') != NULL)
 744             fmt = (uri->i_port != 0) ? "[%s]:%d" : "[%s]";
 745         else
 746             fmt = (uri->i_port != 0) ? "%s:%d" : "%s";
 747         /* No IDNA decoding here. Seems unnecessary, dangerous even. */
 748         vlc_memstream_printf(&stream, fmt, uri->psz_host, uri->i_port);
 749     }
 750
 751     if (uri->psz_path != NULL)
 752         vlc_memstream_puts(&stream, uri->psz_path);
 753     if (uri->psz_option != NULL)
 754         vlc_memstream_printf(&stream, "?%s", uri->psz_option);
 755     /* NOTE: fragment not handled currently */
 756
 757     if (vlc_memstream_close(&stream))
 758         return NULL;
 759     return stream.ptr;
 760
 761 error:
 762     if (vlc_memstream_close(&stream) == 0)
 763         free(stream.ptr);
 764     return NULL;
 765 }
 766
 767 char *vlc_uri_resolve(const char *base, const char *ref)
 768 {
 769     vlc_url_t base_uri, rel_uri;
 770     vlc_url_t tgt_uri;
 771     char *pathbuf = NULL, *ret = NULL;
 772
 773     if (vlc_UrlParse(&rel_uri, ref))
 774     {
 775         vlc_UrlClean(&rel_uri);
 776         return NULL;
 777     }
 778
 779     if (rel_uri.psz_protocol != NULL)
 780     {   /* Short circuit in case of absolute URI */
 781         vlc_UrlClean(&rel_uri);
 782         return strdup(ref);
 783     }
 784
 785     vlc_UrlParse(&base_uri, base);
 786
 787     /* RFC3986 section 5.2.2 */
 788     do
 789     {
 790         tgt_uri = rel_uri;
 791         tgt_uri.psz_protocol = base_uri.psz_protocol;
 792
 793         if (rel_uri.psz_host != NULL)
 794             break;
 795
 796         tgt_uri.psz_username = base_uri.psz_username;
 797         tgt_uri.psz_password = base_uri.psz_password;
 798         tgt_uri.psz_host = base_uri.psz_host;
 799         tgt_uri.i_port = base_uri.i_port;
 800
 801         if (rel_uri.psz_path == NULL || rel_uri.psz_path[0] == '\0')
 802         {
 803             tgt_uri.psz_path = base_uri.psz_path;
 804             if (rel_uri.psz_option == NULL)
 805                 tgt_uri.psz_option = base_uri.psz_option;
 806             break;
 807         }
 808
 809         if (rel_uri.psz_path[0] == '/')
 810             break;
 811
 812         pathbuf = vlc_uri_merge_paths(base_uri.psz_path, rel_uri.psz_path);
 813         if (unlikely(pathbuf == NULL))
 814             goto error;
 815
 816         tgt_uri.psz_path = pathbuf;
 817     }
 818     while (0);
 819
 820     if (tgt_uri.psz_path != NULL)
 821         vlc_uri_remove_dot_segments(tgt_uri.psz_path);
 822
 823     ret = vlc_uri_compose(&tgt_uri);
 824 error:
 825     free(pathbuf);
 826     vlc_UrlClean(&base_uri);
 827     vlc_UrlClean(&rel_uri);
 828     return ret;
 829 }
 830
 831 static char *vlc_uri_fixup_inner(const char *str, const char *extras)
 832 {
 833     assert(str && extras);
 834
 835     bool encode_percent = false;
 836     for (size_t i = 0; str[i] != '\0'; i++)
 837         if (str[i] == '%' && !(isurihex(str[i+1]) && isurihex(str[i+2])))
 838         {
 839             encode_percent = true;
 840             break;
 841         }
 842
 843     struct vlc_memstream stream;
 844
 845     vlc_memstream_open(&stream);
 846
 847     for (size_t i = 0; str[i] != '\0'; i++)
 848     {
 849         unsigned char c = str[i];
 850
 851         if (isurisafe(c) || isurisubdelim(c) || (strchr(extras, c) != NULL)
 852          || (c == '%' && !encode_percent))
 853             vlc_memstream_putc(&stream, c);
 854         else
 855             vlc_memstream_printf(&stream, "%%%02hhX", c);
 856     }
 857
 858     if (vlc_memstream_close(&stream))
 859         return NULL;
 860     return stream.ptr;
 861 }
 862
 863 char *vlc_uri_fixup(const char *str)
 864 {
 865     static const char extras[] = ":/?#[]@";
 866
 867     /* Rule number one is do not change a (potentially) valid URI */
 868     if (vlc_uri_component_validate(str, extras))
 869         return strdup(str);
 870
 871     return vlc_uri_fixup_inner(str, extras);
 872 }
 873
 874 #if defined (HAVE_IDN)
 875 # include <idna.h>
 876 #elif defined (_WIN32)
 877 # include <windows.h>
 878 # include <vlc_charset.h>
 879 #endif
 880
 881 /**
 882  * Converts a UTF-8 nul-terminated IDN to nul-terminated ASCII domain name.
 883  * \param idn UTF-8 Internationalized Domain Name to convert
 884  * \return a heap-allocated string or NULL on error.
 885  */
 886 static char *vlc_idna_to_ascii (const char *idn)
 887 {
 888 #if defined (HAVE_IDN)
 889     char *adn;
 890
 891     switch (idna_to_ascii_8z(idn, &adn, IDNA_ALLOW_UNASSIGNED))
 892     {
 893         case IDNA_SUCCESS:
 894             return adn;
 895         case IDNA_MALLOC_ERROR:
 896             errno = ENOMEM;
 897             return NULL;
 898         case IDNA_DLOPEN_ERROR:
 899             errno = ENOSYS;
 900             return NULL;
 901         default:
 902             errno = EINVAL;
 903             return NULL;
 904     }
 905
 906 #elif defined (_WIN32)
 907     char *ret = NULL;
 908
 909     if (idn[0] == '\0')
 910         return strdup("");
 911
 912     wchar_t *wide = ToWide (idn);
 913     if (wide == NULL)
 914         return NULL;
 915
 916     int len = IdnToAscii (IDN_ALLOW_UNASSIGNED, wide, -1, NULL, 0);
 917     if (len == 0)
 918     {
 919         errno = EINVAL;
 920         goto error;
 921     }
 922
 923     wchar_t *buf = vlc_alloc (len, sizeof (*buf));
 924     if (unlikely(buf == NULL))
 925         goto error;
 926     if (!IdnToAscii (IDN_ALLOW_UNASSIGNED, wide, -1, buf, len))
 927     {
 928         free (buf);
 929         errno = EINVAL;
 930         goto error;
 931     }
 932     ret = FromWide (buf);
 933     free (buf);
 934 error:
 935     free (wide);
 936     return ret;
 937
 938 #else
 939     /* No IDN support, filter out non-ASCII domain names */
 940     for (const char *p = idn; *p; p++)
 941         if (((unsigned char)*p) >= 0x80)
 942         {
 943             errno = ENOSYS;
 944             return NULL;
 945         }
 946
 947     return strdup (idn);
 948
 949 #endif
 950 }