return newest;
}
+/* scan for byte values < 31 or 127 */
+static bool junkscan(const char *part, unsigned int flags)
+{
+ if(part) {
+ static const char badbytes[]={
+ /* */ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+ 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
+ 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
+ 0x7f, 0x00 /* null-terminate */
+ };
+ size_t n = strlen(part);
+ size_t nfine = strcspn(part, badbytes);
+ if(nfine != n)
+ /* since we don't know which part is scanned, return a generic error
+ code */
+ return TRUE;
+ if(!(flags & CURLU_ALLOW_SPACE) && strchr(part, ' '))
+ return TRUE;
+ }
+ return FALSE;
+}
+
/*
* parse_hostname_login()
*
(h && (h->flags & PROTOPT_URLOPTIONS)) ?
&optionsp:NULL);
if(ccode) {
- result = CURLUE_MALFORMED_INPUT;
+ result = CURLUE_BAD_LOGIN;
goto out;
}
result = CURLUE_USER_NOT_ALLOWED;
goto out;
}
-
+ if(junkscan(userp, flags)) {
+ result = CURLUE_BAD_USER;
+ goto out;
+ }
u->user = userp;
}
- if(passwdp)
+ if(passwdp) {
+ if(junkscan(passwdp, flags)) {
+ result = CURLUE_BAD_PASSWORD;
+ goto out;
+ }
u->password = passwdp;
+ }
- if(optionsp)
+ if(optionsp) {
+ if(junkscan(optionsp, flags)) {
+ result = CURLUE_BAD_LOGIN;
+ goto out;
+ }
u->options = optionsp;
+ }
return CURLUE_OK;
out:
free(userp);
free(passwdp);
free(optionsp);
+ u->user = NULL;
+ u->password = NULL;
+ u->options = NULL;
return result;
}
int zonelen = len;
if(1 == sscanf(hostname + zonelen, "%*[^]]%c%n", &endbracket, &len)) {
if(']' != endbracket)
- return CURLUE_MALFORMED_INPUT;
+ return CURLUE_BAD_IPV6;
portptr = &hostname[--zonelen + len + 1];
}
else
- return CURLUE_MALFORMED_INPUT;
+ return CURLUE_BAD_IPV6;
}
else
- return CURLUE_MALFORMED_INPUT;
+ return CURLUE_BAD_IPV6;
/* this is a RFC2732-style specified IP-address */
if(portptr && *portptr) {
if(*portptr != ':')
- return CURLUE_MALFORMED_INPUT;
+ return CURLUE_BAD_IPV6;
}
else
portptr = NULL;
return CURLUE_OK;
}
-/* scan for byte values < 31 or 127 */
-static bool junkscan(const char *part, unsigned int flags)
-{
- if(part) {
- static const char badbytes[]={
- /* */ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
- 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
- 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
- 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
- 0x7f, 0x00 /* null-terminate */
- };
- size_t n = strlen(part);
- size_t nfine = strcspn(part, badbytes);
- if(nfine != n)
- /* since we don't know which part is scanned, return a generic error
- code */
- return TRUE;
- if(!(flags & CURLU_ALLOW_SPACE) && strchr(part, ' '))
- return TRUE;
- }
- return FALSE;
-}
-
static CURLUcode hostname_check(struct Curl_URL *u, char *hostname)
{
size_t len;
#endif
const char *l = "0123456789abcdefABCDEF:.";
if(hlen < 4) /* '[::]' is the shortest possible valid string */
- return CURLUE_MALFORMED_INPUT;
+ return CURLUE_BAD_IPV6;
hostname++;
hlen -= 2;
if(hostname[hlen] != ']')
- return CURLUE_MALFORMED_INPUT;
+ return CURLUE_BAD_IPV6;
/* only valid letters are ok */
len = strspn(hostname, l);
while(*h && (*h != ']') && (i < 15))
zoneid[i++] = *h++;
if(!i || (']' != *h))
+ /* impossible to reach? */
return CURLUE_MALFORMED_INPUT;
zoneid[i] = 0;
u->zoneid = strdup(zoneid);
hostname[len + 1] = 0; /* terminate the hostname */
}
else
- return CURLUE_MALFORMED_INPUT;
+ return CURLUE_BAD_IPV6;
/* hostname is fine */
}
#ifdef ENABLE_IPV6
hostname[hlen] = 0; /* end the address there */
if(1 != Curl_inet_pton(AF_INET6, hostname, dest))
- return CURLUE_MALFORMED_INPUT;
+ return CURLUE_BAD_IPV6;
hostname[hlen] = ']'; /* restore ending bracket */
#endif
}
len = strcspn(hostname, " \r\n");
if(hlen != len)
/* hostname with bad content */
- return CURLUE_MALFORMED_INPUT;
+ return CURLUE_BAD_HOSTNAME;
}
if(!hostname[0])
return CURLUE_NO_HOST;
CURLcode result = Curl_urldecode(NULL, hostname, 0,
outp, &dlen, REJECT_CTRL);
if(result)
- return CURLUE_MALFORMED_INPUT;
+ return CURLUE_BAD_HOSTNAME;
}
return CURLUE_OK;
if(url_has_scheme && !strcmp(schemebuf, "file")) {
if(urllen <= 6)
/* file:/ is not enough to actually be a complete file: URL */
- return CURLUE_MALFORMED_INPUT;
+ return CURLUE_BAD_FILE_URL;
/* path has been allocated large enough to hold this */
strcpy(path, &url[5]);
host name */
path = strpbrk(ptr, "/\\:*?\"<>|");
if(!path || *path != '/')
- return CURLUE_MALFORMED_INPUT;
+ return CURLUE_BAD_FILE_URL;
len = path - ptr;
if(len) {
#else
/* Invalid file://hostname/, expected localhost or 127.0.0.1 or
none */
- return CURLUE_MALFORMED_INPUT;
+ return CURLUE_BAD_FILE_URL;
#endif
}
}
if(('/' == path[0] && STARTS_WITH_URL_DRIVE_PREFIX(&path[1])) ||
STARTS_WITH_URL_DRIVE_PREFIX(path)) {
/* File drive letters are only accepted in MSDOS/Windows */
- return CURLUE_MALFORMED_INPUT;
+ return CURLUE_BAD_FILE_URL;
}
#else
/* If the path starts with a slash and a drive letter, ditch the slash */
}
if((i < 1) || (i>3))
/* less than one or more than three slashes */
- return CURLUE_MALFORMED_INPUT;
+ return CURLUE_BAD_SLASHES;
schemep = schemebuf;
if(!Curl_builtin_scheme(schemep) &&
return CURLUE_UNSUPPORTED_SCHEME;
if(junkscan(schemep, flags))
- return CURLUE_MALFORMED_INPUT;
+ return CURLUE_BAD_SCHEME;
}
else {
/* no scheme! */
if(!(flags & (CURLU_DEFAULT_SCHEME|CURLU_GUESS_SCHEME)))
- return CURLUE_MALFORMED_INPUT;
+ return CURLUE_BAD_SCHEME;
if(flags & CURLU_DEFAULT_SCHEME)
schemep = DEFAULT_SCHEME;
}
hostp = p; /* host name starts here */
- while(*p && !HOSTNAME_END(*p)) /* find end of host name */
+ /* find the end of the host name + port number */
+ while(*p && !HOSTNAME_END(*p))
p++;
len = p - hostp;
}
else {
if(!(flags & CURLU_NO_AUTHORITY))
- return CURLUE_MALFORMED_INPUT;
+ return CURLUE_NO_HOST;
}
len = strlen(p);
}
}
- if(junkscan(path, flags))
- return CURLUE_MALFORMED_INPUT;
-
if((flags & CURLU_URLENCODE) && path[0]) {
/* worst case output length is 3x the original! */
char *newp = malloc(strlen(path) * 3);
fragment = strchr(path, '#');
if(fragment) {
*fragment++ = 0;
+ if(junkscan(fragment, flags))
+ return CURLUE_BAD_FRAGMENT;
if(fragment[0]) {
u->fragment = strdup(fragment);
if(!u->fragment)
query = strchr(path, '?');
if(query) {
*query++ = 0;
+ if(junkscan(query, flags))
+ return CURLUE_BAD_QUERY;
/* done even if the query part is a blank string */
u->query = strdup(query);
if(!u->query)
return CURLUE_OUT_OF_MEMORY;
}
+ if(junkscan(path, flags))
+ return CURLUE_BAD_PATH;
+
if(!path[0])
/* if there's no path left set, unset */
path = NULL;
if(hostname) {
char normalized_ipv4[sizeof("255.255.255.255") + 1];
+
/*
* Parse the login details and strip them out of the host name.
*/
- if(junkscan(hostname, flags))
- return CURLUE_MALFORMED_INPUT;
-
result = parse_hostname_login(u, &hostname, flags);
if(result)
return result;
if(result)
return result;
+ if(junkscan(hostname, flags))
+ return CURLUE_BAD_HOSTNAME;
+
if(0 == strlen(hostname) && (flags & CURLU_NO_AUTHORITY)) {
/* Skip hostname check, it's allowed to be empty. */
u->host = strdup("");
break;
case CURLUPART_ZONEID:
ptr = u->zoneid;
+ ifmissing = CURLUE_NO_ZONEID;
break;
case CURLUPART_PORT:
ptr = u->port;
case CURLUPART_SCHEME:
if(strlen(part) > MAX_SCHEME_LEN)
/* too long */
- return CURLUE_MALFORMED_INPUT;
+ return CURLUE_BAD_SCHEME;
if(!(flags & CURLU_NON_SUPPORT_SCHEME) &&
/* verify that it is a fine scheme */
!Curl_builtin_scheme(part))
size_t len = strcspn(part, " \r\n");
if(strlen(part) != len)
/* hostname with bad content */
- return CURLUE_MALFORMED_INPUT;
+ return CURLUE_BAD_HOSTNAME;
storep = &u->host;
Curl_safefree(u->zoneid);
break;
return CURLUE_BAD_PORT_NUMBER;
if(*endp)
/* weirdly provided number, not good! */
- return CURLUE_MALFORMED_INPUT;
+ return CURLUE_BAD_PORT_NUMBER;
storep = &u->port;
}
break;
else {
if(hostname_check(u, (char *)newp)) {
free((char *)newp);
- return CURLUE_MALFORMED_INPUT;
+ return CURLUE_BAD_HOSTNAME;
}
}
}
};
static const struct testcase get_parts_list[] ={
+ {"https://user:password@example.net/get?this=and#but frag then", "",
+ CURLU_DEFAULT_SCHEME, 0, CURLUE_BAD_FRAGMENT},
{"https://user:password@example.net/get?this=and what", "",
- CURLU_DEFAULT_SCHEME, 0, CURLUE_MALFORMED_INPUT},
+ CURLU_DEFAULT_SCHEME, 0, CURLUE_BAD_QUERY},
{"https://user:password@example.net/ge t?this=and-what", "",
- CURLU_DEFAULT_SCHEME, 0, CURLUE_MALFORMED_INPUT},
+ CURLU_DEFAULT_SCHEME, 0, CURLUE_BAD_PATH},
{"https://user:pass word@example.net/get?this=and-what", "",
- CURLU_DEFAULT_SCHEME, 0, CURLUE_MALFORMED_INPUT},
+ CURLU_DEFAULT_SCHEME, 0, CURLUE_BAD_PASSWORD},
{"https://u ser:password@example.net/get?this=and-what", "",
- CURLU_DEFAULT_SCHEME, 0, CURLUE_MALFORMED_INPUT},
+ CURLU_DEFAULT_SCHEME, 0, CURLUE_BAD_USER},
+ {"imap://user:pass;opt ion@server/path", "",
+ CURLU_DEFAULT_SCHEME, 0, CURLUE_BAD_LOGIN},
/* no space allowed in scheme */
{"htt ps://user:password@example.net/get?this=and-what", "",
- CURLU_NON_SUPPORT_SCHEME|CURLU_ALLOW_SPACE, 0, CURLUE_MALFORMED_INPUT},
+ 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]",
"com/color/?green#no-red",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK },
{"http://[ab.be:1]/x", "",
- CURLU_DEFAULT_SCHEME, 0, CURLUE_MALFORMED_INPUT},
+ CURLU_DEFAULT_SCHEME, 0, CURLUE_BAD_IPV6},
{"http://[ab.be]/x", "",
- CURLU_DEFAULT_SCHEME, 0, CURLUE_MALFORMED_INPUT},
+ CURLU_DEFAULT_SCHEME, 0, CURLUE_BAD_IPV6},
/* URL without host name */
{"http://a:b@/x", "",
CURLU_DEFAULT_SCHEME, 0, CURLUE_NO_HOST},
0, 0, CURLUE_OK},
{"file://hello.html",
"",
- 0, 0, CURLUE_MALFORMED_INPUT},
+ 0, 0, CURLUE_BAD_FILE_URL},
{"http://HO0_-st/",
"http | [11] | [12] | [13] | HO0_-st | [15] | / | [16] | [17]",
0, 0, CURLUE_OK},
0, 0, CURLUE_OK},
{"file:/",
"file | [11] | [12] | [13] | [14] | [15] | | [16] | [17]",
- 0, 0, CURLUE_MALFORMED_INPUT},
+ 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},
"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},
+ CURLU_DEFAULT_SCHEME, 0, CURLUE_BAD_HOSTNAME},
{"https://e x a m p l e.com?check", "",
- CURLU_DEFAULT_SCHEME, 0, CURLUE_MALFORMED_INPUT},
+ CURLU_DEFAULT_SCHEME, 0, CURLUE_BAD_HOSTNAME},
{"https://example.com?check",
"https | [11] | [12] | [13] | example.com | [15] | / | check | [17]",
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
{"http:////user:password@example.com:1234/path/html?query=name#anchor",
"",
- CURLU_DEFAULT_SCHEME, 0, CURLUE_MALFORMED_INPUT},
+ CURLU_DEFAULT_SCHEME, 0, CURLUE_BAD_SLASHES},
{NULL, NULL, 0, 0, CURLUE_OK},
};
{"https://h%c", "https://h%25c/", 0, 0, CURLUE_OK},
{"https://%%%%%%", "https://%25%25%25%25%25%25/", 0, 0, CURLUE_OK},
{"https://%41", "https://A/", 0, 0, CURLUE_OK},
- {"https://%20", "", 0, 0, CURLUE_MALFORMED_INPUT},
- {"https://%41%0d", "", 0, 0, CURLUE_MALFORMED_INPUT},
+ {"https://%20", "", 0, 0, CURLUE_BAD_HOSTNAME},
+ {"https://%41%0d", "", 0, 0, CURLUE_BAD_HOSTNAME},
{"https://%25", "https://%25/", 0, 0, CURLUE_OK},
{"https://_%c0_", "https://_\xC0_/", 0, 0, CURLUE_OK},
{"https://_%c0_", "https://_%C0_/", 0, CURLU_URLENCODE, CURLUE_OK},
{"https://+127.0.0.1", "https://%2B127.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://127.0. 1", "https://127.0.0.1/", 0, 0, CURLUE_BAD_HOSTNAME},
{"https://1.0x1000000", "https://1.0x1000000/", 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},
/* 41 bytes scheme is not allowed */
{"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA://hostname/path",
"",
- CURLU_NON_SUPPORT_SCHEME, 0, CURLUE_MALFORMED_INPUT},
+ CURLU_NON_SUPPORT_SCHEME, 0, CURLUE_BAD_SCHEME},
{"https://[fe80::20c:29ff:fe9c:409b%]:1234",
"",
- 0, 0, CURLUE_MALFORMED_INPUT},
+ 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},
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: 123/", "", 0, 0, CURLUE_BAD_PORT_NUMBER},
+ {"http:/@example.com:123 /", "", 0, 0, CURLUE_BAD_PORT_NUMBER},
{"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},
+ {"http://host/file\r", "", 0, 0, CURLUE_BAD_PATH},
+ {"http://host/file\n\x03", "", 0, 0, CURLUE_BAD_PATH},
{"htt\x02://host/file", "",
- CURLU_NON_SUPPORT_SCHEME, 0, CURLUE_MALFORMED_INPUT},
- {" http://host/file", "", 0, 0, CURLUE_MALFORMED_INPUT},
+ CURLU_NON_SUPPORT_SCHEME, 0, CURLUE_BAD_SCHEME},
+ {" http://host/file", "", 0, 0, CURLUE_BAD_SCHEME},
/* 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},
{"file:./",
"file://",
- 0, 0, CURLUE_MALFORMED_INPUT},
+ 0, 0, CURLUE_BAD_SCHEME},
{"http://example.com/hello/../here",
"http://example.com/hello/../here",
CURLU_PATH_AS_IS, 0, CURLUE_OK},
CURLU_DEFAULT_SCHEME, 0, CURLUE_OK},
{"example.com/path/html",
"",
- 0, 0, CURLUE_MALFORMED_INPUT},
+ 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},
CURLU_NON_SUPPORT_SCHEME, 0, CURLUE_OK},
{"custom-scheme://?expected=test-bad",
"",
- CURLU_NON_SUPPORT_SCHEME, 0, CURLUE_MALFORMED_INPUT},
+ 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},
/* 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_MALFORMED_INPUT},
+ 0, CURLU_NON_SUPPORT_SCHEME, CURLUE_OK, CURLUE_BAD_SCHEME},
{"https://example.com/",
/* set a 40 bytes scheme */
"scheme=bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,",
{"https://host:1234/",
"port=56 78,",
"https://host:1234/",
- 0, 0, CURLUE_OK, CURLUE_MALFORMED_INPUT},
+ 0, 0, CURLUE_OK, CURLUE_BAD_PORT_NUMBER},
{"https://host:1234/",
"port=0,",
"https://host:1234/",
{NULL,
"scheme=https,host= ,path= ,user= ,password= ,query= ,fragment= ,",
"[nothing]",
- 0, CURLU_URLENCODE, CURLUE_OK, CURLUE_MALFORMED_INPUT},
+ 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",
"host=\"\",",
"custom-scheme://host/",
CURLU_NON_SUPPORT_SCHEME, CURLU_NON_SUPPORT_SCHEME, CURLUE_OK,
- CURLUE_MALFORMED_INPUT},
+ CURLUE_BAD_HOSTNAME},
{"custom-scheme://host",
"host=\"\",",
"custom-scheme:///",
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_OK)
+ fprintf(stderr, "unexpected return code %u on line %u\n", (int)rc,
+ __LINE__);
+
+ curl_url_cleanup(u);
+ }
+ return 0;
+}
+
int test(char *URL)
{
(void)URL; /* not used */
+ if(get_nothing())
+ return 7;
+
if(scopeid())
return 6;
projects / thirdparty / curl.git / commitdiff
