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