unsigned short dstport = srcport; /* the same by default */
size_t entries = 0;
struct Curl_str alpn;
-#ifdef CURL_DISABLE_VERBOSE_STRINGS
- (void)data;
-#endif
DEBUGASSERT(asi);
struct async_thrdd_addr_ctx *addr_ctx = *paddr_ctx;
bool destroy;
- (void)data;
if(!addr_ctx)
return;
size_t nwritten;
CURLcode result;
- (void)data;
if(Curl_bufq_is_empty(&ctx->outbufq))
return CURLE_OK;
CURLcode result;
(void)flags;
- (void)data;
(void)session;
DEBUGASSERT(stream_id); /* should never be a zero stream ID here */
if(stream_id != ctx->tunnel.stream_id) {
size_t nread;
(void)source;
- (void)data;
(void)ctx;
if(!stream_id)
struct Curl_easy *data = CF_DATA_CURRENT(cf);
(void)session;
- (void)data;
if(stream_id != ctx->tunnel.stream_id)
return 0;
static void cf_haproxy_destroy(struct Curl_cfilter *cf,
struct Curl_easy *data)
{
- (void)data;
CURL_TRC_CF(data, cf, "destroy");
cf_haproxy_ctx_free(cf->ctx);
}
{
struct cf_hc_ctx *ctx = cf->ctx;
- (void)data;
CURL_TRC_CF(data, cf, "destroy");
cf_hc_reset(cf, data);
Curl_safefree(ctx);
CURLcode result = CURLE_COULDNT_CONNECT;
bool is_tcp;
- (void)data;
DEBUGASSERT(ctx->sock == CURL_SOCKET_BAD);
ctx->started_at = *Curl_pgrs_now(data);
#ifdef SOCK_NONBLOCK
CURLcode result = CURLE_COULDNT_CONNECT;
int rc = 0;
- (void)data;
if(cf->connected) {
*done = TRUE;
return CURLE_OK;
int r;
*input_pending = FALSE;
- (void)data;
+
if(!ctx || ctx->sock == CURL_SOCKET_BAD)
return FALSE;
int index,
struct Curl_cfilter *cf)
{
- (void)data;
DEBUGASSERT(conn);
DEBUGASSERT(!cf->conn);
DEBUGASSERT(!cf->next);
struct connectdata *conn, void *param)
{
struct cpool_do_conn_ctx *dctx = param;
- (void)data;
+
if(conn->connection_id == dctx->id) {
dctx->cb(conn, data, dctx->cbdata);
return 1;
static int cpool_reap_no_reuse(struct Curl_easy *data,
struct connectdata *conn, void *param)
{
- (void)data;
(void)param;
if(!CONN_INUSE(conn) && conn->bits.no_reuse) {
Curl_conn_terminate(data, conn, FALSE);
{
struct cf_setup_ctx *ctx = cf->ctx;
- (void)data;
CURL_TRC_CF(data, cf, "destroy");
Curl_safefree(ctx);
}
display_gss_error(minor, GSS_C_MECH_CODE, buf, len);
infof(data, "%s%s", prefix, buf);
-#ifdef CURL_DISABLE_VERBOSE_STRINGS
- (void)data;
- (void)prefix;
-#endif
}
#if defined(__GNUC__) && defined(__APPLE__)
struct Curl_addrinfo *ai = NULL;
(void)ip_version;
-#ifdef CURL_DISABLE_VERBOSE_STRINGS
- (void)data;
-#endif
ai = Curl_ipv4_resolve_r(hostname, port);
if(!ai)
size_t nwritten;
CURLcode result;
- (void)data;
if(Curl_bufq_is_empty(&ctx->outbufq))
return CURLE_OK;
{
struct cf_proxy_ctx *ctx = cf->ctx;
- (void)data;
CURL_TRC_CF(data, cf, "destroy");
curlx_free(ctx);
}
struct pingpong *pp;
size_t nread = 0;
- (void)data;
if(!imapc || !imap)
return CURLE_FAILED_INIT;
pp = &imapc->pp;
{
struct imap_conn *imapc = Curl_conn_meta_get(conn, CURL_META_IMAP_CONN);
- (void)data;
if(imapc) {
/* We cannot send quit unconditionally. If this connection is stale or
bad in any way (pingpong has pending data to send),
uint32_t checks_to_perform)
{
unsigned int ret_val = CONNRESULT_NONE;
- (void)data;
if(checks_to_perform & CONNCHECK_ISDEAD) {
bool input_pending;
DEBUGASSERT(ps->init == CURL_EASY_POLLSET_MAGIC);
#endif
- (void)data;
DEBUGASSERT(VALID_SOCK(sock));
if(!VALID_SOCK(sock))
return CURLE_BAD_FUNCTION_ARGUMENT;
static CURLcode cr_in_init(struct Curl_easy *data, struct Curl_creader *reader)
{
struct cr_in_ctx *ctx = reader->ctx;
- (void)data;
ctx->read_cb = data->state.fread_func;
ctx->cb_user_data = data->state.in;
ctx->total_len = -1;
struct cr_buf_ctx *ctx = reader->ctx;
size_t nread = ctx->blen - ctx->index;
- (void)data;
if(!nread || !ctx->buf) {
*pnread = 0;
*peos = TRUE;
{
struct smtp_conn *smtpc = Curl_conn_meta_get(conn, CURL_META_SMTP_CONN);
- (void)data;
if(!smtpc)
return CURLE_FAILED_INIT;
*/
char proxy_env[20];
const char *envp = proxy_env;
-#ifdef CURL_DISABLE_VERBOSE_STRINGS
- (void)data;
-#endif
curl_msnprintf(proxy_env, sizeof(proxy_env), "%s_proxy",
conn->handler->scheme);
int port = -1;
CURLcode result = CURLE_OK;
-#ifdef CURL_DISABLE_VERBOSE_STRINGS
- (void)data;
-#endif
-
*hostname_result = NULL;
*port_result = -1;
status == SEC_I_COMPLETE_AND_CONTINUE)
Curl_pSecFn->CompleteAuthToken(&credentials, &resp_desc);
else if(status != SEC_E_OK && status != SEC_I_CONTINUE_NEEDED) {
-#ifndef CURL_DISABLE_VERBOSE_STRINGS
- char buffer[STRERROR_LEN];
-#endif
-
Curl_pSecFn->FreeCredentialsHandle(&credentials);
Curl_sspi_free_identity(p_identity);
curlx_free(spn);
return CURLE_OUT_OF_MEMORY;
#ifndef CURL_DISABLE_VERBOSE_STRINGS
- infof(data, "schannel: InitializeSecurityContext failed: %s",
- Curl_sspi_strerror(status, buffer, sizeof(buffer)));
+ {
+ char buffer[STRERROR_LEN];
+ infof(data, "schannel: InitializeSecurityContext failed: %s",
+ Curl_sspi_strerror(status, buffer, sizeof(buffer)));
+ }
#endif
return CURLE_AUTH_ERROR;
SecBufferDesc chlg_desc;
SECURITY_STATUS status;
- (void)data;
-
/* Query the security package for DigestSSP */
status =
Curl_pSecFn->QuerySecurityPackageInfo(
status == SEC_I_COMPLETE_AND_CONTINUE)
Curl_pSecFn->CompleteAuthToken(&credentials, &resp_desc);
else if(status != SEC_E_OK && status != SEC_I_CONTINUE_NEEDED) {
-#ifndef CURL_DISABLE_VERBOSE_STRINGS
- char buffer[STRERROR_LEN];
-#endif
-
Curl_pSecFn->FreeCredentialsHandle(&credentials);
Curl_sspi_free_identity(p_identity);
return CURLE_OUT_OF_MEMORY;
#ifndef CURL_DISABLE_VERBOSE_STRINGS
- infof(data, "schannel: InitializeSecurityContext failed: %s",
- Curl_sspi_strerror(status, buffer, sizeof(buffer)));
+ {
+ char buffer[STRERROR_LEN];
+ infof(data, "schannel: InitializeSecurityContext failed: %s",
+ Curl_sspi_strerror(status, buffer, sizeof(buffer)));
+ }
#endif
return CURLE_AUTH_ERROR;
SecPkgContext_Sizes sizes;
SECURITY_STATUS status;
-#ifdef CURL_DISABLE_VERBOSE_STRINGS
- (void)data;
-#endif
-
/* Ensure we have a valid challenge message */
DEBUGASSERT(chlg);
if(!Curl_bufref_len(chlg)) {
const unsigned char *type2 = Curl_bufref_uptr(type2ref);
size_t type2len = Curl_bufref_len(type2ref);
-#ifdef CURL_DISABLE_VERBOSE_STRINGS
- (void)data;
-#endif
-
if(type2len >= 48) {
target_info_len = Curl_read16_le(&type2[40]);
target_info_offset = Curl_read32_le(&type2[44]);
const unsigned char *type2 = Curl_bufref_uptr(type2ref);
size_t type2len = Curl_bufref_len(type2ref);
-#ifdef CURL_DISABLE_VERBOSE_STRINGS
- (void)data;
-#endif
-
ntlm->flags = 0;
if((type2len < 32) ||
const struct bufref *type2,
struct ntlmdata *ntlm)
{
-#ifdef CURL_DISABLE_VERBOSE_STRINGS
- (void)data;
-#endif
-
/* Ensure we have a valid type-2 message */
if(!Curl_bufref_len(type2)) {
infof(data, "NTLM handshake failure (empty type-2 message)");
SECURITY_STATUS status;
unsigned long attrs;
-#ifdef CURL_DISABLE_VERBOSE_STRINGS
- (void)data;
-#endif
(void)passwdp;
(void)userp;
SecBufferDesc resp_desc;
unsigned long attrs;
-#ifdef CURL_DISABLE_VERBOSE_STRINGS
- (void)data;
-#endif
-
if(nego->context && nego->status == SEC_E_OK) {
/* We finished successfully our part of authentication, but server
* rejected it (since we are again here). Exit with an error since we
int fin = (flags & NGTCP2_STREAM_DATA_FLAG_FIN) ? 1 : 0;
struct Curl_easy *data = stream_user_data;
(void)offset;
- (void)data;
nconsumed =
nghttp3_conn_read_stream(ctx->h3conn, stream_id, buf, buflen, fin);
(void)tconn;
(void)final_size;
(void)app_error_code;
- (void)data;
rv = nghttp3_conn_shutdown_stream_read(ctx->h3conn, stream_id);
CURL_TRC_CF(data, cf, "[%" PRId64 "] reset -> %d", stream_id, rv);
struct Curl_easy *data = stream_user_data;
int rv;
(void)conn;
- (void)data;
rv = ngtcp2_conn_shutdown_stream_write(ctx->qconn, 0, stream_id,
app_error_code);
struct Curl_cfilter *cf = NULL;
CURLcode result;
- (void)data;
ctx = curlx_calloc(1, sizeof(*ctx));
if(!ctx) {
result = CURLE_OUT_OF_MEMORY;
struct Curl_cfilter *cf = NULL;
CURLcode result;
- (void)data;
ctx = curlx_calloc(1, sizeof(*ctx));
if(!ctx) {
result = CURLE_OUT_OF_MEMORY;
struct Curl_cfilter *cf = NULL;
CURLcode result;
- (void)data;
- (void)conn;
ctx = curlx_calloc(1, sizeof(*ctx));
if(!ctx) {
result = CURLE_OUT_OF_MEMORY;
const struct connectdata *conn,
unsigned char transport)
{
- (void)conn;
(void)data;
+ (void)conn;
(void)transport;
DEBUGF(infof(data, "QUIC is not supported in this build"));
return CURLE_NOT_BUILT_IN;
ssize_t nwritten;
size_t remain = blen;
- (void)data;
DEBUGASSERT(backend);
*pnwritten = 0;
struct gtls_ssl_backend_data *backend =
(struct gtls_ssl_backend_data *)connssl->backend;
- (void)data;
DEBUGASSERT(backend);
CURL_TRC_CF(data, cf, "close");
if(backend->gtls.session) {
CURLcode result = CURLE_OK;
ssize_t nread;
- (void)data;
DEBUGASSERT(backend);
nread = gnutls_record_recv(backend->gtls.session, buf, blen);
CURLcode result = CURLE_OK;
int nwritten;
- (void)data;
DEBUGASSERT(backend);
*pnwritten = 0;
connssl->io_need = CURL_SSL_IO_NEED_NONE;
CURLcode result = CURLE_OK;
int nread;
- (void)data;
DEBUGASSERT(backend);
*pnread = 0;
connssl->io_need = CURL_SSL_IO_NEED_NONE;
CURLcode result = CURLE_OK;
int nwritten;
- (void)data;
DEBUGASSERT(octx);
*pnwritten = 0;
ERR_clear_error();
CURLcode result = CURLE_OK;
int nread;
- (void)data;
DEBUGASSERT(octx);
*pnread = 0;
const unsigned char *pubkey, size_t pubkeylen)
{
CURLcode result = CURLE_SSL_PINNEDPUBKEYNOTMATCH;
-#ifdef CURL_DISABLE_VERBOSE_STRINGS
- (void)data;
-#endif
/* if a path was not specified, do not pin */
if(!pinnedpubkey)
size_t remain = curlx_sotouz_range(dec->payload_len - dec->payload_offset,
0, SIZE_MAX);
- (void)data;
while(remain && Curl_bufq_peek(inraw, &inbuf, &inlen)) {
if(inlen > remain)
inlen = remain;