static size_t writefunction(void *ptr, size_t size, size_t nmemb, void *stream)
{
fwrite(ptr, size, nmemb, (FILE *)stream);
- return (nmemb*size);
+ return nmemb * size;
}
static CURLcode sslctx_function(CURL *curl, void *sslctx, void *parm)
void *stream)
{
fwrite(ptr, size, nmemb, stream);
- return (nmemb*size);
+ return nmemb * size;
}
static size_t SyncTime_CURL_WriteHeader(void *ptr, size_t size, size_t nmemb,
" Server Date is no longer valid.\n");
AutoSyncTime = 0;
}
- return (nmemb*size);
+ return nmemb * size;
}
static void SyncTime_CURL_Init(CURL *curl, const char *proxy_port,
static size_t writefunction(void *ptr, size_t size, size_t nmemb, void *stream)
{
fwrite(ptr, size, nmemb, stream);
- return (nmemb*size);
+ return nmemb * size;
}
static CURLcode sslctx_function(CURL *curl, void *sslctx, void *parm)
static bool tunnel_want_send(struct h1_tunnel_state *ts)
{
- return (ts->tunnel_state == H1_TUNNEL_CONNECT);
+ return ts->tunnel_state == H1_TUNNEL_CONNECT;
}
static CURLcode start_CONNECT(struct Curl_cfilter *cf,
(void)data;
readable = SOCKET_READABLE(ctx->sock, 0);
- return (readable > 0 && (readable & CURL_CSELECT_IN));
+ return readable > 0 && (readable & CURL_CSELECT_IN);
}
#ifdef USE_WINSOCK
size_t len;
/* scan for all the octets that are *not* in cookie-octet */
len = strcspn(p, badoctets);
- return (p[len] != '\0');
+ return p[len] != '\0';
}
#define CERR_OK 0
l2 = c2->path ? strlen(c2->path) : 0;
if(l1 != l2)
- return (l2 > l1) ? 1 : -1 ; /* avoid size_t <=> int conversions */
+ return (l2 > l1) ? 1 : -1; /* avoid size_t <=> int conversions */
/* 2 - compare cookie domain lengths */
l1 = c1->domain ? strlen(c1->domain) : 0;
l2 = c2->domain ? strlen(c2->domain) : 0;
if(l1 != l2)
- return (l2 > l1) ? 1 : -1 ; /* avoid size_t <=> int conversions */
+ return (l2 > l1) ? 1 : -1; /* avoid size_t <=> int conversions */
/* 3 - compare cookie name lengths */
l1 = c1->name ? strlen(c1->name) : 0;
free(ibuf);
free(obuf);
#endif
- return (*out ? true : false);
+ return *out ? true : false;
}
int curlx_win32_open(const char *filename, int oflag, ...)
*/
int Curl_easyopts_check(void)
{
- return ((CURLOPT_LASTENTRY%10000) != (326 + 1));
+ return (CURLOPT_LASTENTRY % 10000) != (326 + 1);
}
#endif
ipv6_works = 1;
sclose(s);
}
- return (ipv6_works > 0);
+ return ipv6_works > 0;
}
}
#endif /* USE_IPV6 */
if((data->state.httpwant == CURL_HTTP_VERSION_1_0) &&
(conn->httpversion <= 10))
return FALSE;
- return ((data->state.httpwant == CURL_HTTP_VERSION_NONE) ||
- (data->state.httpwant >= CURL_HTTP_VERSION_1_1));
+ return (data->state.httpwant == CURL_HTTP_VERSION_NONE) ||
+ (data->state.httpwant >= CURL_HTTP_VERSION_1_1);
}
static const char *get_http_string(const struct Curl_easy *data,
struct Curl_creader *r = Curl_creader_get_by_type(data, &cr_exp100);
if(r) {
struct cr_exp100_ctx *ctx = r->ctx;
- return (ctx->state == EXP100_AWAITING_CONTINUE);
+ return ctx->state == EXP100_AWAITING_CONTINUE;
}
return FALSE;
}
{
if(Curl_conn_is_http2(data, data->conn, FIRSTSOCKET)) {
int err = Curl_conn_get_stream_error(data, data->conn, FIRSTSOCKET);
- return (err == NGHTTP2_HTTP_1_1_REQUIRED);
+ return err == NGHTTP2_HTTP_1_1_REQUIRED;
}
return FALSE;
}
return LDAP_SCOPE_SUBTREE;
if(strcasecompare(p, "subtree"))
return LDAP_SCOPE_SUBTREE;
- return (-1);
+ return -1;
}
/*
source, line, wantedsize,
mem ? (void *)mem->mem : (void *)0);
- return (mem ? mem->mem : NULL);
+ return mem ? mem->mem : NULL;
}
ALLOC_FUNC void *curl_dbg_calloc(size_t wanted_elements, size_t wanted_size,
source, line, wanted_elements, wanted_size,
mem ? (void *)mem->mem : (void *)0);
- return (mem ? mem->mem : NULL);
+ return mem ? mem->mem : NULL;
}
ALLOC_FUNC char *curl_dbg_strdup(const char *str,
{
struct cr_mime_ctx *ctx = reader->ctx;
(void)data;
- return (ctx->part && ctx->part->lastreadstatus == CURL_READFUNC_PAUSE);
+ return ctx->part && ctx->part->lastreadstatus == CURL_READFUNC_PAUSE;
}
static const struct Curl_crtype cr_mime = {
/* Return TRUE if the application asked for multiplexing */
bool Curl_multiplex_wanted(const struct Curl_multi *multi)
{
- return (multi && (multi->multiplexing));
+ return multi && multi->multiplexing;
}
/*
bool Curl_is_in_callback(struct Curl_easy *data)
{
- return (data && data->multi && data->multi->in_callback);
+ return data && data->multi && data->multi->in_callback;
}
unsigned int Curl_multi_max_concurrent_streams(struct Curl_multi *multi)
return FALSE;
return TRUE;
}
- return (address == check);
+ return address == check;
}
UNITTEST bool Curl_cidr6_match(const char *ipv6,
*/
int Curl_easyopts_check(void)
{
- return ((CURLOPT_LASTENTRY%10000) != ($lastnum + 1));
+ return (CURLOPT_LASTENTRY % 10000) != ($lastnum + 1);
}
#endif
FOOT
bool Curl_pp_moredata(struct pingpong *pp)
{
- return (!pp->sendleft && Curl_dyn_len(&pp->recvbuf) > pp->nfinal);
+ return !pp->sendleft && Curl_dyn_len(&pp->recvbuf) > pp->nfinal;
}
#endif
if(actual < minimum) {
/* if it downloaded the data faster than the limit, make it wait the
difference */
- return (minimum - actual);
+ return minimum - actual;
}
return 0;
return casecompare(first, second);
/* if both pointers are NULL then treat them as equal */
- return (NULL == first && NULL == second);
+ return NULL == first && NULL == second;
}
static int ncasecompare(const char *first, const char *second, size_t max)
return ncasecompare(first, second, max);
/* if both pointers are NULL then treat them as equal if max is non-zero */
- return (NULL == first && NULL == second && max);
+ return NULL == first && NULL == second && max;
}
/* Copy an upper case version of the string from src to dest. The
* strings may overlap. No more than n characters of the string are copied
*p = '\0';
}
- return (*buf ? buf : NULL);
+ return *buf ? buf : NULL;
}
#endif /* _WIN32 || _WIN32_WCE */
bool want_send = ((data)->req.keepon & KEEP_SEND);
bool want_recv = ((data)->req.keepon & KEEP_RECV);
if(!want_send)
- return (want_recv && Curl_cwriter_is_paused(data));
+ return want_recv && Curl_cwriter_is_paused(data);
else if(!want_recv)
- return (want_send && Curl_creader_is_paused(data));
+ return want_send && Curl_creader_is_paused(data);
else
return Curl_creader_is_paused(data) && Curl_cwriter_is_paused(data);
}
static bool ssh_config_matches(struct connectdata *one,
struct connectdata *two)
{
- return (Curl_safecmp(one->proto.sshc.rsa, two->proto.sshc.rsa) &&
- Curl_safecmp(one->proto.sshc.rsa_pub, two->proto.sshc.rsa_pub));
+ return Curl_safecmp(one->proto.sshc.rsa, two->proto.sshc.rsa) &&
+ Curl_safecmp(one->proto.sshc.rsa_pub, two->proto.sshc.rsa_pub);
}
#else
#define ssh_config_matches(x,y) FALSE
Curl_pSecFn->FreeContextBuffer(SecurityPackage);
}
- return (status == SEC_E_OK);
+ return status == SEC_E_OK;
}
/*
Curl_pSecFn->FreeContextBuffer(SecurityPackage);
}
- return (status == SEC_E_OK);
+ return status == SEC_E_OK;
}
/*
Curl_pSecFn->FreeContextBuffer(SecurityPackage);
}
- return (status == SEC_E_OK);
+ return status == SEC_E_OK;
}
/*
}
- return (status == SEC_E_OK);
+ return status == SEC_E_OK;
}
/*
bool Curl_auth_allowed_to_host(struct Curl_easy *data)
{
struct connectdata *conn = data->conn;
- 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) &&
- (data->state.first_remote_port == conn->remote_port) &&
- (data->state.first_remote_protocol == conn->handler->protocol)));
+ 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) &&
+ (data->state.first_remote_port == conn->remote_port) &&
+ (data->state.first_remote_protocol == conn->handler->protocol));
}
#elif defined(USE_MSH3)
return Curl_conn_is_msh3(data, conn, sockindex);
#else
- return ((conn->handler->protocol & PROTO_FAMILY_HTTP) &&
- (conn->httpversion == 30));
+ return (conn->handler->protocol & PROTO_FAMILY_HTTP) &&
+ (conn->httpversion == 30);
#endif
}
#ifdef BIO_CTRL_EOF
case BIO_CTRL_EOF:
/* EOF has been reached on input? */
- return (!cf->next || !cf->next->connected);
+ return !cf->next || !cf->next->connected;
#endif
default:
ret = 0;
*/
static bool rand_enough(void)
{
- return (0 != RAND_status());
+ return 0 != RAND_status();
}
static CURLcode ossl_seed(struct Curl_easy *data)
}
infof(data, "libcurl is now using a weak random seed");
- return (rand_enough() ? CURLE_OK :
- CURLE_SSL_CONNECT_ERROR /* confusing error code */);
+ return rand_enough() ? CURLE_OK :
+ CURLE_SSL_CONNECT_ERROR; /* confusing error code */
#endif
}
*/
static bool is_pkcs11_uri(const char *string)
{
- return (string && strncasecompare(string, "pkcs11:", 7));
+ return string && strncasecompare(string, "pkcs11:", 7);
}
#endif
}
/* RAND_bytes() returns 1 on success, 0 otherwise. */
rc = RAND_bytes(entropy, (ossl_valsize_t)curlx_uztosi(length));
- return (rc == 1 ? CURLE_OK : CURLE_FAILED_INIT);
+ return rc == 1 ? CURLE_OK : CURLE_FAILED_INIT;
}
#if (OPENSSL_VERSION_NUMBER >= 0x0090800fL) && !defined(OPENSSL_NO_SHA256)
DEBUGASSERT(backend);
if(backend->ctxt) /* SSL/TLS is in use */
- return (backend->decdata_offset > 0 ||
- (backend->encdata_offset > 0 && !backend->encdata_is_incomplete) ||
- backend->recv_connection_closed ||
- backend->recv_sspi_close_notify ||
- backend->recv_unrecoverable_err);
+ return backend->decdata_offset > 0 ||
+ (backend->encdata_offset > 0 && !backend->encdata_is_incomplete) ||
+ backend->recv_connection_closed ||
+ backend->recv_sspi_close_notify ||
+ backend->recv_unrecoverable_err;
else
return FALSE;
}
static int schannel_init(void)
{
- return (Curl_sspi_global_init() == CURLE_OK ? 1 : 0);
+ return Curl_sspi_global_init() == CURLE_OK ? 1 : 0;
}
static void schannel_cleanup(void)
#ifdef WOLFSSL_BIO_CTRL_EOF
case WOLFSSL_BIO_CTRL_EOF:
/* EOF has been reached on input? */
- return (!cf->next || !cf->next->connected);
+ return !cf->next || !cf->next->connected;
#endif
default:
ret = 0;
}
*sanitized = strdup(dos_name);
- return (*sanitized ? SANITIZE_ERR_OK : SANITIZE_ERR_OUT_OF_MEMORY);
+ return *sanitized ? SANITIZE_ERR_OK : SANITIZE_ERR_OUT_OF_MEMORY;
}
#endif /* MSDOS */
#endif
*sanitized = strdup(fname);
- return (*sanitized ? SANITIZE_ERR_OK : SANITIZE_ERR_OUT_OF_MEMORY);
+ return *sanitized ? SANITIZE_ERR_OK : SANITIZE_ERR_OUT_OF_MEMORY;
}
#ifdef __DJGPP__
bool stdin_upload(const char *uploadfile)
{
- return (!strcmp(uploadfile, "-") || !strcmp(uploadfile, "."));
+ return !strcmp(uploadfile, "-") || !strcmp(uploadfile, ".");
}
/* Convert a CURLUcode into a CURLcode */