luna - curl/tests/libtest/lib1560.c

   1/***************************************************************************
   2 *                                  _   _ ____  _
   3 *  Project                     ___| | | |  _ \| |
   4 *                             / __| | | | |_) | |
   5 *                            | (__| |_| |  _ <| |___
   6 *                             \___|\___/|_| \_\_____|
   7 *
   8 * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
   9 *
  10 * This software is licensed as described in the file COPYING, which
  11 * you should have received as part of this distribution. The terms
  12 * are also available at https://curl.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 * SPDX-License-Identifier: curl
  22 *
  23 ***************************************************************************/
  24
  25/*
  26 * Note:
  27 *
  28 * Since the URL parser by default only accepts schemes that *this instance*
  29 * of libcurl supports, make sure that the test1560 file lists all the schemes
  30 * that this test will assume to be present!
  31 */
  32
  33#include "first.h"
  34#if defined(USE_LIBIDN2) || defined(USE_WIN32_IDN) || defined(USE_APPLE_IDN)
  35#define USE_IDN
  36#endif
  37
  38static int checkparts(CURLU *u, const char *in, const char *wanted,
  39                      unsigned int getflags)
  40{
  41  int i;
  42  CURLUcode rc;
  43  char buf[256];
  44  char *bufp = &buf[0];
  45  size_t len = sizeof(buf);
  46
  47  struct part {
  48    CURLUPart part;
  49    const char *name;
  50  };
  51
  52  struct part parts[] = {
  53    { CURLUPART_SCHEME, "scheme" },
  54    { CURLUPART_USER, "user" },
  55    { CURLUPART_PASSWORD, "password" },
  56    { CURLUPART_OPTIONS, "options" },
  57    { CURLUPART_HOST, "host" },
  58    { CURLUPART_PORT, "port" },
  59    { CURLUPART_PATH, "path" },
  60    { CURLUPART_QUERY, "query" },
  61    { CURLUPART_FRAGMENT, "fragment" },
  62    { CURLUPART_URL, NULL }
  63  };
  64  memset(buf, 0, sizeof(buf));
  65
  66  for(i = 0; parts[i].name; i++) {
  67    char *p = NULL;
  68    char *z = NULL;
  69    size_t n;
  70    rc = curl_url_get(u, parts[i].part, &p, getflags);
  71    if(!rc && p) {
  72      if((parts[i].part == CURLUPART_HOST) && (p[0] == '['))
  73        /* an IPv6 numerical address host, get the zone */
  74        (void)curl_url_get(u, CURLUPART_ZONEID, &z, getflags);
  75      curl_msnprintf(bufp, len, "%s%s%s%s", buf[0] ? " | " : "", p,
  76                     z ? " " : "", z ? z : "");
  77    }
  78    else
  79      curl_msnprintf(bufp, len, "%s[%d]", buf[0] ? " | " : "", rc);
  80
  81    n = strlen(bufp);
  82    bufp += n;
  83    len -= n;
  84    curl_free(p);
  85    curl_free(z);
  86  }
  87  if(strcmp(buf, wanted)) {
  88    curl_mfprintf(stderr, "in: %s\nwanted: %s\ngot:    %s\n", in, wanted, buf);
  89    return 1;
  90  }
  91  return 0;
  92}
  93
  94struct redircase {
  95  const char *in;
  96  const char *set;
  97  const char *out;
  98  unsigned int urlflags;
  99  unsigned int setflags;
 100  CURLUcode ucode;
 101};
 102
 103struct setcase {
 104  const char *in;
 105  const char *set;
 106  const char *out;
 107  unsigned int urlflags;
 108  unsigned int setflags;
 109  CURLUcode ucode; /* for the main URL set */
 110  CURLUcode pcode; /* for updating parts */
 111};
 112
 113struct setgetcase {
 114  const char *in;
 115  const char *set;
 116  const char *out;
 117  unsigned int urlflags; /* for setting the URL */
 118  unsigned int setflags; /* for updating parts */
 119  unsigned int getflags; /* for getting parts */
 120  CURLUcode pcode; /* for updating parts */
 121};
 122
 123struct testcase {
 124  const char *in;
 125  const char *out;
 126  unsigned int urlflags;
 127  unsigned int getflags;
 128  CURLUcode ucode;
 129};
 130
 131struct urltestcase {
 132  const char *in;
 133  const char *out;
 134  unsigned int urlflags; /* pass to curl_url() */
 135  unsigned int getflags; /* pass to curl_url_get() */
 136  CURLUcode ucode;
 137};
 138
 139struct querycase {
 140  const char *in;
 141  const char *q;
 142  const char *out;
 143  unsigned int urlflags; /* pass to curl_url() */
 144  unsigned int qflags; /* pass to curl_url_get() */
 145  CURLUcode ucode;
 146};
 147
 148struct clearurlcase {
 149  CURLUPart part;
 150  const char *in;
 151  const char *out;
 152  CURLUcode ucode;
 153};
 154
 155static const struct testcase get_parts_list[] = {
 156  { /* query and fragments with control characters */
 157    "http://host/path/?\001#\002",
 158    "", CURLU_URLENCODE, 0, CURLUE_MALFORMED_INPUT },
 159  { /* Control code in port number is never okay, even when URL encoding */
 160    "http://host:\x1f""80/path/",
 161    "", CURLU_URLENCODE, 0, CURLUE_MALFORMED_INPUT },
 162  { /* Control code in scheme never okay, even when URL encoding */
 163    "http\x1f://host/path/",
 164    "", CURLU_URLENCODE, 0, CURLUE_MALFORMED_INPUT },
 165  { /* Control code in separator never okay, even when URL encoding */
 166    "http:/%1f/host/path/",
 167    "", CURLU_URLENCODE, 0, CURLUE_BAD_HOSTNAME },
 168  { /* Path with control characters */
 169    "http://host/path\001with\002ctrl/",
 170    "", CURLU_URLENCODE, 0, CURLUE_MALFORMED_INPUT },
 171  { /* Path with control characters and space! */
 172    "http://host/path\x7fwith space/",
 173    "", CURLU_URLENCODE, 0, CURLUE_MALFORMED_INPUT },
 174  { /* Ensure %2f is NOT normalized to / even if path-as-is is NOT set */
 175    "http://host/path%2f..%2f/",
 176    "http | [11] | [12] | [13] | host | [15] | /path%2f..%2f/ | [16] | [17]",
 177    0, 0, CURLUE_OK },
 178  { /* Set without scheme using guess, then get without it */
 179    "example.com/path",
 180    "[10] | [11] | [12] | [13] | example.com | [15] | /path | [16] | [17]",
 181    CURLU_GUESS_SCHEME, CURLU_NO_GUESS_SCHEME, CURLUE_OK
 182  },
 183  { /* CURLU_GET_EMPTY: ensures empty query/fragments are returned as "" not
 184       NULL */
 185    "http://host/path?#",
 186    "http | [11] | [12] | [13] | host | [15] | /path |  | ",
 187    0, CURLU_GET_EMPTY, CURLUE_OK },
 188  { /* Port number overflow ( > 65535 ) */
 189    "http://host:65536/",
 190    "", 0, 0, CURLUE_BAD_PORT_NUMBER },
 191  { /* Port zero - often discouraged/invalid in URLs */
 192    "http://host:0/",
 193    "http | [11] | [12] | [13] | host | 0 | / | [16] | [17]",
 194    0, 0, CURLUE_OK },
 195  { /* Leading zeros in port */
 196    "http://host:00080/",
 197    "http | [11] | [12] | [13] | host | 80 | / | [16] | [17]",
 198    0, 0, CURLUE_OK },
 199  { /* Single dot host - not ok */
 200    "http://./",
 201    "",
 202    0, 0, CURLUE_BAD_HOSTNAME },
 203  { /* Host starting with a dash (RFC 1123 technically allows it, but many
 204       parsers don't) */
 205    "http://-atest/",
 206    "http | [11] | [12] | [13] | -atest | [15] | / | [16] | [17]",
 207    0, 0, CURLUE_OK },
 208  { /* Multiple trailing dots is not okey */
 209    "http://example.com../",
 210    "",
 211    0, 0, CURLUE_BAD_HOSTNAME },
 212  {  /* Empty IPv6 Zone ID */
 213    "http://[fe80::1%]/",
 214    "", 0, 0, CURLUE_BAD_IPV6 },
 215  { /* Zone ID with escaped characters */
 216    "http://[fe80::1%25eth0]/",
 217    "http | [11] | [12] | [13] | [fe80::1] eth0 | [15] | / | [16] | [17]",
 218    0, 0, CURLUE_OK },
 219  { "curl.se",
 220    "[10] | [11] | [12] | [13] | curl.se | [15] | / | [16] | [17]",
 221    CURLU_GUESS_SCHEME, CURLU_NO_GUESS_SCHEME, CURLUE_OK },
 222  { "https://curl.se:0/#",
 223    "https | [11] | [12] | [13] | curl.se | 0 | / | [16] | ",
 224    0, CURLU_GET_EMPTY, CURLUE_OK },
 225  { "https://curl.se/#",
 226    "https | [11] | [12] | [13] | curl.se | [15] | / | [16] | ",
 227    0, CURLU_GET_EMPTY, CURLUE_OK },
 228  { "https://curl.se/?#",
 229    "https | [11] | [12] | [13] | curl.se | [15] | / |  | ",
 230    0, CURLU_GET_EMPTY, CURLUE_OK },
 231  { "https://curl.se/?",
 232    "https | [11] | [12] | [13] | curl.se | [15] | / |  | [17]",
 233    0, CURLU_GET_EMPTY, CURLUE_OK },
 234  { "https://curl.se/?",
 235    "https | [11] | [12] | [13] | curl.se | [15] | / | [16] | [17]",
 236    0, 0, CURLUE_OK },
 237  { "https://curl.se/?#",
 238    "https | [11] | [12] | [13] | curl.se | [15] | / | [16] | [17]",
 239    0, 0, CURLUE_OK },
 240  { "https://curl.se/#  ",
 241    "https | [11] | [12] | [13] | curl.se | [15] | / | [16] | %20%20",
 242    CURLU_URLENCODE | CURLU_ALLOW_SPACE, 0, CURLUE_OK },
 243  { "", "", 0, 0, CURLUE_MALFORMED_INPUT },
 244  { " ", "", 0, 0, CURLUE_MALFORMED_INPUT },
 245  { "1h://example.net", "", 0, 0, CURLUE_BAD_SCHEME },
 246  { "..://example.net", "", 0, 0, CURLUE_BAD_SCHEME },
 247  { "-ht://example.net", "", 0, 0, CURLUE_BAD_SCHEME },
 248  { "+ftp://example.net", "", 0, 0, CURLUE_BAD_SCHEME },
 249  { "hej.hej://example.net",
 250    "hej.hej | [11] | [12] | [13] | example.net | [15] | / | [16] | [17]",
 251    CURLU_NON_SUPPORT_SCHEME, 0, CURLUE_OK },
 252  { "ht-tp://example.net",
 253    "ht-tp | [11] | [12] | [13] | example.net | [15] | / | [16] | [17]",
 254    CURLU_NON_SUPPORT_SCHEME, 0, CURLUE_OK },
 255  { "ftp+more://example.net",
 256    "ftp+more | [11] | [12] | [13] | example.net | [15] | / | [16] | [17]",
 257    CURLU_NON_SUPPORT_SCHEME, 0, CURLUE_OK },
 258  { "f1337://example.net",
 259    "f1337 | [11] | [12] | [13] | example.net | [15] | / | [16] | [17]",
 260    CURLU_NON_SUPPORT_SCHEME, 0, CURLUE_OK },
 261  { "https://user@example.net?hello# space ",
 262    "https | user | [12] | [13] | example.net | [15] | / | hello | "
 263    "%20space%20",
 264    CURLU_ALLOW_SPACE | CURLU_URLENCODE, 0, CURLUE_OK },
 265  { "https://test%test", "", 0, 0, CURLUE_BAD_HOSTNAME },
 266  { "https://example.com%252f%40@example.net",
 267    "https | example.com%2f@ | [12] | [13] | example.net | [15] | / "
 268    "| [16] | [17]",
 269    0, CURLU_URLDECODE, CURLUE_OK },
 270#ifdef USE_IDN
 271  /*
 272    https://sv.wikipedia.org/wiki/R%c3%a4ksm%c3%b6rg%c3%a5s
 273    https://codepoints.net/U+00E4 Latin Small Letter A with Diaeresis
 274    https://codepoints.net/U+00F6 Latin Small Letter O with Diaeresis
 275    https://codepoints.net/U+00E5 Latin Small Letter A with Ring Above
 276  */
 277  { "https://r\xc3\xa4ksm\xc3\xb6rg\xc3\xa5s.se",
 278    "https | [11] | [12] | [13] | xn--rksmrgs-5wao1o.se | "
 279    "[15] | / | [16] | [17]", 0, CURLU_PUNYCODE, CURLUE_OK },
 280  { "https://xn--rksmrgs-5wao1o.se",
 281    "https | [11] | [12] | [13] | r\xc3\xa4ksm\xc3\xb6rg\xc3\xa5s.se | "
 282    "[15] | / | [16] | [17]", 0, CURLU_PUNY2IDN, CURLUE_OK },
 283  { "https://www.xn--rksmrgs-5wao1o.se",
 284    "https | [11] | [12] | [13] | www.r\xc3\xa4ksm\xc3\xb6rg\xc3\xa5s.se | "
 285    "[15] | / | [16] | [17]", 0, CURLU_PUNY2IDN, CURLUE_OK },
 286  { "https://www.r\xc3\xa4ksm\xc3\xb6rg\xc3\xa5s.se",
 287    "https | [11] | [12] | [13] | www.r\xc3\xa4ksm\xc3\xb6rg\xc3\xa5s.se | "
 288    "[15] | / | [16] | [17]", 0, CURLU_PUNY2IDN, CURLUE_OK },
 289#else
 290  { "https://r\xc3\xa4ksm\xc3\xb6rg\xc3\xa5s.se",
 291    "https | [11] | [12] | [13] | [30] | [15] | / | [16] | [17]",
 292    0, CURLU_PUNYCODE, CURLUE_OK },
 293#endif
 294  /*
 295    https://codepoints.net/U+2102  Double-Struck Capital C
 296    https://codepoints.net/U+1d64  Latin Subscript Small Letter U
 297    https://codepoints.net/U+24c7  Circled Latin Capital Letter R
 298    https://codepoints.net/U+2112  Script Capital L
 299    https://codepoints.net/U+3002  Ideographic Full Stop
 300    https://codepoints.net/U+1d412 Mathematical Bold Capital S
 301    https://codepoints.net/U+1f134 Squared Latin Capital Letter E
 302  */
 303  {"https://"
 304   "%e2%84%82%e1%b5%a4%e2%93%87%e2%84%92%e3%80%82%f0%9d%90%92%f0%9f%84%b4",
 305   "https | [11] | [12] | [13] | "
 306   "\xe2\x84\x82\xe1\xb5\xa4\xe2\x93\x87\xe2\x84\x92"
 307   "\xe3\x80\x82\xf0\x9d\x90\x92\xf0\x9f\x84\xb4"
 308   " | [15] | / | [16] | [17]",
 309   0, 0, CURLUE_OK},
 310  {"https://"
 311   "%e2%84%82%e1%b5%a4%e2%93%87%e2%84%92%e3%80%82%f0%9d%90%92%f0%9f%84%b4",
 312   "https | [11] | [12] | [13] | "
 313   "%E2%84%82%E1%B5%A4%E2%93%87%E2%84%92%E3%80%82%F0%9D%90%92%F0%9F%84%B4 "
 314   "| [15] | / | [16] | [17]",
 315   0, CURLU_URLENCODE, CURLUE_OK},
 316  {"https://"
 317   "\xe2\x84\x82\xe1\xb5\xa4\xe2\x93\x87\xe2\x84\x92"
 318   "\xe3\x80\x82\xf0\x9d\x90\x92\xf0\x9f\x84\xb4",
 319   "https | [11] | [12] | [13] | "
 320   "%E2%84%82%E1%B5%A4%E2%93%87%E2%84%92%E3%80%82%F0%9D%90%92%F0%9F%84%B4 "
 321   "| [15] | / | [16] | [17]",
 322   0, CURLU_URLENCODE, CURLUE_OK},
 323  {"https://user@example.net?he l lo",
 324   "https | user | [12] | [13] | example.net | [15] | / | he+l+lo | [17]",
 325   CURLU_ALLOW_SPACE, CURLU_URLENCODE, CURLUE_OK},
 326  {"https://user@example.net?he l lo",
 327   "https | user | [12] | [13] | example.net | [15] | / | he l lo | [17]",
 328   CURLU_ALLOW_SPACE, 0, CURLUE_OK},
 329  {"https://exam{}[]ple.net", "", 0, 0, CURLUE_BAD_HOSTNAME},
 330  {"https://exam{ple.net", "", 0, 0, CURLUE_BAD_HOSTNAME},
 331  {"https://exam}ple.net", "", 0, 0, CURLUE_BAD_HOSTNAME},
 332  {"https://exam]ple.net", "", 0, 0, CURLUE_BAD_HOSTNAME},
 333  {"https://exam\\ple.net", "", 0, 0, CURLUE_BAD_HOSTNAME},
 334  {"https://exam$ple.net", "", 0, 0, CURLUE_BAD_HOSTNAME},
 335  {"https://exam'ple.net", "", 0, 0, CURLUE_BAD_HOSTNAME},
 336  {"https://exam\"ple.net", "", 0, 0, CURLUE_BAD_HOSTNAME},
 337  {"https://exam^ple.net", "", 0, 0, CURLUE_BAD_HOSTNAME},
 338  {"https://exam`ple.net", "", 0, 0, CURLUE_BAD_HOSTNAME},
 339  {"https://exam*ple.net", "", 0, 0, CURLUE_BAD_HOSTNAME},
 340  {"https://exam<ple.net", "", 0, 0, CURLUE_BAD_HOSTNAME},
 341  {"https://exam>ple.net", "", 0, 0, CURLUE_BAD_HOSTNAME},
 342  {"https://exam=ple.net", "", 0, 0, CURLUE_BAD_HOSTNAME},
 343  {"https://exam;ple.net", "", 0, 0, CURLUE_BAD_HOSTNAME},
 344  {"https://example,net", "", 0, 0, CURLUE_BAD_HOSTNAME},
 345  {"https://example&net", "", 0, 0, CURLUE_BAD_HOSTNAME},
 346  {"https://example+net", "", 0, 0, CURLUE_BAD_HOSTNAME},
 347  {"https://example(net", "", 0, 0, CURLUE_BAD_HOSTNAME},
 348  {"https://example)net", "", 0, 0, CURLUE_BAD_HOSTNAME},
 349  {"https://example.net/}",
 350   "https | [11] | [12] | [13] | example.net | [15] | /} | [16] | [17]",
 351   0, 0, CURLUE_OK},
 352
 353  /* blank user is blank */
 354  {"https://:password@example.net",
 355   "https |  | password | [13] | example.net | [15] | / | [16] | [17]",
 356   0, 0, CURLUE_OK},
 357  /* blank user + blank password */
 358  {"https://:@example.net",
 359   "https |  |  | [13] | example.net | [15] | / | [16] | [17]",
 360   0, 0, CURLUE_OK},
 361  /* user-only (no password) */
 362  {"https://user@example.net",
 363   "https | user | [12] | [13] | example.net | [15] | / | [16] | [17]",
 364   0, 0, CURLUE_OK},
 365#ifndef CURL_DISABLE_WEBSOCKETS
 366  {"ws://example.com/color/?green",
 367   "ws | [11] | [12] | [13] | example.com | [15] | /color/ | green |"
 368   " [17]",
 369   CURLU_DEFAULT_SCHEME, 0, CURLUE_OK },
 370  {"wss://example.com/color/?green",
 371   "wss | [11] | [12] | [13] | example.com | [15] | /color/ | green |"
 372   " [17]",
 373   CURLU_DEFAULT_SCHEME, 0, CURLUE_OK },
 374#endif
 375
 376  {"https://user:password@example.net/get?this=and#but frag then", "",
 377   CURLU_DEFAULT_SCHEME, 0, CURLUE_MALFORMED_INPUT},
 378  {"https://user:password@example.net/get?this=and what", "",
 379   CURLU_DEFAULT_SCHEME, 0, CURLUE_MALFORMED_INPUT},
 380  {"https://user:password@example.net/ge t?this=and-what", "",
 381   CURLU_DEFAULT_SCHEME, 0, CURLUE_MALFORMED_INPUT},
 382  {"https://user:pass word@example.net/get?this=and-what", "",
 383   CURLU_DEFAULT_SCHEME, 0, CURLUE_MALFORMED_INPUT},
 384  {"https://u ser:password@example.net/get?this=and-what", "",
 385   CURLU_DEFAULT_SCHEME, 0, CURLUE_MALFORMED_INPUT},
 386  {"imap://user:pass;opt ion@server/path", "",
 387   CURLU_DEFAULT_SCHEME, 0, CURLUE_MALFORMED_INPUT},
 388  /* no space allowed in scheme */
 389  {"htt ps://user:password@example.net/get?this=and-what", "",
 390   CURLU_NON_SUPPORT_SCHEME | CURLU_ALLOW_SPACE, 0, CURLUE_BAD_SCHEME},
 391  {"https://user:password@example.net/get?this=and what",
 392   "https | user | password | [13] | example.net | [15] | /get | "
 393   "this=and what | [17]",
 394   CURLU_ALLOW_SPACE, 0, CURLUE_OK},
 395  {"https://user:password@example.net/ge t?this=and-what",
 396   "https | user | password | [13] | example.net | [15] | /ge t | "
 397   "this=and-what | [17]",
 398   CURLU_ALLOW_SPACE, 0, CURLUE_OK},
 399  {"https://user:pass word@example.net/get?this=and-what",
 400   "https | user | pass word | [13] | example.net | [15] | /get | "
 401   "this=and-what | [17]",
 402   CURLU_ALLOW_SPACE, 0, CURLUE_OK},
 403  {"https://u ser:password@example.net/get?this=and-what",
 404   "https | u ser | password | [13] | example.net | [15] | /get | "
 405   "this=and-what | [17]",
 406   CURLU_ALLOW_SPACE, 0, CURLUE_OK},
 407  {"https://user:password@example.net/ge t?this=and-what",
 408   "https | user | password | [13] | example.net | [15] | /ge%20t | "
 409   "this=and-what | [17]",
 410   CURLU_ALLOW_SPACE | CURLU_URLENCODE, 0, CURLUE_OK},
 411  {"[0:0:0:0:0:0:0:1]",
 412   "http | [11] | [12] | [13] | [::1] | [15] | / | [16] | [17]",
 413   CURLU_GUESS_SCHEME, 0, CURLUE_OK },
 414  {"[::1]",
 415   "http | [11] | [12] | [13] | [::1] | [15] | / | [16] | [17]",
 416   CURLU_GUESS_SCHEME, 0, CURLUE_OK },
 417  {"[::]",
 418   "http | [11] | [12] | [13] | [::] | [15] | / | [16] | [17]",
 419   CURLU_GUESS_SCHEME, 0, CURLUE_OK },
 420  {"https://[::1]",
 421   "https | [11] | [12] | [13] | [::1] | [15] | / | [16] | [17]",
 422   0, 0, CURLUE_OK },
 423  {"user:moo@ftp.example.com/color/#green?no-red",
 424   "ftp | user | moo | [13] | ftp.example.com | [15] | /color/ | [16] | "
 425   "green?no-red",
 426   CURLU_GUESS_SCHEME, 0, CURLUE_OK },
 427  {"ftp.user:moo@example.com/color/#green?no-red",
 428   "http | ftp.user | moo | [13] | example.com | [15] | /color/ | [16] | "
 429   "green?no-red",
 430   CURLU_GUESS_SCHEME, 0, CURLUE_OK },
 431#ifdef _WIN32
 432  {"file:/C:\\programs\\foo",
 433   "file | [11] | [12] | [13] | [14] | [15] | C:\\programs\\foo | [16] | [17]",
 434   CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
 435  {"file://C:\\programs\\foo",
 436   "file | [11] | [12] | [13] | [14] | [15] | C:\\programs\\foo | [16] | [17]",
 437   CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
 438  {"file:///C:\\programs\\foo",
 439   "file | [11] | [12] | [13] | [14] | [15] | C:\\programs\\foo | [16] | [17]",
 440   CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
 441#endif
 442  {"file://host.example.com/Share/path/to/file.txt", "",
 443   CURLU_DEFAULT_SCHEME, 0, CURLUE_BAD_FILE_URL},
 444  {"https://example.com/color/#green?no-red",
 445   "https | [11] | [12] | [13] | example.com | [15] | /color/ | [16] | "
 446   "green?no-red",
 447   CURLU_DEFAULT_SCHEME, 0, CURLUE_OK },
 448  {"https://example.com/color/#green#no-red",
 449   "https | [11] | [12] | [13] | example.com | [15] | /color/ | [16] | "
 450   "green#no-red",
 451   CURLU_DEFAULT_SCHEME, 0, CURLUE_OK },
 452  {"https://example.com/color/?green#no-red",
 453   "https | [11] | [12] | [13] | example.com | [15] | /color/ | green | "
 454   "no-red",
 455   CURLU_DEFAULT_SCHEME, 0, CURLUE_OK },
 456  {"https://example.com/#color/?green#no-red",
 457   "https | [11] | [12] | [13] | example.com | [15] | / | [16] | "
 458   "color/?green#no-red",
 459   CURLU_DEFAULT_SCHEME, 0, CURLUE_OK },
 460  {"https://example.#com/color/?green#no-red",
 461   "https | [11] | [12] | [13] | example. | [15] | / | [16] | "
 462   "com/color/?green#no-red",
 463   CURLU_DEFAULT_SCHEME, 0, CURLUE_OK },
 464  {"http://[ab.be:1]/x", "",
 465   CURLU_DEFAULT_SCHEME, 0, CURLUE_BAD_IPV6},
 466  {"http://[ab.be]/x", "",
 467   CURLU_DEFAULT_SCHEME, 0, CURLUE_BAD_IPV6},
 468  /* URL without hostname */
 469  {"http://a:b@/x", "",
 470   CURLU_DEFAULT_SCHEME, 0, CURLUE_NO_HOST},
 471  {"boing:80",
 472   "https | [11] | [12] | [13] | boing | 80 | / | [16] | [17]",
 473   CURLU_DEFAULT_SCHEME | CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 474  {"http://[fd00:a41::50]:8080",
 475   "http | [11] | [12] | [13] | [fd00:a41::50] | 8080 | / | [16] | [17]",
 476   CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
 477  {"http://[fd00:a41::50]/",
 478   "http | [11] | [12] | [13] | [fd00:a41::50] | [15] | / | [16] | [17]",
 479   CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
 480  {"http://[fd00:a41::50]",
 481   "http | [11] | [12] | [13] | [fd00:a41::50] | [15] | / | [16] | [17]",
 482   CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
 483  {"https://[::1%252]:1234",
 484   "https | [11] | [12] | [13] | [::1] 2 | 1234 | / | [16] | [17]",
 485   CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
 486
 487  /* non-RFC6874 (unescaped '%') zone id, still accepted/normalized */
 488  {"https://[fe80::20c:29ff:fe9c:409b%eth0]:1234",
 489   "https | [11] | [12] | [13] | [fe80::20c:29ff:fe9c:409b] eth0 | 1234 "
 490   "| / | [16] | [17]",
 491   CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
 492  {"https://127.0.0.1:443",
 493   "https | [11] | [12] | [13] | 127.0.0.1 | [15] | / | [16] | [17]",
 494   0, CURLU_NO_DEFAULT_PORT, CURLUE_OK},
 495  {"http://%3a:%3a@ex4mple/%3f+?+%3f+%23#+%23%3f%g7",
 496   "http | : | : | [13] | ex4mple | [15] | /?+ |  ? # | +#?%g7",
 497   0, CURLU_URLDECODE, CURLUE_OK},
 498  {"http://%3a:%3a@ex4mple/%3f?%3f%35#%35%3f%g7",
 499   "http | %3a | %3a | [13] | ex4mple | [15] | /%3f | %3f%35 | %35%3f%g7",
 500   0, 0, CURLUE_OK},
 501  {"http://HO0_-st%41/",
 502   "http | [11] | [12] | [13] | HO0_-stA | [15] | / | [16] | [17]",
 503   0, 0, CURLUE_OK},
 504  {"file://hello.html",
 505   "",
 506   0, 0, CURLUE_BAD_FILE_URL},
 507  {"http://HO0_-st/",
 508   "http | [11] | [12] | [13] | HO0_-st | [15] | / | [16] | [17]",
 509   0, 0, CURLUE_OK},
 510  {"imap://user:pass;option@server/path",
 511   "imap | user | pass | option | server | [15] | /path | [16] | [17]",
 512   0, 0, CURLUE_OK},
 513  {"http://user:pass;option@server/path",
 514   "http | user | pass;option | [13] | server | [15] | /path | [16] | [17]",
 515   0, 0, CURLUE_OK},
 516  {"file:/hello.html",
 517   "file | [11] | [12] | [13] | [14] | [15] | /hello.html | [16] | [17]",
 518   0, 0, CURLUE_OK},
 519  {"file:/h",
 520   "file | [11] | [12] | [13] | [14] | [15] | /h | [16] | [17]",
 521   0, 0, CURLUE_OK},
 522  {"file:/",
 523   "file | [11] | [12] | [13] | [14] | [15] | | [16] | [17]",
 524   0, 0, CURLUE_BAD_FILE_URL},
 525  {"file://127.0.0.1/hello.html",
 526   "file | [11] | [12] | [13] | [14] | [15] | /hello.html | [16] | [17]",
 527   0, 0, CURLUE_OK},
 528  {"file:////hello.html",
 529   "file | [11] | [12] | [13] | [14] | [15] | //hello.html | [16] | [17]",
 530   0, 0, CURLUE_OK},
 531  {"file:///hello.html",
 532   "file | [11] | [12] | [13] | [14] | [15] | /hello.html | [16] | [17]",
 533   0, 0, CURLUE_OK},
 534  {"https://127.0.0.1",
 535   "https | [11] | [12] | [13] | 127.0.0.1 | 443 | / | [16] | [17]",
 536   0, CURLU_DEFAULT_PORT, CURLUE_OK},
 537  {"https://127.0.0.1",
 538   "https | [11] | [12] | [13] | 127.0.0.1 | [15] | / | [16] | [17]",
 539   CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
 540  {"https://[::1]:1234",
 541   "https | [11] | [12] | [13] | [::1] | 1234 | / | [16] | [17]",
 542   CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
 543  {"https://127abc.com",
 544   "https | [11] | [12] | [13] | 127abc.com | [15] | / | [16] | [17]",
 545   CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
 546  {"https:// example.com?check", "",
 547   CURLU_DEFAULT_SCHEME, 0, CURLUE_MALFORMED_INPUT},
 548  {"https://e x a m p l e.com?check", "",
 549   CURLU_DEFAULT_SCHEME, 0, CURLUE_MALFORMED_INPUT},
 550  {"https://example.com?check",
 551   "https | [11] | [12] | [13] | example.com | [15] | / | check | [17]",
 552   CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
 553  {"https://example.com:65536",
 554   "",
 555   CURLU_DEFAULT_SCHEME, 0, CURLUE_BAD_PORT_NUMBER},
 556  {"https://example.com:-1#moo",
 557   "",
 558   CURLU_DEFAULT_SCHEME, 0, CURLUE_BAD_PORT_NUMBER},
 559  {"https://example.com:0#moo",
 560   "https | [11] | [12] | [13] | example.com | 0 | / | "
 561   "[16] | moo",
 562   CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
 563  {"https://example.com:01#moo",
 564   "https | [11] | [12] | [13] | example.com | 1 | / | "
 565   "[16] | moo",
 566   CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
 567  {"https://example.com:1#moo",
 568   "https | [11] | [12] | [13] | example.com | 1 | / | "
 569   "[16] | moo",
 570   CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
 571  {"http://example.com#moo",
 572   "http | [11] | [12] | [13] | example.com | [15] | / | "
 573   "[16] | moo",
 574   CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
 575  {"http://example.com",
 576   "http | [11] | [12] | [13] | example.com | [15] | / | "
 577   "[16] | [17]",
 578   CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
 579  {"http://example.com/path/html",
 580   "http | [11] | [12] | [13] | example.com | [15] | /path/html | "
 581   "[16] | [17]",
 582   CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
 583  {"http://example.com/path/html?query=name",
 584   "http | [11] | [12] | [13] | example.com | [15] | /path/html | "
 585   "query=name | [17]",
 586   CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
 587  {"http://example.com/path/html?query=name#anchor",
 588   "http | [11] | [12] | [13] | example.com | [15] | /path/html | "
 589   "query=name | anchor",
 590   CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
 591  {"http://example.com:1234/path/html?query=name#anchor",
 592   "http | [11] | [12] | [13] | example.com | 1234 | /path/html | "
 593   "query=name | anchor",
 594   CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
 595  {"http:///user:password@example.com:1234/path/html?query=name#anchor",
 596   "http | user | password | [13] | example.com | 1234 | /path/html | "
 597   "query=name | anchor",
 598   CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
 599  {"https://user:password@example.com:1234/path/html?query=name#anchor",
 600   "https | user | password | [13] | example.com | 1234 | /path/html | "
 601   "query=name | anchor",
 602   CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
 603  {"http://user:password@example.com:1234/path/html?query=name#anchor",
 604   "http | user | password | [13] | example.com | 1234 | /path/html | "
 605   "query=name | anchor",
 606   CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
 607  {"http:/user:password@example.com:1234/path/html?query=name#anchor",
 608   "http | user | password | [13] | example.com | 1234 | /path/html | "
 609   "query=name | anchor",
 610   CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
 611  {"http:////user:password@example.com:1234/path/html?query=name#anchor",
 612   "",
 613   CURLU_DEFAULT_SCHEME, 0, CURLUE_BAD_SLASHES},
 614  { /* CURLU_DISALLOW_USER with user */
 615    "https://user@example.com", "", CURLU_DISALLOW_USER, 0,
 616    CURLUE_USER_NOT_ALLOWED },
 617  { /* CURLU_DISALLOW_USER with user:password */
 618    "https://user:password@example.com", "", CURLU_DISALLOW_USER, 0,
 619    CURLUE_USER_NOT_ALLOWED },
 620  { /* Hostname with trailing dot */
 621    "https://example.com./",
 622    "https | [11] | [12] | [13] | example.com. | [15] | / | [16] | [17]",
 623    0, 0, CURLUE_OK },
 624  {NULL, NULL, 0, 0, CURLUE_OK},
 625};
 626
 627static const struct urltestcase get_url_list[] = {
 628  {"https://127.1.", "https://127.0.0.1/", 0, 0, CURLUE_OK},
 629  {"https://127.1.:443", "https://127.0.0.1:443/", 0, 0, CURLUE_OK},
 630  {"https://127.1.?moo", "https://127.0.0.1/?moo", 0, 0, CURLUE_OK},
 631  {"https://127.1.#moo", "https://127.0.0.1/#moo", 0, 0, CURLUE_OK},
 632  {"https://127.1.a", "https://127.1.a/", 0, 0, CURLUE_OK},
 633  {"https://127.1..", "", 0, 0, CURLUE_BAD_HOSTNAME},
 634  {"https://127.1..:443", "", 0, 0, CURLUE_BAD_HOSTNAME},
 635  {"https://127.1..?moo", "", 0, 0, CURLUE_BAD_HOSTNAME},
 636  {"https://127.1..#moo", "", 0, 0, CURLUE_BAD_HOSTNAME},
 637  {"https://127.1.1.", "https://127.1.0.1/", 0, 0, CURLUE_OK},
 638  {"https://127.1.1./foo", "https://127.1.0.1/foo", 0, 0, CURLUE_OK},
 639  {"https://127.1.1.1.", "https://127.1.1.1/", 0, 0, CURLUE_OK},
 640  {"https://127.1", "https://127.0.0.1/", 0, 0, CURLUE_OK},
 641  {"https://127.0.0.1.", "https://127.0.0.1/", 0, 0, CURLUE_OK},
 642  {"https://127.0.0.0xff.", "https://127.0.0.255/", 0, 0, CURLUE_OK},
 643  {"https://127.0.0.1..", "", 0, 0, CURLUE_BAD_HOSTNAME},
 644  {"https://127.0.0.256..", "", 0, 0, CURLUE_BAD_HOSTNAME},
 645  {"http://hej./", "http://hej./", 0, 0, CURLUE_OK},
 646  {"http://hej../", "", 0, 0, CURLUE_BAD_HOSTNAME},
 647  {"http://hej.../", "", 0, 0, CURLUE_BAD_HOSTNAME},
 648  {"http://hej..../index.html", "", 0, 0, CURLUE_BAD_HOSTNAME},
 649  {"http://.", "", 0, 0, CURLUE_BAD_HOSTNAME},
 650  {"http://..", "", 0, 0, CURLUE_BAD_HOSTNAME},
 651  {"http://...", "", 0, 0, CURLUE_BAD_HOSTNAME},
 652  {"018.0.0.0", "http://018.0.0.0/", CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 653  {"08", "http://08/", CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 654  {"0", "http://0.0.0.0/", CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 655  {"01", "http://0.0.0.1/", CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 656  {"02", "http://0.0.0.2/", CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 657  {"03", "http://0.0.0.3/", CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 658  {"04", "http://0.0.0.4/", CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 659  {"05", "http://0.0.0.5/", CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 660  {"06", "http://0.0.0.6/", CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 661  {"07", "http://0.0.0.7/", CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 662  {"07.1", "http://7.0.0.1/", CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 663  {"7.1", "http://7.0.0.1/", CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 664  {"0x7.1", "http://7.0.0.1/", CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 665  {"0x", "http://0x/", CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 666  {"0x1", "http://0.0.0.1/", CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 667  {"0x2", "http://0.0.0.2/", CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 668  {"0x3", "http://0.0.0.3/", CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 669  {"0x4", "http://0.0.0.4/", CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 670  {"0x5", "http://0.0.0.5/", CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 671  {"0x6", "http://0.0.0.6/", CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 672  {"0x7", "http://0.0.0.7/", CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 673  {"0x8", "http://0.0.0.8/", CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 674  {"0x9", "http://0.0.0.9/", CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 675  {"0xa", "http://0.0.0.10/", CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 676  {"0xb", "http://0.0.0.11/", CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 677  {"0xc", "http://0.0.0.12/", CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 678  {"0xd", "http://0.0.0.13/", CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 679  {"0xe", "http://0.0.0.14/", CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 680  {"0xf", "http://0.0.0.15/", CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 681  {"0xg", "http://0xg/", CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 682  {"https://0/", "https://0.0.0.0/", 0, 0, CURLUE_OK},
 683  {"https://0.0x0/", "https://0.0.0.0/", 0, 0, CURLUE_OK},
 684  {"https://0.000/", "https://0.0.0.0/", 0, 0, CURLUE_OK},
 685  {"example.com",
 686   "example.com/",
 687   CURLU_GUESS_SCHEME, CURLU_NO_GUESS_SCHEME, CURLUE_OK},
 688  {"http://user@example.com?#",
 689   "http://user@example.com/?#",
 690   0, CURLU_GET_EMPTY, CURLUE_OK},
 691  /* WHATWG disagrees, it wants "https:/0.0.0.0/" */
 692  {"https://0x.0x.0", "https://0x.0x.0/", 0, 0, CURLUE_OK},
 693
 694  {"https://example.com:000000000000000000000443/foo",
 695   "https://example.com/foo",
 696   0, CURLU_NO_DEFAULT_PORT, CURLUE_OK},
 697  {"https://example.com:000000000000000000000/foo",
 698   "https://example.com:0/foo",
 699   0, CURLU_NO_DEFAULT_PORT, CURLUE_OK},
 700  {"https://192.0x0000A80001", "https://192.168.0.1/", 0, 0, CURLUE_OK},
 701  {"https://0xffffffff", "https://255.255.255.255/", 0, 0, CURLUE_OK},
 702  {"https://1.0x1000000", "https://1.0x1000000/", 0, 0, CURLUE_OK},
 703  {"https://0x7f.1", "https://127.0.0.1/", 0, 0, CURLUE_OK},
 704  {"https://1.2.3.256.com", "https://1.2.3.256.com/", 0, 0, CURLUE_OK},
 705  {"https://10.com", "https://10.com/", 0, 0, CURLUE_OK},
 706  {"https://1.2.com", "https://1.2.com/", 0, 0, CURLUE_OK},
 707  {"https://1.2.3.com", "https://1.2.3.com/", 0, 0, CURLUE_OK},
 708  {"https://1.2.com.99", "https://1.2.com.99/", 0, 0, CURLUE_OK},
 709  {"https://[fe80::0000:20c:29ff:fe9c:409b]:80/moo",
 710   "https://[fe80::20c:29ff:fe9c:409b]:80/moo",
 711   0, 0, CURLUE_OK},
 712  {"https://[fe80::020c:29ff:fe9c:409b]:80/moo",
 713   "https://[fe80::20c:29ff:fe9c:409b]:80/moo",
 714   0, 0, CURLUE_OK},
 715  {"https://[fe80:0000:0000:0000:020c:29ff:fe9c:409b]:80/moo",
 716   "https://[fe80::20c:29ff:fe9c:409b]:80/moo",
 717   0, 0, CURLUE_OK},
 718  {"https://[fe80:0:0:0:409b::]:80/moo",
 719   "https://[fe80::409b:0:0:0]:80/moo",
 720   0, 0, CURLUE_OK},
 721  /* normalize to lower case */
 722  {"https://[FE80:0:A:0:409B:0:0:0]:80/moo",
 723   "https://[fe80:0:a:0:409b::]:80/moo",
 724   0, 0, CURLUE_OK},
 725  {"https://[::%25fakeit];80/moo",
 726   "",
 727   0, 0, CURLUE_BAD_PORT_NUMBER},
 728  {"https://[fe80::20c:29ff:fe9c:409b]-80/moo",
 729   "",
 730   0, 0, CURLUE_BAD_PORT_NUMBER},
 731#ifdef USE_IDN
 732  {"https://r\xc3\xa4ksm\xc3\xb6rg\xc3\xa5s.se/path?q#frag",
 733   "https://xn--rksmrgs-5wao1o.se/path?q#frag", 0, CURLU_PUNYCODE, CURLUE_OK},
 734#endif
 735  /* unsupported schemes with no guessing enabled */
 736  {"data:text/html;charset=utf-8;base64,PCFET0NUWVBFIEhUTUw+PG1ldGEgY",
 737   "", 0, 0, CURLUE_UNSUPPORTED_SCHEME},
 738  {"d:anything-really", "", 0, 0, CURLUE_UNSUPPORTED_SCHEME},
 739  {"about:config", "", 0, 0, CURLUE_UNSUPPORTED_SCHEME},
 740  {"example://foo", "", 0, 0, CURLUE_UNSUPPORTED_SCHEME},
 741  {"mailto:infobot@example.com?body=send%20current-issue", "", 0, 0,
 742   CURLUE_UNSUPPORTED_SCHEME},
 743  {"about:80", "https://about:80/", CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
 744  /* percent encoded hostnames */
 745  {"http://example.com%40127.0.0.1/", "", 0, 0, CURLUE_BAD_HOSTNAME},
 746  {"http://example.com%21127.0.0.1/", "", 0, 0, CURLUE_BAD_HOSTNAME},
 747  {"http://example.com%3f127.0.0.1/", "", 0, 0, CURLUE_BAD_HOSTNAME},
 748  {"http://example.com%23127.0.0.1/", "", 0, 0, CURLUE_BAD_HOSTNAME},
 749  {"http://example.com%3a127.0.0.1/", "", 0, 0, CURLUE_BAD_HOSTNAME},
 750  {"http://example.com%09127.0.0.1/", "", 0, 0, CURLUE_BAD_HOSTNAME},
 751  {"http://example.com%2F127.0.0.1/", "", 0, 0, CURLUE_BAD_HOSTNAME},
 752  {"https://%41", "https://A/", 0, 0, CURLUE_OK},
 753  {"https://%20", "", 0, 0, CURLUE_BAD_HOSTNAME},
 754  {"https://%41%0D", "", 0, 0, CURLUE_BAD_HOSTNAME},
 755  {"https://%25", "", 0, 0, CURLUE_BAD_HOSTNAME},
 756  {"https://_%c0_", "https://_\xC0_/", 0, 0, CURLUE_OK},
 757  {"https://_%c0_", "https://_%C0_/", 0, CURLU_URLENCODE, CURLUE_OK},
 758
 759  /* IPv4 trickeries */
 760  {"https://16843009", "https://1.1.1.1/", 0, 0, CURLUE_OK},
 761  {"https://0177.1", "https://127.0.0.1/", 0, 0, CURLUE_OK},
 762  {"https://0111.02.0x3", "https://73.2.0.3/", 0, 0, CURLUE_OK},
 763  {"https://0111.02.0x3.", "https://73.2.0.3/", 0, 0, CURLUE_OK},
 764  {"https://0111.02.030", "https://73.2.0.24/", 0, 0, CURLUE_OK},
 765  {"https://0111.02.030.", "https://73.2.0.24/", 0, 0, CURLUE_OK},
 766  {"https://0xff.0xff.0377.255", "https://255.255.255.255/", 0, 0, CURLUE_OK},
 767  {"https://1.0xffffff", "https://1.255.255.255/", 0, 0, CURLUE_OK},
 768  /* IPv4 numerical overflows or syntax errors will not normalize */
 769  {"https://a127.0.0.1", "https://a127.0.0.1/", 0, 0, CURLUE_OK},
 770  {"https://\xff.127.0.0.1", "https://%FF.127.0.0.1/", 0, CURLU_URLENCODE,
 771   CURLUE_OK},
 772  {"https://127.-0.0.1", "https://127.-0.0.1/", 0, 0, CURLUE_OK},
 773  {"https://127.0. 1", "https://127.0.0.1/", 0, 0, CURLUE_MALFORMED_INPUT},
 774  {"https://1.2.3.256", "https://1.2.3.256/", 0, 0, CURLUE_OK},
 775  {"https://1.2.3.256.", "https://1.2.3.256./", 0, 0, CURLUE_OK},
 776  {"https://1.2.3.4.5", "https://1.2.3.4.5/", 0, 0, CURLUE_OK},
 777  {"https://1.2.0x100.3", "https://1.2.0x100.3/", 0, 0, CURLUE_OK},
 778  {"https://4294967296", "https://4294967296/", 0, 0, CURLUE_OK},
 779  {"https://123host", "https://123host/", 0, 0, CURLUE_OK},
 780  /* 40 bytes scheme is the max allowed */
 781  {"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA://hostname/path",
 782   "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa://hostname/path",
 783   CURLU_NON_SUPPORT_SCHEME, 0, CURLUE_OK},
 784  /* 41 bytes scheme is not allowed */
 785  {"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA://hostname/path",
 786   "",
 787   CURLU_NON_SUPPORT_SCHEME, 0, CURLUE_BAD_SCHEME},
 788  {"https://[fe80::20c:29ff:fe9c:409b%]:1234",
 789   "",
 790   0, 0, CURLUE_BAD_IPV6},
 791  {"https://[fe80::20c:29ff:fe9c:409b%25]:1234",
 792   "https://[fe80::20c:29ff:fe9c:409b%2525]:1234/",
 793   0, 0, CURLUE_OK},
 794  {"https://[fe80::20c:29ff:fe9c:409b%eth0]:1234",
 795   "https://[fe80::20c:29ff:fe9c:409b%25eth0]:1234/",
 796   0, 0, CURLUE_OK},
 797  {"https://[::%25fakeit]/moo",
 798   "https://[::%25fakeit]/moo",
 799   0, 0, CURLUE_OK},
 800  {"smtp.example.com/path/html",
 801   "smtp://smtp.example.com/path/html",
 802   CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 803  {"https.example.com/path/html",
 804   "http://https.example.com/path/html",
 805   CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 806  {"dict.example.com/path/html",
 807   "dict://dict.example.com/path/html",
 808   CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 809  {"pop3.example.com/path/html",
 810   "pop3://pop3.example.com/path/html",
 811   CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 812  {"ldap.example.com/path/html",
 813   "ldap://ldap.example.com/path/html",
 814   CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 815  {"imap.example.com/path/html",
 816   "imap://imap.example.com/path/html",
 817   CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 818  {"ftp.example.com/path/html",
 819   "ftp://ftp.example.com/path/html",
 820   CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 821  {"example.com/path/html",
 822   "http://example.com/path/html",
 823   CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 824  {"smtp.com/path/html",
 825   "smtp://smtp.com/path/html",
 826   CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 827  {"dict.com/path/html",
 828   "dict://dict.com/path/html",
 829   CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 830  {"pop3.com/path/html",
 831   "pop3://pop3.com/path/html",
 832   CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 833  {"ldap.com/path/html",
 834   "ldap://ldap.com/path/html",
 835   CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 836  {"imap.com/path/html",
 837   "imap://imap.com/path/html",
 838   CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 839  {"ftp.com/path/html",
 840   "ftp://ftp.com/path/html",
 841   CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 842  {"smtp/path/html",
 843   "http://smtp/path/html",
 844   CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 845  {"dict/path/html",
 846   "http://dict/path/html",
 847   CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 848  {"pop3/path/html",
 849   "http://pop3/path/html",
 850   CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 851  {"ldap/path/html",
 852   "http://ldap/path/html",
 853   CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 854  {"imap/path/html",
 855   "http://imap/path/html",
 856   CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 857  {"ftp/path/html",
 858   "http://ftp/path/html",
 859   CURLU_GUESS_SCHEME, 0, CURLUE_OK},
 860  {"HTTP://test/", "http://test/", 0, 0, CURLUE_OK},
 861  {"http://HO0_-st..~./", "http://HO0_-st..~./", 0, 0, CURLUE_OK},
 862  {"http:/@example.com: 123/", "", 0, 0, CURLUE_MALFORMED_INPUT},
 863  {"http:/@example.com:123 /", "", 0, 0, CURLUE_MALFORMED_INPUT},
 864  {"http:/@example.com:123a/", "", 0, 0, CURLUE_BAD_PORT_NUMBER},
 865  {"http://host/file\r", "", 0, 0, CURLUE_MALFORMED_INPUT},
 866  {"http://host/file\n\x03", "", 0, 0, CURLUE_MALFORMED_INPUT},
 867  {"htt\x02://host/file", "",
 868   CURLU_NON_SUPPORT_SCHEME, 0, CURLUE_MALFORMED_INPUT},
 869  {" http://host/file", "", 0, 0, CURLUE_MALFORMED_INPUT},
 870  /* here the password ends at the semicolon and options is 'word' */
 871  {"imap://user:pass;word@host/file",
 872   "imap://user:pass;word@host/file",
 873   0, 0, CURLUE_OK},
 874  /* here the password has the semicolon */
 875  {"http://user:pass;word@host/file",
 876   "http://user:pass;word@host/file", 0, 0, CURLUE_OK},
 877  {"file:///file.txt#moo", "file:///file.txt#moo", 0, 0, CURLUE_OK},
 878  {"file:////file.txt", "file:////file.txt", 0, 0, CURLUE_OK},
 879  {"file:///file.txt", "file:///file.txt", 0, 0, CURLUE_OK},
 880  {"file:///", "file:///", 0, 0, CURLUE_OK},
 881  {"file:///.", "file:///", 0, 0, CURLUE_OK},
 882  {"file:///./", "file:///", 0, 0, CURLUE_OK},
 883  {"file:///a", "file:///a", 0, 0, CURLUE_OK},
 884  {"file:./", "file://", 0, 0, CURLUE_OK},
 885  {"http://example.com/hello/../here",
 886   "http://example.com/hello/../here",
 887   CURLU_PATH_AS_IS, 0, CURLUE_OK},
 888  {"http://example.com/hello/../here",
 889   "http://example.com/here",
 890   0, 0, CURLUE_OK},
 891  {"http://example.com:80",
 892   "http://example.com/",
 893   0, CURLU_NO_DEFAULT_PORT, CURLUE_OK},
 894  {"tp://example.com/path/html",
 895   "",
 896   0, 0, CURLUE_UNSUPPORTED_SCHEME},
 897  {"http://hello:fool@example.com",
 898   "",
 899   CURLU_DISALLOW_USER, 0, CURLUE_USER_NOT_ALLOWED},
 900  {"http:/@example.com:123",
 901   "http://@example.com:123/",
 902   0, 0, CURLUE_OK},
 903  {"http:/:password@example.com",
 904   "http://:password@example.com/",
 905   0, 0, CURLUE_OK},
 906  {"http://user@example.com?#",
 907   "http://user@example.com/",
 908   0, 0, CURLUE_OK},
 909  {"http://user@example.com?",
 910   "http://user@example.com/",
 911   0, 0, CURLUE_OK},
 912  {"http://user@example.com#anchor",
 913   "http://user@example.com/#anchor",
 914   0, 0, CURLUE_OK},
 915  {"example.com/path/html",
 916   "https://example.com/path/html",
 917   CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
 918  {"example.com/path/html",
 919   "",
 920   0, 0, CURLUE_BAD_SCHEME},
 921  {"http://user:password@example.com:1234/path/html?query=name#anchor",
 922   "http://user:password@example.com:1234/path/html?query=name#anchor",
 923   0, 0, CURLUE_OK},
 924  {"http://example.com:1234/path/html?query=name#anchor",
 925   "http://example.com:1234/path/html?query=name#anchor",
 926   0, 0, CURLUE_OK},
 927  {"http://example.com/path/html?query=name#anchor",
 928   "http://example.com/path/html?query=name#anchor",
 929   0, 0, CURLUE_OK},
 930  {"http://example.com/path/html?query=name",
 931   "http://example.com/path/html?query=name",
 932   0, 0, CURLUE_OK},
 933  {"http://example.com/path/html",
 934   "http://example.com/path/html",
 935   0, 0, CURLUE_OK},
 936  {"tp://example.com/path/html",
 937   "tp://example.com/path/html",
 938   CURLU_NON_SUPPORT_SCHEME, 0, CURLUE_OK},
 939  {"custom-scheme://host?expected=test-good",
 940   "custom-scheme://host/?expected=test-good",
 941   CURLU_NON_SUPPORT_SCHEME, 0, CURLUE_OK},
 942  {"custom-scheme://?expected=test-bad",
 943   "",
 944   CURLU_NON_SUPPORT_SCHEME, 0, CURLUE_NO_HOST},
 945  {"custom-scheme://?expected=test-new-good",
 946   "custom-scheme:///?expected=test-new-good",
 947   CURLU_NON_SUPPORT_SCHEME | CURLU_NO_AUTHORITY, 0, CURLUE_OK},
 948  {"custom-scheme://host?expected=test-still-good",
 949   "custom-scheme://host/?expected=test-still-good",
 950   CURLU_NON_SUPPORT_SCHEME | CURLU_NO_AUTHORITY, 0, CURLUE_OK},
 951  {"https://%41%0D%0A%42/", "", 0, 0, CURLUE_BAD_HOSTNAME},
 952  {"https://[fe80::1]:0/foo", "https://[fe80::1]:0/foo", 0, 0, CURLUE_OK},
 953  {NULL, NULL, 0, 0, CURLUE_OK}
 954};
 955
 956static int checkurl(const char *org, const char *url, const char *out)
 957{
 958  if(strcmp(out, url)) {
 959    curl_mfprintf(stderr,
 960                  "Org:    %s\n"
 961                  "Wanted: %s\n"
 962                  "Got   : %s\n",
 963                  org, out, url);
 964    return 1;
 965  }
 966  return 0;
 967}
 968
 969/* 1. Set the URL
 970   2. Set components
 971   3. Extract all components (not URL)
 972*/
 973static const struct setgetcase setget_parts_list[] = {
 974  {"https://example.com/",
 975   "query=\"\",",
 976   "https | [11] | [12] | [13] | example.com | [15] | / |  | [17]",
 977   0, 0, CURLU_GET_EMPTY, CURLUE_OK},
 978  {"https://example.com/",
 979   "fragment=\"\",",
 980   "https | [11] | [12] | [13] | example.com | [15] | / | [16] | ",
 981   0, 0, CURLU_GET_EMPTY, CURLUE_OK},
 982  {"https://example.com/",
 983   "query=\"\",",
 984   "https | [11] | [12] | [13] | example.com | [15] | / | [16] | [17]",
 985   0, 0, 0, CURLUE_OK},
 986  {"https://example.com",
 987   "path=get,",
 988   "https | [11] | [12] | [13] | example.com | [15] | /get | [16] | [17]",
 989   0, 0, 0, CURLUE_OK},
 990  {"https://example.com",
 991   "path=/get,",
 992   "https | [11] | [12] | [13] | example.com | [15] | /get | [16] | [17]",
 993   0, 0, 0, CURLUE_OK},
 994  {"https://example.com",
 995   "path=g e t,",
 996   "https | [11] | [12] | [13] | example.com | [15] | /g%20e%20t | "
 997   "[16] | [17]",
 998   0, CURLU_URLENCODE, 0, CURLUE_OK},
 999  {NULL, NULL, NULL, 0, 0, 0, CURLUE_OK}
1000};
1001
1002/* !checksrc! disable SPACEBEFORECOMMA 1 */
1003static const struct setcase set_parts_list[] = {
1004  {"https://example.com/",
1005   "path=one /$!$&'()*+;=:@{}[]%,",
1006   "https://example.com/one%20/$!$&'()*+;=:@{}[]%25",
1007   0, CURLU_URLENCODE, CURLUE_OK, CURLUE_OK},
1008  {NULL, /* start fresh! */
1009   "scheme=https,path=/,url=\"\",", /* incomplete url, redirect to "" */
1010   "https://example.com/",
1011   0, 0, CURLUE_OK, CURLUE_MALFORMED_INPUT},
1012  {NULL, /* start fresh! */
1013   "scheme=https,host=example.com,path=/,url=\"\",", /* redirect to "" */
1014   "https://example.com/",
1015   0, 0, CURLUE_OK, CURLUE_OK},
1016  {"https://example.com/",
1017   "path=one\ntwo,",
1018   "https://example.com/one\ntwo",
1019   0, 0, CURLUE_OK, CURLUE_OK},
1020  {"https://example.com/",
1021   "path=one\rtwo,",
1022   "https://example.com/one\rtwo",
1023   0, 0, CURLUE_OK, CURLUE_OK},
1024  {"https://example.com/",
1025   "path=one\ntwo,",
1026   "https://example.com/one%0Atwo",
1027   0, CURLU_URLENCODE, CURLUE_OK, CURLUE_OK},
1028  {"https://example.com/",
1029   "path=one\rtwo,",
1030   "https://example.com/one%0Dtwo",
1031   0, CURLU_URLENCODE, CURLUE_OK, CURLUE_OK},
1032  {"https://example.com/",
1033   "host=%43url.se,",
1034   "https://%43url.se/",
1035   0, 0, CURLUE_OK, CURLUE_OK},
1036  {"https://example.com/",
1037   "host=%25url.se,",
1038   "",
1039   0, 0, CURLUE_OK, CURLUE_BAD_HOSTNAME},
1040  {"https://example.com/?param=value",
1041   "query=\"\",",
1042   "https://example.com/",
1043   0, CURLU_APPENDQUERY | CURLU_URLENCODE, CURLUE_OK, CURLUE_OK},
1044  {"https://example.com/",
1045   "host=\"\",",
1046   "https://example.com/",
1047   0, CURLU_URLENCODE, CURLUE_OK, CURLUE_BAD_HOSTNAME},
1048  {"https://example.com/",
1049   "host=\"\",",
1050   "https://example.com/",
1051   0, 0, CURLUE_OK, CURLUE_BAD_HOSTNAME},
1052  {"https://example.com",
1053   "path=get,",
1054   "https://example.com/get",
1055   0, 0, CURLUE_OK, CURLUE_OK},
1056  {"https://example.com/",
1057   "scheme=ftp+-.123,",
1058   "ftp+-.123://example.com/",
1059   0, CURLU_NON_SUPPORT_SCHEME, CURLUE_OK, CURLUE_OK},
1060  {"https://example.com/",
1061   "scheme=1234,",
1062   "https://example.com/",
1063   0, CURLU_NON_SUPPORT_SCHEME, CURLUE_OK, CURLUE_BAD_SCHEME},
1064  {"https://example.com/",
1065   "scheme=1http,",
1066   "https://example.com/",
1067   0, CURLU_NON_SUPPORT_SCHEME, CURLUE_OK, CURLUE_BAD_SCHEME},
1068  {"https://example.com/",
1069   "scheme=-ftp,",
1070   "https://example.com/",
1071   0, CURLU_NON_SUPPORT_SCHEME, CURLUE_OK, CURLUE_BAD_SCHEME},
1072  {"https://example.com/",
1073   "scheme=+ftp,",
1074   "https://example.com/",
1075   0, CURLU_NON_SUPPORT_SCHEME, CURLUE_OK, CURLUE_BAD_SCHEME},
1076  {"https://example.com/",
1077   "scheme=.ftp,",
1078   "https://example.com/",
1079   0, CURLU_NON_SUPPORT_SCHEME, CURLUE_OK, CURLUE_BAD_SCHEME},
1080  {"https://example.com/",
1081   "host=example.com%2fmoo,",
1082   "",
1083   0, /* get */
1084   0, /* set */
1085   CURLUE_OK, CURLUE_BAD_HOSTNAME},
1086  {"https://example.com/",
1087   "host=http://fake,",
1088   "",
1089   0, /* get */
1090   0, /* set */
1091   CURLUE_OK, CURLUE_BAD_HOSTNAME},
1092  {"https://example.com/",
1093   "host=test%,",
1094   "",
1095   0, /* get */
1096   0, /* set */
1097   CURLUE_OK, CURLUE_BAD_HOSTNAME},
1098  {"https://example.com/",
1099   "host=te st,",
1100   "",
1101   0, /* get */
1102   0, /* set */
1103   CURLUE_OK, CURLUE_BAD_HOSTNAME},
1104  {"https://example.com/",
1105   "host=0xff,", /* '++' there is no automatic URL decode when setting this
1106                  part */
1107   "https://0xff/",
1108   0, /* get */
1109   0, /* set */
1110   CURLUE_OK, CURLUE_OK},
1111
1112  {"https://example.com/",
1113   "query=Al2cO3tDkcDZ3EWE5Lh+LX8TPHs,", /* contains '+' */
1114   "https://example.com/?Al2cO3tDkcDZ3EWE5Lh%2BLX8TPHs",
1115   CURLU_URLDECODE, /* decode on get */
1116   CURLU_URLENCODE, /* encode on set */
1117   CURLUE_OK, CURLUE_OK},
1118
1119  {"https://example.com/",
1120   /* Set a bad scheme *including* :// */
1121   "scheme=https://,",
1122   "https://example.com/",
1123   0, CURLU_NON_SUPPORT_SCHEME, CURLUE_OK, CURLUE_BAD_SCHEME},
1124  {"https://example.com/",
1125   /* Set a 41 bytes scheme. That is too long so the old scheme remains set. */
1126   "scheme=bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbc,",
1127   "https://example.com/",
1128   0, CURLU_NON_SUPPORT_SCHEME, CURLUE_OK, CURLUE_BAD_SCHEME},
1129  {"https://example.com/",
1130   /* set a 40 bytes scheme */
1131   "scheme=bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,",
1132   "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb://example.com/",
1133   0, CURLU_NON_SUPPORT_SCHEME, CURLUE_OK, CURLUE_OK},
1134  {"https://[::1%25fake]:1234/",
1135   "zoneid=NULL,",
1136   "https://[::1]:1234/",
1137   0, 0, CURLUE_OK, CURLUE_OK},
1138  {"https://host:1234/",
1139   "port=NULL,",
1140   "https://host/",
1141   0, 0, CURLUE_OK, CURLUE_OK},
1142  {"https://host:1234/",
1143   "port=\"\",",
1144   "https://host:1234/",
1145   0, 0, CURLUE_OK, CURLUE_BAD_PORT_NUMBER},
1146  {"https://host:1234/",
1147   "port=56 78,",
1148   "https://host:1234/",
1149   0, 0, CURLUE_OK, CURLUE_BAD_PORT_NUMBER},
1150  {"https://host:1234/",
1151   "port=0,",
1152   "https://host:0/",
1153   0, 0, CURLUE_OK, CURLUE_OK},
1154  {"https://host:1234/",
1155   "port=65535,",
1156   "https://host:65535/",
1157   0, 0, CURLUE_OK, CURLUE_OK},
1158  {"https://host:1234/",
1159   "port=65536,",
1160   "https://host:1234/",
1161   0, 0, CURLUE_OK, CURLUE_BAD_PORT_NUMBER},
1162  {"https://host/",
1163   "path=%4A%4b%4C,",
1164   "https://host/%4A%4B%4C",
1165   0, 0, CURLUE_OK, CURLUE_OK},
1166  {"https://host/mooo?q#f",
1167   "path=NULL,query=NULL,fragment=NULL,",
1168   "https://host/",
1169   0, 0, CURLUE_OK, CURLUE_OK},
1170  {"https://user:secret@host/",
1171   "user=NULL,password=NULL,",
1172   "https://host/",
1173   0, 0, CURLUE_OK, CURLUE_OK},
1174  {NULL,
1175   "scheme=https,user=   @:,host=foobar,",
1176   "https://%20%20%20%40%3A@foobar/",
1177   0, CURLU_URLENCODE, CURLUE_OK, CURLUE_OK},
1178  /* Setting a hostname with spaces is not OK: */
1179  {NULL,
1180   "scheme=https,host=  ,path= ,user= ,password= ,query= ,fragment= ,",
1181   "[nothing]",
1182   0, CURLU_URLENCODE, CURLUE_OK, CURLUE_BAD_HOSTNAME},
1183  {NULL,
1184   "scheme=https,host=foobar,path=/this /path /is /here,",
1185   "https://foobar/this%20/path%20/is%20/here",
1186   0, CURLU_URLENCODE, CURLUE_OK, CURLUE_OK},
1187  {NULL,
1188   "scheme=https,host=foobar,path=\xc3\xa4\xc3\xb6\xc3\xbc,",
1189   "https://foobar/%C3%A4%C3%B6%C3%BC",
1190   0, CURLU_URLENCODE, CURLUE_OK, CURLUE_OK},
1191  {"imap://user:secret;opt@host/",
1192   "options=updated,scheme=imaps,password=p4ssw0rd,",
1193   "imaps://user:p4ssw0rd;updated@host/",
1194   0, 0, CURLUE_NO_HOST, CURLUE_OK},
1195  {"imap://user:secret;optit@host/",
1196   "scheme=https,",
1197   "https://user:secret@host/",
1198   0, 0, CURLUE_NO_HOST, CURLUE_OK},
1199  {"file:///file#anchor",
1200   "scheme=https,host=example,",
1201   "https://example/file#anchor",
1202   0, 0, CURLUE_NO_HOST, CURLUE_OK},
1203  {NULL, /* start fresh! */
1204   "scheme=file,host=127.0.0.1,path=/no,user=anonymous,",
1205   "file:///no",
1206   0, 0, CURLUE_OK, CURLUE_OK},
1207  {NULL, /* start fresh! */
1208   "scheme=ftp,host=127.0.0.1,path=/no,user=anonymous,",
1209   "ftp://anonymous@127.0.0.1/no",
1210   0, 0, CURLUE_OK, CURLUE_OK},
1211  {NULL, /* start fresh! */
1212   "scheme=https,host=example.com,",
1213   "https://example.com/",
1214   0, CURLU_NON_SUPPORT_SCHEME, CURLUE_OK, CURLUE_OK},
1215  {"http://user:foo@example.com/path?query#frag",
1216   "fragment=changed,",
1217   "http://user:foo@example.com/path?query#changed",
1218   0, CURLU_NON_SUPPORT_SCHEME, CURLUE_OK, CURLUE_OK},
1219  {"http://example.com/",
1220   "scheme=foo,", /* not accepted */
1221   "http://example.com/",
1222   0, 0, CURLUE_OK, CURLUE_UNSUPPORTED_SCHEME},
1223  {"http://example.com/",
1224   "scheme=https,path=/hello,fragment=snippet,",
1225   "https://example.com/hello#snippet",
1226   0, 0, CURLUE_OK, CURLUE_OK},
1227  {"http://example.com:80",
1228   "user=foo,port=1922,",
1229   "http://foo@example.com:1922/",
1230   0, 0, CURLUE_OK, CURLUE_OK},
1231  {"http://example.com:80",
1232   "user=foo,password=bar,",
1233   "http://foo:bar@example.com:80/",
1234   0, 0, CURLUE_OK, CURLUE_OK},
1235  {"http://example.com:80",
1236   "user=foo,",
1237   "http://foo@example.com:80/",
1238   0, 0, CURLUE_OK, CURLUE_OK},
1239  {"http://example.com",
1240   "host=www.example.com,",
1241   "http://www.example.com/",
1242   0, 0, CURLUE_OK, CURLUE_OK},
1243  {"http://example.com:80",
1244   "scheme=ftp,",
1245   "ftp://example.com:80/",
1246   0, 0, CURLUE_OK, CURLUE_OK},
1247  {"custom-scheme://host",
1248   "host=\"\",",
1249   "custom-scheme://host/",
1250   CURLU_NON_SUPPORT_SCHEME, CURLU_NON_SUPPORT_SCHEME, CURLUE_OK,
1251   CURLUE_BAD_HOSTNAME},
1252  {"custom-scheme://host",
1253   "host=\"\",",
1254   "custom-scheme:///",
1255   CURLU_NON_SUPPORT_SCHEME, CURLU_NON_SUPPORT_SCHEME | CURLU_NO_AUTHORITY,
1256   CURLUE_OK, CURLUE_OK},
1257  {"https://example.com/",
1258   "port=0,",
1259   "https://example.com:0/",
1260   0, 0, CURLUE_OK, CURLUE_OK},
1261  {"https://example.com/",
1262   "port=65535,",
1263   "https://example.com:65535/",
1264   0, 0, CURLUE_OK, CURLUE_OK},
1265  {"https://example.com/",
1266   "query=foo=bar,",
1267   "https://example.com/?foo=bar",
1268   0, CURLU_APPENDQUERY, CURLUE_OK, CURLUE_OK},
1269  {NULL, NULL, NULL, 0, 0, CURLUE_OK, CURLUE_OK}
1270};
1271
1272static CURLUPart part2id(const char *part)
1273{
1274  if(!strcmp("url", part))
1275    return CURLUPART_URL;
1276  if(!strcmp("scheme", part))
1277    return CURLUPART_SCHEME;
1278  if(!strcmp("user", part))
1279    return CURLUPART_USER;
1280  if(!strcmp("password", part))
1281    return CURLUPART_PASSWORD;
1282  if(!strcmp("options", part))
1283    return CURLUPART_OPTIONS;
1284  if(!strcmp("host", part))
1285    return CURLUPART_HOST;
1286  if(!strcmp("port", part))
1287    return CURLUPART_PORT;
1288  if(!strcmp("path", part))
1289    return CURLUPART_PATH;
1290  if(!strcmp("query", part))
1291    return CURLUPART_QUERY;
1292  if(!strcmp("fragment", part))
1293    return CURLUPART_FRAGMENT;
1294  if(!strcmp("zoneid", part))
1295    return CURLUPART_ZONEID;
1296  /* NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange) */
1297  return (CURLUPart)9999; /* bad input => bad output */
1298}
1299
1300static CURLUcode updateurl(CURLU *u, const char *cmd, unsigned int setflags)
1301{
1302  const char *p = cmd;
1303  CURLUcode uc;
1304
1305  /* make sure the last command ends with a comma too! */
1306  while(p) {
1307    const char *e = strchr(p, ',');
1308    if(e) {
1309      size_t n = (size_t)(e - p);
1310      char buf[80];
1311      char part[80];
1312      char value[80];
1313
1314      memset(part, 0, sizeof(part)); /* Avoid valgrind false positive. */
1315      memset(value, 0, sizeof(value)); /* Avoid valgrind false positive. */
1316      memcpy(buf, p, n);
1317      buf[n] = 0;
1318      /* !checksrc! disable BANNEDFUNC 1 */
1319      if(sscanf(buf, "%79[^=]=%79[^,]", part, value) == 2) {
1320        CURLUPart what = part2id(part);
1321#if 0
1322        /* for debugging this */
1323        curl_mfprintf(stderr, "%s = \"%s\" [%d]\n", part, value, what);
1324#endif
1325        if(what > CURLUPART_ZONEID)
1326          curl_mfprintf(stderr, "UNKNOWN part '%s'\n", part);
1327
1328        if(!strcmp("NULL", value))
1329          uc = curl_url_set(u, what, NULL, setflags);
1330        else if(!strcmp("\"\"", value))
1331          uc = curl_url_set(u, what, "", setflags);
1332        else
1333          uc = curl_url_set(u, what, value, setflags);
1334        if(uc)
1335          return uc;
1336      }
1337      p = e + 1;
1338      continue;
1339    }
1340    break;
1341  }
1342  return CURLUE_OK;
1343}
1344
1345static const struct redircase set_url_list[] = {
1346  {"https://example.com",
1347   "", /* blank redirect */
1348   "https://example.com/",
1349   0, 0, CURLUE_OK },
1350  {"http://firstplace.example.com/want/1314",
1351   "//somewhere.example.com/reply/1314",
1352   "http://somewhere.example.com/reply/1314",
1353   0, 0, CURLUE_OK },
1354  {"http://127.0.0.1:46383/want?uri=http://anything/276?secondq/276",
1355   "data/2760002.txt?coolsite=http://anotherurl/?a_second/2760002",
1356   "http://127.0.0.1:46383/"
1357   "data/2760002.txt?coolsite=http://anotherurl/?a_second/2760002",
1358   0, 0, CURLUE_OK },
1359  {"file:///basic#", "#yay",
1360   "file:///basic#yay", 0, 0, CURLUE_OK},
1361  {"file:///basic", "?yay",
1362   "file:///basic?yay", 0, 0, CURLUE_OK},
1363  {"file:///basic?", "?yay",
1364   "file:///basic?yay", 0, 0, CURLUE_OK},
1365  {"file:///basic?hello", "#frag",
1366   "file:///basic?hello#frag", 0, 0, CURLUE_OK},
1367  {"file:///basic?hello", "?q",
1368   "file:///basic?q", 0, 0, CURLUE_OK},
1369  {"http://example.org#without/ash", "/moo#frag",
1370   "http://example.org/moo#frag",
1371   0, 0, CURLUE_OK},
1372  {"http://example.org/", "../path/././../././../moo",
1373   "http://example.org/moo",
1374   0, 0, CURLUE_OK},
1375  {"http://example.org/", ".%2e/path/././../%2E/./../moo",
1376   "http://example.org/moo",
1377   0, 0, CURLUE_OK},
1378  {"http://example.org/", ".%2e/path/./%2e/.%2E/%2E/./%2e%2E/moo",
1379   "http://example.org/moo",
1380   0, 0, CURLUE_OK},
1381
1382  {"http://example.org?bar/moo", "?weird",
1383   "http://example.org/?weird", 0, 0, CURLUE_OK},
1384  {"http://example.org/foo?bar", "?weird",
1385   "http://example.org/foo?weird", 0, 0, CURLUE_OK},
1386  {"http://example.org/foo", "?weird",
1387   "http://example.org/foo?weird", 0, 0, CURLUE_OK},
1388  {"http://example.org", "?weird",
1389   "http://example.org/?weird", 0, 0, CURLUE_OK},
1390  {"http://example.org/#original", "?weird#moo",
1391   "http://example.org/?weird#moo", 0, 0, CURLUE_OK},
1392
1393  {"http://example.org?bar/moo#yes/path", "#new/slash",
1394   "http://example.org/?bar/moo#new/slash", 0, 0, CURLUE_OK},
1395  {"http://example.org/foo?bar", "#weird",
1396   "http://example.org/foo?bar#weird", 0, 0, CURLUE_OK},
1397  {"http://example.org/foo?bar#original", "#weird",
1398   "http://example.org/foo?bar#weird", 0, 0, CURLUE_OK},
1399  {"http://example.org/foo#original", "#weird",
1400   "http://example.org/foo#weird", 0, 0, CURLUE_OK},
1401  {"http://example.org/#original", "#weird",
1402   "http://example.org/#weird", 0, 0, CURLUE_OK},
1403  {"http://example.org#original", "#weird",
1404   "http://example.org/#weird", 0, 0, CURLUE_OK},
1405  {"http://example.org/foo?bar", "moo?hey#weird",
1406   "http://example.org/moo?hey#weird", 0, 0, CURLUE_OK},
1407  {"http://example.org/",
1408   "../path/././../../moo",
1409   "http://example.org/moo",
1410   0, 0, CURLUE_OK},
1411  {"http://example.org/",
1412   "//example.org/../path/../../",
1413   "http://example.org/",
1414   0, 0, CURLUE_OK},
1415  {"http://example.org/",
1416   "///example.org/../path/../../",
1417   "http://example.org/",
1418   0, 0, CURLUE_OK},
1419  {"http://example.org/foo/bar",
1420   ":23",
1421   "http://example.org/foo/:23",
1422   0, 0, CURLUE_OK},
1423  {"http://example.org/foo/bar",
1424   "\\x",
1425   "http://example.org/foo/\\x",
1426   /* WHATWG disagrees */
1427   0, 0, CURLUE_OK},
1428  {"http://example.org/foo/bar",
1429   "#/",
1430   "http://example.org/foo/bar#/",
1431   0, 0, CURLUE_OK},
1432  {"http://example.org/foo/bar",
1433   "?/",
1434   "http://example.org/foo/bar?/",
1435   0, 0, CURLUE_OK},
1436  {"http://example.org/foo/bar",
1437   "#;?",
1438   "http://example.org/foo/bar#;?",
1439   0, 0, CURLUE_OK},
1440  {"http://example.org/foo/bar",
1441   "#",
1442   "http://example.org/foo/bar",
1443   /* This happens because the parser removes empty fragments */
1444   0, 0, CURLUE_OK},
1445  {"http://example.org/foo/bar",
1446   "?",
1447   "http://example.org/foo/bar",
1448   /* This happens because the parser removes empty queries */
1449   0, 0, CURLUE_OK},
1450  {"http://example.org/foo/bar",
1451   "?#",
1452   "http://example.org/foo/bar",
1453   /* This happens because the parser removes empty queries and fragments */
1454   0, 0, CURLUE_OK},
1455  {"http://example.com/please/../gimme/%TESTNUMBER?foobar#hello",
1456   "http://example.net/there/it/is/../../tes t case=/%TESTNUMBER0002? yes no",
1457   "http://example.net/there/tes%20t%20case=/%TESTNUMBER0002?+yes+no",
1458   0, CURLU_URLENCODE | CURLU_ALLOW_SPACE, CURLUE_OK},
1459  {"http://local.test?redirect=http://local.test:80?-321",
1460   "http://local.test:80?-123",
1461   "http://local.test:80/?-123",
1462   0, CURLU_URLENCODE | CURLU_ALLOW_SPACE, CURLUE_OK},
1463  {"http://local.test?redirect=http://local.test:80?-321",
1464   "http://local.test:80?-123",
1465   "http://local.test:80/?-123",
1466   0, 0, CURLUE_OK},
1467  {"http://example.org/static/favicon/wikipedia.ico",
1468   "//fake.example.com/licenses/by-sa/3.0/",
1469   "http://fake.example.com/licenses/by-sa/3.0/",
1470   0, 0, CURLUE_OK},
1471  {"https://example.org/static/favicon/wikipedia.ico",
1472   "//fake.example.com/licenses/by-sa/3.0/",
1473   "https://fake.example.com/licenses/by-sa/3.0/",
1474   0, 0, CURLUE_OK},
1475  {"file://localhost/path?query#frag",
1476   "foo#another",
1477   "file:///foo#another",
1478   0, 0, CURLUE_OK},
1479  {"http://example.com/path?query#frag",
1480   "https://two.example.com/bradnew",
1481   "https://two.example.com/bradnew",
1482   0, 0, CURLUE_OK},
1483  {"http://example.com/path?query#frag",
1484   "../../newpage#foo",
1485   "http://example.com/newpage#foo",
1486   0, 0, CURLUE_OK},
1487  {"http://user:foo@example.com/path?query#frag",
1488   "../../newpage",
1489   "http://user:foo@example.com/newpage",
1490   0, 0, CURLUE_OK},
1491  {"http://user:foo@example.com/path?query#frag",
1492   "../newpage",
1493   "http://user:foo@example.com/newpage",
1494   0, 0, CURLUE_OK},
1495  {"http://user:foo@example.com/path?query#frag",
1496   "http://?hi",
1497   "http:///?hi",
1498   0, CURLU_NO_AUTHORITY, CURLUE_OK},
1499  {"http://host/path", "?query", "http://host/path?query", 0, 0, CURLUE_OK},
1500  {"http://host/path", "#frag", "http://host/path#frag", 0, 0, CURLUE_OK},
1501  {NULL, NULL, NULL, 0, 0, CURLUE_OK}
1502};
1503
1504static int set_url(void)
1505{
1506  int i;
1507  int error = 0;
1508
1509  for(i = 0; set_url_list[i].in && !error; i++) {
1510    CURLUcode rc;
1511    CURLU *urlp = curl_url();
1512    if(!urlp)
1513      break;
1514    rc = curl_url_set(urlp, CURLUPART_URL, set_url_list[i].in,
1515                      set_url_list[i].urlflags);
1516    if(!rc) {
1517      rc = curl_url_set(urlp, CURLUPART_URL, set_url_list[i].set,
1518                        set_url_list[i].setflags);
1519      if(rc) {
1520        curl_mfprintf(stderr, "%s:%d Set URL %s returned %d (%s)\n",
1521                      __FILE__, __LINE__, set_url_list[i].set,
1522                      rc, curl_url_strerror(rc));
1523        error++;
1524      }
1525      else {
1526        char *url = NULL;
1527        rc = curl_url_get(urlp, CURLUPART_URL, &url, 0);
1528        if(rc) {
1529          curl_mfprintf(stderr, "%s:%d Get URL returned %d (%s)\n",
1530                        __FILE__, __LINE__, rc, curl_url_strerror(rc));
1531          error++;
1532        }
1533        else {
1534          if(checkurl(set_url_list[i].in, url, set_url_list[i].out)) {
1535            error++;
1536          }
1537        }
1538        curl_free(url);
1539      }
1540    }
1541    else if(rc != set_url_list[i].ucode) {
1542      curl_mfprintf(stderr, "Set URL\nin: %s\nreturned %d (expected %d)\n",
1543                    set_url_list[i].in, rc, set_url_list[i].ucode);
1544      error++;
1545    }
1546    curl_url_cleanup(urlp);
1547  }
1548  return error;
1549}
1550
1551/* 1. Set a URL
1552   2. Set one or more parts
1553   3. Extract and compare all parts - not the URL
1554*/
1555static int setget_parts(bool has_utf8)
1556{
1557  int i;
1558  int error = 0;
1559
1560  for(i = 0; setget_parts_list[i].set && !error; i++) {
1561    CURLU *urlp = curl_url();
1562    if(!urlp) {
1563      error++;
1564      break;
1565    }
1566    if((setget_parts_list[i].getflags != CURLU_PUNYCODE &&
1567        setget_parts_list[i].getflags != CURLU_PUNY2IDN) || has_utf8) {
1568      CURLUcode rc;
1569      if(setget_parts_list[i].in)
1570        rc = curl_url_set(urlp, CURLUPART_URL, setget_parts_list[i].in,
1571                          setget_parts_list[i].urlflags);
1572      else
1573        rc = CURLUE_OK;
1574      if(!rc) {
1575        char *url = NULL;
1576        CURLUcode uc = updateurl(urlp, setget_parts_list[i].set,
1577                                 setget_parts_list[i].setflags);
1578
1579        if(uc != setget_parts_list[i].pcode) {
1580          curl_mfprintf(stderr,
1581                        "updateurl\nin: %s\nreturned %d (expected %d)\n",
1582                        setget_parts_list[i].set, uc,
1583                        setget_parts_list[i].pcode);
1584          error++;
1585        }
1586        if(!uc) {
1587          if(checkparts(urlp,
1588                        setget_parts_list[i].set,
1589                        setget_parts_list[i].out,
1590                        setget_parts_list[i].getflags))
1591            error++;        /* add */
1592        }
1593        curl_free(url);
1594      }
1595      else if(rc != CURLUE_OK) {
1596        curl_mfprintf(stderr, "Set parts\nin: %s\nreturned %d (expected %d)\n",
1597                      setget_parts_list[i].in, rc, 0);
1598        error++;
1599      }
1600    }
1601    curl_url_cleanup(urlp);
1602  }
1603  return error;
1604}
1605
1606static int set_parts(void)
1607{
1608  int i;
1609  int error = 0;
1610
1611  for(i = 0; set_parts_list[i].set && !error; i++) {
1612    CURLUcode rc;
1613    CURLU *urlp = curl_url();
1614    if(!urlp) {
1615      error++;
1616      break;
1617    }
1618    if(set_parts_list[i].in)
1619      rc = curl_url_set(urlp, CURLUPART_URL, set_parts_list[i].in,
1620                        set_parts_list[i].urlflags);
1621    else
1622      rc = CURLUE_OK;
1623    if(!rc) {
1624      char *url = NULL;
1625      CURLUcode uc = updateurl(urlp, set_parts_list[i].set,
1626                               set_parts_list[i].setflags);
1627
1628      if(uc != set_parts_list[i].pcode) {
1629        curl_mfprintf(stderr, "updateurl\nin: %s\nreturned %d (expected %d)\n",
1630                      set_parts_list[i].set, uc, set_parts_list[i].pcode);
1631        error++;
1632      }
1633      if(!uc) {
1634        /* only do this if it worked */
1635        rc = curl_url_get(urlp, CURLUPART_URL, &url, 0);
1636
1637        if(rc) {
1638          curl_mfprintf(stderr, "%s:%d Get URL returned %d (%s)\n",
1639                        __FILE__, __LINE__, rc, curl_url_strerror(rc));
1640          error++;
1641        }
1642        else if(checkurl(set_parts_list[i].in, url, set_parts_list[i].out)) {
1643          error++;
1644        }
1645      }
1646      curl_free(url);
1647    }
1648    else if(rc != set_parts_list[i].ucode) {
1649      curl_mfprintf(stderr, "Set parts\nin: %s\nreturned %d (expected %d)\n",
1650                    set_parts_list[i].in, rc, set_parts_list[i].ucode);
1651      error++;
1652    }
1653    curl_url_cleanup(urlp);
1654  }
1655  return error;
1656}
1657
1658static int get_url(bool has_utf8)
1659{
1660  int i;
1661  int error = 0;
1662  for(i = 0; get_url_list[i].in && !error; i++) {
1663    CURLU *urlp = curl_url();
1664    if(!urlp) {
1665      error++;
1666      break;
1667    }
1668    if((get_url_list[i].getflags != CURLU_PUNYCODE &&
1669        get_url_list[i].getflags != CURLU_PUNY2IDN) || has_utf8) {
1670      CURLUcode rc;
1671      rc = curl_url_set(urlp, CURLUPART_URL, get_url_list[i].in,
1672                        get_url_list[i].urlflags);
1673      if(!rc) {
1674        char *url = NULL;
1675        rc = curl_url_get(urlp, CURLUPART_URL, &url, get_url_list[i].getflags);
1676
1677        if(rc) {
1678          curl_mfprintf(stderr, "%s:%d returned %d (%s). URL: '%s'\n",
1679                        __FILE__, __LINE__, rc, curl_url_strerror(rc),
1680                        get_url_list[i].in);
1681          error++;
1682        }
1683        else {
1684          if(checkurl(get_url_list[i].in, url, get_url_list[i].out)) {
1685            error++;
1686          }
1687        }
1688        curl_free(url);
1689      }
1690      if(rc != get_url_list[i].ucode) {
1691        curl_mfprintf(stderr, "Get URL\nin: %s\nreturned %d (expected %d)\n",
1692                      get_url_list[i].in, rc, get_url_list[i].ucode);
1693        error++;
1694      }
1695    }
1696    curl_url_cleanup(urlp);
1697  }
1698  return error;
1699}
1700
1701static int get_parts(bool has_utf8)
1702{
1703  int i;
1704  int error = 0;
1705  for(i = 0; get_parts_list[i].in && !error; i++) {
1706    CURLU *urlp = curl_url();
1707    if(!urlp) {
1708      error++;
1709      break;
1710    }
1711    if((get_parts_list[i].getflags != CURLU_PUNYCODE &&
1712        get_parts_list[i].getflags != CURLU_PUNY2IDN) || has_utf8) {
1713      CURLUcode rc;
1714      rc = curl_url_set(urlp, CURLUPART_URL,
1715                        get_parts_list[i].in,
1716                        get_parts_list[i].urlflags);
1717      if(rc != get_parts_list[i].ucode) {
1718        curl_mfprintf(stderr, "Get parts\nin: %s\nreturned %d (expected %d)\n",
1719                      get_parts_list[i].in, rc, get_parts_list[i].ucode);
1720        error++;
1721      }
1722      else if(get_parts_list[i].ucode) {
1723        /* the expected error happened */
1724      }
1725      else if(checkparts(urlp, get_parts_list[i].in, get_parts_list[i].out,
1726                         get_parts_list[i].getflags))
1727        error++;
1728    }
1729    curl_url_cleanup(urlp);
1730  }
1731  return error;
1732}
1733
1734static const struct querycase append_list[] = {
1735  {"HTTP://test/?s", "name=joe\x02", "http://test/?s&name=joe%02",
1736   0, CURLU_URLENCODE, CURLUE_OK},
1737  {"HTTP://test/?size=2#f", "name=joe=", "http://test/?size=2&name=joe%3D#f",
1738   0, CURLU_URLENCODE, CURLUE_OK},
1739  {"HTTP://test/?size=2#f", "name=joe doe",
1740   "http://test/?size=2&name=joe+doe#f",
1741   0, CURLU_URLENCODE, CURLUE_OK},
1742  {"HTTP://test/", "name=joe", "http://test/?name=joe", 0, 0, CURLUE_OK},
1743  {"HTTP://test/?size=2", "name=joe", "http://test/?size=2&name=joe",
1744   0, 0, CURLUE_OK},
1745  {"HTTP://test/?size=2&", "name=joe", "http://test/?size=2&name=joe",
1746   0, 0, CURLUE_OK},
1747  {"HTTP://test/?size=2#f", "name=joe", "http://test/?size=2&name=joe#f",
1748   0, 0, CURLUE_OK},
1749  {NULL, NULL, NULL, 0, 0, CURLUE_OK}
1750};
1751
1752static int append(void)
1753{
1754  int i;
1755  int error = 0;
1756  for(i = 0; append_list[i].in && !error; i++) {
1757    CURLUcode rc;
1758    CURLU *urlp = curl_url();
1759    if(!urlp) {
1760      error++;
1761      break;
1762    }
1763    rc = curl_url_set(urlp, CURLUPART_URL,
1764                      append_list[i].in,
1765                      append_list[i].urlflags);
1766    if(rc)
1767      error++;
1768    else
1769      rc = curl_url_set(urlp, CURLUPART_QUERY,
1770                        append_list[i].q,
1771                        append_list[i].qflags | CURLU_APPENDQUERY);
1772    if(error)
1773      ;
1774    else if(rc != append_list[i].ucode) {
1775      curl_mfprintf(stderr, "Append\nin: %s\nreturned %d (expected %d)\n",
1776                    append_list[i].in, rc, append_list[i].ucode);
1777      error++;
1778    }
1779    else if(append_list[i].ucode) {
1780      /* the expected error happened */
1781    }
1782    else {
1783      char *url;
1784      rc = curl_url_get(urlp, CURLUPART_URL, &url, 0);
1785      if(rc) {
1786        curl_mfprintf(stderr, "%s:%d Get URL returned %d (%s)\n",
1787                      __FILE__, __LINE__, rc, curl_url_strerror(rc));
1788        error++;
1789      }
1790      else {
1791        if(checkurl(append_list[i].in, url, append_list[i].out)) {
1792          error++;
1793        }
1794        curl_free(url);
1795      }
1796    }
1797    curl_url_cleanup(urlp);
1798  }
1799  return error;
1800}
1801
1802static int scopeid(void)
1803{
1804  CURLU *u = curl_url();
1805  int error = 0;
1806  CURLUcode rc;
1807  char *url;
1808
1809  rc = curl_url_set(u, CURLUPART_URL,
1810                    "https://[fe80::20c:29ff:fe9c:409b%25eth0]/hello.html", 0);
1811  if(rc != CURLUE_OK) {
1812    curl_mfprintf(stderr, "%s:%d curl_url_set returned %d (%s)\n",
1813                  __FILE__, __LINE__, rc, curl_url_strerror(rc));
1814    error++;
1815  }
1816
1817  rc = curl_url_get(u, CURLUPART_HOST, &url, 0);
1818  if(rc != CURLUE_OK) {
1819    curl_mfprintf(stderr,
1820                  "%s:%d curl_url_get CURLUPART_HOST returned %d (%s)\n",
1821                  __FILE__, __LINE__, rc, curl_url_strerror(rc));
1822    error++;
1823  }
1824  else {
1825    curl_free(url);
1826  }
1827
1828  rc = curl_url_set(u, CURLUPART_HOST, "[::1]", 0);
1829  if(rc != CURLUE_OK) {
1830    curl_mfprintf(stderr,
1831                  "%s:%d curl_url_set CURLUPART_HOST returned %d (%s)\n",
1832                  __FILE__, __LINE__, rc, curl_url_strerror(rc));
1833    error++;
1834  }
1835
1836  rc = curl_url_get(u, CURLUPART_URL, &url, 0);
1837  if(rc != CURLUE_OK) {
1838    curl_mfprintf(stderr,
1839                  "%s:%d curl_url_get CURLUPART_URL returned %d (%s)\n",
1840                  __FILE__, __LINE__, rc, curl_url_strerror(rc));
1841    error++;
1842  }
1843  else {
1844    curl_free(url);
1845  }
1846
1847  rc = curl_url_set(u, CURLUPART_HOST, "example.com", 0);
1848  if(rc != CURLUE_OK) {
1849    curl_mfprintf(stderr,
1850                  "%s:%d curl_url_set CURLUPART_HOST returned %d (%s)\n",
1851                  __FILE__, __LINE__, rc, curl_url_strerror(rc));
1852    error++;
1853  }
1854
1855  rc = curl_url_get(u, CURLUPART_URL, &url, 0);
1856  if(rc != CURLUE_OK) {
1857    curl_mfprintf(stderr,
1858                  "%s:%d curl_url_get CURLUPART_URL returned %d (%s)\n",
1859                  __FILE__, __LINE__, rc, curl_url_strerror(rc));
1860    error++;
1861  }
1862  else {
1863    curl_free(url);
1864  }
1865
1866  rc = curl_url_set(u, CURLUPART_HOST,
1867                    "[fe80::20c:29ff:fe9c:409b%25eth0]", 0);
1868  if(rc != CURLUE_OK) {
1869    curl_mfprintf(stderr,
1870                  "%s:%d curl_url_set CURLUPART_HOST returned %d (%s)\n",
1871                  __FILE__, __LINE__, rc, curl_url_strerror(rc));
1872    error++;
1873  }
1874
1875  rc = curl_url_get(u, CURLUPART_URL, &url, 0);
1876  if(rc != CURLUE_OK) {
1877    curl_mfprintf(stderr,
1878                  "%s:%d curl_url_get CURLUPART_URL returned %d (%s)\n",
1879                  __FILE__, __LINE__, rc, curl_url_strerror(rc));
1880    error++;
1881  }
1882  else {
1883    curl_free(url);
1884  }
1885
1886  rc = curl_url_get(u, CURLUPART_HOST, &url, 0);
1887  if(rc != CURLUE_OK) {
1888    curl_mfprintf(stderr,
1889                  "%s:%d curl_url_get CURLUPART_HOST returned %d (%s)\n",
1890                  __FILE__, __LINE__, rc, curl_url_strerror(rc));
1891    error++;
1892  }
1893  else {
1894    curl_free(url);
1895  }
1896
1897  rc = curl_url_get(u, CURLUPART_ZONEID, &url, 0);
1898  if(rc != CURLUE_OK) {
1899    curl_mfprintf(stderr,
1900                  "%s:%d curl_url_get CURLUPART_ZONEID returned %d (%s)\n",
1901                  __FILE__, __LINE__, rc, curl_url_strerror(rc));
1902    error++;
1903  }
1904  else {
1905    curl_free(url);
1906  }
1907
1908  rc = curl_url_set(u, CURLUPART_ZONEID, "clown", 0);
1909  if(rc != CURLUE_OK) {
1910    curl_mfprintf(stderr,
1911                  "%s:%d curl_url_set CURLUPART_ZONEID returned %d (%s)\n",
1912                  __FILE__, __LINE__, rc, curl_url_strerror(rc));
1913    error++;
1914  }
1915
1916  rc = curl_url_get(u, CURLUPART_URL, &url, 0);
1917  if(rc != CURLUE_OK) {
1918    curl_mfprintf(stderr,
1919                  "%s:%d curl_url_get CURLUPART_URL returned %d (%s)\n",
1920                  __FILE__, __LINE__, rc, curl_url_strerror(rc));
1921    error++;
1922  }
1923  else {
1924    curl_free(url);
1925  }
1926
1927  curl_url_cleanup(u);
1928
1929  return error;
1930}
1931
1932static int get_nothing(void)
1933{
1934  CURLU *u = curl_url();
1935  if(u) {
1936    char *p;
1937    CURLUcode rc;
1938
1939    rc = curl_url_get(u, CURLUPART_SCHEME, &p, 0);
1940    if(rc != CURLUE_NO_SCHEME)
1941      curl_mfprintf(stderr, "unexpected return code line %d\n", __LINE__);
1942
1943    rc = curl_url_get(u, CURLUPART_HOST, &p, 0);
1944    if(rc != CURLUE_NO_HOST)
1945      curl_mfprintf(stderr, "unexpected return code line %d\n", __LINE__);
1946
1947    rc = curl_url_get(u, CURLUPART_USER, &p, 0);
1948    if(rc != CURLUE_NO_USER)
1949      curl_mfprintf(stderr, "unexpected return code line %d\n", __LINE__);
1950
1951    rc = curl_url_get(u, CURLUPART_PASSWORD, &p, 0);
1952    if(rc != CURLUE_NO_PASSWORD)
1953      curl_mfprintf(stderr, "unexpected return code line %d\n", __LINE__);
1954
1955    rc = curl_url_get(u, CURLUPART_OPTIONS, &p, 0);
1956    if(rc != CURLUE_NO_OPTIONS)
1957      curl_mfprintf(stderr, "unexpected return code line %d\n", __LINE__);
1958
1959    rc = curl_url_get(u, CURLUPART_PATH, &p, 0);
1960    if(rc != CURLUE_OK)
1961      curl_mfprintf(stderr, "unexpected return code line %d\n", __LINE__);
1962    else
1963      curl_free(p);
1964
1965    rc = curl_url_get(u, CURLUPART_QUERY, &p, 0);
1966    if(rc != CURLUE_NO_QUERY)
1967      curl_mfprintf(stderr, "unexpected return code line %d\n", __LINE__);
1968
1969    rc = curl_url_get(u, CURLUPART_FRAGMENT, &p, 0);
1970    if(rc != CURLUE_NO_FRAGMENT)
1971      curl_mfprintf(stderr, "unexpected return code line %d\n", __LINE__);
1972
1973    rc = curl_url_get(u, CURLUPART_ZONEID, &p, 0);
1974    if(rc != CURLUE_NO_ZONEID)
1975      curl_mfprintf(stderr, "unexpected return code %d on line %d\n", rc,
1976                    __LINE__);
1977
1978    curl_url_cleanup(u);
1979  }
1980  return 0;
1981}
1982
1983static const struct clearurlcase clear_url_list[] = {
1984  { CURLUPART_SCHEME, "http", NULL, CURLUE_NO_SCHEME },
1985  { CURLUPART_USER, "user", NULL, CURLUE_NO_USER },
1986  { CURLUPART_PASSWORD, "password", NULL, CURLUE_NO_PASSWORD },
1987  { CURLUPART_OPTIONS, "options", NULL, CURLUE_NO_OPTIONS },
1988  { CURLUPART_HOST, "host", NULL, CURLUE_NO_HOST },
1989  { CURLUPART_ZONEID, "eth0", NULL, CURLUE_NO_ZONEID },
1990  { CURLUPART_PORT, "1234", NULL, CURLUE_NO_PORT },
1991  { CURLUPART_PATH, "/hello", "/", CURLUE_OK },
1992  { CURLUPART_QUERY, "a=b", NULL, CURLUE_NO_QUERY },
1993  { CURLUPART_FRAGMENT, "anchor", NULL, CURLUE_NO_FRAGMENT },
1994  { CURLUPART_URL, NULL, NULL, CURLUE_OK },
1995};
1996
1997static int clear_url(void)
1998{
1999  CURLU *u = curl_url();
2000  int i, error = 0;
2001  if(u) {
2002    char *p = NULL;
2003    CURLUcode rc;
2004
2005    for(i = 0; clear_url_list[i].in && !error; i++) {
2006      rc = curl_url_set(u, clear_url_list[i].part, clear_url_list[i].in, 0);
2007      if(rc != CURLUE_OK)
2008        curl_mfprintf(stderr, "unexpected return code line %d\n", __LINE__);
2009
2010      rc = curl_url_set(u, CURLUPART_URL, NULL, 0);
2011      if(rc != CURLUE_OK)
2012        curl_mfprintf(stderr, "unexpected return code line %d\n", __LINE__);
2013
2014      rc = curl_url_get(u, clear_url_list[i].part, &p, 0);
2015      if(rc != clear_url_list[i].ucode ||
2016         (clear_url_list[i].out && strcmp(p, clear_url_list[i].out) != 0)) {
2017
2018        curl_mfprintf(stderr, "unexpected return code line %d\n", __LINE__);
2019        error++;
2020      }
2021      if(rc == CURLUE_OK)
2022        curl_free(p);
2023    }
2024  }
2025
2026  curl_url_cleanup(u);
2027
2028  return error;
2029}
2030
2031static char total[128000];
2032static char bigpart[120000];
2033
2034/*
2035 * verify ridiculous URL part sizes
2036 */
2037static int huge(void)
2038{
2039  static const char *smallpart = "c";
2040  int i;
2041  CURLU *urlp = curl_url();
2042  CURLUcode rc;
2043  CURLUPart part[] = {
2044    CURLUPART_SCHEME,
2045    CURLUPART_USER,
2046    CURLUPART_PASSWORD,
2047    CURLUPART_HOST,
2048    CURLUPART_PATH,
2049    CURLUPART_QUERY,
2050    CURLUPART_FRAGMENT
2051  };
2052  int error = 0;
2053  if(!urlp)
2054    return 1;
2055  bigpart[0] = '/'; /* for the path */
2056  memset(&bigpart[1], 'a', sizeof(bigpart) - 2);
2057  bigpart[sizeof(bigpart) - 1] = 0;
2058
2059  for(i = 0; i < 7; i++) {
2060    char *partp;
2061    curl_msnprintf(total, sizeof(total),
2062                   "%s://%s:%s@%s/%s?%s#%s",
2063                   (i == 0) ? &bigpart[1] : smallpart,
2064                   (i == 1) ? &bigpart[1] : smallpart,
2065                   (i == 2) ? &bigpart[1] : smallpart,
2066                   (i == 3) ? &bigpart[1] : smallpart,
2067                   (i == 4) ? &bigpart[1] : smallpart,
2068                   (i == 5) ? &bigpart[1] : smallpart,
2069                   (i == 6) ? &bigpart[1] : smallpart);
2070    rc = curl_url_set(urlp, CURLUPART_URL, total, CURLU_NON_SUPPORT_SCHEME);
2071    if((!i && (rc != CURLUE_BAD_SCHEME)) ||
2072       (i && rc)) {
2073      curl_mprintf("URL %d: failed to parse [%s]\n", i, total);
2074      error++;
2075    }
2076
2077    /* only extract if the parse worked */
2078    if(!rc) {
2079      curl_url_get(urlp, part[i], &partp, 0);
2080      if(!partp || strcmp(partp, &bigpart[1 - (i == 4)])) {
2081        curl_mprintf("URL %d part %u: failure\n", i, part[i]);
2082        error++;
2083      }
2084      curl_free(partp);
2085    }
2086  }
2087  curl_url_cleanup(urlp);
2088  return error;
2089}
2090
2091static int urldup(void)
2092{
2093  static const char *url[] = {
2094    "http://"
2095    "user:pwd@"
2096    "[2a04:4e42:e00::347%25eth0]"
2097    ":80"
2098    "/path"
2099    "?query"
2100    "#fraggie",
2101    "https://example.com",
2102    "https://user@example.com",
2103    "https://user.pwd@example.com",
2104    "https://user.pwd@example.com:1234",
2105    "https://example.com:1234",
2106    "example.com:1234",
2107    "https://user.pwd@example.com:1234/path?query#frag",
2108    NULL
2109  };
2110  CURLU *copy = NULL;
2111  char *h_str = NULL, *copy_str = NULL;
2112  CURLU *h = curl_url();
2113  int i;
2114
2115  if(!h)
2116    goto err;
2117
2118  for(i = 0; url[i]; i++) {
2119    CURLUcode rc = curl_url_set(h, CURLUPART_URL, url[i],
2120                                CURLU_GUESS_SCHEME);
2121    if(rc)
2122      goto err;
2123    copy = curl_url_dup(h);
2124
2125    rc = curl_url_get(h, CURLUPART_URL, &h_str, 0);
2126    if(rc)
2127      goto err;
2128
2129    rc = curl_url_get(copy, CURLUPART_URL, &copy_str, 0);
2130    if(rc)
2131      goto err;
2132
2133    if(strcmp(h_str, copy_str)) {
2134      curl_mprintf("Original:  %s\nParsed:    %s\nCopy:      %s\n",
2135                   url[i], h_str, copy_str);
2136      goto err;
2137    }
2138    curl_free(copy_str);
2139    curl_free(h_str);
2140    curl_url_cleanup(copy);
2141    copy_str = NULL;
2142    h_str = NULL;
2143    copy = NULL;
2144  }
2145  curl_url_cleanup(h);
2146  return 0;
2147err:
2148  curl_free(copy_str);
2149  curl_free(h_str);
2150  curl_url_cleanup(copy);
2151  curl_url_cleanup(h);
2152  return 1;
2153}
2154
2155static int test_api_errors(void)
2156{
2157  CURLU *u = curl_url();
2158  char *p;
2159  CURLUcode rc;
2160  if(!u)
2161    return 1;
2162
2163  /* NULL handle */
2164  rc = curl_url_get(NULL, CURLUPART_URL, &p, 0);
2165  if(rc != CURLUE_BAD_HANDLE)
2166    return 1;
2167
2168  rc = curl_url_set(NULL, CURLUPART_URL, "http://example.com", 0);
2169  if(rc != CURLUE_BAD_HANDLE)
2170    return 1;
2171
2172  /* NULL part pointer */
2173  rc = curl_url_get(u, CURLUPART_URL, NULL, 0);
2174  if(rc != CURLUE_BAD_PARTPOINTER)
2175    return 2;
2176
2177  /* Unknown part */
2178  /* NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange) */
2179  rc = curl_url_get(u, (CURLUPart)12345, &p, 0);
2180  if(rc != CURLUE_UNKNOWN_PART)
2181    return 3;
2182
2183  curl_url_cleanup(u);
2184  return 0;
2185}
2186
2187static CURLcode test_lib1560(const char *URL)
2188{
2189  bool has_utf8 = !!getenv("CURL_TEST_HAVE_CODESET_UTF8");
2190
2191  (void)URL;
2192
2193  if(test_api_errors())
2194    return (CURLcode)12;
2195
2196  if(urldup())
2197    return (CURLcode)11;
2198
2199  if(setget_parts(has_utf8))
2200    return (CURLcode)10;
2201
2202  if(get_url(has_utf8))
2203    return (CURLcode)3;
2204
2205  if(huge())
2206    return (CURLcode)9;
2207
2208  if(get_nothing())
2209    return (CURLcode)7;
2210
2211  if(scopeid())
2212    return (CURLcode)6;
2213
2214  if(append())
2215    return (CURLcode)5;
2216
2217  if(set_url())
2218    return (CURLcode)1;
2219
2220  if(set_parts())
2221    return (CURLcode)2;
2222
2223  if(get_parts(has_utf8))
2224    return (CURLcode)4;
2225
2226  if(clear_url())
2227    return (CURLcode)8;
2228
2229  curl_mprintf("success\n");
2230  return CURLE_OK;
2231}