snow/curl-w32
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity
curl-w32/tests/libtest/lib1560.c

1798 lines
58 KiB
C
Raw Normal View History

Import from curl-8.6.0.zip Upstream: https://github.com/curl/curl/releases/tag/curl-8_6_0
2024-03-02 03:51:05 +00:00
/***************************************************************************
* _ _ ____ _
* Project ___| | | | _ \| |
* / __| | | | |_) | |
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
* Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
* are also available at https://curl.se/docs/copyright.html.
*
* You may opt to use, copy, modify, merge, publish, distribute and/or sell
* copies of the Software, and permit persons to whom the Software is
* furnished to do so, under the terms of the COPYING file.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
* SPDX-License-Identifier: curl
*
***************************************************************************/
/*
* Note:
*
* Since the URL parser by default only accepts schemes that *this instance*
* of libcurl supports, make sure that the test1560 file lists all the schemes
* that this test will assume to be present!
*/
#include "test.h"
#if defined(USE_LIBIDN2) || defined(USE_WIN32_IDN)
#define USE_IDN
#endif
#include "testutil.h"
#include "warnless.h"
#include "memdebug.h" /* LAST include file */
struct part {
CURLUPart part;
const char *name;
};
static int checkparts(CURLU *u, const char *in, const char *wanted,
unsigned int getflags)
{
int i;
CURLUcode rc;
char buf[256];
char *bufp = &buf[0];
size_t len = sizeof(buf);
struct part parts[] = {
{CURLUPART_SCHEME, "scheme"},
{CURLUPART_USER, "user"},
{CURLUPART_PASSWORD, "password"},
{CURLUPART_OPTIONS, "options"},
{CURLUPART_HOST, "host"},
{CURLUPART_PORT, "port"},
{CURLUPART_PATH, "path"},
{CURLUPART_QUERY, "query"},
{CURLUPART_FRAGMENT, "fragment"},
{CURLUPART_URL, NULL}
};
memset(buf, 0, sizeof(buf));
for(i = 0; parts[i].name; i++) {
char *p = NULL;
size_t n;
rc = curl_url_get(u, parts[i].part, &p, getflags);
if(!rc && p) {
msnprintf(bufp, len, "%s%s", buf[0]?" | ":"", p);
}
else
msnprintf(bufp, len, "%s[%d]", buf[0]?" | ":"", (int)rc);
n = strlen(bufp);
bufp += n;
len -= n;
curl_free(p);
}
if(strcmp(buf, wanted)) {
fprintf(stderr, "in: %s\nwanted: %s\ngot: %s\n", in, wanted, buf);
return 1;
}
return 0;
}
struct redircase {
const char *in;
const char *set;
const char *out;
unsigned int urlflags;
unsigned int setflags;
CURLUcode ucode;
};
struct setcase {
const char *in;
const char *set;
const char *out;
unsigned int urlflags;
unsigned int setflags;
CURLUcode ucode; /* for the main URL set */
CURLUcode pcode; /* for updating parts */
};
struct setgetcase {
const char *in;
const char *set;
const char *out;
unsigned int urlflags; /* for setting the URL */
unsigned int setflags; /* for updating parts */
unsigned int getflags; /* for getting parts */
CURLUcode pcode; /* for updating parts */
};
struct testcase {
const char *in;
const char *out;
unsigned int urlflags;
unsigned int getflags;
CURLUcode ucode;
};
struct urltestcase {
const char *in;
const char *out;
unsigned int urlflags; /* pass to curl_url() */
unsigned int getflags; /* pass to curl_url_get() */
CURLUcode ucode;
};
struct querycase {
const char *in;
const char *q;
const char *out;
unsigned int urlflags; /* pass to curl_url() */
unsigned int qflags; /* pass to curl_url_get() */
CURLUcode ucode;
};
struct clearurlcase {
CURLUPart part;
const char *in;
const char *out;
CURLUcode ucode;
};
static const struct testcase get_parts_list[] ={
{"https://curl.se/# ",
"https | [11] | [12] | [13] | curl.se | [15] | / | [16] | %20%20",
CURLU_URLENCODE|CURLU_ALLOW_SPACE, 0, CURLUE_OK},
{"", "", 0, 0, CURLUE_MALFORMED_INPUT},
{" ", "", 0, 0, CURLUE_MALFORMED_INPUT},
{"1h://example.net", "", 0, 0, CURLUE_BAD_SCHEME},
{"..://example.net", "", 0, 0, CURLUE_BAD_SCHEME},
{"-ht://example.net", "", 0, 0, CURLUE_BAD_SCHEME},
{"+ftp://example.net", "", 0, 0, CURLUE_BAD_SCHEME},
{"hej.hej://example.net",
"hej.hej | [11] | [12] | [13] | example.net | [15] | / | [16] | [17]",
CURLU_NON_SUPPORT_SCHEME, 0, CURLUE_OK},
{"ht-tp://example.net",
"ht-tp | [11] | [12] | [13] | example.net | [15] | / | [16] | [17]",
CURLU_NON_SUPPORT_SCHEME, 0, CURLUE_OK},
{"ftp+more://example.net",
"ftp+more | [11] | [12] | [13] | example.net | [15] | / | [16] | [17]",
CURLU_NON_SUPPORT_SCHEME, 0, CURLUE_OK},
{"f1337://example.net",
"f1337 | [11] | [12] | [13] | example.net | [15] | / | [16] | [17]",
CURLU_NON_SUPPORT_SCHEME, 0, CURLUE_OK},
{"https://user@example.net?hello# space ",
"https | user | [12] | [13] | example.net | [15] | / | hello | %20space%20",
CURLU_ALLOW_SPACE|CURLU_URLENCODE, 0, CURLUE_OK},
{"https://test%test", "", 0, 0, CURLUE_BAD_HOSTNAME},
{"https://example.com%252f%40@example.net",
"https | example.com%2f@ | [12] | [13] | example.net | [15] | / "
"| [16] | [17]",
0, CURLU_URLDECODE, CURLUE_OK },
#ifdef USE_IDN
{"https://räksmörgås.se",
"https | [11] | [12] | [13] | xn--rksmrgs-5wao1o.se | "
"[15] | / | [16] | [17]", 0, CURLU_PUNYCODE, CURLUE_OK},
{"https://xn--rksmrgs-5wao1o.se",
"https | [11] | [12] | [13] | räksmörgås.se | "
"[15] | / | [16] | [17]", 0, CURLU_PUNY2IDN, CURLUE_OK},
#else
{"https://räksmörgås.se",
"https | [11] | [12] | [13] | [30] | [15] | / | [16] | [17]",
0, CURLU_PUNYCODE, CURLUE_OK},
#endif
/* https://ℂᵤⓇℒ。𝐒🄴 */
{"https://"
"%e2%84%82%e1%b5%a4%e2%93%87%e2%84%92%e3%80%82%f0%9d%90%92%f0%9f%84%b4",
"https | [11] | [12] | [13] | ℂᵤⓇℒ。𝐒🄴 | [15] |"
" / | [16] | [17]",
0, 0, CURLUE_OK},
{"https://"
"%e2%84%82%e1%b5%a4%e2%93%87%e2%84%92%e3%80%82%f0%9d%90%92%f0%9f%84%b4",
"https | [11] | [12] | [13] | "
"%e2%84%82%e1%b5%a4%e2%93%87%e2%84%92%e3%80%82%f0%9d%90%92%f0%9f%84%b4 "
"| [15] | / | [16] | [17]",
0, CURLU_URLENCODE, CURLUE_OK},
{"https://"
"\xe2\x84\x82\xe1\xb5\xa4\xe2\x93\x87\xe2\x84\x92"
"\xe3\x80\x82\xf0\x9d\x90\x92\xf0\x9f\x84\xb4",
"https | [11] | [12] | [13] | "
"%e2%84%82%e1%b5%a4%e2%93%87%e2%84%92%e3%80%82%f0%9d%90%92%f0%9f%84%b4 "
"| [15] | / | [16] | [17]",
0, CURLU_URLENCODE, CURLUE_OK},
{"https://user@example.net?he l lo",
"https | user | [12] | [13] | example.net | [15] | / | he+l+lo | [17]",
CURLU_ALLOW_SPACE, CURLU_URLENCODE, CURLUE_OK},
{"https://user@example.net?he l lo",
"https | user | [12] | [13] | example.net | [15] | / | he l lo | [17]",
CURLU_ALLOW_SPACE, 0, CURLUE_OK},
{"https://exam{}[]ple.net", "", 0, 0, CURLUE_BAD_HOSTNAME},
{"https://exam{ple.net", "", 0, 0, CURLUE_BAD_HOSTNAME},
{"https://exam}ple.net", "", 0, 0, CURLUE_BAD_HOSTNAME},
{"https://exam]ple.net", "", 0, 0, CURLUE_BAD_HOSTNAME},
{"https://exam\\ple.net", "", 0, 0, CURLUE_BAD_HOSTNAME},
{"https://exam$ple.net", "", 0, 0, CURLUE_BAD_HOSTNAME},
{"https://exam'ple.net", "", 0, 0, CURLUE_BAD_HOSTNAME},
{"https://exam\"ple.net", "", 0, 0, CURLUE_BAD_HOSTNAME},
{"https://exam^ple.net", "", 0, 0, CURLUE_BAD_HOSTNAME},
{"https://exam`ple.net", "", 0, 0, CURLUE_BAD_HOSTNAME},
{"https://exam*ple.net", "", 0, 0, CURLUE_BAD_HOSTNAME},
{"https://exam<ple.net", "", 0, 0, CURLUE_BAD_HOSTNAME},
{"https://exam>ple.net", "", 0, 0, CURLUE_BAD_HOSTNAME},
{"https://exam=ple.net", "", 0, 0, CURLUE_BAD_HOSTNAME},
{"https://exam;ple.net", "", 0, 0, CURLUE_BAD_HOSTNAME},
{"https://example,net", "", 0, 0, CURLUE_BAD_HOSTNAME},
{"https://example&net", "", 0, 0, CURLUE_BAD_HOSTNAME},
{"https://example+net", "", 0, 0, CURLUE_BAD_HOSTNAME},
{"https://example(net", "", 0, 0, CURLUE_BAD_HOSTNAME},
{"https://example)net", "", 0, 0, CURLUE_BAD_HOSTNAME},
{"https://example.net/}",
"https | [11] | [12] | [13] | example.net | [15] | /} | [16] | [17]",
0, 0, CURLUE_OK},
/* blank user is blank */
{"https://:password@example.net",
"https | | password | [13] | example.net | [15] | / | [16] | [17]",
0, 0, CURLUE_OK},
/* blank user + blank password */
{"https://:@example.net",
"https | | | [13] | example.net | [15] | / | [16] | [17]",
0, 0, CURLUE_OK},
/* user-only (no password) */
{"https://user@example.net",
"https | user | [12] | [13] | example.net | [15] | / | [16] | [17]",
0, 0, CURLUE_OK},
#ifdef USE_WEBSOCKETS
{"ws://example.com/color/?green",
"ws | [11] | [12] | [13] | example.com | [15] | /color/ | green |"
" [17]",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK },
{"wss://example.com/color/?green",
"wss | [11] | [12] | [13] | example.com | [15] | /color/ | green |"
" [17]",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK },
#endif
{"https://user:password@example.net/get?this=and#but frag then", "",
CURLU_DEFAULT_SCHEME, 0, CURLUE_MALFORMED_INPUT},
{"https://user:password@example.net/get?this=and what", "",
CURLU_DEFAULT_SCHEME, 0, CURLUE_MALFORMED_INPUT},
{"https://user:password@example.net/ge t?this=and-what", "",
CURLU_DEFAULT_SCHEME, 0, CURLUE_MALFORMED_INPUT},
{"https://user:pass word@example.net/get?this=and-what", "",
CURLU_DEFAULT_SCHEME, 0, CURLUE_MALFORMED_INPUT},
{"https://u ser:password@example.net/get?this=and-what", "",
CURLU_DEFAULT_SCHEME, 0, CURLUE_MALFORMED_INPUT},
{"imap://user:pass;opt ion@server/path", "",
CURLU_DEFAULT_SCHEME, 0, CURLUE_MALFORMED_INPUT},
/* no space allowed in scheme */
{"htt ps://user:password@example.net/get?this=and-what", "",
CURLU_NON_SUPPORT_SCHEME|CURLU_ALLOW_SPACE, 0, CURLUE_BAD_SCHEME},
{"https://user:password@example.net/get?this=and what",
"https | user | password | [13] | example.net | [15] | /get | "
"this=and what | [17]",
CURLU_ALLOW_SPACE, 0, CURLUE_OK},
{"https://user:password@example.net/ge t?this=and-what",
"https | user | password | [13] | example.net | [15] | /ge t | "
"this=and-what | [17]",
CURLU_ALLOW_SPACE, 0, CURLUE_OK},
{"https://user:pass word@example.net/get?this=and-what",
"https | user | pass word | [13] | example.net | [15] | /get | "
"this=and-what | [17]",
CURLU_ALLOW_SPACE, 0, CURLUE_OK},
{"https://u ser:password@example.net/get?this=and-what",
"https | u ser | password | [13] | example.net | [15] | /get | "
"this=and-what | [17]",
CURLU_ALLOW_SPACE, 0, CURLUE_OK},
{"https://user:password@example.net/ge t?this=and-what",
"https | user | password | [13] | example.net | [15] | /ge%20t | "
"this=and-what | [17]",
CURLU_ALLOW_SPACE | CURLU_URLENCODE, 0, CURLUE_OK},
{"[0:0:0:0:0:0:0:1]",
"http | [11] | [12] | [13] | [::1] | [15] | / | [16] | [17]",
CURLU_GUESS_SCHEME, 0, CURLUE_OK },
{"[::1]",
"http | [11] | [12] | [13] | [::1] | [15] | / | [16] | [17]",
CURLU_GUESS_SCHEME, 0, CURLUE_OK },
{"[::]",
"http | [11] | [12] | [13] | [::] | [15] | / | [16] | [17]",
CURLU_GUESS_SCHEME, 0, CURLUE_OK },
{"https://[::1]",
"https | [11] | [12] | [13] | [::1] | [15] | / | [16] | [17]",
0, 0, CURLUE_OK },
{"user:moo@ftp.example.com/color/#green?no-red",
"ftp | user | moo | [13] | ftp.example.com | [15] | /color/ | [16] | "
"green?no-red",
CURLU_GUESS_SCHEME, 0, CURLUE_OK },
{"ftp.user:moo@example.com/color/#green?no-red",
"http | ftp.user | moo | [13] | example.com | [15] | /color/ | [16] | "
"green?no-red",
CURLU_GUESS_SCHEME, 0, CURLUE_OK },
#ifdef _WIN32
{"file:/C:\\programs\\foo",
"file | [11] | [12] | [13] | [14] | [15] | C:\\programs\\foo | [16] | [17]",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
{"file://C:\\programs\\foo",
"file | [11] | [12] | [13] | [14] | [15] | C:\\programs\\foo | [16] | [17]",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
{"file:///C:\\programs\\foo",
"file | [11] | [12] | [13] | [14] | [15] | C:\\programs\\foo | [16] | [17]",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
{"file://host.example.com/Share/path/to/file.txt",
"file | [11] | [12] | [13] | host.example.com | [15] | "
"//host.example.com/Share/path/to/file.txt | [16] | [17]",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
#endif
{"https://example.com/color/#green?no-red",
"https | [11] | [12] | [13] | example.com | [15] | /color/ | [16] | "
"green?no-red",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK },
{"https://example.com/color/#green#no-red",
"https | [11] | [12] | [13] | example.com | [15] | /color/ | [16] | "
"green#no-red",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK },
{"https://example.com/color/?green#no-red",
"https | [11] | [12] | [13] | example.com | [15] | /color/ | green | "
"no-red",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK },
{"https://example.com/#color/?green#no-red",
"https | [11] | [12] | [13] | example.com | [15] | / | [16] | "
"color/?green#no-red",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK },
{"https://example.#com/color/?green#no-red",
"https | [11] | [12] | [13] | example. | [15] | / | [16] | "
"com/color/?green#no-red",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK },
{"http://[ab.be:1]/x", "",
CURLU_DEFAULT_SCHEME, 0, CURLUE_BAD_IPV6},
{"http://[ab.be]/x", "",
CURLU_DEFAULT_SCHEME, 0, CURLUE_BAD_IPV6},
/* URL without host name */
{"http://a:b@/x", "",
CURLU_DEFAULT_SCHEME, 0, CURLUE_NO_HOST},
{"boing:80",
"https | [11] | [12] | [13] | boing | 80 | / | [16] | [17]",
CURLU_DEFAULT_SCHEME|CURLU_GUESS_SCHEME, 0, CURLUE_OK},
{"http://[fd00:a41::50]:8080",
"http | [11] | [12] | [13] | [fd00:a41::50] | 8080 | / | [16] | [17]",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
{"http://[fd00:a41::50]/",
"http | [11] | [12] | [13] | [fd00:a41::50] | [15] | / | [16] | [17]",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
{"http://[fd00:a41::50]",
"http | [11] | [12] | [13] | [fd00:a41::50] | [15] | / | [16] | [17]",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
{"https://[::1%252]:1234",
"https | [11] | [12] | [13] | [::1] | 1234 | / | [16] | [17]",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
/* here's "bad" zone id */
{"https://[fe80::20c:29ff:fe9c:409b%eth0]:1234",
"https | [11] | [12] | [13] | [fe80::20c:29ff:fe9c:409b] | 1234 "
"| / | [16] | [17]",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
{"https://127.0.0.1:443",
"https | [11] | [12] | [13] | 127.0.0.1 | [15] | / | [16] | [17]",
0, CURLU_NO_DEFAULT_PORT, CURLUE_OK},
{"http://%3a:%3a@ex4mple/%3f+?+%3f+%23#+%23%3f%g7",
"http | : | : | [13] | ex4mple | [15] | /?+ | ? # | +#?%g7",
0, CURLU_URLDECODE, CURLUE_OK},
{"http://%3a:%3a@ex4mple/%3f?%3f%35#%35%3f%g7",
"http | %3a | %3a | [13] | ex4mple | [15] | /%3f | %3f%35 | %35%3f%g7",
0, 0, CURLUE_OK},
{"http://HO0_-st%41/",
"http | [11] | [12] | [13] | HO0_-stA | [15] | / | [16] | [17]",
0, 0, CURLUE_OK},
{"file://hello.html",
"",
0, 0, CURLUE_BAD_FILE_URL},
{"http://HO0_-st/",
"http | [11] | [12] | [13] | HO0_-st | [15] | / | [16] | [17]",
0, 0, CURLUE_OK},
{"imap://user:pass;option@server/path",
"imap | user | pass | option | server | [15] | /path | [16] | [17]",
0, 0, CURLUE_OK},
{"http://user:pass;option@server/path",
"http | user | pass;option | [13] | server | [15] | /path | [16] | [17]",
0, 0, CURLUE_OK},
{"file:/hello.html",
"file | [11] | [12] | [13] | [14] | [15] | /hello.html | [16] | [17]",
0, 0, CURLUE_OK},
{"file:/h",
"file | [11] | [12] | [13] | [14] | [15] | /h | [16] | [17]",
0, 0, CURLUE_OK},
{"file:/",
"file | [11] | [12] | [13] | [14] | [15] | | [16] | [17]",
0, 0, CURLUE_BAD_FILE_URL},
{"file://127.0.0.1/hello.html",
"file | [11] | [12] | [13] | [14] | [15] | /hello.html | [16] | [17]",
0, 0, CURLUE_OK},
{"file:////hello.html",
"file | [11] | [12] | [13] | [14] | [15] | //hello.html | [16] | [17]",
0, 0, CURLUE_OK},
{"file:///hello.html",
"file | [11] | [12] | [13] | [14] | [15] | /hello.html | [16] | [17]",
0, 0, CURLUE_OK},
{"https://127.0.0.1",
"https | [11] | [12] | [13] | 127.0.0.1 | 443 | / | [16] | [17]",
0, CURLU_DEFAULT_PORT, CURLUE_OK},
{"https://127.0.0.1",
"https | [11] | [12] | [13] | 127.0.0.1 | [15] | / | [16] | [17]",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
{"https://[::1]:1234",
"https | [11] | [12] | [13] | [::1] | 1234 | / | [16] | [17]",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
{"https://127abc.com",
"https | [11] | [12] | [13] | 127abc.com | [15] | / | [16] | [17]",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
{"https:// example.com?check", "",
CURLU_DEFAULT_SCHEME, 0, CURLUE_MALFORMED_INPUT},
{"https://e x a m p l e.com?check", "",
CURLU_DEFAULT_SCHEME, 0, CURLUE_MALFORMED_INPUT},
{"https://example.com?check",
"https | [11] | [12] | [13] | example.com | [15] | / | check | [17]",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
{"https://example.com:65536",
"",
CURLU_DEFAULT_SCHEME, 0, CURLUE_BAD_PORT_NUMBER},
{"https://example.com:-1#moo",
"",
CURLU_DEFAULT_SCHEME, 0, CURLUE_BAD_PORT_NUMBER},
{"https://example.com:0#moo",
"https | [11] | [12] | [13] | example.com | 0 | / | "
"[16] | moo",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
{"https://example.com:01#moo",
"https | [11] | [12] | [13] | example.com | 1 | / | "
"[16] | moo",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
{"https://example.com:1#moo",
"https | [11] | [12] | [13] | example.com | 1 | / | "
"[16] | moo",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
{"http://example.com#moo",
"http | [11] | [12] | [13] | example.com | [15] | / | "
"[16] | moo",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
{"http://example.com",
"http | [11] | [12] | [13] | example.com | [15] | / | "
"[16] | [17]",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
{"http://example.com/path/html",
"http | [11] | [12] | [13] | example.com | [15] | /path/html | "
"[16] | [17]",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
{"http://example.com/path/html?query=name",
"http | [11] | [12] | [13] | example.com | [15] | /path/html | "
"query=name | [17]",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
{"http://example.com/path/html?query=name#anchor",
"http | [11] | [12] | [13] | example.com | [15] | /path/html | "
"query=name | anchor",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
{"http://example.com:1234/path/html?query=name#anchor",
"http | [11] | [12] | [13] | example.com | 1234 | /path/html | "
"query=name | anchor",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
{"http:///user:password@example.com:1234/path/html?query=name#anchor",
"http | user | password | [13] | example.com | 1234 | /path/html | "
"query=name | anchor",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
{"https://user:password@example.com:1234/path/html?query=name#anchor",
"https | user | password | [13] | example.com | 1234 | /path/html | "
"query=name | anchor",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
{"http://user:password@example.com:1234/path/html?query=name#anchor",
"http | user | password | [13] | example.com | 1234 | /path/html | "
"query=name | anchor",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
{"http:/user:password@example.com:1234/path/html?query=name#anchor",
"http | user | password | [13] | example.com | 1234 | /path/html | "
"query=name | anchor",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
{"http:////user:password@example.com:1234/path/html?query=name#anchor",
"",
CURLU_DEFAULT_SCHEME, 0, CURLUE_BAD_SLASHES},
{NULL, NULL, 0, 0, CURLUE_OK},
};
static const struct urltestcase get_url_list[] = {
{"https://1.0x1000000", "https://1.0x1000000/", 0, 0, CURLUE_OK},
{"https://0x7f.1", "https://127.0.0.1/", 0, 0, CURLUE_OK},
{"https://1.2.3.256.com", "https://1.2.3.256.com/", 0, 0, CURLUE_OK},
{"https://10.com", "https://10.com/", 0, 0, CURLUE_OK},
{"https://1.2.com", "https://1.2.com/", 0, 0, CURLUE_OK},
{"https://1.2.3.com", "https://1.2.3.com/", 0, 0, CURLUE_OK},
{"https://1.2.com.99", "https://1.2.com.99/", 0, 0, CURLUE_OK},
{"https://[fe80::0000:20c:29ff:fe9c:409b]:80/moo",
"https://[fe80::20c:29ff:fe9c:409b]:80/moo",
0, 0, CURLUE_OK},
{"https://[fe80::020c:29ff:fe9c:409b]:80/moo",
"https://[fe80::20c:29ff:fe9c:409b]:80/moo",
0, 0, CURLUE_OK},
{"https://[fe80:0000:0000:0000:020c:29ff:fe9c:409b]:80/moo",
"https://[fe80::20c:29ff:fe9c:409b]:80/moo",
0, 0, CURLUE_OK},
{"https://[fe80:0:0:0:409b::]:80/moo",
"https://[fe80::409b:0:0:0]:80/moo",
0, 0, CURLUE_OK},
{"https://[::%25fakeit];80/moo",
"",
0, 0, CURLUE_BAD_PORT_NUMBER},
{"https://[fe80::20c:29ff:fe9c:409b]-80/moo",
"",
0, 0, CURLUE_BAD_PORT_NUMBER},
#ifdef USE_IDN
{"https://räksmörgås.se/path?q#frag",
"https://xn--rksmrgs-5wao1o.se/path?q#frag", 0, CURLU_PUNYCODE, CURLUE_OK},
#endif
/* unsupported schemes with no guessing enabled */
{"data:text/html;charset=utf-8;base64,PCFET0NUWVBFIEhUTUw+PG1ldGEgY",
"", 0, 0, CURLUE_UNSUPPORTED_SCHEME},
{"d:anything-really", "", 0, 0, CURLUE_UNSUPPORTED_SCHEME},
{"about:config", "", 0, 0, CURLUE_UNSUPPORTED_SCHEME},
{"example://foo", "", 0, 0, CURLUE_UNSUPPORTED_SCHEME},
{"mailto:infobot@example.com?body=send%20current-issue", "", 0, 0,
CURLUE_UNSUPPORTED_SCHEME},
{"about:80", "https://about:80/", CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
/* percent encoded host names */
{"http://example.com%40127.0.0.1/", "", 0, 0, CURLUE_BAD_HOSTNAME},
{"http://example.com%21127.0.0.1/", "", 0, 0, CURLUE_BAD_HOSTNAME},
{"http://example.com%3f127.0.0.1/", "", 0, 0, CURLUE_BAD_HOSTNAME},
{"http://example.com%23127.0.0.1/", "", 0, 0, CURLUE_BAD_HOSTNAME},
{"http://example.com%3a127.0.0.1/", "", 0, 0, CURLUE_BAD_HOSTNAME},
{"http://example.com%09127.0.0.1/", "", 0, 0, CURLUE_BAD_HOSTNAME},
{"http://example.com%2F127.0.0.1/", "", 0, 0, CURLUE_BAD_HOSTNAME},
{"https://%41", "https://A/", 0, 0, CURLUE_OK},
{"https://%20", "", 0, 0, CURLUE_BAD_HOSTNAME},
{"https://%41%0d", "", 0, 0, CURLUE_BAD_HOSTNAME},
{"https://%25", "", 0, 0, CURLUE_BAD_HOSTNAME},
{"https://_%c0_", "https://_\xC0_/", 0, 0, CURLUE_OK},
{"https://_%c0_", "https://_%C0_/", 0, CURLU_URLENCODE, CURLUE_OK},
/* IPv4 trickeries */
{"https://16843009", "https://1.1.1.1/", 0, 0, CURLUE_OK},
{"https://0177.1", "https://127.0.0.1/", 0, 0, CURLUE_OK},
{"https://0111.02.0x3", "https://73.2.0.3/", 0, 0, CURLUE_OK},
{"https://0111.02.0x3.", "https://0111.02.0x3./", 0, 0, CURLUE_OK},
{"https://0111.02.030", "https://73.2.0.24/", 0, 0, CURLUE_OK},
{"https://0111.02.030.", "https://0111.02.030./", 0, 0, CURLUE_OK},
{"https://0xff.0xff.0377.255", "https://255.255.255.255/", 0, 0, CURLUE_OK},
{"https://1.0xffffff", "https://1.255.255.255/", 0, 0, CURLUE_OK},
/* IPv4 numerical overflows or syntax errors will not normalize */
{"https://a127.0.0.1", "https://a127.0.0.1/", 0, 0, CURLUE_OK},
{"https://\xff.127.0.0.1", "https://%FF.127.0.0.1/", 0, CURLU_URLENCODE,
CURLUE_OK},
{"https://127.-0.0.1", "https://127.-0.0.1/", 0, 0, CURLUE_OK},
{"https://127.0. 1", "https://127.0.0.1/", 0, 0, CURLUE_MALFORMED_INPUT},
{"https://1.2.3.256", "https://1.2.3.256/", 0, 0, CURLUE_OK},
{"https://1.2.3.256.", "https://1.2.3.256./", 0, 0, CURLUE_OK},
{"https://1.2.3.4.5", "https://1.2.3.4.5/", 0, 0, CURLUE_OK},
{"https://1.2.0x100.3", "https://1.2.0x100.3/", 0, 0, CURLUE_OK},
{"https://4294967296", "https://4294967296/", 0, 0, CURLUE_OK},
{"https://123host", "https://123host/", 0, 0, CURLUE_OK},
/* 40 bytes scheme is the max allowed */
{"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA://hostname/path",
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa://hostname/path",
CURLU_NON_SUPPORT_SCHEME, 0, CURLUE_OK},
/* 41 bytes scheme is not allowed */
{"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA://hostname/path",
"",
CURLU_NON_SUPPORT_SCHEME, 0, CURLUE_BAD_SCHEME},
{"https://[fe80::20c:29ff:fe9c:409b%]:1234",
"",
0, 0, CURLUE_BAD_IPV6},
{"https://[fe80::20c:29ff:fe9c:409b%25]:1234",
"https://[fe80::20c:29ff:fe9c:409b%2525]:1234/",
0, 0, CURLUE_OK},
{"https://[fe80::20c:29ff:fe9c:409b%eth0]:1234",
"https://[fe80::20c:29ff:fe9c:409b%25eth0]:1234/",
0, 0, CURLUE_OK},
{"https://[::%25fakeit]/moo",
"https://[::%25fakeit]/moo",
0, 0, CURLUE_OK},
{"smtp.example.com/path/html",
"smtp://smtp.example.com/path/html",
CURLU_GUESS_SCHEME, 0, CURLUE_OK},
{"https.example.com/path/html",
"http://https.example.com/path/html",
CURLU_GUESS_SCHEME, 0, CURLUE_OK},
{"dict.example.com/path/html",
"dict://dict.example.com/path/html",
CURLU_GUESS_SCHEME, 0, CURLUE_OK},
{"pop3.example.com/path/html",
"pop3://pop3.example.com/path/html",
CURLU_GUESS_SCHEME, 0, CURLUE_OK},
{"ldap.example.com/path/html",
"ldap://ldap.example.com/path/html",
CURLU_GUESS_SCHEME, 0, CURLUE_OK},
{"imap.example.com/path/html",
"imap://imap.example.com/path/html",
CURLU_GUESS_SCHEME, 0, CURLUE_OK},
{"ftp.example.com/path/html",
"ftp://ftp.example.com/path/html",
CURLU_GUESS_SCHEME, 0, CURLUE_OK},
{"example.com/path/html",
"http://example.com/path/html",
CURLU_GUESS_SCHEME, 0, CURLUE_OK},
{"smtp.com/path/html",
"smtp://smtp.com/path/html",
CURLU_GUESS_SCHEME, 0, CURLUE_OK},
{"dict.com/path/html",
"dict://dict.com/path/html",
CURLU_GUESS_SCHEME, 0, CURLUE_OK},
{"pop3.com/path/html",
"pop3://pop3.com/path/html",
CURLU_GUESS_SCHEME, 0, CURLUE_OK},
{"ldap.com/path/html",
"ldap://ldap.com/path/html",
CURLU_GUESS_SCHEME, 0, CURLUE_OK},
{"imap.com/path/html",
"imap://imap.com/path/html",
CURLU_GUESS_SCHEME, 0, CURLUE_OK},
{"ftp.com/path/html",
"ftp://ftp.com/path/html",
CURLU_GUESS_SCHEME, 0, CURLUE_OK},
{"smtp/path/html",
"http://smtp/path/html",
CURLU_GUESS_SCHEME, 0, CURLUE_OK},
{"dict/path/html",
"http://dict/path/html",
CURLU_GUESS_SCHEME, 0, CURLUE_OK},
{"pop3/path/html",
"http://pop3/path/html",
CURLU_GUESS_SCHEME, 0, CURLUE_OK},
{"ldap/path/html",
"http://ldap/path/html",
CURLU_GUESS_SCHEME, 0, CURLUE_OK},
{"imap/path/html",
"http://imap/path/html",
CURLU_GUESS_SCHEME, 0, CURLUE_OK},
{"ftp/path/html",
"http://ftp/path/html",
CURLU_GUESS_SCHEME, 0, CURLUE_OK},
{"HTTP://test/", "http://test/", 0, 0, CURLUE_OK},
{"http://HO0_-st..~./", "http://HO0_-st..~./", 0, 0, CURLUE_OK},
{"http:/@example.com: 123/", "", 0, 0, CURLUE_MALFORMED_INPUT},
{"http:/@example.com:123 /", "", 0, 0, CURLUE_MALFORMED_INPUT},
{"http:/@example.com:123a/", "", 0, 0, CURLUE_BAD_PORT_NUMBER},
{"http://host/file\r", "", 0, 0, CURLUE_MALFORMED_INPUT},
{"http://host/file\n\x03", "", 0, 0, CURLUE_MALFORMED_INPUT},
{"htt\x02://host/file", "",
CURLU_NON_SUPPORT_SCHEME, 0, CURLUE_MALFORMED_INPUT},
{" http://host/file", "", 0, 0, CURLUE_MALFORMED_INPUT},
/* here the password ends at the semicolon and options is 'word' */
{"imap://user:pass;word@host/file",
"imap://user:pass;word@host/file",
0, 0, CURLUE_OK},
/* here the password has the semicolon */
{"http://user:pass;word@host/file",
"http://user:pass;word@host/file", 0, 0, CURLUE_OK},
{"file:///file.txt#moo", "file:///file.txt#moo", 0, 0, CURLUE_OK},
{"file:////file.txt", "file:////file.txt", 0, 0, CURLUE_OK},
{"file:///file.txt", "file:///file.txt", 0, 0, CURLUE_OK},
{"file:./", "file://", 0, 0, CURLUE_OK},
{"http://example.com/hello/../here",
"http://example.com/hello/../here",
CURLU_PATH_AS_IS, 0, CURLUE_OK},
{"http://example.com/hello/../here",
"http://example.com/here",
0, 0, CURLUE_OK},
{"http://example.com:80",
"http://example.com/",
0, CURLU_NO_DEFAULT_PORT, CURLUE_OK},
{"tp://example.com/path/html",
"",
0, 0, CURLUE_UNSUPPORTED_SCHEME},
{"http://hello:fool@example.com",
"",
CURLU_DISALLOW_USER, 0, CURLUE_USER_NOT_ALLOWED},
{"http:/@example.com:123",
"http://@example.com:123/",
0, 0, CURLUE_OK},
{"http:/:password@example.com",
"http://:password@example.com/",
0, 0, CURLUE_OK},
{"http://user@example.com?#",
"http://user@example.com/",
0, 0, CURLUE_OK},
{"http://user@example.com?",
"http://user@example.com/",
0, 0, CURLUE_OK},
{"http://user@example.com#anchor",
"http://user@example.com/#anchor",
0, 0, CURLUE_OK},
{"example.com/path/html",
"https://example.com/path/html",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
{"example.com/path/html",
"",
0, 0, CURLUE_BAD_SCHEME},
{"http://user:password@example.com:1234/path/html?query=name#anchor",
"http://user:password@example.com:1234/path/html?query=name#anchor",
0, 0, CURLUE_OK},
{"http://example.com:1234/path/html?query=name#anchor",
"http://example.com:1234/path/html?query=name#anchor",
0, 0, CURLUE_OK},
{"http://example.com/path/html?query=name#anchor",
"http://example.com/path/html?query=name#anchor",
0, 0, CURLUE_OK},
{"http://example.com/path/html?query=name",
"http://example.com/path/html?query=name",
0, 0, CURLUE_OK},
{"http://example.com/path/html",
"http://example.com/path/html",
0, 0, CURLUE_OK},
{"tp://example.com/path/html",
"tp://example.com/path/html",
CURLU_NON_SUPPORT_SCHEME, 0, CURLUE_OK},
{"custom-scheme://host?expected=test-good",
"custom-scheme://host/?expected=test-good",
CURLU_NON_SUPPORT_SCHEME, 0, CURLUE_OK},
{"custom-scheme://?expected=test-bad",
"",
CURLU_NON_SUPPORT_SCHEME, 0, CURLUE_NO_HOST},
{"custom-scheme://?expected=test-new-good",
"custom-scheme:///?expected=test-new-good",
CURLU_NON_SUPPORT_SCHEME | CURLU_NO_AUTHORITY, 0, CURLUE_OK},
{"custom-scheme://host?expected=test-still-good",
"custom-scheme://host/?expected=test-still-good",
CURLU_NON_SUPPORT_SCHEME | CURLU_NO_AUTHORITY, 0, CURLUE_OK},
{NULL, NULL, 0, 0, CURLUE_OK}
};
static int checkurl(const char *org, const char *url, const char *out)
{
if(strcmp(out, url)) {
fprintf(stderr,
"Org: %s\n"
"Wanted: %s\n"
"Got : %s\n",
org, out, url);
return 1;
}
return 0;
}
/* 1. Set the URL
2. Set components
3. Extract all components (not URL)
*/
static const struct setgetcase setget_parts_list[] = {
{"https://example.com",
"path=get,",
"https | [11] | [12] | [13] | example.com | [15] | /get | [16] | [17]",
0, 0, 0, CURLUE_OK},
{"https://example.com",
"path=/get,",
"https | [11] | [12] | [13] | example.com | [15] | /get | [16] | [17]",
0, 0, 0, CURLUE_OK},
{"https://example.com",
"path=g e t,",
"https | [11] | [12] | [13] | example.com | [15] | /g%20e%20t | "
"[16] | [17]",
0, CURLU_URLENCODE, 0, CURLUE_OK},
{NULL, NULL, NULL, 0, 0, 0, CURLUE_OK}
};
/* !checksrc! disable SPACEBEFORECOMMA 1 */
static const struct setcase set_parts_list[] = {
{"https://example.com/?param=value",
"query=\"\",",
"https://example.com/",
0, CURLU_APPENDQUERY | CURLU_URLENCODE, CURLUE_OK, CURLUE_OK},
{"https://example.com/",
"host=\"\",",
"https://example.com/",
0, CURLU_URLENCODE, CURLUE_OK, CURLUE_BAD_HOSTNAME},
{"https://example.com/",
"host=\"\",",
"https://example.com/",
0, 0, CURLUE_OK, CURLUE_BAD_HOSTNAME},
{"https://example.com",
"path=get,",
"https://example.com/get",
0, 0, CURLUE_OK, CURLUE_OK},
{"https://example.com/",
"scheme=ftp+-.123,",
"ftp+-.123://example.com/",
0, CURLU_NON_SUPPORT_SCHEME, CURLUE_OK, CURLUE_OK},
{"https://example.com/",
"scheme=1234,",
"https://example.com/",
0, CURLU_NON_SUPPORT_SCHEME, CURLUE_OK, CURLUE_BAD_SCHEME},
{"https://example.com/",
"scheme=1http,",
"https://example.com/",
0, CURLU_NON_SUPPORT_SCHEME, CURLUE_OK, CURLUE_BAD_SCHEME},
{"https://example.com/",
"scheme=-ftp,",
"https://example.com/",
0, CURLU_NON_SUPPORT_SCHEME, CURLUE_OK, CURLUE_BAD_SCHEME},
{"https://example.com/",
"scheme=+ftp,",
"https://example.com/",
0, CURLU_NON_SUPPORT_SCHEME, CURLUE_OK, CURLUE_BAD_SCHEME},
{"https://example.com/",
"scheme=.ftp,",
"https://example.com/",
0, CURLU_NON_SUPPORT_SCHEME, CURLUE_OK, CURLUE_BAD_SCHEME},
{"https://example.com/",
"host=example.com%2fmoo,",
"",
0, /* get */
0, /* set */
CURLUE_OK, CURLUE_BAD_HOSTNAME},
{"https://example.com/",
"host=http://fake,",
"",
0, /* get */
0, /* set */
CURLUE_OK, CURLUE_BAD_HOSTNAME},
{"https://example.com/",
"host=test%,",
"",
0, /* get */
0, /* set */
CURLUE_OK, CURLUE_BAD_HOSTNAME},
{"https://example.com/",
"host=te st,",
"",
0, /* get */
0, /* set */
CURLUE_OK, CURLUE_BAD_HOSTNAME},
{"https://example.com/",
"host=0xff,", /* '++' there's no automatic URL decode when setting this
part */
"https://0xff/",
0, /* get */
0, /* set */
CURLUE_OK, CURLUE_OK},
{"https://example.com/",
"query=Al2cO3tDkcDZ3EWE5Lh+LX8TPHs,", /* contains '+' */
"https://example.com/?Al2cO3tDkcDZ3EWE5Lh%2bLX8TPHs",
CURLU_URLDECODE, /* decode on get */
CURLU_URLENCODE, /* encode on set */
CURLUE_OK, CURLUE_OK},
{"https://example.com/",
/* Set a bad scheme *including* :// */
"scheme=https://,",
"https://example.com/",
0, CURLU_NON_SUPPORT_SCHEME, CURLUE_OK, CURLUE_BAD_SCHEME},
{"https://example.com/",
/* Set a 41 bytes scheme. That's too long so the old scheme remains set. */
"scheme=bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbc,",
"https://example.com/",
0, CURLU_NON_SUPPORT_SCHEME, CURLUE_OK, CURLUE_BAD_SCHEME},
{"https://example.com/",
/* set a 40 bytes scheme */
"scheme=bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,",
"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb://example.com/",
0, CURLU_NON_SUPPORT_SCHEME, CURLUE_OK, CURLUE_OK},
{"https://[::1%25fake]:1234/",
"zoneid=NULL,",
"https://[::1]:1234/",
0, 0, CURLUE_OK, CURLUE_OK},
{"https://host:1234/",
"port=NULL,",
"https://host/",
0, 0, CURLUE_OK, CURLUE_OK},
{"https://host:1234/",
"port=\"\",",
"https://host:1234/",
0, 0, CURLUE_OK, CURLUE_BAD_PORT_NUMBER},
{"https://host:1234/",
"port=56 78,",
"https://host:1234/",
0, 0, CURLUE_OK, CURLUE_BAD_PORT_NUMBER},
{"https://host:1234/",
"port=0,",
"https://host:1234/",
0, 0, CURLUE_OK, CURLUE_BAD_PORT_NUMBER},
{"https://host:1234/",
"port=65535,",
"https://host:65535/",
0, 0, CURLUE_OK, CURLUE_OK},
{"https://host:1234/",
"port=65536,",
"https://host:1234/",
0, 0, CURLUE_OK, CURLUE_BAD_PORT_NUMBER},
{"https://host/",
"path=%4A%4B%4C,",
"https://host/%4a%4b%4c",
0, 0, CURLUE_OK, CURLUE_OK},
{"https://host/mooo?q#f",
"path=NULL,query=NULL,fragment=NULL,",
"https://host/",
0, 0, CURLUE_OK, CURLUE_OK},
{"https://user:secret@host/",
"user=NULL,password=NULL,",
"https://host/",
0, 0, CURLUE_OK, CURLUE_OK},
{NULL,
"scheme=https,user= @:,host=foobar,",
"https://%20%20%20%40%3a@foobar/",
0, CURLU_URLENCODE, CURLUE_OK, CURLUE_OK},
/* Setting a host name with spaces is not OK: */
{NULL,
"scheme=https,host= ,path= ,user= ,password= ,query= ,fragment= ,",
"[nothing]",
0, CURLU_URLENCODE, CURLUE_OK, CURLUE_BAD_HOSTNAME},
{NULL,
"scheme=https,host=foobar,path=/this /path /is /here,",
"https://foobar/this%20/path%20/is%20/here",
0, CURLU_URLENCODE, CURLUE_OK, CURLUE_OK},
{NULL,
"scheme=https,host=foobar,path=\xc3\xa4\xc3\xb6\xc3\xbc,",
"https://foobar/%c3%a4%c3%b6%c3%bc",
0, CURLU_URLENCODE, CURLUE_OK, CURLUE_OK},
{"imap://user:secret;opt@host/",
"options=updated,scheme=imaps,password=p4ssw0rd,",
"imaps://user:p4ssw0rd;updated@host/",
0, 0, CURLUE_NO_HOST, CURLUE_OK},
{"imap://user:secret;optit@host/",
"scheme=https,",
"https://user:secret@host/",
0, 0, CURLUE_NO_HOST, CURLUE_OK},
{"file:///file#anchor",
"scheme=https,host=example,",
"https://example/file#anchor",
0, 0, CURLUE_NO_HOST, CURLUE_OK},
{NULL, /* start fresh! */
"scheme=file,host=127.0.0.1,path=/no,user=anonymous,",
"file:///no",
0, 0, CURLUE_OK, CURLUE_OK},
{NULL, /* start fresh! */
"scheme=ftp,host=127.0.0.1,path=/no,user=anonymous,",
"ftp://anonymous@127.0.0.1/no",
0, 0, CURLUE_OK, CURLUE_OK},
{NULL, /* start fresh! */
"scheme=https,host=example.com,",
"https://example.com/",
0, CURLU_NON_SUPPORT_SCHEME, CURLUE_OK, CURLUE_OK},
{"http://user:foo@example.com/path?query#frag",
"fragment=changed,",
"http://user:foo@example.com/path?query#changed",
0, CURLU_NON_SUPPORT_SCHEME, CURLUE_OK, CURLUE_OK},
{"http://example.com/",
"scheme=foo,", /* not accepted */
"http://example.com/",
0, 0, CURLUE_OK, CURLUE_UNSUPPORTED_SCHEME},
{"http://example.com/",
"scheme=https,path=/hello,fragment=snippet,",
"https://example.com/hello#snippet",
0, 0, CURLUE_OK, CURLUE_OK},
{"http://example.com:80",
"user=foo,port=1922,",
"http://foo@example.com:1922/",
0, 0, CURLUE_OK, CURLUE_OK},
{"http://example.com:80",
"user=foo,password=bar,",
"http://foo:bar@example.com:80/",
0, 0, CURLUE_OK, CURLUE_OK},
{"http://example.com:80",
"user=foo,",
"http://foo@example.com:80/",
0, 0, CURLUE_OK, CURLUE_OK},
{"http://example.com",
"host=www.example.com,",
"http://www.example.com/",
0, 0, CURLUE_OK, CURLUE_OK},
{"http://example.com:80",
"scheme=ftp,",
"ftp://example.com:80/",
0, 0, CURLUE_OK, CURLUE_OK},
{"custom-scheme://host",
"host=\"\",",
"custom-scheme://host/",
CURLU_NON_SUPPORT_SCHEME, CURLU_NON_SUPPORT_SCHEME, CURLUE_OK,
CURLUE_BAD_HOSTNAME},
{"custom-scheme://host",
"host=\"\",",
"custom-scheme:///",
CURLU_NON_SUPPORT_SCHEME, CURLU_NON_SUPPORT_SCHEME | CURLU_NO_AUTHORITY,
CURLUE_OK, CURLUE_OK},
{NULL, NULL, NULL, 0, 0, CURLUE_OK, CURLUE_OK}
};
static CURLUPart part2id(char *part)
{
if(!strcmp("url", part))
return CURLUPART_URL;
if(!strcmp("scheme", part))
return CURLUPART_SCHEME;
if(!strcmp("user", part))
return CURLUPART_USER;
if(!strcmp("password", part))
return CURLUPART_PASSWORD;
if(!strcmp("options", part))
return CURLUPART_OPTIONS;
if(!strcmp("host", part))
return CURLUPART_HOST;
if(!strcmp("port", part))
return CURLUPART_PORT;
if(!strcmp("path", part))
return CURLUPART_PATH;
if(!strcmp("query", part))
return CURLUPART_QUERY;
if(!strcmp("fragment", part))
return CURLUPART_FRAGMENT;
if(!strcmp("zoneid", part))
return CURLUPART_ZONEID;
return (CURLUPart)9999; /* bad input => bad output */
}
static CURLUcode updateurl(CURLU *u, const char *cmd, unsigned int setflags)
{
const char *p = cmd;
CURLUcode uc;
/* make sure the last command ends with a comma too! */
while(p) {
char *e = strchr(p, ',');
if(e) {
size_t n = (size_t)(e - p);
char buf[80];
char part[80];
char value[80];
memset(part, 0, sizeof(part)); /* Avoid valgrind false positive. */
memset(value, 0, sizeof(value)); /* Avoid valgrind false positive. */
memcpy(buf, p, n);
buf[n] = 0;
if(2 == sscanf(buf, "%79[^=]=%79[^,]", part, value)) {
CURLUPart what = part2id(part);
#if 0
/* for debugging this */
fprintf(stderr, "%s = \"%s\" [%d]\n", part, value, (int)what);
#endif
if(what > CURLUPART_ZONEID)
fprintf(stderr, "UNKNOWN part '%s'\n", part);
if(!strcmp("NULL", value))
uc = curl_url_set(u, what, NULL, setflags);
else if(!strcmp("\"\"", value))
uc = curl_url_set(u, what, "", setflags);
else
uc = curl_url_set(u, what, value, setflags);
if(uc)
return uc;
}
p = e + 1;
continue;
}
break;
}
return CURLUE_OK;
}
static const struct redircase set_url_list[] = {
{"http://example.com/please/../gimme/%TESTNUMBER?foobar#hello",
"http://example.net/there/it/is/../../tes t case=/%TESTNUMBER0002? yes no",
"http://example.net/there/tes%20t%20case=/%TESTNUMBER0002?+yes+no",
0, CURLU_URLENCODE|CURLU_ALLOW_SPACE, CURLUE_OK},
{"http://local.test?redirect=http://local.test:80?-321",
"http://local.test:80?-123",
"http://local.test:80/?-123",
0, CURLU_URLENCODE|CURLU_ALLOW_SPACE, CURLUE_OK},
{"http://local.test?redirect=http://local.test:80?-321",
"http://local.test:80?-123",
"http://local.test:80/?-123",
0, 0, CURLUE_OK},
{"http://example.org/static/favicon/wikipedia.ico",
"//fake.example.com/licenses/by-sa/3.0/",
"http://fake.example.com/licenses/by-sa/3.0/",
0, 0, CURLUE_OK},
{"https://example.org/static/favicon/wikipedia.ico",
"//fake.example.com/licenses/by-sa/3.0/",
"https://fake.example.com/licenses/by-sa/3.0/",
0, 0, CURLUE_OK},
{"file://localhost/path?query#frag",
"foo#another",
"file:///foo#another",
0, 0, CURLUE_OK},
{"http://example.com/path?query#frag",
"https://two.example.com/bradnew",
"https://two.example.com/bradnew",
0, 0, CURLUE_OK},
{"http://example.com/path?query#frag",
"../../newpage#foo",
"http://example.com/newpage#foo",
0, 0, CURLUE_OK},
{"http://user:foo@example.com/path?query#frag",
"../../newpage",
"http://user:foo@example.com/newpage",
0, 0, CURLUE_OK},
{"http://user:foo@example.com/path?query#frag",
"../newpage",
"http://user:foo@example.com/newpage",
0, 0, CURLUE_OK},
{"http://user:foo@example.com/path?query#frag",
"http://?hi",
"http:///?hi",
0, CURLU_NO_AUTHORITY, CURLUE_OK},
{NULL, NULL, NULL, 0, 0, CURLUE_OK}
};
static int set_url(void)
{
int i;
int error = 0;
for(i = 0; set_url_list[i].in && !error; i++) {
CURLUcode rc;
CURLU *urlp = curl_url();
if(!urlp)
break;
rc = curl_url_set(urlp, CURLUPART_URL, set_url_list[i].in,
set_url_list[i].urlflags);
if(!rc) {
rc = curl_url_set(urlp, CURLUPART_URL, set_url_list[i].set,
set_url_list[i].setflags);
if(rc) {
fprintf(stderr, "%s:%d Set URL %s returned %d (%s)\n",
__FILE__, __LINE__, set_url_list[i].set,
(int)rc, curl_url_strerror(rc));
error++;
}
else {
char *url = NULL;
rc = curl_url_get(urlp, CURLUPART_URL, &url, 0);
if(rc) {
fprintf(stderr, "%s:%d Get URL returned %d (%s)\n",
__FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
error++;
}
else {
if(checkurl(set_url_list[i].in, url, set_url_list[i].out)) {
error++;
}
}
curl_free(url);
}
}
else if(rc != set_url_list[i].ucode) {
fprintf(stderr, "Set URL\nin: %s\nreturned %d (expected %d)\n",
set_url_list[i].in, (int)rc, set_url_list[i].ucode);
error++;
}
curl_url_cleanup(urlp);
}
return error;
}
/* 1. Set a URL
2. Set one or more parts
3. Extract and compare all parts - not the URL
*/
static int setget_parts(void)
{
int i;
int error = 0;
for(i = 0; setget_parts_list[i].set && !error; i++) {
CURLUcode rc;
CURLU *urlp = curl_url();
if(!urlp) {
error++;
break;
}
if(setget_parts_list[i].in)
rc = curl_url_set(urlp, CURLUPART_URL, setget_parts_list[i].in,
setget_parts_list[i].urlflags);
else
rc = CURLUE_OK;
if(!rc) {
char *url = NULL;
CURLUcode uc = updateurl(urlp, setget_parts_list[i].set,
setget_parts_list[i].setflags);
if(uc != setget_parts_list[i].pcode) {
fprintf(stderr, "updateurl\nin: %s\nreturned %d (expected %d)\n",
setget_parts_list[i].set, (int)uc, setget_parts_list[i].pcode);
error++;
}
if(!uc) {
if(checkparts(urlp, setget_parts_list[i].set, setget_parts_list[i].out,
setget_parts_list[i].getflags))
error++; /* add */
}
curl_free(url);
}
else if(rc != CURLUE_OK) {
fprintf(stderr, "Set parts\nin: %s\nreturned %d (expected %d)\n",
setget_parts_list[i].in, (int)rc, 0);
error++;
}
curl_url_cleanup(urlp);
}
return error;
}
static int set_parts(void)
{
int i;
int error = 0;
for(i = 0; set_parts_list[i].set && !error; i++) {
CURLUcode rc;
CURLU *urlp = curl_url();
if(!urlp) {
error++;
break;
}
if(set_parts_list[i].in)
rc = curl_url_set(urlp, CURLUPART_URL, set_parts_list[i].in,
set_parts_list[i].urlflags);
else
rc = CURLUE_OK;
if(!rc) {
char *url = NULL;
CURLUcode uc = updateurl(urlp, set_parts_list[i].set,
set_parts_list[i].setflags);
if(uc != set_parts_list[i].pcode) {
fprintf(stderr, "updateurl\nin: %s\nreturned %d (expected %d)\n",
set_parts_list[i].set, (int)uc, set_parts_list[i].pcode);
error++;
}
if(!uc) {
/* only do this if it worked */
rc = curl_url_get(urlp, CURLUPART_URL, &url, 0);
if(rc) {
fprintf(stderr, "%s:%d Get URL returned %d (%s)\n",
__FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
error++;
}
else if(checkurl(set_parts_list[i].in, url, set_parts_list[i].out)) {
error++;
}
}
curl_free(url);
}
else if(rc != set_parts_list[i].ucode) {
fprintf(stderr, "Set parts\nin: %s\nreturned %d (expected %d)\n",
set_parts_list[i].in, (int)rc, set_parts_list[i].ucode);
error++;
}
curl_url_cleanup(urlp);
}
return error;
}
static int get_url(void)
{
int i;
int error = 0;
for(i = 0; get_url_list[i].in && !error; i++) {
CURLUcode rc;
CURLU *urlp = curl_url();
if(!urlp) {
error++;
break;
}
rc = curl_url_set(urlp, CURLUPART_URL, get_url_list[i].in,
get_url_list[i].urlflags);
if(!rc) {
char *url = NULL;
rc = curl_url_get(urlp, CURLUPART_URL, &url, get_url_list[i].getflags);
if(rc) {
fprintf(stderr, "%s:%d returned %d (%s). URL: '%s'\n",
__FILE__, __LINE__, (int)rc, curl_url_strerror(rc),
get_url_list[i].in);
error++;
}
else {
if(checkurl(get_url_list[i].in, url, get_url_list[i].out)) {
error++;
}
}
curl_free(url);
}
if(rc != get_url_list[i].ucode) {
fprintf(stderr, "Get URL\nin: %s\nreturned %d (expected %d)\n",
get_url_list[i].in, (int)rc, get_url_list[i].ucode);
error++;
}
curl_url_cleanup(urlp);
}
return error;
}
static int get_parts(void)
{
int i;
int error = 0;
for(i = 0; get_parts_list[i].in && !error; i++) {
CURLUcode rc;
CURLU *urlp = curl_url();
if(!urlp) {
error++;
break;
}
rc = curl_url_set(urlp, CURLUPART_URL,
get_parts_list[i].in,
get_parts_list[i].urlflags);
if(rc != get_parts_list[i].ucode) {
fprintf(stderr, "Get parts\nin: %s\nreturned %d (expected %d)\n",
get_parts_list[i].in, (int)rc, get_parts_list[i].ucode);
error++;
}
else if(get_parts_list[i].ucode) {
/* the expected error happened */
}
else if(checkparts(urlp, get_parts_list[i].in, get_parts_list[i].out,
get_parts_list[i].getflags))
error++;
curl_url_cleanup(urlp);
}
return error;
}
static const struct querycase append_list[] = {
{"HTTP://test/?s", "name=joe\x02", "http://test/?s&name=joe%02",
0, CURLU_URLENCODE, CURLUE_OK},
{"HTTP://test/?size=2#f", "name=joe=", "http://test/?size=2&name=joe%3d#f",
0, CURLU_URLENCODE, CURLUE_OK},
{"HTTP://test/?size=2#f", "name=joe doe",
"http://test/?size=2&name=joe+doe#f",
0, CURLU_URLENCODE, CURLUE_OK},
{"HTTP://test/", "name=joe", "http://test/?name=joe", 0, 0, CURLUE_OK},
{"HTTP://test/?size=2", "name=joe", "http://test/?size=2&name=joe",
0, 0, CURLUE_OK},
{"HTTP://test/?size=2&", "name=joe", "http://test/?size=2&name=joe",
0, 0, CURLUE_OK},
{"HTTP://test/?size=2#f", "name=joe", "http://test/?size=2&name=joe#f",
0, 0, CURLUE_OK},
{NULL, NULL, NULL, 0, 0, CURLUE_OK}
};
static int append(void)
{
int i;
int error = 0;
for(i = 0; append_list[i].in && !error; i++) {
CURLUcode rc;
CURLU *urlp = curl_url();
if(!urlp) {
error++;
break;
}
rc = curl_url_set(urlp, CURLUPART_URL,
append_list[i].in,
append_list[i].urlflags);
if(rc)
error++;
else
rc = curl_url_set(urlp, CURLUPART_QUERY,
append_list[i].q,
append_list[i].qflags | CURLU_APPENDQUERY);
if(error)
;
else if(rc != append_list[i].ucode) {
fprintf(stderr, "Append\nin: %s\nreturned %d (expected %d)\n",
append_list[i].in, (int)rc, append_list[i].ucode);
error++;
}
else if(append_list[i].ucode) {
/* the expected error happened */
}
else {
char *url;
rc = curl_url_get(urlp, CURLUPART_URL, &url, 0);
if(rc) {
fprintf(stderr, "%s:%d Get URL returned %d (%s)\n",
__FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
error++;
}
else {
if(checkurl(append_list[i].in, url, append_list[i].out)) {
error++;
}
curl_free(url);
}
}
curl_url_cleanup(urlp);
}
return error;
}
static int scopeid(void)
{
CURLU *u = curl_url();
int error = 0;
CURLUcode rc;
char *url;
rc = curl_url_set(u, CURLUPART_URL,
"https://[fe80::20c:29ff:fe9c:409b%25eth0]/hello.html", 0);
if(rc != CURLUE_OK) {
fprintf(stderr, "%s:%d curl_url_set returned %d (%s)\n",
__FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
error++;
}
rc = curl_url_get(u, CURLUPART_HOST, &url, 0);
if(rc != CURLUE_OK) {
fprintf(stderr, "%s:%d curl_url_get CURLUPART_HOST returned %d (%s)\n",
__FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
error++;
}
else {
curl_free(url);
}
rc = curl_url_set(u, CURLUPART_HOST, "[::1]", 0);
if(rc != CURLUE_OK) {
fprintf(stderr, "%s:%d curl_url_set CURLUPART_HOST returned %d (%s)\n",
__FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
error++;
}
rc = curl_url_get(u, CURLUPART_URL, &url, 0);
if(rc != CURLUE_OK) {
fprintf(stderr, "%s:%d curl_url_get CURLUPART_URL returned %d (%s)\n",
__FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
error++;
}
else {
curl_free(url);
}
rc = curl_url_set(u, CURLUPART_HOST, "example.com", 0);
if(rc != CURLUE_OK) {
fprintf(stderr, "%s:%d curl_url_set CURLUPART_HOST returned %d (%s)\n",
__FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
error++;
}
rc = curl_url_get(u, CURLUPART_URL, &url, 0);
if(rc != CURLUE_OK) {
fprintf(stderr, "%s:%d curl_url_get CURLUPART_URL returned %d (%s)\n",
__FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
error++;
}
else {
curl_free(url);
}
rc = curl_url_set(u, CURLUPART_HOST,
"[fe80::20c:29ff:fe9c:409b%25eth0]", 0);
if(rc != CURLUE_OK) {
fprintf(stderr, "%s:%d curl_url_set CURLUPART_HOST returned %d (%s)\n",
__FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
error++;
}
rc = curl_url_get(u, CURLUPART_URL, &url, 0);
if(rc != CURLUE_OK) {
fprintf(stderr, "%s:%d curl_url_get CURLUPART_URL returned %d (%s)\n",
__FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
error++;
}
else {
curl_free(url);
}
rc = curl_url_get(u, CURLUPART_HOST, &url, 0);
if(rc != CURLUE_OK) {
fprintf(stderr, "%s:%d curl_url_get CURLUPART_HOST returned %d (%s)\n",
__FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
error++;
}
else {
curl_free(url);
}
rc = curl_url_get(u, CURLUPART_ZONEID, &url, 0);
if(rc != CURLUE_OK) {
fprintf(stderr, "%s:%d curl_url_get CURLUPART_ZONEID returned %d (%s)\n",
__FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
error++;
}
else {
curl_free(url);
}
rc = curl_url_set(u, CURLUPART_ZONEID, "clown", 0);
if(rc != CURLUE_OK) {
fprintf(stderr, "%s:%d curl_url_set CURLUPART_ZONEID returned %d (%s)\n",
__FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
error++;
}
rc = curl_url_get(u, CURLUPART_URL, &url, 0);
if(rc != CURLUE_OK) {
fprintf(stderr, "%s:%d curl_url_get CURLUPART_URL returned %d (%s)\n",
__FILE__, __LINE__, (int)rc, curl_url_strerror(rc));
error++;
}
else {
curl_free(url);
}
curl_url_cleanup(u);
return error;
}
static int get_nothing(void)
{
CURLU *u = curl_url();
if(u) {
char *p;
CURLUcode rc;
rc = curl_url_get(u, CURLUPART_SCHEME, &p, 0);
if(rc != CURLUE_NO_SCHEME)
fprintf(stderr, "unexpected return code line %u\n", __LINE__);
rc = curl_url_get(u, CURLUPART_HOST, &p, 0);
if(rc != CURLUE_NO_HOST)
fprintf(stderr, "unexpected return code line %u\n", __LINE__);
rc = curl_url_get(u, CURLUPART_USER, &p, 0);
if(rc != CURLUE_NO_USER)
fprintf(stderr, "unexpected return code line %u\n", __LINE__);
rc = curl_url_get(u, CURLUPART_PASSWORD, &p, 0);
if(rc != CURLUE_NO_PASSWORD)
fprintf(stderr, "unexpected return code line %u\n", __LINE__);
rc = curl_url_get(u, CURLUPART_OPTIONS, &p, 0);
if(rc != CURLUE_NO_OPTIONS)
fprintf(stderr, "unexpected return code line %u\n", __LINE__);
rc = curl_url_get(u, CURLUPART_PATH, &p, 0);
if(rc != CURLUE_OK)
fprintf(stderr, "unexpected return code line %u\n", __LINE__);
else
curl_free(p);
rc = curl_url_get(u, CURLUPART_QUERY, &p, 0);
if(rc != CURLUE_NO_QUERY)
fprintf(stderr, "unexpected return code line %u\n", __LINE__);
rc = curl_url_get(u, CURLUPART_FRAGMENT, &p, 0);
if(rc != CURLUE_NO_FRAGMENT)
fprintf(stderr, "unexpected return code line %u\n", __LINE__);
rc = curl_url_get(u, CURLUPART_ZONEID, &p, 0);
if(rc != CURLUE_NO_ZONEID)
fprintf(stderr, "unexpected return code %u on line %u\n", (int)rc,
__LINE__);
curl_url_cleanup(u);
}
return 0;
}
static const struct clearurlcase clear_url_list[] ={
{CURLUPART_SCHEME, "http", NULL, CURLUE_NO_SCHEME},
{CURLUPART_USER, "user", NULL, CURLUE_NO_USER},
{CURLUPART_PASSWORD, "password", NULL, CURLUE_NO_PASSWORD},
{CURLUPART_OPTIONS, "options", NULL, CURLUE_NO_OPTIONS},
{CURLUPART_HOST, "host", NULL, CURLUE_NO_HOST},
{CURLUPART_ZONEID, "eth0", NULL, CURLUE_NO_ZONEID},
{CURLUPART_PORT, "1234", NULL, CURLUE_NO_PORT},
{CURLUPART_PATH, "/hello", "/", CURLUE_OK},
{CURLUPART_QUERY, "a=b", NULL, CURLUE_NO_QUERY},
{CURLUPART_FRAGMENT, "anchor", NULL, CURLUE_NO_FRAGMENT},
{CURLUPART_URL, NULL, NULL, CURLUE_OK},
};
static int clear_url(void)
{
CURLU *u = curl_url();
int i, error = 0;
if(u) {
char *p = NULL;
CURLUcode rc;
for(i = 0; clear_url_list[i].in && !error; i++) {
rc = curl_url_set(u, clear_url_list[i].part, clear_url_list[i].in, 0);
if(rc != CURLUE_OK)
fprintf(stderr, "unexpected return code line %u\n", __LINE__);
rc = curl_url_set(u, CURLUPART_URL, NULL, 0);
if(rc != CURLUE_OK)
fprintf(stderr, "unexpected return code line %u\n", __LINE__);
rc = curl_url_get(u, clear_url_list[i].part, &p, 0);
if(rc != clear_url_list[i].ucode || (clear_url_list[i].out &&
0 != strcmp(p, clear_url_list[i].out))) {
fprintf(stderr, "unexpected return code line %u\n", __LINE__);
error++;
}
if(rc == CURLUE_OK)
curl_free(p);
}
}
curl_url_cleanup(u);
return error;
}
static char total[128000];
static char bigpart[120000];
/*
* verify ridiculous URL part sizes
*/
static int huge(void)
{
const char *smallpart = "c";
int i;
CURLU *urlp = curl_url();
CURLUcode rc;
CURLUPart part[]= {
CURLUPART_SCHEME,
CURLUPART_USER,
CURLUPART_PASSWORD,
CURLUPART_HOST,
CURLUPART_PATH,
CURLUPART_QUERY,
CURLUPART_FRAGMENT
};
int error = 0;
if(!urlp)
return 1;
bigpart[0] = '/'; /* for the path */
memset(&bigpart[1], 'a', sizeof(bigpart) - 2);
bigpart[sizeof(bigpart) - 1] = 0;
for(i = 0; i < 7; i++) {
char *partp;
msnprintf(total, sizeof(total),
"%s://%s:%s@%s/%s?%s#%s",
(i == 0)? &bigpart[1] : smallpart,
(i == 1)? &bigpart[1] : smallpart,
(i == 2)? &bigpart[1] : smallpart,
(i == 3)? &bigpart[1] : smallpart,
(i == 4)? &bigpart[1] : smallpart,
(i == 5)? &bigpart[1] : smallpart,
(i == 6)? &bigpart[1] : smallpart);
rc = curl_url_set(urlp, CURLUPART_URL, total, CURLU_NON_SUPPORT_SCHEME);
if((!i && (rc != CURLUE_BAD_SCHEME)) ||
(i && rc)) {
printf("URL %u: failed to parse [%s]\n", i, total);
error++;
}
/* only extract if the parse worked */
if(!rc) {
curl_url_get(urlp, part[i], &partp, 0);
if(!partp || strcmp(partp, &bigpart[1 - (i == 4)])) {
printf("URL %u part %u: failure\n", i, part[i]);
error++;
}
curl_free(partp);
}
}
curl_url_cleanup(urlp);
return error;
}
static int urldup(void)
{
const char *url[] = {
"http://"
"user:pwd@"
"[2a04:4e42:e00::347%25eth0]"
":80"
"/path"
"?query"
"#fraggie",
"https://example.com",
"https://user@example.com",
"https://user.pwd@example.com",
"https://user.pwd@example.com:1234",
"https://example.com:1234",
"example.com:1234",
"https://user.pwd@example.com:1234/path?query#frag",
NULL
};
CURLU *copy = NULL;
char *h_str = NULL, *copy_str = NULL;
CURLU *h = curl_url();
int i;
if(!h)
goto err;
for(i = 0; url[i]; i++) {
CURLUcode rc = curl_url_set(h, CURLUPART_URL, url[i],
CURLU_GUESS_SCHEME);
if(rc)
goto err;
copy = curl_url_dup(h);
rc = curl_url_get(h, CURLUPART_URL, &h_str, 0);
if(rc)
goto err;
rc = curl_url_get(copy, CURLUPART_URL, &copy_str, 0);
if(rc)
goto err;
if(strcmp(h_str, copy_str)) {
printf("Original: %s\nParsed: %s\nCopy: %s\n",
url[i], h_str, copy_str);
goto err;
}
curl_free(copy_str);
curl_free(h_str);
curl_url_cleanup(copy);
copy_str = NULL;
h_str = NULL;
copy = NULL;
}
curl_url_cleanup(h);
return 0;
err:
curl_free(copy_str);
curl_free(h_str);
curl_url_cleanup(copy);
curl_url_cleanup(h);
return 1;
}
int test(char *URL)
{
(void)URL; /* not used */
if(urldup())
return 11;
if(setget_parts())
return 10;
if(get_url())
return 3;
if(huge())
return 9;
if(get_nothing())
return 7;
if(scopeid())
return 6;
if(append())
return 5;
if(set_url())
return 1;
if(set_parts())
return 2;
if(get_parts())
return 4;
if(clear_url())
return 8;
printf("success\n");
return 0;
}
Reference in a new issue Copy permalink