#define C_SSLVERSION_VALUE(x) (x & 0xffff)
#define C_SSLVERSION_MAX_VALUE(x) (x & 0xffff0000)
-static CURLcode protocol2num(char *str, curl_prot_t *val)
+static CURLcode protocol2num(const char *str, curl_prot_t *val)
{
- bool found_comma = FALSE;
- static struct scheme {
- const char *name;
- curl_prot_t bit;
- } const protos[] = {
- { "dict", CURLPROTO_DICT },
- { "file", CURLPROTO_FILE },
- { "ftp", CURLPROTO_FTP },
- { "ftps", CURLPROTO_FTPS },
- { "gopher", CURLPROTO_GOPHER },
- { "gophers", CURLPROTO_GOPHERS },
- { "http", CURLPROTO_HTTP },
- { "https", CURLPROTO_HTTPS },
- { "imap", CURLPROTO_IMAP },
- { "imaps", CURLPROTO_IMAPS },
- { "ldap", CURLPROTO_LDAP },
- { "ldaps", CURLPROTO_LDAPS },
- { "mqtt", CURLPROTO_MQTT },
- { "pop3", CURLPROTO_POP3 },
- { "pop3s", CURLPROTO_POP3S },
- { "rtmp", CURLPROTO_RTMP },
- { "rtmpe", CURLPROTO_RTMPE },
- { "rtmps", CURLPROTO_RTMPS },
- { "rtmpt", CURLPROTO_RTMPT },
- { "rtmpte", CURLPROTO_RTMPTE },
- { "rtmpts", CURLPROTO_RTMPTS },
- { "rtsp", CURLPROTO_RTSP },
- { "scp", CURLPROTO_SCP },
- { "sftp", CURLPROTO_SFTP },
- { "smb", CURLPROTO_SMB },
- { "smbs", CURLPROTO_SMBS },
- { "smtp", CURLPROTO_SMTP },
- { "smtps", CURLPROTO_SMTPS },
- { "telnet", CURLPROTO_TELNET },
- { "tftp", CURLPROTO_TFTP },
-#ifdef USE_WEBSOCKETS
- { "ws", CURLPROTO_WS },
- { "wss", CURLPROTO_WSS },
-#endif
- { NULL, 0 }
- };
-
if(!str)
return CURLE_BAD_FUNCTION_ARGUMENT;
- else if(curl_strequal(str, "all")) {
- *val = (curl_prot_t)~0;
+
+ if(curl_strequal(str, "all")) {
+ *val = ~(curl_prot_t) 0;
return CURLE_OK;
}
*val = 0;
do {
+ const char *token = str;
size_t tlen;
- struct scheme const *pp;
- char *token;
- token = strchr(str, ',');
- found_comma = token ? TRUE : FALSE;
- if(!token)
- token = strchr(str, '\0');
- tlen = token - str;
+
+ str = strchr(str, ',');
+ tlen = str? (size_t) (str - token): strlen(token);
if(tlen) {
- for(pp = protos; pp->name; pp++) {
- if((strlen(pp->name) == tlen) &&
- curl_strnequal(str, pp->name, tlen)) {
- *val |= pp->bit;
- break;
- }
- }
- if(!(pp->name))
- /* protocol name didn't match */
- return CURLE_BAD_FUNCTION_ARGUMENT;
+ const struct Curl_handler *h = Curl_builtin_scheme(token, tlen);
+
+ if(!h)
+ return CURLE_UNSUPPORTED_PROTOCOL;
+
+ *val |= h->protocol;
}
- if(found_comma)
- str = token + 1;
- } while(found_comma);
+ } while(str++);
+
if(!*val)
- /* no matching protocol */
+ /* no protocol listed */
return CURLE_BAD_FUNCTION_ARGUMENT;
return CURLE_OK;
}
return Curl_uc_to_curlcode(uc);
}
- p = Curl_builtin_scheme(scheme);
+ p = Curl_builtin_scheme(scheme, CURL_ZERO_TERMINATED);
if(p && (p->protocol != data->info.conn_protocol)) {
infof(data, "Clear auth, redirects scheme from %s to %s",
data->info.conn_scheme, scheme);
}
/* returns the handler if the given scheme is built-in */
-const struct Curl_handler *Curl_builtin_scheme(const char *scheme)
+const struct Curl_handler *Curl_builtin_scheme(const char *scheme,
+ size_t schemelen)
{
const struct Curl_handler * const *pp;
const struct Curl_handler *p;
/* Scan protocol handler table and match against 'scheme'. The handler may
be changed later when the protocol specific setup function is called. */
+ if(schemelen == CURL_ZERO_TERMINATED)
+ schemelen = strlen(scheme);
for(pp = protocols; (p = *pp) != NULL; pp++)
- if(strcasecompare(p->scheme, scheme))
- /* Protocol found in table. Check if allowed */
+ if(strncasecompare(p->scheme, scheme, schemelen) && !p->scheme[schemelen])
+ /* Protocol found in table. */
return p;
return NULL; /* not found */
}
struct connectdata *conn,
const char *protostr)
{
- const struct Curl_handler *p = Curl_builtin_scheme(protostr);
+ const struct Curl_handler *p = Curl_builtin_scheme(protostr,
+ CURL_ZERO_TERMINATED);
if(p && /* Protocol found in table. Check if allowed */
(data->set.allowed_protocols & p->protocol)) {
char **userptr, char **passwdptr,
char **optionsptr);
-const struct Curl_handler *Curl_builtin_scheme(const char *scheme);
+const struct Curl_handler *Curl_builtin_scheme(const char *scheme,
+ size_t schemelen);
bool Curl_is_ASCII_name(const char *hostname);
CURLcode Curl_idnconvert_hostname(struct Curl_easy *data,
/* if this is a known scheme, get some details */
if(u->scheme)
- h = Curl_builtin_scheme(u->scheme);
+ h = Curl_builtin_scheme(u->scheme, CURL_ZERO_TERMINATED);
/* We could use the login information in the URL so extract it. Only parse
options if the handler says we should. Note that 'h' might be NULL! */
}
schemep = schemebuf;
- if(!Curl_builtin_scheme(schemep) &&
+ if(!Curl_builtin_scheme(schemep, CURL_ZERO_TERMINATED) &&
!(flags & CURLU_NON_SUPPORT_SCHEME)) {
result = CURLUE_UNSUPPORTED_SCHEME;
goto fail;
/* there's no stored port number, but asked to deliver
a default one for the scheme */
const struct Curl_handler *h =
- Curl_builtin_scheme(u->scheme);
+ Curl_builtin_scheme(u->scheme, CURL_ZERO_TERMINATED);
if(h) {
msnprintf(portbuf, sizeof(portbuf), "%u", h->defport);
ptr = portbuf;
/* there is a stored port number, but ask to inhibit if
it matches the default one for the scheme */
const struct Curl_handler *h =
- Curl_builtin_scheme(u->scheme);
+ Curl_builtin_scheme(u->scheme, CURL_ZERO_TERMINATED);
if(h && (h->defport == u->portnum) &&
(flags & CURLU_NO_DEFAULT_PORT))
ptr = NULL;
else
return CURLUE_NO_SCHEME;
- h = Curl_builtin_scheme(scheme);
+ h = Curl_builtin_scheme(scheme, CURL_ZERO_TERMINATED);
if(!port && (flags & CURLU_DEFAULT_PORT)) {
/* there's no stored port number, but asked to deliver
a default one for the scheme */
return CURLUE_BAD_SCHEME;
if(!(flags & CURLU_NON_SUPPORT_SCHEME) &&
/* verify that it is a fine scheme */
- !Curl_builtin_scheme(part))
+ !Curl_builtin_scheme(part, CURL_ZERO_TERMINATED))
return CURLUE_UNSUPPORTED_SCHEME;
storep = &u->scheme;
urlencode = FALSE; /* never */
<name>
--libcurl for GET with various options
</name>
+<features>
+http
+ftp
+file
+</features>
<setenv>
SSL_CERT_FILE=
</setenv>
struct pair {
const char *in;
- CURLcode exp;
+ CURLcode *exp;
};
int test(char *URL)
CURL *curl = NULL;
int res = 0;
CURLcode result = CURLE_OK;
+ CURLcode ok = CURLE_OK;
+ CURLcode bad = CURLE_BAD_FUNCTION_ARGUMENT;
+ CURLcode unsup = CURLE_UNSUPPORTED_PROTOCOL;
+ CURLcode httpcode = CURLE_UNSUPPORTED_PROTOCOL;
+ CURLcode httpscode = CURLE_UNSUPPORTED_PROTOCOL;
+ curl_version_info_data *curlinfo;
+ const char *const *proto;
+ char protolist[1024];
+ int n;
int i;
struct pair prots[] = {
- {"goobar", CURLE_BAD_FUNCTION_ARGUMENT},
- {"http ", CURLE_BAD_FUNCTION_ARGUMENT},
- {" http", CURLE_BAD_FUNCTION_ARGUMENT},
- {"http", CURLE_OK},
- {"http,", CURLE_OK},
- {"https,", CURLE_OK},
- {"https,http", CURLE_OK},
- {"http,http", CURLE_OK},
- {"HTTP,HTTP", CURLE_OK},
- {",HTTP,HTTP", CURLE_OK},
- {"http,http,ft", CURLE_BAD_FUNCTION_ARGUMENT},
- {"", CURLE_BAD_FUNCTION_ARGUMENT},
- {",,", CURLE_BAD_FUNCTION_ARGUMENT},
- {"DICT,FILE,FTP,FTPS,GOPHER,GOPHERS,HTTP,HTTPS,IMAP,IMAPS,LDAP,LDAPS,"
- "POP3,POP3S,RTMP,RTMPE,RTMPS,RTMPT,RTMPTE,RTMPTS,RTSP,SCP,SFTP,SMB,"
- "SMBS,SMTP,SMTPS,TELNET,TFTP", CURLE_OK},
- {"all", CURLE_OK},
- {NULL, CURLE_OK},
+ {"goobar", &unsup},
+ {"http ", &unsup},
+ {" http", &unsup},
+ {"http", &httpcode},
+ {"http,", &httpcode},
+ {"https,", &httpscode},
+ {"https,http", &httpscode},
+ {"http,http", &httpcode},
+ {"HTTP,HTTP", &httpcode},
+ {",HTTP,HTTP", &httpcode},
+ {"http,http,ft", &unsup},
+ {"", &bad},
+ {",,", &bad},
+ {protolist, &ok},
+ {"all", &ok},
+ {NULL, NULL},
};
(void)URL;
easy_init(curl);
+ /* Get enabled protocols.*/
+ curlinfo = curl_version_info(CURLVERSION_NOW);
+ if(!curlinfo) {
+ fputs("curl_version_info failed\n", stderr);
+ res = (int) TEST_ERR_FAILURE;
+ goto test_cleanup;
+ }
+
+ n = 0;
+ for(proto = curlinfo->protocols; *proto; proto++) {
+ if((size_t) n >= sizeof(protolist)) {
+ puts("protolist buffer too small\n");
+ res = (int) TEST_ERR_FAILURE;
+ goto test_cleanup;
+ }
+ n += msnprintf(protolist + n, sizeof(protolist) - n, ",%s", *proto);
+ if(curl_strequal(*proto, "http"))
+ httpcode = CURLE_OK;
+ if(curl_strequal(*proto, "https"))
+ httpscode = CURLE_OK;
+ }
+
+ /* Run the tests. */
for(i = 0; prots[i].in; i++) {
result = curl_easy_setopt(curl, CURLOPT_PROTOCOLS_STR, prots[i].in);
- if(result != prots[i].exp) {
+ if(result != *prots[i].exp) {
printf("unexpectedly '%s' returned %u\n",
prots[i].in, result);
break;
case CURLE_BAD_FUNCTION_ARGUMENT: /* the most normal */
case CURLE_UNKNOWN_OPTION: /* left out from the build */
case CURLE_NOT_BUILT_IN: /* not supported */
+ case CURLE_UNSUPPORTED_PROTOCOL: /* detected by protocol2num() */
break;
default:
/* all other return codes are unexpected */
projects / thirdparty / curl.git / commitdiff
