#include "urldata.h"
#include "altsvc.h"
#include "curl_get_line.h"
-#include "strcase.h"
#include "parsedate.h"
#include "sendf.h"
#include "curlx/warnless.h"
if(hlen != clen)
/* they cannot match if they have different lengths */
return FALSE;
- return strncasecompare(host, check, hlen);
+ return curl_strnequal(host, check, hlen);
}
/* altsvc_flush() removes all alternatives for this source origin from the
#include "sigpipe.h"
#include "connect.h"
#include "select.h"
-#include "strcase.h"
#include "curlx/strparse.h"
#include "uint-table.h"
#include "vquic/vquic.h" /* for quic cfilters */
#include "http_proxy.h"
#include "socks.h"
-#include "strcase.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
enum alpnid Curl_alpn2alpnid(const char *name, size_t len)
{
if(len == 2) {
- if(strncasecompare(name, "h1", 2))
+ if(curl_strnequal(name, "h1", 2))
return ALPN_h1;
- if(strncasecompare(name, "h2", 2))
+ if(curl_strnequal(name, "h2", 2))
return ALPN_h2;
- if(strncasecompare(name, "h3", 2))
+ if(curl_strnequal(name, "h3", 2))
return ALPN_h3;
}
else if(len == 8) {
- if(strncasecompare(name, "http/1.1", 8))
+ if(curl_strnequal(name, "http/1.1", 8))
return ALPN_h1;
}
return ALPN_none; /* unknown, probably rubbish input */
#include "http.h"
#include "content_encoding.h"
#include "strdup.h"
-#include "strcase.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
for(cep = general_unencoders; *cep; cep++) {
ce = *cep;
- if(!strcasecompare(ce->name, CONTENT_ENCODING_DEFAULT))
+ if(!curl_strequal(ce->name, CONTENT_ENCODING_DEFAULT))
len += strlen(ce->name) + 2;
}
char *p = buf;
for(cep = general_unencoders; *cep; cep++) {
ce = *cep;
- if(!strcasecompare(ce->name, CONTENT_ENCODING_DEFAULT)) {
+ if(!curl_strequal(ce->name, CONTENT_ENCODING_DEFAULT)) {
strcpy(p, ce->name);
p += strlen(p);
*p++ = ',';
if(phase == CURL_CW_TRANSFER_DECODE) {
for(cep = transfer_unencoders; *cep; cep++) {
const struct Curl_cwtype *ce = *cep;
- if((strncasecompare(name, ce->name, len) && !ce->name[len]) ||
- (ce->alias && strncasecompare(name, ce->alias, len)
+ if((curl_strnequal(name, ce->name, len) && !ce->name[len]) ||
+ (ce->alias && curl_strnequal(name, ce->alias, len)
&& !ce->alias[len]))
return ce;
}
/* look among the general decoders */
for(cep = general_unencoders; *cep; cep++) {
const struct Curl_cwtype *ce = *cep;
- if((strncasecompare(name, ce->name, len) && !ce->name[len]) ||
- (ce->alias && strncasecompare(name, ce->alias, len) && !ce->alias[len]))
+ if((curl_strnequal(name, ce->name, len) && !ce->name[len]) ||
+ (ce->alias && curl_strnequal(name, ce->alias, len) && !ce->alias[len]))
return ce;
}
return NULL;
CURL_TRC_WRITE(data, "looking for %s decoder: %.*s",
is_transfer ? "transfer" : "content", (int)namelen, name);
is_chunked = (is_transfer && (namelen == 7) &&
- strncasecompare(name, "chunked", 7));
+ curl_strnequal(name, "chunked", 7));
/* if we skip the decoding in this phase, do not look further.
* Exception is "chunked" transfer-encoding which always must happen */
if((is_transfer && !data->set.http_transfer_encoding && !is_chunked) ||
(!is_transfer && data->set.http_ce_skip)) {
- bool is_identity = strncasecompare(name, "identity", 8);
+ bool is_identity = curl_strnequal(name, "identity", 8);
/* not requested, ignore */
CURL_TRC_WRITE(data, "decoder not requested, ignored: %.*s",
(int)namelen, name);
if(hostname_len < cookie_domain_len)
return FALSE;
- if(!strncasecompare(cookie_domain,
- hostname + hostname_len-cookie_domain_len,
- cookie_domain_len))
+ if(!curl_strnequal(cookie_domain,
+ hostname + hostname_len-cookie_domain_len,
+ cookie_domain_len))
return FALSE;
/*
/* Make sure domain contains a dot or is localhost. */
static bool bad_domain(const char *domain, size_t len)
{
- if((len == 9) && strncasecompare(domain, "localhost", 9))
+ if((len == 9) && curl_strnequal(domain, "localhost", 9))
return FALSE;
else {
/* there must be a dot present, but that dot must not be a trailing dot */
* domain can access the variable. Set TRUE when the cookie says
* .example.com and to false when the domain is complete www.example.com
*/
- co->tailmatch = !!strncasecompare(ptr, "TRUE", len);
+ co->tailmatch = !!curl_strnequal(ptr, "TRUE", len);
break;
case 2:
/* The file format allows the path field to remain not filled in */
FALLTHROUGH();
case 3:
co->secure = FALSE;
- if(strncasecompare(ptr, "TRUE", len)) {
+ if(curl_strnequal(ptr, "TRUE", len)) {
if(secure || ci->running)
co->secure = TRUE;
else
return CERR_OUT_OF_MEMORY;
else {
/* For Netscape file format cookies we check prefix on the name */
- if(strncasecompare("__Secure-", co->name, 9))
+ if(curl_strnequal("__Secure-", co->name, 9))
co->prefix_secure = TRUE;
- else if(strncasecompare("__Host-", co->name, 7))
+ else if(curl_strnequal("__Host-", co->name, 7))
co->prefix_host = TRUE;
}
break;
bool matching_domains = FALSE;
if(clist->domain && co->domain) {
- if(strcasecompare(clist->domain, co->domain))
+ if(curl_strequal(clist->domain, co->domain))
/* The domains are identical */
matching_domains = TRUE;
}
else
cllen = strlen(clist->spath);
- if(strncasecompare(clist->spath, co->spath, cllen)) {
+ if(curl_strnequal(clist->spath, co->spath, cllen)) {
infof(data, "cookie '%s' for domain '%s' dropped, would "
"overlay an existing cookie", co->name, co->domain);
return CERR_BAD_SECURE;
/* the names are identical */
if(clist->domain && co->domain) {
- if(strcasecompare(clist->domain, co->domain) &&
+ if(curl_strequal(clist->domain, co->domain) &&
(clist->tailmatch == co->tailmatch))
/* The domains are identical */
replace_old = TRUE;
/* the domains were identical */
if(clist->spath && co->spath &&
- !strcasecompare(clist->spath, co->spath))
+ !curl_strequal(clist->spath, co->spath))
replace_old = FALSE;
else if(!clist->spath != !co->spath)
replace_old = FALSE;
if(!co->domain ||
(co->tailmatch && !is_ip &&
cookie_tailmatch(co->domain, strlen(co->domain), host)) ||
- ((!co->tailmatch || is_ip) && strcasecompare(host, co->domain)) ) {
+ ((!co->tailmatch || is_ip) && curl_strequal(host, co->domain)) ) {
/*
* the right part of the host matches the domain stuff in the
* cookie data
#include "sigpipe.h"
#include "connect.h"
#include "select.h"
-#include "strcase.h"
#include "curlx/strparse.h"
/* The last 3 #include files should be in this order */
#include "easyif.h"
#include "cfilters.h"
#include "multiif.h"
-#include "strcase.h"
#include "cf-socket.h"
#include "connect.h"
***************************************************************************/
#include "strparse.h"
-#include "../strcase.h"
+
+#ifndef WITHOUT_LIBCURL
+#include <curl/curl.h> /* for curl_strnequal() */
+#endif
void curlx_str_init(struct Curl_str *out)
{
int curlx_str_casecompare(struct Curl_str *str, const char *check)
{
size_t clen = check ? strlen(check) : 0;
- return ((str->len == clen) && strncasecompare(str->str, check, clen));
+ return ((str->len == clen) && curl_strnequal(str->str, check, clen));
}
#endif
#include "progress.h"
#include "dict.h"
#include "curl_printf.h"
-#include "strcase.h"
#include "curl_memory.h"
/* The last #include file should be: */
#include "memdebug.h"
if(result)
return result;
- if(strncasecompare(path, DICT_MATCH, sizeof(DICT_MATCH)-1) ||
- strncasecompare(path, DICT_MATCH2, sizeof(DICT_MATCH2)-1) ||
- strncasecompare(path, DICT_MATCH3, sizeof(DICT_MATCH3)-1)) {
+ if(curl_strnequal(path, DICT_MATCH, sizeof(DICT_MATCH)-1) ||
+ curl_strnequal(path, DICT_MATCH2, sizeof(DICT_MATCH2)-1) ||
+ curl_strnequal(path, DICT_MATCH3, sizeof(DICT_MATCH3)-1)) {
word = strchr(path, ':');
if(word) {
}
Curl_xfer_setup1(data, CURL_XFER_RECV, -1, FALSE); /* no upload */
}
- else if(strncasecompare(path, DICT_DEFINE, sizeof(DICT_DEFINE)-1) ||
- strncasecompare(path, DICT_DEFINE2, sizeof(DICT_DEFINE2)-1) ||
- strncasecompare(path, DICT_DEFINE3, sizeof(DICT_DEFINE3)-1)) {
+ else if(curl_strnequal(path, DICT_DEFINE, sizeof(DICT_DEFINE)-1) ||
+ curl_strnequal(path, DICT_DEFINE2, sizeof(DICT_DEFINE2)-1) ||
+ curl_strnequal(path, DICT_DEFINE3, sizeof(DICT_DEFINE3)-1)) {
word = strchr(path, ':');
if(word) {
size_t i;
for(i = 0; i < dynhds->hds_len; ++i) {
if(dynhds->hds[i]->namelen == namelen &&
- strncasecompare(dynhds->hds[i]->name, name, namelen)) {
+ curl_strnequal(dynhds->hds[i]->name, name, namelen)) {
return dynhds->hds[i];
}
}
size_t i;
for(i = 0; i < dynhds->hds_len; ++i) {
if((namelen == dynhds->hds[i]->namelen) &&
- strncasecompare(name, dynhds->hds[i]->name, namelen))
+ curl_strnequal(name, dynhds->hds[i]->name, namelen))
++n;
}
}
size_t i, len;
for(i = 0; i < dynhds->hds_len; ++i) {
if((namelen == dynhds->hds[i]->namelen) &&
- strncasecompare(name, dynhds->hds[i]->name, namelen)) {
+ curl_strnequal(name, dynhds->hds[i]->name, namelen)) {
++n;
--dynhds->hds_len;
dynhds->strs_len -= (dynhds->hds[i]->namelen +
***************************************************************************/
#include "curl_setup.h"
-#include "strcase.h"
#include "easyoptions.h"
#ifndef CURL_DISABLE_GETOPTIONS
const struct curl_easyoption *o = &Curl_easyopts[0];
do {
if(name) {
- if(strcasecompare(o->name, name))
+ if(curl_strequal(o->name, name))
return o;
}
else {
#include "urldata.h" /* for struct Curl_easy */
#include "mime.h"
#include "vtls/vtls.h"
-#include "strcase.h"
#include "sendf.h"
#include "strdup.h"
#include "rand.h"
return CURLE_OUT_OF_MEMORY;
/* Check for special servers here. */
- if(strcasecompare(os, "OS/400")) {
+ if(curl_strequal(os, "OS/400")) {
/* Force OS400 name format 1. */
result = Curl_pp_sendf(data, &ftpc->pp, "%s", "SITE NAMEFMT 1");
if(result) {
#include "urldata.h"
#include "strdup.h"
-#include "strcase.h"
#include "sendf.h"
#include "headers.h"
#include "curlx/strparse.h"
/* we need a first round to count amount of this header */
for(e = Curl_llist_head(&data->state.httphdrs); e; e = Curl_node_next(e)) {
hs = Curl_node_elem(e);
- if(strcasecompare(hs->name, name) &&
+ if(curl_strequal(hs->name, name) &&
(hs->type & type) &&
(hs->request == request)) {
amount++;
else {
for(e = Curl_llist_head(&data->state.httphdrs); e; e = Curl_node_next(e)) {
hs = Curl_node_elem(e);
- if(strcasecompare(hs->name, name) &&
+ if(curl_strequal(hs->name, name) &&
(hs->type & type) &&
(hs->request == request) &&
(match++ == nameindex)) {
the index for the currently selected entry */
for(e = Curl_llist_head(&data->state.httphdrs); e; e = Curl_node_next(e)) {
struct Curl_header_store *check = Curl_node_elem(e);
- if(strcasecompare(hs->name, check->name) &&
+ if(curl_strequal(hs->name, check->name) &&
(check->request == request) &&
(check->type & type))
amount++;
{
if(plen > flen)
return FALSE;
- return strncasecompare(part, &full[flen - plen], plen);
+ return curl_strnequal(part, &full[flen - plen], plen);
}
static struct Curl_addrinfo *
goto error;
if(!is_ipaddr &&
- (strcasecompare(hostname, "localhost") ||
- strcasecompare(hostname, "localhost.") ||
+ (curl_strequal(hostname, "localhost") ||
+ curl_strequal(hostname, "localhost.") ||
tailmatch(hostname, hostname_len, STRCONST(".localhost")) ||
tailmatch(hostname, hostname_len, STRCONST(".localhost.")))) {
addr = get_localhost(port, hostname);
#include "llist.h"
#include "hsts.h"
#include "curl_get_line.h"
-#include "strcase.h"
#include "sendf.h"
#include "parsedate.h"
#include "fopen.h"
do {
curlx_str_passblanks(&p);
- if(strncasecompare("max-age", p, 7)) {
+ if(curl_strnequal("max-age", p, 7)) {
bool quoted = FALSE;
int rc;
}
gotma = TRUE;
}
- else if(strncasecompare("includesubdomains", p, 17)) {
+ else if(curl_strnequal("includesubdomains", p, 17)) {
if(gotinc)
return CURLE_BAD_FUNCTION_ARGUMENT;
subdomains = TRUE;
if((subdomain && sts->includeSubDomains) && (ntail < hlen)) {
size_t offs = hlen - ntail;
if((hostname[offs-1] == '.') &&
- strncasecompare(&hostname[offs], sts->host, ntail) &&
+ curl_strnequal(&hostname[offs], sts->host, ntail) &&
(ntail > blen)) {
/* save the tail match with the longest tail */
bestsub = sts;
blen = ntail;
}
}
- /* avoid strcasecompare because the host name is not null-terminated */
- if((hlen == ntail) && strncasecompare(hostname, sts->host, hlen))
+ /* avoid curl_strequal because the host name is not null-terminated */
+ if((hlen == ntail) && curl_strnequal(hostname, sts->host, hlen))
return sts;
}
}
for(head = (conn->bits.proxy && data->set.sep_headers) ?
data->set.proxyheaders : data->set.headers;
head; head = head->next) {
- if(strncasecompare(head->data, thisheader, thislen) &&
+ if(curl_strnequal(head->data, thisheader, thislen) &&
Curl_headersep(head->data[thislen]))
return head->data;
}
{
/* the auth string must not have an alnum following */
size_t n = strlen(auth);
- return strncasecompare(auth, line, n) && !ISALNUM(line[n]);
+ return curl_strnequal(auth, line, n) && !ISALNUM(line[n]);
}
#endif
DEBUGASSERT(header);
DEBUGASSERT(content);
- if(!strncasecompare(headerline, header, hlen))
+ if(!curl_strnequal(headerline, header, hlen))
return FALSE; /* does not start with header */
/* pass the header */
size_t len;
p = curlx_str(&val);
for(len = curlx_strlen(&val); len >= curlx_strlen(&val); len--, p++) {
- if(strncasecompare(p, content, clen))
+ if(curl_strnequal(p, content, clen))
return TRUE; /* match! */
}
}
ptr = Curl_checkheaders(data, STRCONST("Host"));
if(ptr && (!data->state.this_is_a_follow ||
- strcasecompare(data->state.first_host, conn->host.name))) {
+ curl_strequal(data->state.first_host, conn->host.name))) {
#if !defined(CURL_DISABLE_COOKIES)
/* If we have a given custom Host: header, we extract the hostname in
order to possibly use it for cookie reasons later on. We only allow the
}
#endif
- if(!strcasecompare("Host:", ptr)) {
+ if(!curl_strequal("Host:", ptr)) {
aptr->host = aprintf("Host:%s\r\n", &ptr[5]);
if(!aptr->host)
return CURLE_OUT_OF_MEMORY;
return CURLE_OUT_OF_MEMORY;
}
- if(strcasecompare("http", data->state.up.scheme)) {
+ if(curl_strequal("http", data->state.up.scheme)) {
/* when getting HTTP, we do not want the userinfo the URL */
uc = curl_url_set(h, CURLUPART_USER, NULL, 0);
if(uc) {
if(result)
return result;
- if(strcasecompare("ftp", data->state.up.scheme)) {
+ if(curl_strequal("ftp", data->state.up.scheme)) {
if(data->set.proxy_transfer_mode) {
/* when doing ftp, append ;type=<a|i> if not present */
char *type = strstr(path, ";type=");
data->state.aptr.cookiehost : conn->host.name;
const bool secure_context =
conn->handler->protocol&(CURLPROTO_HTTPS|CURLPROTO_WSS) ||
- strcasecompare("localhost", host) ||
+ curl_strequal("localhost", host) ||
!strcmp(host, "127.0.0.1") ||
!strcmp(host, "::1");
Curl_share_lock(data, CURL_LOCK_DATA_COOKIE, CURL_LOCK_ACCESS_SINGLE);
data->state.aptr.cookiehost : conn->host.name;
const bool secure_context =
conn->handler->protocol&(CURLPROTO_HTTPS|CURLPROTO_WSS) ||
- strcasecompare("localhost", host) ||
+ curl_strequal("localhost", host) ||
!strcmp(host, "127.0.0.1") ||
!strcmp(host, "::1");
if(e->namelen < H2_NON_FIELD[i].namelen)
return TRUE;
if(e->namelen == H2_NON_FIELD[i].namelen &&
- strcasecompare(H2_NON_FIELD[i].name, e->name))
+ curl_strequal(H2_NON_FIELD[i].name, e->name))
return FALSE;
}
return TRUE;
e = Curl_dynhds_getn(&req->headers, i);
/* "TE" is special in that it is only permissible when it
* has only value "trailers". RFC 9113 ch. 8.2.2 */
- if(e->namelen == 2 && strcasecompare("TE", e->name)) {
+ if(e->namelen == 2 && curl_strequal("TE", e->name)) {
if(http_TE_has_token(e->value, "trailers"))
result = Curl_dynhds_add(h2_headers, e->name, e->namelen,
"trailers", sizeof("trailers") - 1);
#include "sendf.h"
#include "select.h"
#include "curlx/base64.h"
-#include "strcase.h"
#include "multiif.h"
#include "url.h"
#include "urlapi-int.h"
if(!check)
/* no memory */
return NGHTTP2_ERR_CALLBACK_FAILURE;
- if(!strcasecompare(check, (const char *)value) &&
+ if(!curl_strequal(check, (const char *)value) &&
((cf->conn->remote_port != cf->conn->given->defport) ||
- !strcasecompare(cf->conn->host.name, (const char *)value))) {
+ !curl_strequal(cf->conn->host.name, (const char *)value))) {
/* This is push is not for the same authority that was asked for in
* the URL. RFC 7540 section 8.2 says: "A client MUST treat a
* PUSH_PROMISE for which the server is not authoritative as a stream
#include "cf-h1-proxy.h"
#include "cf-h2-proxy.h"
#include "connect.h"
-#include "strcase.h"
#include "vtls/vtls.h"
#include "transfer.h"
#include "multiif.h"
static bool hd_name_eq(const char *n1, size_t n1len,
const char *n2, size_t n2len)
{
- return (n1len == n2len) ? strncasecompare(n1, n2, n1len) : FALSE;
+ return (n1len == n2len) ? curl_strnequal(n1, n2, n1len) : FALSE;
}
static CURLcode dynhds_add_custom(struct Curl_easy *data,
#endif
#include "curlx/inet_ntop.h"
-#include "strcase.h"
#include "if2ip.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
for(iface = head; iface != NULL; iface = iface->ifa_next) {
if(iface->ifa_addr) {
if(iface->ifa_addr->sa_family == af) {
- if(strcasecompare(iface->ifa_name, interf)) {
+ if(curl_strequal(iface->ifa_name, interf)) {
void *addr;
const char *ip;
char scope[12] = "";
}
}
else if((res == IF2IP_NOT_FOUND) &&
- strcasecompare(iface->ifa_name, interf)) {
+ curl_strequal(iface->ifa_name, interf)) {
res = IF2IP_AF_NOT_SUPPORTED;
}
}
/* Does the command name match and is it followed by a space character or at
the end of line? */
- if(line + cmd_len <= end && strncasecompare(line, cmd, cmd_len) &&
+ if(line + cmd_len <= end && curl_strnequal(line, cmd, cmd_len) &&
(line[cmd_len] == ' ' || line + cmd_len + 2 == end))
return TRUE;
case IMAP_LIST:
if((!imap->custom && !imap_matchresp(line, len, "LIST")) ||
(imap->custom && !imap_matchresp(line, len, imap->custom) &&
- (!strcasecompare(imap->custom, "STORE") ||
+ (!curl_strequal(imap->custom, "STORE") ||
!imap_matchresp(line, len, "FETCH")) &&
- !strcasecompare(imap->custom, "SELECT") &&
- !strcasecompare(imap->custom, "EXAMINE") &&
- !strcasecompare(imap->custom, "SEARCH") &&
- !strcasecompare(imap->custom, "EXPUNGE") &&
- !strcasecompare(imap->custom, "LSUB") &&
- !strcasecompare(imap->custom, "UID") &&
- !strcasecompare(imap->custom, "GETQUOTAROOT") &&
- !strcasecompare(imap->custom, "NOOP")))
+ !curl_strequal(imap->custom, "SELECT") &&
+ !curl_strequal(imap->custom, "EXAMINE") &&
+ !curl_strequal(imap->custom, "SEARCH") &&
+ !curl_strequal(imap->custom, "EXPUNGE") &&
+ !curl_strequal(imap->custom, "LSUB") &&
+ !curl_strequal(imap->custom, "UID") &&
+ !curl_strequal(imap->custom, "GETQUOTAROOT") &&
+ !curl_strequal(imap->custom, "NOOP")))
return FALSE;
break;
else if(imapcode == IMAP_RESP_OK) {
/* Check if the UIDVALIDITY has been specified and matches */
if(imap->uidvalidity && imapc->mailbox_uidvalidity &&
- !strcasecompare(imap->uidvalidity, imapc->mailbox_uidvalidity)) {
+ !curl_strequal(imap->uidvalidity, imapc->mailbox_uidvalidity)) {
failf(data, "Mailbox UIDVALIDITY has changed");
result = CURLE_REMOTE_FILE_NOT_FOUND;
}
/* Determine if the requested mailbox (with the same UIDVALIDITY if set)
has already been selected on this connection */
if(imap->mailbox && imapc->mailbox &&
- strcasecompare(imap->mailbox, imapc->mailbox) &&
+ curl_strequal(imap->mailbox, imapc->mailbox) &&
(!imap->uidvalidity || !imapc->mailbox_uidvalidity ||
- strcasecompare(imap->uidvalidity, imapc->mailbox_uidvalidity)))
+ curl_strequal(imap->uidvalidity, imapc->mailbox_uidvalidity)))
selected = TRUE;
/* Start the first command in the DO phase */
while(*ptr && *ptr != ';')
ptr++;
- if(strncasecompare(key, "AUTH=+LOGIN", 11)) {
+ if(curl_strnequal(key, "AUTH=+LOGIN", 11)) {
/* User prefers plaintext LOGIN over any SASL, including SASL LOGIN */
prefer_login = TRUE;
imapc->sasl.prefmech = SASL_AUTH_NONE;
}
- else if(strncasecompare(key, "AUTH=", 5)) {
+ else if(curl_strnequal(key, "AUTH=", 5)) {
prefer_login = FALSE;
result = Curl_sasl_parse_url_auth_option(&imapc->sasl,
value, ptr - value);
PARTIAL) stripping of the trailing slash character if it is present.
Note: Unknown parameters trigger a URL_MALFORMAT error. */
- if(strcasecompare(name, "UIDVALIDITY") && !imap->uidvalidity) {
+ if(curl_strequal(name, "UIDVALIDITY") && !imap->uidvalidity) {
if(valuelen > 0 && value[valuelen - 1] == '/')
value[valuelen - 1] = '\0';
imap->uidvalidity = value;
value = NULL;
}
- else if(strcasecompare(name, "UID") && !imap->uid) {
+ else if(curl_strequal(name, "UID") && !imap->uid) {
if(valuelen > 0 && value[valuelen - 1] == '/')
value[valuelen - 1] = '\0';
imap->uid = value;
value = NULL;
}
- else if(strcasecompare(name, "MAILINDEX") && !imap->mindex) {
+ else if(curl_strequal(name, "MAILINDEX") && !imap->mindex) {
if(valuelen > 0 && value[valuelen - 1] == '/')
value[valuelen - 1] = '\0';
imap->mindex = value;
value = NULL;
}
- else if(strcasecompare(name, "SECTION") && !imap->section) {
+ else if(curl_strequal(name, "SECTION") && !imap->section) {
if(valuelen > 0 && value[valuelen - 1] == '/')
value[valuelen - 1] = '\0';
imap->section = value;
value = NULL;
}
- else if(strcasecompare(name, "PARTIAL") && !imap->partial) {
+ else if(curl_strequal(name, "PARTIAL") && !imap->partial) {
if(valuelen > 0 && value[valuelen - 1] == '/')
value[valuelen - 1] = '\0';
#include "transfer.h"
#include "curl_krb5.h"
#include "curlx/warnless.h"
-#include "strcase.h"
#include "strdup.h"
/* The last 3 #include files should be in this order */
#include "escape.h"
#include "progress.h"
#include "transfer.h"
-#include "strcase.h"
#include "curlx/strparse.h"
#include "curl_ldap.h"
#include "curlx/multibyte.h"
if(conn->ssl_config.verifypeer) {
/* OpenLDAP SDK supports BASE64 files. */
if((data->set.ssl.cert_type) &&
- (!strcasecompare(data->set.ssl.cert_type, "PEM"))) {
+ (!curl_strequal(data->set.ssl.cert_type, "PEM"))) {
failf(data, "LDAP local: ERROR OpenLDAP only supports PEM cert-type");
result = CURLE_SSL_CERTPROBLEM;
goto quit;
*/
static int str2scope(const char *p)
{
- if(strcasecompare(p, "one"))
+ if(curl_strequal(p, "one"))
return LDAP_SCOPE_ONELEVEL;
- if(strcasecompare(p, "onetree"))
+ if(curl_strequal(p, "onetree"))
return LDAP_SCOPE_ONELEVEL;
- if(strcasecompare(p, "base"))
+ if(curl_strequal(p, "base"))
return LDAP_SCOPE_BASE;
- if(strcasecompare(p, "sub"))
+ if(curl_strequal(p, "sub"))
return LDAP_SCOPE_SUBTREE;
- if(strcasecompare(p, "subtree"))
+ if(curl_strequal(p, "subtree"))
return LDAP_SCOPE_SUBTREE;
return -1;
}
if(!data ||
!data->state.up.path ||
data->state.up.path[0] != '/' ||
- !strncasecompare("LDAP", data->state.up.scheme, 4))
+ !curl_strnequal("LDAP", data->state.up.scheme, 4))
return LDAP_INVALID_SYNTAX;
ludp->lud_scope = LDAP_SCOPE_BASE;
#include "rand.h"
#include "slist.h"
-#include "strcase.h"
#include "curlx/dynbuf.h"
/* The last 3 #include files should be in this order */
#include "curl_printf.h"
{
char *value = NULL;
- if(strncasecompare(hdr->data, lbl, len) && hdr->data[len] == ':')
+ if(curl_strnequal(hdr->data, lbl, len) && hdr->data[len] == ':')
for(value = hdr->data + len + 1; *value == ' '; value++)
;
return value;
return CURLE_OK; /* Removing current encoder. */
for(mep = encoders; mep->name; mep++)
- if(strcasecompare(encoding, mep->name)) {
+ if(curl_strequal(encoding, mep->name)) {
part->encoder = mep;
result = CURLE_OK;
}
for(i = 0; i < CURL_ARRAYSIZE(ctts); i++) {
size_t len2 = strlen(ctts[i].extension);
- if(len1 >= len2 && strcasecompare(nameend - len2, ctts[i].extension))
+ if(len1 >= len2 && curl_strequal(nameend - len2, ctts[i].extension))
return ctts[i].type;
}
}
static bool content_type_match(const char *contenttype,
const char *target, size_t len)
{
- if(contenttype && strncasecompare(contenttype, target, len))
+ if(contenttype && curl_strnequal(contenttype, target, len))
switch(contenttype[len]) {
case '\0':
case '\t':
if(!search_header(part->userheaders, STRCONST("Content-Disposition"))) {
if(!disposition)
if(part->filename || part->name ||
- (contenttype && !strncasecompare(contenttype, "multipart/", 10)))
+ (contenttype && !curl_strnequal(contenttype, "multipart/", 10)))
disposition = DISPOSITION_DEFAULT;
if(disposition && curl_strequal(disposition, "attachment") &&
!part->name && !part->filename)
switch(state) {
case NOTHING:
- if(strcasecompare("macdef", tok))
+ if(curl_strequal("macdef", tok))
/* Define a macro. A macro is defined with the specified name; its
contents begin with the next .netrc line and continue until a
null line (consecutive new-line characters) is encountered. */
state = MACDEF;
- else if(strcasecompare("machine", tok)) {
+ else if(curl_strequal("machine", tok)) {
/* the next tok is the machine name, this is in itself the delimiter
that starts the stuff entered for this machine, after this we
need to search for 'login' and 'password'. */
if(!specific_login)
Curl_safefree(login);
}
- else if(strcasecompare("default", tok)) {
+ else if(curl_strequal("default", tok)) {
state = HOSTVALID;
retcode = NETRC_OK; /* we did find our host */
}
state = NOTHING;
break;
case HOSTFOUND:
- if(strcasecompare(host, tok)) {
+ if(curl_strequal(host, tok)) {
/* and yes, this is our host! */
state = HOSTVALID;
retcode = NETRC_OK; /* we did find our host */
found |= FOUND_PASSWORD;
keyword = NONE;
}
- else if(strcasecompare("login", tok))
+ else if(curl_strequal("login", tok))
keyword = LOGIN;
- else if(strcasecompare("password", tok))
+ else if(curl_strequal("password", tok))
keyword = PASSWORD;
- else if(strcasecompare("machine", tok)) {
+ else if(curl_strequal("machine", tok)) {
/* a new machine here */
if(found & FOUND_PASSWORD) {
done = TRUE;
if(!specific_login)
Curl_safefree(login);
}
- else if(strcasecompare("default", tok)) {
+ else if(curl_strequal("default", tok)) {
state = HOSTVALID;
retcode = NETRC_OK; /* we did find our host */
Curl_safefree(password);
#ifndef CURL_DISABLE_PROXY
+#include <curl/curl.h> /* for curl_strnequal() */
#include "curlx/inet_pton.h"
-#include "strcase.h"
#include "noproxy.h"
#include "curlx/strparse.h"
*/
if(tokenlen == namelen)
/* case A, exact match */
- match = strncasecompare(token, name, namelen);
+ match = curl_strnequal(token, name, namelen);
else if(tokenlen < namelen) {
/* case B, tailmatch domain */
match = (name[namelen - tokenlen - 1] == '.') &&
- strncasecompare(token, name + (namelen - tokenlen),
- tokenlen);
+ curl_strnequal(token, name + (namelen - tokenlen),
+ tokenlen);
}
/* case C passes through, not a match */
break;
#include <limits.h>
#include <curl/curl.h>
-#include "strcase.h"
#include "curlx/warnless.h"
#include "parsedate.h"
#include "curlx/strparse.h"
for(i = 0; i < 7; i++) {
size_t ilen = strlen(what[0]);
if((ilen == len) &&
- strncasecompare(check, what[0], len))
+ curl_strnequal(check, what[0], len))
return i;
what++;
}
return -1; /* not a month */
for(i = 0; i < 12; i++) {
- if(strncasecompare(check, what[0], 3))
+ if(curl_strnequal(check, what[0], 3))
return i;
what++;
}
for(i = 0; i < CURL_ARRAYSIZE(tz); i++) {
size_t ilen = strlen(what->name);
if((ilen == len) &&
- strncasecompare(check, what->name, len))
+ curl_strnequal(check, what->name, len))
return what->offset*60;
what++;
}
#include "socks.h"
#include "pingpong.h"
#include "pop3.h"
-#include "strcase.h"
#include "vtls/vtls.h"
#include "cfilters.h"
#include "connect.h"
{
size_t i;
for(i = 0; i < CURL_ARRAYSIZE(pop3cmds); ++i) {
- if(strncasecompare(pop3cmds[i].name, cmdline, pop3cmds[i].nlen)) {
+ if(curl_strnequal(pop3cmds[i].name, cmdline, pop3cmds[i].nlen)) {
if(!cmdline[pop3cmds[i].nlen])
return pop3cmds[i].multiline;
else if(cmdline[pop3cmds[i].nlen] == ' ')
while(*ptr && *ptr != ';')
ptr++;
- if(strncasecompare(key, "AUTH=", 5)) {
+ if(curl_strnequal(key, "AUTH=", 5)) {
result = Curl_sasl_parse_url_auth_option(&pop3c->sasl,
value, ptr - value);
- if(result && strncasecompare(value, "+APOP", ptr - value)) {
+ if(result && curl_strnequal(value, "+APOP", ptr - value)) {
pop3c->preftype = POP3_TYPE_APOP;
pop3c->sasl.prefmech = SASL_AUTH_NONE;
result = CURLE_OK;
if(!ptr)
break;
- if(strcasecompare(ptr, "ALL")) {
+ if(curl_strequal(ptr, "ALL")) {
/* clear all cookies */
Curl_share_lock(data, CURL_LOCK_DATA_COOKIE, CURL_LOCK_ACCESS_SINGLE);
Curl_cookie_clearall(data->cookies);
Curl_share_unlock(data, CURL_LOCK_DATA_COOKIE);
}
- else if(strcasecompare(ptr, "SESS")) {
+ else if(curl_strequal(ptr, "SESS")) {
/* clear session cookies */
Curl_share_lock(data, CURL_LOCK_DATA_COOKIE, CURL_LOCK_ACCESS_SINGLE);
Curl_cookie_clearsess(data->cookies);
Curl_share_unlock(data, CURL_LOCK_DATA_COOKIE);
}
- else if(strcasecompare(ptr, "FLUSH")) {
+ else if(curl_strequal(ptr, "FLUSH")) {
/* flush cookies to file, takes care of the locking */
Curl_flush_cookies(data, FALSE);
}
- else if(strcasecompare(ptr, "RELOAD")) {
+ else if(curl_strequal(ptr, "RELOAD")) {
/* reload cookies from file */
Curl_cookie_loadfiles(data);
break;
return Curl_setstropt(&data->set.str[STRING_TLSAUTH_PASSWORD_PROXY], ptr);
#endif
case CURLOPT_TLSAUTH_TYPE:
- if(ptr && !strcasecompare(ptr, "SRP"))
+ if(ptr && !curl_strequal(ptr, "SRP"))
return CURLE_BAD_FUNCTION_ARGUMENT;
break;
#ifndef CURL_DISABLE_PROXY
case CURLOPT_PROXY_TLSAUTH_TYPE:
- if(ptr && !strcasecompare(ptr, "SRP"))
+ if(ptr && !curl_strequal(ptr, "SRP"))
return CURLE_BAD_FUNCTION_ARGUMENT;
break;
#endif
#include "mime.h"
#include "socks.h"
#include "smtp.h"
-#include "strcase.h"
#include "vtls/vtls.h"
#include "cfilters.h"
#include "connect.h"
while(*ptr && *ptr != ';')
ptr++;
- if(strncasecompare(key, "AUTH=", 5))
+ if(curl_strnequal(key, "AUTH=", 5))
result = Curl_sasl_parse_url_auth_option(&smtpc->sasl,
value, ptr - value);
else
#include <curl/curl.h>
-/*
- * Only "raw" case insensitive strings. This is meant to be locale independent
- * and only compare strings we know are safe for this.
- *
- * The function is capable of comparing a-z case insensitively.
- *
- * Result is 1 if text matches and 0 if not.
- */
-
-#define strcasecompare(a,b) curl_strequal(a,b)
-#define strncasecompare(a,b,c) curl_strnequal(a,b,c)
-
char Curl_raw_toupper(char in);
char Curl_raw_tolower(char in);
return Curl_raw_toupper(*first) == Curl_raw_toupper(*second);
}
+/*
+ * Only "raw" case insensitive strings. This is meant to be locale independent
+ * and only compare strings we know are safe for this.
+ *
+ * The function is capable of comparing a-z case insensitively.
+ *
+ * Result is 1 if text matches and 0 if not.
+ */
+
/* --- public function --- */
int curl_strequal(const char *first, const char *second)
{
#include "system_win32.h"
#include "arpa_telnet.h"
#include "select.h"
-#include "strcase.h"
#include "curlx/warnless.h"
#include "curlx/strparse.h"
switch(olen) {
case 5:
/* Terminal type */
- if(strncasecompare(option, "TTYPE", 5)) {
+ if(curl_strnequal(option, "TTYPE", 5)) {
tn->subopt_ttype = arg;
tn->us_preferred[CURL_TELOPT_TTYPE] = CURL_YES;
break;
case 8:
/* Display variable */
- if(strncasecompare(option, "XDISPLOC", 8)) {
+ if(curl_strnequal(option, "XDISPLOC", 8)) {
tn->subopt_xdisploc = arg;
tn->us_preferred[CURL_TELOPT_XDISPLOC] = CURL_YES;
break;
case 7:
/* Environment variable */
- if(strncasecompare(option, "NEW_ENV", 7)) {
+ if(curl_strnequal(option, "NEW_ENV", 7)) {
beg = curl_slist_append(tn->telnet_vars, arg);
if(!beg) {
result = CURLE_OUT_OF_MEMORY;
case 2:
/* Window Size */
- if(strncasecompare(option, "WS", 2)) {
+ if(curl_strnequal(option, "WS", 2)) {
const char *p = arg;
curl_off_t x = 0;
curl_off_t y = 0;
case 6:
/* To take care or not of the 8th bit in data exchange */
- if(strncasecompare(option, "BINARY", 6)) {
+ if(curl_strnequal(option, "BINARY", 6)) {
int binary_option = atoi(arg);
if(binary_option != 1) {
tn->us_preferred[CURL_TELOPT_BINARY] = CURL_NO;
#include "connect.h"
#include "http2.h"
#include "mime.h"
-#include "strcase.h"
#include "hsts.h"
#include "setopt.h"
#include "headers.h"
DEBUGASSERT(thisheader[thislen-1] != ':');
for(head = data->set.headers; head; head = head->next) {
- if(strncasecompare(head->data, thisheader, thislen) &&
+ if(curl_strnequal(head->data, thisheader, thislen) &&
Curl_headersep(head->data[thislen]) )
return head->data;
}
{
if((data->proxytype == needle->proxytype) &&
(data->port == needle->port) &&
- strcasecompare(data->host.name, needle->host.name))
+ curl_strequal(data->host.name, needle->host.name))
return TRUE;
return FALSE;
|| !m->needle->bits.httpproxy || m->needle->bits.tunnel_proxy
#endif
) {
- if(!strcasecompare(m->needle->handler->scheme, conn->handler->scheme)) {
+ if(!curl_strequal(m->needle->handler->scheme, conn->handler->scheme)) {
/* `needle` and `conn` do not have the same scheme... */
if(get_protocol_family(conn->handler) != m->needle->handler->protocol) {
/* and `conn`s protocol family is not the protocol `needle` wants.
}
/* If needle has "conn_to_*" set, conn must match this */
- if((m->needle->bits.conn_to_host && !strcasecompare(
+ if((m->needle->bits.conn_to_host && !curl_strequal(
m->needle->conn_to_host.name, conn->conn_to_host.name)) ||
(m->needle->bits.conn_to_port &&
m->needle->conn_to_port != conn->conn_to_port))
return FALSE;
/* hostname and port must match */
- if(!strcasecompare(m->needle->host.name, conn->host.name) ||
+ if(!curl_strequal(m->needle->host.name, conn->host.name) ||
m->needle->remote_port != conn->remote_port)
return FALSE;
}
}
h = protocols[c % 67];
- if(h && strncasecompare(scheme, h->scheme, len) && !h->scheme[len])
+ if(h && curl_strnequal(scheme, h->scheme, len) && !h->scheme[len])
return h;
}
return NULL;
uc = curl_url_get(uh, CURLUPART_HOST, &data->state.up.hostname, 0);
if(uc) {
- if(!strcasecompare("file", data->state.up.scheme))
+ if(!curl_strequal("file", data->state.up.scheme))
return CURLE_OUT_OF_MEMORY;
}
else if(strlen(data->state.up.hostname) > MAX_URL_LEN) {
#ifndef CURL_DISABLE_HSTS
/* HSTS upgrade */
- if(data->hsts && strcasecompare("http", data->state.up.scheme)) {
+ if(data->hsts && curl_strequal("http", data->state.up.scheme)) {
/* This MUST use the IDN decoded name */
if(Curl_hsts(data->hsts, conn->host.name, strlen(conn->host.name), TRUE)) {
char *url;
uc = curl_url_get(uh, CURLUPART_PORT, &data->state.up.port,
CURLU_DEFAULT_PORT);
if(uc) {
- if(!strcasecompare("file", data->state.up.scheme))
+ if(!curl_strequal("file", data->state.up.scheme))
return CURLE_OUT_OF_MEMORY;
}
else {
* This can cause 'internal' http/ftp requests to be
* arbitrarily redirected by any external attacker.
*/
- if(!proxy && !strcasecompare("http_proxy", proxy_env)) {
+ if(!proxy && !curl_strequal("http_proxy", proxy_env)) {
/* There was no lowercase variable, try the uppercase version: */
Curl_strntoupper(proxy_env, proxy_env, sizeof(proxy_env));
proxy = curl_getenv(proxy_env);
if(!proxy) {
#ifndef CURL_DISABLE_WEBSOCKETS
/* websocket proxy fallbacks */
- if(strcasecompare("ws_proxy", proxy_env)) {
+ if(curl_strequal("ws_proxy", proxy_env)) {
proxy = curl_getenv("http_proxy");
}
- else if(strcasecompare("wss_proxy", proxy_env)) {
+ else if(curl_strequal("wss_proxy", proxy_env)) {
proxy = curl_getenv("https_proxy");
if(!proxy)
proxy = curl_getenv("HTTPS_PROXY");
goto error;
}
- if(strcasecompare("https", scheme)) {
+ if(curl_strequal("https", scheme)) {
if(proxytype != CURLPROXY_HTTPS2)
proxytype = CURLPROXY_HTTPS;
else
proxytype = CURLPROXY_HTTPS2;
}
- else if(strcasecompare("socks5h", scheme))
+ else if(curl_strequal("socks5h", scheme))
proxytype = CURLPROXY_SOCKS5_HOSTNAME;
- else if(strcasecompare("socks5", scheme))
+ else if(curl_strequal("socks5", scheme))
proxytype = CURLPROXY_SOCKS5;
- else if(strcasecompare("socks4a", scheme))
+ else if(curl_strequal("socks4a", scheme))
proxytype = CURLPROXY_SOCKS4A;
- else if(strcasecompare("socks4", scheme) ||
- strcasecompare("socks", scheme))
+ else if(curl_strequal("socks4", scheme) ||
+ curl_strequal("socks", scheme))
proxytype = CURLPROXY_SOCKS4;
- else if(strcasecompare("http", scheme))
+ else if(curl_strequal("http", scheme))
; /* leave it as HTTP or HTTP/1.0 */
else {
/* Any other xxx:// reject! */
goto error;
}
#ifdef USE_UNIX_SOCKETS
- if(sockstype && strcasecompare(UNIX_SOCKET_PREFIX, host)) {
+ if(sockstype && curl_strequal(UNIX_SOCKET_PREFIX, host)) {
uc = curl_url_get(uhp, CURLUPART_PATH, &path, CURLU_URLDECODE);
if(uc) {
result = CURLE_OUT_OF_MEMORY;
if(!hostname_to_match)
return CURLE_OUT_OF_MEMORY;
hostname_to_match_len = strlen(hostname_to_match);
- host_match = strncasecompare(ptr, hostname_to_match,
- hostname_to_match_len);
+ host_match = curl_strnequal(ptr, hostname_to_match,
+ hostname_to_match_len);
free(hostname_to_match);
ptr += hostname_to_match_len;
* Do this after the hostnames have been IDN-converted.
*************************************************************/
if(conn->bits.conn_to_host &&
- strcasecompare(conn->conn_to_host.name, conn->host.name)) {
+ curl_strequal(conn->conn_to_host.name, conn->host.name)) {
conn->bits.conn_to_host = FALSE;
}
bool depunyfy = (flags & CURLU_PUNY2IDN) ? 1 : 0;
bool urlencode = (flags & CURLU_URLENCODE) ? 1 : 0;
char portbuf[7];
- if(u->scheme && strcasecompare("file", u->scheme)) {
+ if(u->scheme && curl_strequal("file", u->scheme)) {
url = aprintf("file://%s%s%s%s%s",
u->path,
show_query ? "?": "",
#include "../vtls/vtls.h"
#include "../curlx/warnless.h"
#include "../curlx/strparse.h"
-#include "../strcase.h"
#include "../curl_printf.h"
#include "../rand.h"
/* Extract a value=content pair */
if(Curl_auth_digest_get_pair(chlg, value, content, &chlg)) {
- if(strcasecompare(value, "nonce")) {
+ if(curl_strequal(value, "nonce")) {
free(digest->nonce);
digest->nonce = strdup(content);
if(!digest->nonce)
return CURLE_OUT_OF_MEMORY;
}
- else if(strcasecompare(value, "stale")) {
- if(strcasecompare(content, "true")) {
+ else if(curl_strequal(value, "stale")) {
+ if(curl_strequal(content, "true")) {
digest->stale = TRUE;
digest->nc = 1; /* we make a new nonce now */
}
}
- else if(strcasecompare(value, "realm")) {
+ else if(curl_strequal(value, "realm")) {
free(digest->realm);
digest->realm = strdup(content);
if(!digest->realm)
return CURLE_OUT_OF_MEMORY;
}
- else if(strcasecompare(value, "opaque")) {
+ else if(curl_strequal(value, "opaque")) {
free(digest->opaque);
digest->opaque = strdup(content);
if(!digest->opaque)
return CURLE_OUT_OF_MEMORY;
}
- else if(strcasecompare(value, "qop")) {
+ else if(curl_strequal(value, "qop")) {
const char *token = content;
struct Curl_str out;
bool foundAuth = FALSE;
return CURLE_OUT_OF_MEMORY;
}
}
- else if(strcasecompare(value, "algorithm")) {
+ else if(curl_strequal(value, "algorithm")) {
free(digest->algorithm);
digest->algorithm = strdup(content);
if(!digest->algorithm)
return CURLE_OUT_OF_MEMORY;
- if(strcasecompare(content, "MD5-sess"))
+ if(curl_strequal(content, "MD5-sess"))
digest->algo = ALGO_MD5SESS;
- else if(strcasecompare(content, "MD5"))
+ else if(curl_strequal(content, "MD5"))
digest->algo = ALGO_MD5;
- else if(strcasecompare(content, "SHA-256"))
+ else if(curl_strequal(content, "SHA-256"))
digest->algo = ALGO_SHA256;
- else if(strcasecompare(content, "SHA-256-SESS"))
+ else if(curl_strequal(content, "SHA-256-SESS"))
digest->algo = ALGO_SHA256SESS;
- else if(strcasecompare(content, "SHA-512-256")) {
+ else if(curl_strequal(content, "SHA-512-256")) {
#ifdef CURL_HAVE_SHA512_256
digest->algo = ALGO_SHA512_256;
#else /* ! CURL_HAVE_SHA512_256 */
return CURLE_NOT_BUILT_IN;
#endif /* ! CURL_HAVE_SHA512_256 */
}
- else if(strcasecompare(content, "SHA-512-256-SESS")) {
+ else if(curl_strequal(content, "SHA-512-256-SESS")) {
#ifdef CURL_HAVE_SHA512_256
digest->algo = ALGO_SHA512_256SESS;
#else /* ! CURL_HAVE_SHA512_256 */
else
return CURLE_BAD_CONTENT_ENCODING;
}
- else if(strcasecompare(value, "userhash")) {
- if(strcasecompare(content, "true")) {
+ else if(curl_strequal(value, "userhash")) {
+ if(curl_strequal(content, "true")) {
digest->userhash = TRUE;
}
}
if(!hashthis)
return CURLE_OUT_OF_MEMORY;
- if(digest->qop && strcasecompare(digest->qop, "auth-int")) {
+ if(digest->qop && curl_strequal(digest->qop, "auth-int")) {
/* We do not support auth-int for PUT or POST */
char hashed[65];
char *hashthis2;
/* Extract a value=content pair */
if(Curl_auth_digest_get_pair(chlg, value, content, &chlg)) {
- if(strcasecompare(value, "realm")) {
+ if(curl_strequal(value, "realm")) {
/* Setup identity's domain and length */
domain.tchar_ptr = curlx_convert_UTF8_to_tchar(content);
if(!Curl_auth_digest_get_pair(p, value, content, &p))
break;
- if(strcasecompare(value, "stale") &&
- strcasecompare(content, "true")) {
+ if(curl_strequal(value, "stale") &&
+ curl_strequal(content, "true")) {
stale = TRUE;
break;
}
#include "vauth.h"
#include "../urldata.h"
-#include "../strcase.h"
#include "../curlx/multibyte.h"
#include "../curl_printf.h"
#include "../url.h"
return !data->state.this_is_a_follow ||
data->set.allow_auth_to_other_hosts ||
(data->state.first_host &&
- strcasecompare(data->state.first_host, conn->host.name) &&
+ curl_strequal(data->state.first_host, conn->host.name) &&
(data->state.first_remote_port == conn->remote_port) &&
(data->state.first_remote_protocol == conn->handler->protocol));
}
#include "../strdup.h"
#include "../rand.h"
#include "../multiif.h"
-#include "../strcase.h"
#include "../cfilters.h"
#include "../cf-socket.h"
#include "../connect.h"
#include "../strdup.h"
#include "../rand.h"
#include "../multiif.h"
-#include "../strcase.h"
#include "../cfilters.h"
#include "../cf-socket.h"
#include "../connect.h"
#include "../sendf.h"
#include "../strdup.h"
#include "../rand.h"
-#include "../strcase.h"
#include "../multiif.h"
#include "../connect.h"
#include "../progress.h"
#include "../speedcheck.h"
#include "../getinfo.h"
#include "../strdup.h"
-#include "../strcase.h"
#include "../vtls/vtls.h"
#include "../cfilters.h"
#include "../connect.h"
infof(data, "SSH MD5 fingerprint: %s", md5buffer);
- if(!strcasecompare(md5buffer, pubkey_md5)) {
+ if(!curl_strequal(md5buffer, pubkey_md5)) {
failf(data,
"Denied establishing ssh session: mismatch md5 fingerprint. "
"Remote %s is not equal to %s", md5buffer, pubkey_md5);
sshc->acceptfail = TRUE;
}
- if(strcasecompare("pwd", cmd)) {
+ if(curl_strequal("pwd", cmd)) {
/* output debug output if that is requested */
char *tmp = aprintf("257 \"%s\" is current directory.\n", sshp->path);
if(!tmp) {
#include "../speedcheck.h"
#include "../getinfo.h"
#include "../strdup.h"
-#include "../strcase.h"
#include "../vtls/vtls.h"
#include "../cfilters.h"
#include "../connect.h"
/* This does NOT verify the length of 'pubkey_md5' separately, which will
make the comparison below fail unless it is exactly 32 characters */
- if(!fingerprint || !strcasecompare(md5buffer, pubkey_md5)) {
+ if(!fingerprint || !curl_strequal(md5buffer, pubkey_md5)) {
if(fingerprint) {
failf(data,
"Denied establishing ssh session: mismatch md5 fingerprint. "
sshc->acceptfail = TRUE;
}
- if(strcasecompare("pwd", cmd)) {
+ if(curl_strequal("pwd", cmd)) {
/* output debug output if that is requested */
char *tmp = aprintf("257 \"%s\" is current directory.\n", sshp->path);
if(!tmp)
#if defined(USE_MBEDTLS) || defined(USE_RUSTLS)
#include "cipher_suite.h"
#include "../curl_printf.h"
-#include "../strcase.h"
#include <string.h>
/*
size_t len;
/* split the cipher string by '-' or '_' */
- if(strncasecompare(cs_str, "TLS", 3))
+ if(curl_strnequal(cs_str, "TLS", 3))
separator = '_';
do {
/* lookup index for the part (skip empty string at 0) */
for(idx = 1, entry = cs_txt + 1; idx < CS_TXT_LEN; idx++) {
size_t elen = strlen(entry);
- if(elen == len && strncasecompare(entry, cur, len))
+ if(elen == len && curl_strnequal(entry, cur, len))
break;
entry += elen + 1;
}
#include "../connect.h" /* for the connect timeout */
#include "../progress.h"
#include "../select.h"
-#include "../strcase.h"
#include "../strdup.h"
#include "../curlx/warnless.h"
#include "x509asn1.h"
{
if(!type || !type[0])
return GNUTLS_X509_FMT_PEM;
- if(strcasecompare(type, "PEM"))
+ if(curl_strequal(type, "PEM"))
return GNUTLS_X509_FMT_PEM;
- if(strcasecompare(type, "DER"))
+ if(curl_strequal(type, "DER"))
return GNUTLS_X509_FMT_DER;
return GNUTLS_X509_FMT_PEM; /* default to PEM */
}
if(result)
return result;
}
- if(ssl_config->cert_type && strcasecompare(ssl_config->cert_type, "P12")) {
+ if(ssl_config->cert_type && curl_strequal(ssl_config->cert_type, "P12")) {
rc = gnutls_certificate_set_x509_simple_pkcs12_file(
gtls->shared_creds->creds, config->clientcert, GNUTLS_X509_FMT_DER,
ssl_config->key_passwd ? ssl_config->key_passwd : "");
#endif
#include "../curl_memrchr.h"
#include "hostcheck.h"
-#include "../strcase.h"
#include "../hostip.h"
#include "../curl_memory.h"
{
if(hostlen != patternlen)
return FALSE;
- return strncasecompare(hostname, pattern, hostlen);
+ return curl_strnequal(hostname, pattern, hostlen);
}
/*
#endif /* MBEDTLS_VERSION_MAJOR >= 2 */
#include "cipher_suite.h"
-#include "../strcase.h"
#include "../urldata.h"
#include "../sendf.h"
#include "../curlx/inet_pton.h"
size_t len = *end - *str;
if(!id) {
- if(strncasecompare("TLS_ECJPAKE_WITH_AES_128_CCM_8", *str, len))
+ if(curl_strnequal("TLS_ECJPAKE_WITH_AES_128_CCM_8", *str, len))
id = MBEDTLS_TLS_ECJPAKE_WITH_AES_128_CCM_8;
}
return id;
#include "vtls_scache.h"
#include "../vauth/vauth.h"
#include "keylog.h"
-#include "../strcase.h"
#include "hostcheck.h"
#include "../multiif.h"
#include "../curlx/strparse.h"
{
if(!type || !type[0])
return SSL_FILETYPE_PEM;
- if(strcasecompare(type, "PEM"))
+ if(curl_strequal(type, "PEM"))
return SSL_FILETYPE_PEM;
- if(strcasecompare(type, "DER"))
+ if(curl_strequal(type, "DER"))
return SSL_FILETYPE_ASN1;
- if(strcasecompare(type, "PROV"))
+ if(curl_strequal(type, "PROV"))
return SSL_FILETYPE_PROVIDER;
- if(strcasecompare(type, "ENG"))
+ if(curl_strequal(type, "ENG"))
return SSL_FILETYPE_ENGINE;
- if(strcasecompare(type, "P12"))
+ if(curl_strequal(type, "P12"))
return SSL_FILETYPE_PKCS12;
return -1;
}
*/
static bool is_pkcs11_uri(const char *string)
{
- return string && strncasecompare(string, "pkcs11:", 7);
+ return string && curl_strnequal(string, "pkcs11:", 7);
}
#endif
size_t count;
const char *ver = OpenSSL_version(OPENSSL_VERSION);
const char expected[] = OSSL_PACKAGE " "; /* ie "LibreSSL " */
- if(strncasecompare(ver, expected, sizeof(expected) - 1)) {
+ if(curl_strnequal(ver, expected, sizeof(expected) - 1)) {
ver += sizeof(expected) - 1;
}
count = msnprintf(buffer, size, "%s/%s", OSSL_PACKAGE, ver);
#include "vtls.h"
#include "vtls_int.h"
#include "vtls_scache.h"
-#include "../strcase.h"
#include "../sendf.h"
#include "../connect.h" /* for the connect timeout */
#include "../strerror.h"
}
if((fInCert || blob) && (data->set.ssl.cert_type) &&
- (!strcasecompare(data->set.ssl.cert_type, "P12"))) {
+ (!curl_strequal(data->set.ssl.cert_type, "P12"))) {
failf(data, "schannel: certificate format compatibility error "
" for %s",
blob ? "(memory blob)" : data->set.ssl.primary.clientcert);
!Curl_timestrcmp(c1->username, c2->username) &&
!Curl_timestrcmp(c1->password, c2->password) &&
#endif
- strcasecompare(c1->cipher_list, c2->cipher_list) &&
- strcasecompare(c1->cipher_list13, c2->cipher_list13) &&
- strcasecompare(c1->curves, c2->curves) &&
- strcasecompare(c1->signature_algorithms, c2->signature_algorithms) &&
- strcasecompare(c1->CRLfile, c2->CRLfile) &&
- strcasecompare(c1->pinned_key, c2->pinned_key))
+ curl_strequal(c1->cipher_list, c2->cipher_list) &&
+ curl_strequal(c1->cipher_list13, c2->cipher_list13) &&
+ curl_strequal(c1->curves, c2->curves) &&
+ curl_strequal(c1->signature_algorithms, c2->signature_algorithms) &&
+ curl_strequal(c1->CRLfile, c2->CRLfile) &&
+ curl_strequal(c1->pinned_key, c2->pinned_key))
return TRUE;
return FALSE;
env = curl_getenv("CURL_SSL_BACKEND");
if(env) {
for(i = 0; available_backends[i]; i++) {
- if(strcasecompare(env, available_backends[i]->info.name)) {
+ if(curl_strequal(env, available_backends[i]->info.name)) {
Curl_ssl = available_backends[i];
free(env);
return 0;
#ifdef CURL_DEFAULT_SSL_BACKEND
for(i = 0; available_backends[i]; i++) {
- if(strcasecompare(CURL_DEFAULT_SSL_BACKEND,
- available_backends[i]->info.name)) {
+ if(curl_strequal(CURL_DEFAULT_SSL_BACKEND,
+ available_backends[i]->info.name)) {
Curl_ssl = available_backends[i];
free(env);
return 0;
if(Curl_ssl != &Curl_ssl_multi)
return id == Curl_ssl->info.id ||
- (name && strcasecompare(name, Curl_ssl->info.name)) ?
+ (name && curl_strequal(name, Curl_ssl->info.name)) ?
CURLSSLSET_OK :
#if defined(CURL_WITH_MULTI_SSL)
CURLSSLSET_TOO_LATE;
for(i = 0; available_backends[i]; i++) {
if(available_backends[i]->info.id == id ||
- (name && strcasecompare(available_backends[i]->info.name, name))) {
+ (name && curl_strequal(available_backends[i]->info.name, name))) {
multissl_setup(available_backends[i]);
return CURLSSLSET_OK;
}
/* check for entries with known peer_key */
for(i = 0; scache && i < scache->peer_count; i++) {
if(scache->peers[i].ssl_peer_key &&
- strcasecompare(ssl_peer_key, scache->peers[i].ssl_peer_key) &&
+ curl_strequal(ssl_peer_key, scache->peers[i].ssl_peer_key) &&
cf_ssl_scache_match_auth(&scache->peers[i], conn_config)) {
/* yes, we have a cached session for this! */
*ppeer = &scache->peers[i];
#include "../connect.h" /* for the connect timeout */
#include "../progress.h"
#include "../select.h"
-#include "../strcase.h"
#include "../strdup.h"
#include "x509asn1.h"
#include "../curl_printf.h"
{
if(!type || !type[0])
return WOLFSSL_FILETYPE_PEM;
- if(strcasecompare(type, "PEM"))
+ if(curl_strequal(type, "PEM"))
return WOLFSSL_FILETYPE_PEM;
- if(strcasecompare(type, "DER"))
+ if(curl_strequal(type, "DER"))
return WOLFSSL_FILETYPE_ASN1;
return -1;
}
#include <curl/curl.h>
#include "../urldata.h"
-#include "../strcase.h"
#include "../curl_ctype.h"
#include "hostcheck.h"
#include "vtls.h"
{
const struct Curl_OID *op;
for(op = OIDtable; op->numoid; op++)
- if(!strcmp(op->numoid, oid) || strcasecompare(op->textoid, oid))
+ if(!strcmp(op->numoid, oid) || curl_strequal(op->textoid, oid))
return op;
return NULL;
/* Generate all information records for the public key. */
- if(strcasecompare(algo, "ecPublicKey")) {
+ if(curl_strequal(algo, "ecPublicKey")) {
/*
* ECC public key is all the data, a value of type BIT STRING mapped to
* OCTET STRING and should not be parsed as an ASN.1 value.
if(!getASN1Element(&pk, pubkey->beg + 1, pubkey->end))
return 1;
- if(strcasecompare(algo, "rsaEncryption")) {
+ if(curl_strequal(algo, "rsaEncryption")) {
const char *q;
size_t len;
if(do_pubkey_field(data, certnum, "rsa(e)", &elem))
return 1;
}
- else if(strcasecompare(algo, "dsa")) {
+ else if(curl_strequal(algo, "dsa")) {
p = getASN1Element(&elem, param->beg, param->end);
if(p) {
if(do_pubkey_field(data, certnum, "dsa(p)", &elem))
}
}
}
- else if(strcasecompare(algo, "dhpublicnumber")) {
+ else if(curl_strequal(algo, "dhpublicnumber")) {
p = getASN1Element(&elem, param->beg, param->end);
if(p) {
if(do_pubkey_field(data, certnum, "dh(p)", &elem))
projects / thirdparty / curl.git / commitdiff
