#include <sys/time.h>
#endif
-#ifdef __cplusplus
+#ifdef __cplusplus
extern "C" {
#endif
#elif defined(_WIN32) || \
(CURL_HAS_DECLSPEC_ATTRIBUTE(dllexport) && \
CURL_HAS_DECLSPEC_ATTRIBUTE(dllimport))
-# if defined(BUILDING_LIBCURL)
+# ifdef BUILDING_LIBCURL
# define CURL_EXTERN __declspec(dllexport)
# else
# define CURL_EXTERN __declspec(dllimport)
void *userptr);
-#ifdef __cplusplus
+#ifdef __cplusplus
} /* end of extern "C" */
#endif
* SPDX-License-Identifier: curl
*
***************************************************************************/
-#ifdef __cplusplus
+#ifdef __cplusplus
extern "C" {
#endif
*/
CURL_EXTERN CURLcode curl_easy_upkeep(CURL *curl);
-#ifdef __cplusplus
+#ifdef __cplusplus
} /* end of extern "C" */
#endif
*
***************************************************************************/
-#ifdef __cplusplus
+#ifdef __cplusplus
extern "C" {
#endif
#include <stdio.h> /* needed for FILE */
#include "curl.h" /* for CURL_EXTERN */
-#ifdef __cplusplus
+#ifdef __cplusplus
extern "C" {
#endif
defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
!defined(CURL_NO_FMT_CHECKS)
#if defined(__MINGW32__) && !defined(__clang__)
-#if defined(__MINGW_PRINTF_FORMAT) /* mingw-w64 3.0.0+. Needs stdio.h. */
+#ifdef __MINGW_PRINTF_FORMAT /* mingw-w64 3.0.0+. Needs stdio.h. */
#define CURL_TEMP_PRINTF(fmt, arg) \
__attribute__((format(__MINGW_PRINTF_FORMAT, fmt, arg)))
#else
#undef CURL_TEMP_PRINTF
-#ifdef __cplusplus
+#ifdef __cplusplus
} /* end of extern "C" */
#endif
*/
#include "curl.h"
-#ifdef __cplusplus
+#ifdef __cplusplus
extern "C" {
#endif
*
***************************************************************************/
-#ifdef __cplusplus
+#ifdef __cplusplus
extern "C" {
#endif
# define CURL_TYPEOF_CURL_SOCKLEN_T int
#elif defined(__POCC__)
-# if defined(_MSC_VER)
+# ifdef _MSC_VER
# define CURL_TYPEOF_CURL_OFF_T __int64
# define CURL_FORMAT_CURL_OFF_T "I64d"
# define CURL_FORMAT_CURL_OFF_TU "I64u"
# define CURL_TYPEOF_CURL_SOCKLEN_T int
#elif defined(__LCC__)
-# if defined(__MCST__) /* MCST eLbrus Compiler Collection */
+# ifdef __MCST__ /* MCST eLbrus Compiler Collection */
# define CURL_TYPEOF_CURL_OFF_T long
# define CURL_FORMAT_CURL_OFF_T "ld"
# define CURL_FORMAT_CURL_OFF_TU "lu"
# define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int
#elif defined(__TANDEM)
-# if !defined(__LP64)
+# ifndef __LP64
# define CURL_TYPEOF_CURL_OFF_T long long
# define CURL_FORMAT_CURL_OFF_T "lld"
# define CURL_FORMAT_CURL_OFF_TU "llu"
# endif
#elif defined(UNDER_CE)
-# if defined(__MINGW32CE__)
+# ifdef __MINGW32CE__
# define CURL_TYPEOF_CURL_OFF_T long long
# define CURL_FORMAT_CURL_OFF_T "lld"
# define CURL_FORMAT_CURL_OFF_TU "llu"
# define CURL_PULL_SYS_TYPES_H 1
#elif defined(__VMS)
-# if defined(__VAX)
+# ifdef __VAX
# define CURL_TYPEOF_CURL_OFF_T long
# define CURL_FORMAT_CURL_OFF_T "ld"
# define CURL_FORMAT_CURL_OFF_TU "lu"
# define CURL_PULL_SYS_SOCKET_H 1
#elif defined(__MVS__)
-# if defined(_LONG_LONG)
+# ifdef _LONG_LONG
# define CURL_TYPEOF_CURL_OFF_T long long
# define CURL_FORMAT_CURL_OFF_T "lld"
# define CURL_FORMAT_CURL_OFF_TU "llu"
#elif defined(__370__)
# if defined(__IBMC__) || defined(__IBMCPP__)
-# if defined(_LONG_LONG)
+# ifdef _LONG_LONG
# define CURL_TYPEOF_CURL_OFF_T long long
# define CURL_FORMAT_CURL_OFF_T "lld"
# define CURL_FORMAT_CURL_OFF_TU "llu"
# define CURL_PULL_SYS_SOCKET_H 1
#elif defined(__xlc__) /* IBM xlc compiler */
-# if !defined(_LP64)
+# ifndef _LP64
# define CURL_TYPEOF_CURL_OFF_T long long
# define CURL_FORMAT_CURL_OFF_T "lld"
# define CURL_FORMAT_CURL_OFF_TU "llu"
# define CURL_PULL_SYS_SOCKET_H 1
#elif defined(__hpux) /* HP aCC compiler */
-# if !defined(_LP64)
+# ifndef _LP64
# define CURL_TYPEOF_CURL_OFF_T long long
# define CURL_FORMAT_CURL_OFF_T "lld"
# define CURL_FORMAT_CURL_OFF_TU "llu"
#include "curl.h"
-#ifdef __cplusplus
+#ifdef __cplusplus
extern "C" {
#endif
*
***************************************************************************/
-#ifdef __cplusplus
+#ifdef __cplusplus
extern "C" {
#endif
CURL_EXTERN const struct curl_ws_frame *curl_ws_meta(CURL *curl);
-#ifdef __cplusplus
+#ifdef __cplusplus
}
#endif
#ifdef USE_CURL_ASYNC
struct Curl_async {
-#ifdef CURLRES_ARES /* */
+#ifdef CURLRES_ARES
struct async_ares_ctx ares;
#elif defined(CURLRES_THREADED)
struct async_thrdd_ctx thrdd;
extern struct Curl_cftype Curl_cft_h2_proxy;
-
-#endif /* defined(USE_NGHTTP2) && !defined(CURL_DISABLE_PROXY) */
+#endif /* USE_NGHTTP2 && !CURL_DISABLE_PROXY */
#endif /* HEADER_CURL_H2_PROXY_H */
#include "curl_setup.h"
-#if !defined(CURL_DISABLE_PROXY)
+#ifndef CURL_DISABLE_PROXY
#include <curl/curl.h>
#include "urldata.h"
#include "curl_setup.h"
#include "urldata.h"
-#if !defined(CURL_DISABLE_PROXY)
+#ifndef CURL_DISABLE_PROXY
CURLcode Curl_cf_haproxy_insert_after(struct Curl_cfilter *cf_at,
struct Curl_easy *data);
#include "curl_setup.h"
-#if !defined(CURL_DISABLE_HTTP)
+#ifndef CURL_DISABLE_HTTP
#include "urldata.h"
#include <curl/curl.h>
return result;
}
-#endif /* !defined(CURL_DISABLE_HTTP) */
+#endif /* !CURL_DISABLE_HTTP */
***************************************************************************/
#include "curl_setup.h"
-#if !defined(CURL_DISABLE_HTTP)
+#ifndef CURL_DISABLE_HTTP
struct Curl_cfilter;
struct Curl_easy;
int sockindex);
-#endif /* !defined(CURL_DISABLE_HTTP) */
+#endif /* !CURL_DISABLE_HTTP */
#endif /* HEADER_CURL_CF_HTTP_H */
static void tcpnodelay(struct Curl_easy *data, curl_socket_t sockfd)
{
-#if defined(TCP_NODELAY)
+#ifdef TCP_NODELAY
curl_socklen_t onoff = (curl_socklen_t) 1;
int level = IPPROTO_TCP;
char buffer[STRERROR_LEN];
(void)data;
if(setsockopt(sockfd, SOL_SOCKET, SO_NOSIGPIPE,
(void *)&onoff, sizeof(onoff)) < 0) {
-#if !defined(CURL_DISABLE_VERBOSE_STRINGS)
+#ifndef CURL_DISABLE_VERBOSE_STRINGS
char buffer[STRERROR_LEN];
infof(data, "Could not set SO_NOSIGPIPE: %s",
Curl_strerror(SOCKERRNO, buffer, sizeof(buffer)));
sockfd, SOCKERRNO);
}
else {
-#if defined(SIO_KEEPALIVE_VALS) /* Windows */
+#ifdef SIO_KEEPALIVE_VALS /* Windows */
/* Windows 10, version 1709 (10.0.16299) and later versions */
-#if defined(CURL_WINSOCK_KEEP_SSO)
+#ifdef CURL_WINSOCK_KEEP_SSO
optval = curlx_sltosi(data->set.tcp_keepidle);
KEEPALIVE_FACTOR(optval);
if(setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPIDLE,
switch(error) {
case SOCKEINPROGRESS:
case SOCKEWOULDBLOCK:
-#if defined(EAGAIN)
+#ifdef EAGAIN
#if (EAGAIN) != (SOCKEWOULDBLOCK)
/* On some platforms EAGAIN and EWOULDBLOCK are the
* same value, and on others they are different, hence
(void)data;
if(is_tcp_fastopen) {
-#if defined(CONNECT_DATA_IDEMPOTENT) /* Darwin */
-# if defined(HAVE_BUILTIN_AVAILABLE)
+#ifdef CONNECT_DATA_IDEMPOTENT /* Darwin */
+# ifdef HAVE_BUILTIN_AVAILABLE
/* while connectx function is available since macOS 10.11 / iOS 9,
it did not have the interface declared correctly until
Xcode 9 / macOS SDK 10.13 */
else
*pnwritten = (size_t)nwritten;
-#if defined(USE_WINSOCK)
+#ifdef USE_WINSOCK
if(!result)
win_update_sndbuf_size(ctx);
#endif
}
#endif /* USE_SSL */
-#if !defined(CURL_DISABLE_HTTP)
+#ifndef CURL_DISABLE_HTTP
if(cf->conn->bits.tunnel_proxy) {
result = Curl_cf_http_proxy_insert_after(cf, data);
if(result)
#endif /* !CURL_DISABLE_PROXY */
if(ctx->state < CF_SETUP_CNNCT_HAPROXY) {
-#if !defined(CURL_DISABLE_PROXY)
+#ifndef CURL_DISABLE_PROXY
if(data->set.haproxyprotocol) {
if(Curl_conn_is_ssl(cf->conn, cf->sockindex)) {
failf(data, "haproxy protocol not support with SSL "
Curl_resolv_unlink(data, &data->state.dns[sockindex]);
data->state.dns[sockindex] = dns;
-#if !defined(CURL_DISABLE_HTTP)
+#ifndef CURL_DISABLE_HTTP
if(!conn->cfilter[sockindex] &&
conn->handler->protocol == CURLPROTO_HTTPS) {
DEBUGASSERT(ssl_mode != CURL_CF_SSL_DISABLE);
if(result)
goto out;
}
-#endif /* !defined(CURL_DISABLE_HTTP) */
+#endif /* !CURL_DISABLE_HTTP */
/* Still no cfilter set, apply default. */
if(!conn->cfilter[sockindex]) {
Curl_detach_connection(data);
for(i = 0; i < ps.num; i++) {
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Warith-conversion"
#endif
FD_SET(ps.sockets[i], read_fd_set);
if(ps.actions[i] & CURL_POLL_OUT)
FD_SET(ps.sockets[i], write_fd_set);
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic pop
#endif
if((ps.actions[i] & (CURL_POLL_OUT | CURL_POLL_IN)) &&
*/
#if defined(__INTEL_COMPILER) && (__INTEL_COMPILER == 910) && \
- defined(__OPTIMIZE__) && defined(__unix__) && defined(__i386__)
+ defined(__OPTIMIZE__) && defined(__unix__) && defined(__i386__)
/* workaround icc 9.1 optimizer issue */
# define vqualifier volatile
#else
freeaddrinfo(freethis);
#endif
}
-#endif /* defined(CURLDEBUG) && defined(HAVE_FREEADDRINFO) */
+#endif /* CURLDEBUG && HAVE_FREEADDRINFO */
#if defined(CURLDEBUG) && defined(HAVE_GETADDRINFO)
source, line);
return res;
}
-#endif /* defined(CURLDEBUG) && defined(HAVE_GETADDRINFO) */
+#endif /* CURLDEBUG && HAVE_GETADDRINFO */
#if defined(HAVE_GETADDRINFO) && defined(USE_RESOLVE_ON_IPS)
/*
#include "curl_memory.h"
#include "memdebug.h"
-#if defined(__GNUC__)
+#ifdef __GNUC__
#define CURL_ALIGN8 __attribute__((aligned(8)))
#else
#define CURL_ALIGN8
#include "curl_setup.h"
#include <curl/curl.h>
-#if defined(USE_CURL_NTLM_CORE)
+#ifdef USE_CURL_NTLM_CORE
#define MD4_DIGEST_LENGTH 16
CURLcode Curl_md4it(unsigned char *output, const unsigned char *input,
const size_t len);
-#endif /* defined(USE_CURL_NTLM_CORE) */
+#endif /* USE_CURL_NTLM_CORE */
#endif /* HEADER_CURL_MD4_H */
#include "curl_setup.h"
-#if defined(USE_CURL_NTLM_CORE)
+#ifdef USE_CURL_NTLM_CORE
/*
* NTLM details:
in NTLM type-3 messages.
*/
-#if defined(USE_OPENSSL)
+#ifdef USE_OPENSSL
#include <openssl/opensslconf.h>
#if !defined(OPENSSL_NO_DES) && !defined(OPENSSL_NO_DEPRECATED_3_0)
#define USE_OPENSSL_DES
#endif
#elif defined(USE_WOLFSSL)
#include <wolfssl/options.h>
- #if !defined(NO_DES3)
+ #ifndef NO_DES3
#define USE_OPENSSL_DES
#endif
#endif
-#if defined(USE_OPENSSL_DES)
+#ifdef USE_OPENSSL_DES
-#if defined(USE_OPENSSL)
+#ifdef USE_OPENSSL
# include <openssl/des.h>
# include <openssl/md5.h>
# include <openssl/ssl.h>
# include <openssl/rand.h>
-# if defined(OPENSSL_IS_AWSLC)
+# ifdef OPENSSL_IS_AWSLC
# define DES_set_key_unchecked (void)DES_set_key
# define DESKEYARG(x) *x
# define DESKEY(x) &x
# include <wolfssl/openssl/md5.h>
# include <wolfssl/openssl/ssl.h>
# include <wolfssl/openssl/rand.h>
-# if defined(OPENSSL_COEXIST)
+# ifdef OPENSSL_COEXIST
# define DES_key_schedule WOLFSSL_DES_key_schedule
# define DES_cblock WOLFSSL_DES_cblock
# define DES_set_odd_parity wolfSSL_DES_set_odd_parity
#include "curl_memory.h"
#include "memdebug.h"
-#if !defined(CURL_NTLM_NOT_SUPPORTED)
+#ifndef CURL_NTLM_NOT_SUPPORTED
/*
* Turns a 56-bit key into being 64-bit wide.
*/
}
#endif
-#if defined(USE_OPENSSL_DES)
+#ifdef USE_OPENSSL_DES
/*
* Turns a 56-bit key into a 64-bit, odd parity key and sets the key. The
* key schedule ks is also set.
return TRUE;
}
-#endif /* defined(USE_WIN32_CRYPTO) */
+#endif /* USE_WIN32_CRYPTO */
/*
* takes a 21 byte array and treats it as 3 56-bit DES keys. The
const unsigned char *plaintext,
unsigned char *results)
{
-#if defined(USE_OPENSSL_DES)
+#ifdef USE_OPENSSL_DES
DES_key_schedule ks;
setup_des_key(keys, DESKEY(ks));
unsigned char *lmbuffer /* 21 bytes */)
{
unsigned char pw[14];
-#if !defined(CURL_NTLM_NOT_SUPPORTED)
+#ifndef CURL_NTLM_NOT_SUPPORTED
static const unsigned char magic[] = {
0x4B, 0x47, 0x53, 0x21, 0x40, 0x23, 0x24, 0x25 /* i.e. KGS!@#$% */
};
{
/* Create LanManager hashed password. */
-#if defined(USE_OPENSSL_DES)
+#ifdef USE_OPENSSL_DES
DES_key_schedule ks;
setup_des_key(pw, DESKEY(ks));
}
}
-#if !defined(USE_WINDOWS_SSPI)
+#ifndef USE_WINDOWS_SSPI
static void ascii_uppercase_to_unicode_le(unsigned char *dest,
const char *src, size_t srclen)
return result;
}
-#if !defined(USE_WINDOWS_SSPI)
+#ifndef USE_WINDOWS_SSPI
#define NTLMv2_BLOB_SIGNATURE "\x01\x01\x00\x00"
#define NTLMv2_BLOB_LEN (44 -16 + ntlm->target_info_len + 4)
#include "curl_setup.h"
-#if defined(USE_CURL_NTLM_CORE)
+#ifdef USE_CURL_NTLM_CORE
#include "vauth/vauth.h"
CURLcode Curl_ntlm_core_mk_nt_hash(const char *password,
unsigned char *ntbuffer /* 21 bytes */);
-#if !defined(USE_WINDOWS_SSPI)
+#ifndef USE_WINDOWS_SSPI
CURLcode Curl_hmac_md5(const unsigned char *key, unsigned int keylen,
const unsigned char *data, unsigned int datalen,
/* Calculate the supported authentication mechanism, by decreasing order of
security, as well as the initial response where appropriate */
if(sasl_choose_external(data, &sctx) ||
-#if defined(USE_KERBEROS5)
+#ifdef USE_KERBEROS5
sasl_choose_krb5(data, &sctx) ||
#endif
#ifdef USE_GSASL
}
#endif
-#if defined(USE_KERBEROS5)
+#ifdef USE_KERBEROS5
case SASL_GSSAPI: {
struct kerberos5data *krb5 = Curl_auth_krb5_get(conn);
result = !krb5 ? CURLE_OUT_OF_MEMORY :
#define CURL_CONC_MACROS(A,B) CURL_CONC_MACROS_(A,B)
/* curl uses its own printf() function internally. It understands the GNU
- * format. Use this format, so that is matches the GNU format attribute we
+ * format. Use this format, so that it matches the GNU format attribute we
* use with the MinGW compiler, allowing it to verify them at compile-time.
*/
-#ifdef __MINGW32__
+#ifdef __MINGW32__
# undef CURL_FORMAT_CURL_OFF_T
# undef CURL_FORMAT_CURL_OFF_TU
# define CURL_FORMAT_CURL_OFF_T "lld"
#ifndef SIZEOF_OFF_T
# if defined(__VMS) && !defined(__VAX)
-# if defined(_LARGEFILE)
+# ifdef _LARGEFILE
# define SIZEOF_OFF_T 8
# endif
# elif defined(__OS400__) && defined(__ILEC400__)
-# if defined(_LARGE_FILES)
+# ifdef _LARGE_FILES
# define SIZEOF_OFF_T 8
# endif
# elif defined(__MVS__) && defined(__IBMC__)
/* for systems that do not detect this in configure */
#ifndef CURL_SA_FAMILY_T
-# if defined(HAVE_SA_FAMILY_T)
+# ifdef HAVE_SA_FAMILY_T
# define CURL_SA_FAMILY_T sa_family_t
# elif defined(HAVE_ADDRESS_FAMILY)
# define CURL_SA_FAMILY_T ADDRESS_FAMILY
#endif
#if defined(USE_UNIX_SOCKETS) && defined(_WIN32)
-# if !defined(UNIX_PATH_MAX)
+# ifndef UNIX_PATH_MAX
/* Replicating logic present in afunix.h
(distributed with newer Windows 10 SDK versions only) */
# define UNIX_PATH_MAX 108
* * Rustls
* Skip the backend if it does not support the required algorithm */
-#if defined(USE_OPENSSL)
+#ifdef USE_OPENSSL
# include <openssl/opensslv.h>
# if (!defined(LIBRESSL_VERSION_NUMBER) && \
defined(OPENSSL_VERSION_NUMBER) && \
#if !defined(HAS_SHA512_256_IMPLEMENTATION) && defined(USE_GNUTLS)
# include <nettle/sha.h>
-# if defined(SHA512_256_DIGEST_SIZE)
+# ifdef SHA512_256_DIGEST_SIZE
# define USE_GNUTLS_SHA512_256 1
# endif
#endif /* ! HAS_SHA512_256_IMPLEMENTATION && USE_GNUTLS */
-#if defined(USE_OPENSSL_SHA512_256)
+#ifdef USE_OPENSSL_SHA512_256
/* OpenSSL does not provide macros for SHA-512/256 sizes */
#include <curl/curl.h>
-#if defined(USE_THREADS_POSIX)
+#ifdef USE_THREADS_POSIX
# ifdef HAVE_PTHREAD_H
# include <pthread.h>
# endif
/* The last #include file should be: */
#include "memdebug.h"
-#if defined(USE_THREADS_POSIX)
+#ifdef USE_THREADS_POSIX
struct Curl_actual_call {
unsigned int (*func)(void *);
***************************************************************************/
#include "curl_setup.h"
-#if defined(USE_THREADS_POSIX)
+#ifdef USE_THREADS_POSIX
# define CURL_STDCALL
# define curl_mutex_t pthread_mutex_t
# define curl_thread_t pthread_t *
}
}
-#if !defined(CURL_DISABLE_VERBOSE_STRINGS)
+#ifndef CURL_DISABLE_VERBOSE_STRINGS
static void trc_infof(struct Curl_easy *data,
struct curl_trc_feat *feat,
{ &Curl_cft_ssl_proxy, TRC_CT_PROXY },
#endif
#endif
-#if !defined(CURL_DISABLE_PROXY)
-#if !defined(CURL_DISABLE_HTTP)
+#ifndef CURL_DISABLE_PROXY
+#ifndef CURL_DISABLE_HTTP
{ &Curl_cft_h1_proxy, TRC_CT_PROXY },
#ifdef USE_NGHTTP2
{ &Curl_cft_h2_proxy, TRC_CT_PROXY },
#if !defined(CURL_DISABLE_HTTP) && defined(USE_HTTP3)
{ &Curl_cft_http3, TRC_CT_PROTOCOL },
#endif
-#if !defined(CURL_DISABLE_HTTP)
+#ifndef CURL_DISABLE_HTTP
{ &Curl_cft_http_connect, TRC_CT_PROTOCOL },
#endif
};
#endif
}
-#else /* defined(CURL_DISABLE_VERBOSE_STRINGS) */
+#else /* CURL_DISABLE_VERBOSE_STRINGS */
CURLcode Curl_trc_init(void)
{
}
#endif
-#endif /* !defined(CURL_DISABLE_VERBOSE_STRINGS) */
+#endif /* !CURL_DISABLE_VERBOSE_STRINGS */
(ft)->log_level >= CURL_LOG_LVL_INFO)
#define CURL_MSTATE_NAME(s) Curl_trc_mstate_name((int)(s))
-#else /* defined(CURL_DISABLE_VERBOSE_STRINGS) */
+#else /* CURL_DISABLE_VERBOSE_STRINGS */
/* All informational messages are not compiled in for size savings */
#define Curl_trc_is_verbose(d) (FALSE)
#define Curl_trc_ft_is_verbose(x,y) (FALSE)
#define CURL_MSTATE_NAME(x) ((void)(x), "-")
-#endif /* !defined(CURL_DISABLE_VERBOSE_STRINGS) */
+#endif /* !CURL_DISABLE_VERBOSE_STRINGS */
#endif /* HEADER_CURL_TRC_H */
int curlx_nonblock(curl_socket_t sockfd, /* operate on this */
int nonblock /* TRUE or FALSE */)
{
-#if defined(HAVE_FCNTL_O_NONBLOCK)
+#ifdef HAVE_FCNTL_O_NONBLOCK
/* most recent Unix versions */
int flags;
flags = sfcntl(sockfd, F_GETFL, 0);
SET_SOCKERRNO(SOCKEINVAL);
return -1;
}
-#if defined(MSDOS)
+#ifdef MSDOS
delay((unsigned int)timeout_ms);
#elif defined(_WIN32)
/* prevent overflow, timeout_ms is typecast to ULONG/DWORD. */
* ways, but at this point it must be defined as the system-supplied strdup
* so the callback pointer is initialized correctly.
*/
-#if defined(UNDER_CE)
+#ifdef UNDER_CE
#define system_strdup _strdup
#elif !defined(HAVE_STRDUP)
#define system_strdup Curl_strdup
bool found = FALSE;
struct Curl_easy *data = easy;
-#if defined(CURL_DISABLE_VERBOSE_STRINGS)
+#ifdef CURL_DISABLE_VERBOSE_STRINGS
(void)easy;
#endif
(void)socketp;
return result;
}
-
/*
* curl_easy_perform() is the external interface that performs a blocking
* transfer as previously setup.
{
return easy_perform(data, TRUE);
}
-
#endif
/*
#elif defined(HAVE_ATOMIC) && defined(HAVE_STDATOMIC_H)
#include <stdatomic.h>
-#if defined(HAVE_SCHED_YIELD)
+#ifdef HAVE_SCHED_YIELD
#include <sched.h>
#endif
mode |= O_TRUNC;
#if (defined(ANDROID) || defined(__ANDROID__)) && \
- (defined(__i386__) || defined(__arm__))
+ (defined(__i386__) || defined(__arm__))
fd = open(file->path, mode, (mode_t)data->set.new_file_perms);
#else
fd = open(file->path, mode, data->set.new_file_perms);
***************************************************************************/
#include "curl_setup.h"
+
#ifndef CURL_DISABLE_FTP
+
#include "strdup.h"
#include "fileinfo.h"
#include "curl_memory.h"
curlx_dyn_free(&finfo->buf);
free(finfo);
}
+
#endif
result = CURLE_WRITE_ERROR;
#if (defined(ANDROID) || defined(__ANDROID__)) && \
- (defined(__i386__) || defined(__arm__))
+ (defined(__i386__) || defined(__arm__))
fd = open(tempstore, O_WRONLY | O_CREAT | O_EXCL, (mode_t)(0600|sb.st_mode));
#else
fd = open(tempstore, O_WRONLY | O_CREAT | O_EXCL, 0600|sb.st_mode);
#endif
)
{
-#if defined(CURL_DISABLE_VERBOSE_STRINGS)
+#ifdef CURL_DISABLE_VERBOSE_STRINGS
(void)data;
#ifdef DEBUGBUILD
(void)lineno;
struct Curl_addrinfo *head = NULL, *tail = NULL;
size_t entry_len;
char address[64];
-#if !defined(CURL_DISABLE_VERBOSE_STRINGS)
+#ifndef CURL_DISABLE_VERBOSE_STRINGS
const char *addresses = NULL;
#endif
curl_off_t port = 0;
curlx_str_single(&host, ':'))
goto err;
-#if !defined(CURL_DISABLE_VERBOSE_STRINGS)
+#ifndef CURL_DISABLE_VERBOSE_STRINGS
addresses = host;
#endif
#endif /* CURLRES_SYNCH */
#endif /* CURLRES_IPV4 */
-#if defined(CURLRES_IPV4) && \
- !defined(CURLRES_ARES) && !defined(CURLRES_AMIGA)
+#if defined(CURLRES_IPV4) && !defined(CURLRES_ARES) && !defined(CURLRES_AMIGA)
/*
* Curl_ipv4_resolve_r() - ipv4 threadsafe resolver function.
int port)
{
#if !(defined(HAVE_GETADDRINFO) && defined(HAVE_GETADDRINFO_THREADSAFE)) && \
- defined(HAVE_GETHOSTBYNAME_R_3)
+ defined(HAVE_GETHOSTBYNAME_R_3)
int res;
#endif
struct Curl_addrinfo *ai = NULL;
* platforms.
*/
-#if defined(HAVE_GETHOSTBYNAME_R_5)
+#ifdef HAVE_GETHOSTBYNAME_R_5
/* Solaris, IRIX and more */
h = gethostbyname_r(hostname,
(struct hostent *)buf,
return ai;
}
-#endif /* defined(CURLRES_IPV4) && !defined(CURLRES_ARES) &&
- !defined(CURLRES_AMIGA) */
+#endif /* CURLRES_IPV4 && !CURLRES_ARES && !CURLRES_AMIGA */
#include "curl_memory.h"
#include "memdebug.h"
-#if defined(CURLRES_SYNCH)
+#ifdef CURLRES_SYNCH
#ifdef DEBUG_ADDRINFO
static void dump_addrinfo(const struct Curl_addrinfo *ai)
if(abort_upload) {
/* We'd like to abort the upload - but should we? */
-#if defined(USE_NTLM)
+#ifdef USE_NTLM
if((data->state.authproxy.picked == CURLAUTH_NTLM) ||
(data->state.authhost.picked == CURLAUTH_NTLM)) {
ongoing_auth = "NTLM";
}
}
#endif
-#if defined(USE_SPNEGO)
+#ifdef USE_SPNEGO
/* There is still data left to send */
if((data->state.authproxy.picked == CURLAUTH_NEGOTIATE) ||
(data->state.authhost.picked == CURLAUTH_NEGOTIATE)) {
ptr = Curl_checkheaders(data, STRCONST("Host"));
if(ptr && (!data->state.this_is_a_follow ||
curl_strequal(data->state.first_host, conn->host.name))) {
-#if !defined(CURL_DISABLE_COOKIES)
+#ifndef 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
custom Host: header if this is NOT a redirect, as setting Host: in the
return result;
}
-#if !defined(CURL_DISABLE_COOKIES)
+#ifndef CURL_DISABLE_COOKIES
static CURLcode http_cookies(struct Curl_easy *data,
struct connectdata *conn,
(void)hdlen;
#endif
-#if !defined(CURL_DISABLE_COOKIES)
+#ifndef CURL_DISABLE_COOKIES
v = (data->cookies && data->state.cookie_engine) ?
HD_VAL(hd, hdlen, "Set-Cookie:") : NULL;
if(v) {
/* At this point we have some idea about the fate of the connection.
If we are closing the connection it may result auth failure. */
-#if defined(USE_NTLM)
+#ifdef USE_NTLM
if(conn->bits.close &&
(((data->req.httpcode == 401) &&
(conn->http_ntlm_state == NTLMSTATE_TYPE2)) ||
data->state.authproblem = TRUE;
}
#endif
-#if defined(USE_SPNEGO)
+#ifdef USE_SPNEGO
if(conn->bits.close &&
(((data->req.httpcode == 401) &&
(conn->http_negotiate_state == GSS_AUTHRECV)) ||
#ifndef CURL_DISABLE_HTTP
-#if defined(USE_HTTP3)
+#ifdef USE_HTTP3
#include <stdint.h>
#endif
const uint8_t *value, size_t valuelen,
uint8_t flags,
void *userp);
-#if !defined(CURL_DISABLE_VERBOSE_STRINGS)
+#ifndef CURL_DISABLE_VERBOSE_STRINGS
static int error_callback(nghttp2_session *session, const char *msg,
size_t len, void *userp);
#endif
nghttp2_session_callbacks_set_on_begin_headers_callback(
cbs, on_begin_headers);
nghttp2_session_callbacks_set_on_header_callback(cbs, on_header);
-#if !defined(CURL_DISABLE_VERBOSE_STRINGS)
+#ifndef CURL_DISABLE_VERBOSE_STRINGS
nghttp2_session_callbacks_set_error_callback(cbs, error_callback);
#endif
return (nread == 0) ? NGHTTP2_ERR_DEFERRED : nread;
}
-#if !defined(CURL_DISABLE_VERBOSE_STRINGS)
+#ifndef CURL_DISABLE_VERBOSE_STRINGS
static int error_callback(nghttp2_session *session,
const char *msg,
size_t len,
return true;
}
-#endif /* !defined(CURL_DISABLE_HTTP) && !defined(CURL_DISABLE_AWS) */
+#endif /* !CURL_DISABLE_HTTP && !CURL_DISABLE_AWS */
if(!passwdp)
passwdp = "";
-#if defined(USE_WINDOWS_SSPI)
+#ifdef USE_WINDOWS_SSPI
have_chlg = !!digest->input_token;
#else
have_chlg = !!digest->nonce;
/* SSL backend-specific #if branches in this file must be kept in the order
documented in curl_ntlm_core. */
-#if defined(USE_WINDOWS_SSPI)
+#ifdef USE_WINDOWS_SSPI
#include "curl_sspi.h"
#endif
#define HTTPS_RR_CODE_ECH 0x05
#define HTTPS_RR_CODE_IPV6 0x06
-#if defined(USE_ARES)
+#ifdef USE_ARES
CURLcode Curl_httpsrr_from_ares(struct Curl_easy *data,
const ares_dns_record_t *dnsrec,
struct Curl_https_rrinfo *hinfo);
#include "memdebug.h"
/* for macOS and iOS targets */
-#if defined(USE_APPLE_IDN)
+#ifdef USE_APPLE_IDN
#include <unicode/uidna.h>
#include <iconv.h>
#include <langinfo.h>
#if !defined(CURL_DISABLE_BINDLOCAL) || !defined(CURL_DISABLE_FTP)
-#if defined(HAVE_GETIFADDRS)
+#ifdef HAVE_GETIFADDRS
if2ip_result_t Curl_if2ip(int af,
#ifdef USE_IPV6
*/
/* Wincrypt must be included before anything that could include OpenSSL. */
-#if defined(USE_WIN32_CRYPTO)
+#ifdef USE_WIN32_CRYPTO
#include <wincrypt.h>
/* Undefine wincrypt conflicting symbols for BoringSSL. */
#undef X509_NAME
struct ldap_urldesc {
char *lud_host;
int lud_port;
-#if defined(USE_WIN32_LDAP)
+#ifdef USE_WIN32_LDAP
TCHAR *lud_dn;
TCHAR **lud_attrs;
#else
char **lud_attrs;
#endif
int lud_scope;
-#if defined(USE_WIN32_LDAP)
+#ifdef USE_WIN32_LDAP
TCHAR *lud_filter;
#else
char *lud_filter;
};
#endif
-#if defined(USE_WIN32_LDAP)
+#ifdef USE_WIN32_LDAP
-#if defined(USE_WINDOWS_SSPI)
+#ifdef USE_WINDOWS_SSPI
static int ldap_win_bind_auth(LDAP *server, const char *user,
const char *passwd, unsigned long authflags)
{
memset(&cred, 0, sizeof(cred));
-#if defined(USE_SPNEGO)
+#ifdef USE_SPNEGO
if(authflags & CURLAUTH_NEGOTIATE) {
method = LDAP_AUTH_NEGOTIATE;
}
else
#endif
-#if defined(USE_NTLM)
+#ifdef USE_NTLM
if(authflags & CURLAUTH_NTLM) {
method = LDAP_AUTH_NTLM;
}
else
#endif
-#if !defined(CURL_DISABLE_DIGEST_AUTH)
+#ifndef CURL_DISABLE_DIGEST_AUTH
if(authflags & CURLAUTH_DIGEST) {
method = LDAP_AUTH_DIGEST;
}
}
return rc;
}
-#endif /* #if defined(USE_WINDOWS_SSPI) */
+#endif /* USE_WINDOWS_SSPI */
static int ldap_win_bind(struct Curl_easy *data, LDAP *server,
const char *user, const char *passwd)
curlx_unicodefree(inuser);
curlx_unicodefree(inpass);
}
-#if defined(USE_WINDOWS_SSPI)
+#ifdef USE_WINDOWS_SSPI
else {
rc = (int)ldap_win_bind_auth(server, user, passwd, data->set.httpauth);
}
return rc;
}
-#endif /* #if defined(USE_WIN32_LDAP) */
+#endif /* USE_WIN32_LDAP */
-#if defined(USE_WIN32_LDAP)
+#ifdef USE_WIN32_LDAP
#define FREE_ON_WINLDAP(x) curlx_unicodefree(x)
#define curl_ldap_num_t ULONG
#else
#ifdef LDAP_OPT_NETWORK_TIMEOUT
struct timeval ldap_timeout = {10, 0}; /* 10 sec connection/search timeout */
#endif
-#if defined(USE_WIN32_LDAP)
+#ifdef USE_WIN32_LDAP
TCHAR *host = NULL;
#else
char *host = NULL;
infof(data, "LDAP local: trying to establish %s connection",
ldap_ssl ? "encrypted" : "cleartext");
-#if defined(USE_WIN32_LDAP)
+#ifdef USE_WIN32_LDAP
host = curlx_convert_UTF8_to_tchar(conn->host.name);
if(!host) {
result = CURLE_OUT_OF_MEMORY;
entryIterator;
entryIterator = ldap_next_entry(server, entryIterator), num++) {
BerElement *ber = NULL;
-#if defined(USE_WIN32_LDAP)
+#ifdef USE_WIN32_LDAP
TCHAR *attribute;
#else
char *attribute;
{
char *name;
size_t name_len;
-#if defined(USE_WIN32_LDAP)
+#ifdef USE_WIN32_LDAP
TCHAR *dn = ldap_get_dn(server, entryIterator);
name = curlx_convert_tchar_to_UTF8(dn);
if(!name) {
attribute = ldap_next_attribute(server, entryIterator, ber)) {
BerValue **vals;
size_t attr_len;
-#if defined(USE_WIN32_LDAP)
+#ifdef USE_WIN32_LDAP
char *attr = curlx_convert_tchar_to_UTF8(attribute);
if(!attr) {
if(ber)
goto quit;
}
-#if defined(USE_WIN32_LDAP)
+#ifdef USE_WIN32_LDAP
/* Convert the unescaped string to a tchar */
ludp->lud_dn = curlx_convert_UTF8_to_tchar(unescaped);
const char *atp = p;
/* Allocate our array (+1 for the NULL entry) */
-#if defined(USE_WIN32_LDAP)
+#ifdef USE_WIN32_LDAP
ludp->lud_attrs = calloc(count + 1, sizeof(TCHAR *));
#else
ludp->lud_attrs = calloc(count + 1, sizeof(char *));
goto quit;
}
-#if defined(USE_WIN32_LDAP)
+#ifdef USE_WIN32_LDAP
/* Convert the unescaped string to a tchar */
ludp->lud_attrs[i] = curlx_convert_UTF8_to_tchar(unescaped);
goto quit;
}
-#if defined(USE_WIN32_LDAP)
+#ifdef USE_WIN32_LDAP
/* Convert the unescaped string to a tchar */
ludp->lud_filter = curlx_convert_UTF8_to_tchar(unescaped);
if(!ludp)
return;
-#if defined(USE_WIN32_LDAP)
+#ifdef USE_WIN32_LDAP
curlx_unicodefree(ludp->lud_dn);
curlx_unicodefree(ludp->lud_filter);
#else
if(ludp->lud_attrs) {
size_t i;
for(i = 0; i < ludp->lud_attrs_dups; i++) {
-#if defined(USE_WIN32_LDAP)
+#ifdef USE_WIN32_LDAP
curlx_unicodefree(ludp->lud_attrs[i]);
#else
free(ludp->lud_attrs[i]);
#include "curl_setup.h"
-#if defined(USE_CURL_NTLM_CORE)
+#ifdef USE_CURL_NTLM_CORE
#include <string.h>
static void MD4_Final(unsigned char *result, MD4_CTX *ctx)
{
if(ctx->data) {
-#if !defined(HAS_MBEDTLS_RESULT_CODE_BASED_FUNCTIONS)
+#ifndef HAS_MBEDTLS_RESULT_CODE_BASED_FUNCTIONS
mbedtls_md4(ctx->data, ctx->size, result);
#else
(void)mbedtls_md4_ret(ctx->data, ctx->size, result);
#endif
#endif
-#if defined(USE_GNUTLS)
+#ifdef USE_GNUTLS
#include <nettle/md5.h>
#elif defined(USE_OPENSSL_MD5)
#include <openssl/md5.h>
#include "curl_memory.h"
#include "memdebug.h"
-#if defined(USE_GNUTLS)
+#ifdef USE_GNUTLS
typedef struct md5_ctx my_md5_ctx;
const unsigned char *data,
unsigned int length)
{
-#if !defined(HAS_MBEDTLS_RESULT_CODE_BASED_FUNCTIONS)
+#ifndef HAS_MBEDTLS_RESULT_CODE_BASED_FUNCTIONS
(void)mbedtls_md5_update(ctx, data, length);
#else
(void)mbedtls_md5_update_ret(ctx, data, length);
static void my_md5_final(unsigned char *digest, void *ctx)
{
-#if !defined(HAS_MBEDTLS_RESULT_CODE_BASED_FUNCTIONS)
+#ifndef HAS_MBEDTLS_RESULT_CODE_BASED_FUNCTIONS
(void)mbedtls_md5_finish(ctx, digest);
#else
(void)mbedtls_md5_finish_ret(ctx, digest);
*/
if((data->set.reuse_forbid
-#if defined(USE_NTLM)
+#ifdef USE_NTLM
&& !(conn->http_ntlm_state == NTLMSTATE_TYPE2 ||
conn->proxy_ntlm_state == NTLMSTATE_TYPE2)
#endif
-#if defined(USE_SPNEGO)
+#ifdef USE_SPNEGO
&& !(conn->http_negotiate_state == GSS_AUTHRECV ||
conn->proxy_negotiate_state == GSS_AUTHRECV)
#endif
if(!FDSET_SOCK(ps.sockets[i]))
/* pretend it does not exist */
continue;
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Warith-conversion"
#endif
FD_SET(ps.sockets[i], read_fd_set);
if(ps.actions[i] & CURL_POLL_OUT)
FD_SET(ps.sockets[i], write_fd_set);
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic pop
#endif
if((int)ps.sockets[i] > this_max_fd)
#define CURLPIPE_ANY (CURLPIPE_MULTIPLEX)
-#if !defined(CURL_DISABLE_SOCKETPAIR)
+#ifndef CURL_DISABLE_SOCKETPAIR
#define ENABLE_WAKEUP
#endif
{
memset(entropy, 0, length);
-#if defined(HAVE_WIN_BCRYPTGENRANDOM)
+#ifdef HAVE_WIN_BCRYPTGENRANDOM
if(BCryptGenRandom(NULL, entropy, (ULONG)length,
BCRYPT_USE_SYSTEM_PREFERRED_RNG) != STATUS_SUCCESS)
return CURLE_FAILED_INIT;
}
#endif
-#if !defined(USE_SSL)
+#ifndef USE_SSL
/* ---- possibly non-cryptographic version following ---- */
static CURLcode weak_random(struct Curl_easy *data,
unsigned char *entropy,
}
#endif
-#if defined(HAVE_ARC4RANDOM)
+#ifdef HAVE_ARC4RANDOM
(void)data;
r = (unsigned int)arc4random();
memcpy(entropy, &r, length);
#include "curl_setup.h"
-#if !defined(CURL_DISABLE_RTSP)
+#ifndef CURL_DISABLE_RTSP
#include "urldata.h"
#include <curl/curl.h>
data->set.postfieldsize = arg;
break;
#ifndef CURL_DISABLE_HTTP
-#if !defined(CURL_DISABLE_COOKIES)
+#ifndef CURL_DISABLE_COOKIES
case CURLOPT_COOKIESESSION:
/*
* Set this option to TRUE to start a new "cookie session". It will
}
return Curl_setstropt(&data->set.str[STRING_ENCODING], ptr);
-#if !defined(CURL_DISABLE_AWS)
+#ifndef CURL_DISABLE_AWS
case CURLOPT_AWS_SIGV4:
/*
* String that is merged to some authentication
*/
return Curl_setstropt(&data->set.str[STRING_USERAGENT], ptr);
-#if !defined(CURL_DISABLE_COOKIES)
+#ifndef CURL_DISABLE_COOKIES
case CURLOPT_COOKIE:
/*
* Cookie string to send to the remote server in the request.
static CURLcode my_sha256_init(void *ctx)
{
-#if !defined(HAS_MBEDTLS_RESULT_CODE_BASED_FUNCTIONS)
+#ifndef HAS_MBEDTLS_RESULT_CODE_BASED_FUNCTIONS
(void)mbedtls_sha256_starts(ctx, 0);
#else
(void)mbedtls_sha256_starts_ret(ctx, 0);
const unsigned char *data,
unsigned int length)
{
-#if !defined(HAS_MBEDTLS_RESULT_CODE_BASED_FUNCTIONS)
+#ifndef HAS_MBEDTLS_RESULT_CODE_BASED_FUNCTIONS
(void)mbedtls_sha256_update(ctx, data, length);
#else
(void)mbedtls_sha256_update_ret(ctx, data, length);
static void my_sha256_final(unsigned char *digest, void *ctx)
{
-#if !defined(HAS_MBEDTLS_RESULT_CODE_BASED_FUNCTIONS)
+#ifndef HAS_MBEDTLS_RESULT_CODE_BASED_FUNCTIONS
(void)mbedtls_sha256_finish(ctx, digest);
#else
(void)mbedtls_sha256_finish_ret(ctx, digest);
};
typedef struct sha256_ctx my_sha256_ctx;
-#if !defined(CALG_SHA_256)
+#ifndef CALG_SHA_256
#define CALG_SHA_256 0x0000800c
#endif
return CURLE_OK;
}
-#endif /* CURL_DISABLE_SMB && USE_CURL_NTLM_CORE &&
- SIZEOF_CURL_OFF_T > 4 */
+#endif /* CURL_DISABLE_SMB && USE_CURL_NTLM_CORE && SIZEOF_CURL_OFF_T > 4 */
***************************************************************************/
#if !defined(CURL_DISABLE_SMB) && defined(USE_CURL_NTLM_CORE) && \
- (SIZEOF_CURL_OFF_T > 4)
+ (SIZEOF_CURL_OFF_T > 4)
extern const struct Curl_handler Curl_handler_smb;
extern const struct Curl_handler Curl_handler_smbs;
-#endif /* CURL_DISABLE_SMB && USE_CURL_NTLM_CORE &&
- SIZEOF_CURL_OFF_T > 4 */
+#endif /* CURL_DISABLE_SMB && USE_CURL_NTLM_CORE && SIZEOF_CURL_OFF_T > 4 */
#endif /* HEADER_CURL_SMB_H */
#include "curl_setup.h"
-#if !defined(CURL_DISABLE_PROXY)
+#ifndef CURL_DISABLE_PROXY
#ifdef HAVE_NETINET_IN_H
#include <netinet/in.h>
&as /* to */,
allowed_alpns);
}
- #endif
- #ifdef USE_HTTP2
+#endif
+#ifdef USE_HTTP2
if(!hit && (neg->wanted & CURL_HTTP_V2x) &&
!neg->h2_prior_knowledge) {
srcalpnid = ALPN_h2;
&as /* to */,
allowed_alpns);
}
- #endif
+#endif
if(!hit && (neg->wanted & CURL_HTTP_V1x) &&
!neg->only_10) {
srcalpnid = ALPN_h1;
memset(&data->state.priority, 0, sizeof(data->state.priority));
}
-#endif /* defined(USE_HTTP2) || defined(USE_HTTP3) */
+#endif /* USE_HTTP2 || USE_HTTP3 */
CURLcode Curl_conn_meta_set(struct connectdata *conn, const char *key,
void Curl_data_priority_clear_state(struct Curl_easy *data);
#else
#define Curl_data_priority_clear_state(x)
-#endif /* !(defined(USE_HTTP2) || defined(USE_HTTP3)) */
+#endif /* USE_HTTP2 || USE_HTTP3 */
#ifdef USE_NGHTTP2
CURLcode Curl_data_priority_add_child(struct Curl_easy *parent,
#ifndef CURL_DISABLE_DIGEST_AUTH
/* Struct used for Digest challenge-response authentication */
struct digestdata {
-#if defined(USE_WINDOWS_SSPI)
+#ifdef USE_WINDOWS_SSPI
BYTE *input_token;
size_t input_token_len;
CtxtHandle *http_context;
CtxtHandle *sslContext;
#endif
-#if defined(USE_NTLM)
+#ifdef USE_NTLM
curlntlm http_ntlm_state;
curlntlm proxy_ntlm_state;
#endif
struct Curl_async async; /* asynchronous name resolver data */
#endif
-#if defined(USE_OPENSSL)
+#ifdef USE_OPENSSL
/* void instead of ENGINE to avoid bleeding OpenSSL into this header */
void *engine;
/* void instead of OSSL_PROVIDER */
STRING_FTP_ALTERNATIVE_TO_USER, /* command to send if USER/PASS fails */
STRING_FTPPORT, /* port to send with the FTP PORT command */
#endif
-#if defined(HAVE_GSSAPI)
+#ifdef HAVE_GSSAPI
STRING_KRB_LEVEL, /* krb security level */
#endif
#ifndef CURL_DISABLE_NETRC
location: */
BIT(opt_no_body); /* as set with CURLOPT_NOBODY */
BIT(verbose); /* output verbosity */
-#if defined(HAVE_GSSAPI)
+#ifdef HAVE_GSSAPI
BIT(krb); /* Kerberos connection requested */
#endif
BIT(reuse_forbid); /* forbidden to be reused, close after use */
status == SEC_I_COMPLETE_AND_CONTINUE)
Curl_pSecFn->CompleteAuthToken(&credentials, &resp_desc);
else if(status != SEC_E_OK && status != SEC_I_CONTINUE_NEEDED) {
-#if !defined(CURL_DISABLE_VERBOSE_STRINGS)
+#ifndef CURL_DISABLE_VERBOSE_STRINGS
char buffer[STRERROR_LEN];
#endif
if(status == SEC_E_INSUFFICIENT_MEMORY)
return CURLE_OUT_OF_MEMORY;
-#if !defined(CURL_DISABLE_VERBOSE_STRINGS)
+#ifndef CURL_DISABLE_VERBOSE_STRINGS
infof(data, "schannel: InitializeSecurityContext failed: %s",
Curl_sspi_strerror(status, buffer, sizeof(buffer)));
#endif
status == SEC_I_COMPLETE_AND_CONTINUE)
Curl_pSecFn->CompleteAuthToken(&credentials, &resp_desc);
else if(status != SEC_E_OK && status != SEC_I_CONTINUE_NEEDED) {
-#if !defined(CURL_DISABLE_VERBOSE_STRINGS)
+#ifndef CURL_DISABLE_VERBOSE_STRINGS
char buffer[STRERROR_LEN];
#endif
if(status == SEC_E_INSUFFICIENT_MEMORY)
return CURLE_OUT_OF_MEMORY;
-#if !defined(CURL_DISABLE_VERBOSE_STRINGS)
+#ifndef CURL_DISABLE_VERBOSE_STRINGS
infof(data, "schannel: InitializeSecurityContext failed: %s",
Curl_sspi_strerror(status, buffer, sizeof(buffer)));
#endif
SecPkgContext_Sizes sizes;
SECURITY_STATUS status;
-#if defined(CURL_DISABLE_VERBOSE_STRINGS)
+#ifdef CURL_DISABLE_VERBOSE_STRINGS
(void)data;
#endif
const unsigned char *type2 = Curl_bufref_ptr(type2ref);
size_t type2len = Curl_bufref_len(type2ref);
-#if defined(CURL_DISABLE_VERBOSE_STRINGS)
+#ifdef CURL_DISABLE_VERBOSE_STRINGS
(void)data;
#endif
const unsigned char *type2 = Curl_bufref_ptr(type2ref);
size_t type2len = Curl_bufref_len(type2ref);
-#if defined(CURL_DISABLE_VERBOSE_STRINGS)
+#ifdef CURL_DISABLE_VERBOSE_STRINGS
(void)data;
#endif
const struct bufref *type2,
struct ntlmdata *ntlm)
{
-#if defined(CURL_DISABLE_VERBOSE_STRINGS)
+#ifdef CURL_DISABLE_VERBOSE_STRINGS
(void)data;
#endif
unsigned long attrs;
TimeStamp expiry; /* For Windows 9x compatibility of SSPI calls */
-#if defined(CURL_DISABLE_VERBOSE_STRINGS)
+#ifdef CURL_DISABLE_VERBOSE_STRINGS
(void)data;
#endif
(void)passwdp;
unsigned long attrs;
TimeStamp expiry; /* For Windows 9x compatibility of SSPI calls */
-#if defined(CURL_DISABLE_VERBOSE_STRINGS)
+#ifdef CURL_DISABLE_VERBOSE_STRINGS
(void)data;
#endif
*
* Returns a pointer to the newly allocated SPN.
*/
-#if !defined(USE_WINDOWS_SSPI)
+#ifndef USE_WINDOWS_SSPI
char *Curl_auth_build_spn(const char *service, const char *host,
const char *realm)
{
struct Curl_easy;
struct connectdata;
-#if !defined(CURL_DISABLE_DIGEST_AUTH)
+#ifndef CURL_DISABLE_DIGEST_AUTH
struct digestdata;
#endif
-#if defined(USE_NTLM)
+#ifdef USE_NTLM
struct ntlmdata;
#endif
struct negotiatedata;
#endif
-#if defined(USE_GSASL)
+#ifdef USE_GSASL
struct gsasldata;
#endif
bool Curl_auth_allowed_to_host(struct Curl_easy *data);
/* This is used to build an SPN string */
-#if !defined(USE_WINDOWS_SSPI)
+#ifndef USE_WINDOWS_SSPI
char *Curl_auth_build_spn(const char *service, const char *host,
const char *realm);
#else
void Curl_auth_gsasl_cleanup(struct gsasldata *digest);
#endif
-#if defined(USE_NTLM)
+#ifdef USE_NTLM
/* meta key for storing NTML meta at connection */
#define CURL_META_NTLM_CONN "meta:auth:ntml:conn"
const char *bearer,
struct bufref *out);
-#if defined(USE_KERBEROS5)
+#ifdef USE_KERBEROS5
#ifdef HAVE_GSSAPI
# ifdef HAVE_GSSGNU
#define CURL_META_KRB5_CONN "meta:auth:krb5:conn"
struct kerberos5data {
-#if defined(USE_WINDOWS_SSPI)
+#ifdef USE_WINDOWS_SSPI
CredHandle *credentials;
CtxtHandle *context;
TCHAR *spn;
!defined(CURL_DISABLE_HTTP)
FEATURE("HTTPS-proxy", https_proxy_present, CURL_VERSION_HTTPS_PROXY),
#endif
-#if defined(USE_HTTPSRR)
+#ifdef USE_HTTPSRR
FEATURE("HTTPSRR", NULL, 0),
#endif
#if defined(USE_LIBIDN2) || defined(USE_WIN32_IDN) || defined(USE_APPLE_IDN)
#ifdef USE_NTLM
FEATURE("NTLM", NULL, CURL_VERSION_NTLM),
#endif
-#if defined(USE_LIBPSL)
+#ifdef USE_LIBPSL
FEATURE("PSL", NULL, CURL_VERSION_PSL),
#endif
#ifdef USE_SPNEGO
#ifdef USE_SSL
FEATURE("SSL", NULL, CURL_VERSION_SSL),
#endif
-#if defined(USE_SSLS_EXPORT)
+#ifdef USE_SSLS_EXPORT
FEATURE("SSLS-EXPORT", NULL, 0),
#endif
#ifdef USE_WINDOWS_SSPI
const struct feat *p;
int features = 0;
-#if defined(USE_SSH)
+#ifdef USE_SSH
static char ssh_buf[80]; /* 'ssh_buffer' clashes with libssh/libssh.h */
#endif
#ifdef USE_SSL
version_info.libidn = idn2_check_version(IDN2_VERSION);
#endif
-#if defined(USE_SSH)
+#ifdef USE_SSH
Curl_ssh_version(ssh_buf, sizeof(ssh_buf));
version_info.libssh_version = ssh_buf;
#endif
return "SSL_ERROR_WANT_CONNECT";
case SSL_ERROR_WANT_ACCEPT:
return "SSL_ERROR_WANT_ACCEPT";
-#if defined(SSL_ERROR_WANT_ASYNC)
+#ifdef SSL_ERROR_WANT_ASYNC
case SSL_ERROR_WANT_ASYNC:
return "SSL_ERROR_WANT_ASYNC";
#endif
-#if defined(SSL_ERROR_WANT_ASYNC_JOB)
+#ifdef SSL_ERROR_WANT_ASYNC_JOB
case SSL_ERROR_WANT_ASYNC_JOB:
return "SSL_ERROR_WANT_ASYNC_JOB";
#endif
-#if defined(SSL_ERROR_WANT_EARLY)
+#ifdef SSL_ERROR_WANT_EARLY
case SSL_ERROR_WANT_EARLY:
return "SSL_ERROR_WANT_EARLY";
#endif
else
err_descr = "SSL certificate verification failed";
}
-#if defined(SSL_R_TLSV13_ALERT_CERTIFICATE_REQUIRED)
+#ifdef SSL_R_TLSV13_ALERT_CERTIFICATE_REQUIRED
/* SSL_R_TLSV13_ALERT_CERTIFICATE_REQUIRED is only available on
OpenSSL version above v1.1.1, not LibreSSL, BoringSSL, or AWS-LC */
else if((lib == ERR_LIB_SSL) &&
vquic_recv_pkt_cb *recv_cb, void *userp)
{
CURLcode result;
-#if defined(HAVE_SENDMMSG)
+#ifdef HAVE_SENDMMSG
result = recvmmsg_packets(cf, data, qctx, max_pkts, recv_cb, userp);
#elif defined(HAVE_SENDMSG)
result = recvmsg_packets(cf, data, qctx, max_pkts, recv_cb, userp);
#include "../curl_setup.h"
-#if defined(USE_SSH)
+#ifdef USE_SSH
#include "curl_path.h"
#include <curl/curl.h>
#include "../curl_setup.h"
-#if defined(USE_LIBSSH2)
+#ifdef USE_LIBSSH2
#include <libssh2.h>
#include <libssh2_sftp.h>
#elif defined(USE_LIBSSH)
int orig_waitfor; /* default READ/WRITE bits wait for */
char *slash_pos; /* used by the SFTP_CREATE_DIRS state */
-#if defined(USE_LIBSSH)
+#ifdef USE_LIBSSH
CURLcode actualcode; /* the actual error code */
char *readdir_linkPath;
size_t readdir_len;
#endif
#endif
-#if defined(USE_LIBSSH2)
+#ifdef USE_LIBSSH2
/* Feature detection based on version numbers to better work with
non-configure platforms */
"SHA" "\0"
"SHA256" "\0"
"SHA384" "\0"
-#if defined(USE_MBEDTLS)
+#ifdef USE_MBEDTLS
"ARIA" "\0"
"ARIA128" "\0"
"ARIA256" "\0"
CS_TXT_IDX_SHA,
CS_TXT_IDX_SHA256,
CS_TXT_IDX_SHA384,
-#if defined(USE_MBEDTLS)
+#ifdef USE_MBEDTLS
CS_TXT_IDX_ARIA,
CS_TXT_IDX_ARIA128,
CS_TXT_IDX_ARIA256,
CS_ENTRY(0xCCA8, ECDHE,RSA,CHACHA20,POLY1305,,,,),
CS_ENTRY(0xCCA9, TLS,ECDHE,ECDSA,WITH,CHACHA20,POLY1305,SHA256,),
CS_ENTRY(0xCCA9, ECDHE,ECDSA,CHACHA20,POLY1305,,,,),
-#if defined(USE_MBEDTLS)
+#ifdef USE_MBEDTLS
CS_ENTRY(0x002F, TLS,RSA,WITH,AES,128,CBC,SHA,),
CS_ENTRY(0x002F, AES128,SHA,,,,,,),
CS_ENTRY(0x0035, TLS,RSA,WITH,AES,256,CBC,SHA,),
CS_ENTRY(0xC032, TLS,ECDH,RSA,WITH,AES,256,GCM,SHA384),
CS_ENTRY(0xC032, ECDH,RSA,AES256,GCM,SHA384,,,),
#endif
-#if defined(USE_MBEDTLS)
+#ifdef USE_MBEDTLS
CS_ENTRY(0x0001, TLS,RSA,WITH,NULL,MD5,,,),
CS_ENTRY(0x0001, NULL,MD5,,,,,,),
CS_ENTRY(0x0002, TLS,RSA,WITH,NULL,SHA,,,),
CS_ENTRY(0xCCAB, TLS,PSK,WITH,CHACHA20,POLY1305,SHA256,,),
CS_ENTRY(0xCCAB, PSK,CHACHA20,POLY1305,,,,,),
#endif
-#if defined(USE_MBEDTLS)
+#ifdef USE_MBEDTLS
CS_ENTRY(0xC09C, TLS,RSA,WITH,AES,128,CCM,,),
CS_ENTRY(0xC09C, AES128,CCM,,,,,,),
CS_ENTRY(0xC09D, TLS,RSA,WITH,AES,256,CCM,,),
CS_ENTRY(0xC0AF, TLS,ECDHE,ECDSA,WITH,AES,256,CCM,8),
CS_ENTRY(0xC0AF, ECDHE,ECDSA,AES256,CCM8,,,,),
#endif
-#if defined(USE_MBEDTLS)
+#ifdef USE_MBEDTLS
/* entries marked ns are "non-standard", they are not in OpenSSL */
CS_ENTRY(0x0041, TLS,RSA,WITH,CAMELLIA,128,CBC,SHA,),
CS_ENTRY(0x0041, CAMELLIA128,SHA,,,,,,),
* on QUIC this is common. */
init_flags |= GNUTLS_ENABLE_EARLY_DATA;
-#if defined(GNUTLS_FORCE_CLIENT_CERT)
+#ifdef GNUTLS_FORCE_CLIENT_CERT
init_flags |= GNUTLS_FORCE_CLIENT_CERT;
#endif
-#if defined(GNUTLS_NO_TICKETS_TLS12)
+#ifdef GNUTLS_NO_TICKETS_TLS12
init_flags |= GNUTLS_NO_TICKETS_TLS12;
#endif
-#if defined(GNUTLS_NO_STATUS_REQUEST)
+#ifdef GNUTLS_NO_STATUS_REQUEST
if(!config->verifystatus)
/* Disable the "status_request" TLS extension, enabled by default since
GnuTLS 3.8.0. */
}
-#if defined(MBEDTLS_SSL_RENEGOTIATION)
+#ifdef MBEDTLS_SSL_RENEGOTIATION
mbedtls_ssl_conf_renegotiation(&backend->config,
MBEDTLS_SSL_RENEGOTIATION_ENABLED);
#endif
-#if defined(MBEDTLS_SSL_SESSION_TICKETS)
+#ifdef MBEDTLS_SSL_SESSION_TICKETS
mbedtls_ssl_conf_session_tickets(&backend->config,
MBEDTLS_SSL_SESSION_TICKETS_DISABLED);
#endif
static CURLcode mbedtls_random(struct Curl_easy *data,
unsigned char *entropy, size_t length)
{
-#if defined(MBEDTLS_CTR_DRBG_C)
+#ifdef MBEDTLS_CTR_DRBG_C
int ret;
mbedtls_entropy_context ctr_entropy;
mbedtls_ctr_drbg_context ctr_drbg;
#endif
static CURLcode ossl_set_engine(struct Curl_easy *data, const char *engine);
-#if defined(OPENSSL_HAS_PROVIDERS)
+#ifdef OPENSSL_HAS_PROVIDERS
static CURLcode ossl_set_provider(struct Curl_easy *data,
const char *provider);
#endif
}
break;
#endif
-#if defined(OPENSSL_HAS_PROVIDERS)
+#ifdef OPENSSL_HAS_PROVIDERS
/* fall through to compatible provider */
case SSL_FILETYPE_PROVIDER:
{
}
break;
#endif
-#if defined(OPENSSL_HAS_PROVIDERS)
+#ifdef OPENSSL_HAS_PROVIDERS
/* fall through to compatible provider */
case SSL_FILETYPE_PROVIDER:
{
return list;
}
-#if defined(OPENSSL_HAS_PROVIDERS)
+#ifdef OPENSSL_HAS_PROVIDERS
static void ossl_provider_cleanup(struct Curl_easy *data)
{
goto cleanup;
}
-#if defined(USE_ECH)
+#ifdef USE_ECH
if(ECH_ENABLED(data)) {
tls_versions[0] = RUSTLS_TLS_VERSION_TLSV1_3;
tls_versions_len = 1;
return result;
}
-#if defined(USE_ECH)
+#ifdef USE_ECH
static CURLcode
init_config_builder_ech(struct Curl_easy *data,
const struct ssl_connect_data *connssl,
}
}
-#if defined(USE_ECH)
+#ifdef USE_ECH
if(ECH_ENABLED(data)) {
result = init_config_builder_ech(data, connssl, config_builder);
if(result != CURLE_OK && data->set.tls_ech & CURLECH_HARD) {
#pragma warning(pop)
#endif
/* Wincrypt must be included before anything that could include OpenSSL. */
-#if defined(USE_WIN32_CRYPTO)
+#ifdef USE_WIN32_CRYPTO
#include <wincrypt.h>
/* Undefine wincrypt conflicting symbols for BoringSSL. */
#undef X509_NAME
* BoringSSL's <openssl/x509.h>: So just undefine those defines here
* (and only here).
*/
-#if defined(OPENSSL_IS_BORINGSSL)
+#ifdef OPENSSL_IS_BORINGSSL
# undef X509_NAME
# undef X509_CERT_PAIR
# undef X509_EXTENSIONS
BOOL Win8_compat)
{
DWORD actual_length = 0;
-#if defined(CURL_WINDOWS_UWP)
+#ifdef CURL_WINDOWS_UWP
(void)data;
(void)cert_context;
(void)host_names;
LPDWORD alt_name_info_size)
{
bool result = FALSE;
-#if defined(CURL_WINDOWS_UWP)
+#ifdef CURL_WINDOWS_UWP
(void)data;
(void)ctx;
(void)alt_name_info;
};
const struct Curl_ssl *Curl_ssl =
-#if defined(CURL_WITH_MULTI_SSL)
+#ifdef CURL_WITH_MULTI_SSL
&Curl_ssl_multi;
#elif defined(USE_WOLFSSL)
&Curl_ssl_wolfssl;
#endif
static const struct Curl_ssl *available_backends[] = {
-#if defined(USE_WOLFSSL)
+#ifdef USE_WOLFSSL
&Curl_ssl_wolfssl,
#endif
-#if defined(USE_GNUTLS)
+#ifdef USE_GNUTLS
&Curl_ssl_gnutls,
#endif
-#if defined(USE_MBEDTLS)
+#ifdef USE_MBEDTLS
&Curl_ssl_mbedtls,
#endif
-#if defined(USE_OPENSSL)
+#ifdef USE_OPENSSL
&Curl_ssl_openssl,
#endif
-#if defined(USE_SCHANNEL)
+#ifdef USE_SCHANNEL
&Curl_ssl_schannel,
#endif
-#if defined(USE_RUSTLS)
+#ifdef USE_RUSTLS
&Curl_ssl_rustls,
#endif
NULL
/* only cleanup if we did a previous init */
if(Curl_ssl->cleanup)
Curl_ssl->cleanup();
-#if defined(CURL_WITH_MULTI_SSL)
+#ifdef CURL_WITH_MULTI_SSL
Curl_ssl = &Curl_ssl_multi;
#endif
init_ssl = FALSE;
return id == Curl_ssl->info.id ||
(name && curl_strequal(name, Curl_ssl->info.name)) ?
CURLSSLSET_OK :
-#if defined(CURL_WITH_MULTI_SSL)
+#ifdef CURL_WITH_MULTI_SSL
CURLSSLSET_TOO_LATE;
#else
CURLSSLSET_UNKNOWN_BACKEND;
Curl_tls_keylog_write(label, client_random, secret, secretSz);
return 0;
}
-#endif /* defined(HAVE_SECRET_CALLBACK) && defined(WOLFSSL_TLS13) */
+#endif /* HAVE_SECRET_CALLBACK && WOLFSSL_TLS13 */
static void wssl_log_tls12_secret(WOLFSSL *ssl)
{
AC_DEFUN([CURL_INCLUDES_BSDSOCKET], [
curl_includes_bsdsocket="\
/* includes start */
-#if defined(HAVE_PROTO_BSDSOCKET_H)
+#ifdef HAVE_PROTO_BSDSOCKET_H
# define __NO_NET_API
# define __USE_INLINE__
# include <proto/bsdsocket.h>
{"rtmpts", "#ifdef USE_LIBRTMP" },
{"rtsp", "#ifndef CURL_DISABLE_RTSP" },
{"scp", "#if defined(USE_SSH) && !defined(USE_WOLFSSH)" },
- {"sftp", "#if defined(USE_SSH)" },
+ {"sftp", "#ifdef USE_SSH" },
{"smb", "#if !defined(CURL_DISABLE_SMB) && \\\n"
" defined(USE_CURL_NTLM_CORE) && (SIZEOF_CURL_OFF_T > 4)" },
{"smbs", "#if defined(USE_SSL) && !defined(CURL_DISABLE_SMB) && \\\n"
timeout.tv_usec = (int)((wait%1000)*1000);
FD_ZERO(&bits);
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Warith-conversion"
#endif
FD_SET(per->infd, &bits);
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic pop
#endif
if(!select(per->infd + 1, &bits, NULL, NULL, &timeout))
timeout.tv_usec = 1000;
FD_ZERO(&bits);
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Warith-conversion"
#endif
FD_SET(per->infd, &bits);
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic pop
#endif
select(per->infd + 1, &bits, NULL, NULL, &timeout);
#endif
}
}
-#endif /* defined(HAVE_UTIME) || defined(HAVE_UTIMES) || defined(_WIN32) */
+#endif /* HAVE_UTIME || HAVE_UTIMES || _WIN32 */
int getfiletime(const char *filename, struct GlobalConfig *global,
curl_off_t *stamp);
-#if defined(HAVE_UTIME) || defined(HAVE_UTIMES) || \
+#if defined(HAVE_UTIME) || defined(HAVE_UTIMES) || \
(defined(_WIN32) && (SIZEOF_CURL_OFF_T >= 8))
void setfiletime(curl_off_t filetime, const char *filename,
struct GlobalConfig *global);
#else
#define setfiletime(a,b,c) tool_nop_stmt
-#endif /* defined(HAVE_UTIME) || defined(HAVE_UTIMES) || \
- (defined(_WIN32) && (SIZEOF_CURL_OFF_T >= 8)) */
+#endif
#endif /* HEADER_CURL_TOOL_FILETIME_H */
int vms_show = 0;
#endif
-#if defined(__AMIGA__)
-#if defined(__GNUC__)
+#ifdef __AMIGA__
+#ifdef __GNUC__
#define CURL_USED __attribute__((used))
#else
#define CURL_USED
#ifdef _WIN32
if(!env) {
-#if defined(CURL_CA_SEARCH_SAFE)
+#ifdef CURL_CA_SEARCH_SAFE
char *cacert = NULL;
FILE *cafile = tool_execpath("curl-ca-bundle.crt", &cacert);
if(cafile) {
NULL, /* func to merge per server config */
NULL, /* command handlers */
curltest_hooks,
-#if defined(AP_MODULE_FLAG_NONE)
+#ifdef AP_MODULE_FLAG_NONE
AP_MODULE_FLAG_ALWAYS_MERGE
#endif
};
return CURL_SOCKOPT_ALREADY_CONNECTED;
}
-#if defined(__AMIGA__)
+#ifdef __AMIGA__
#define my_inet_pton(x,y,z) inet_pton(x,(unsigned char *)y,z)
#else
#define my_inet_pton(x,y,z) inet_pton(x,y,z)
#include "memdebug.h"
-#if defined(USE_THREADS_POSIX)
+#ifdef USE_THREADS_POSIX
#include <pthread.h>
#endif
return res;
}
-#else /* defined(HAVE_GETRLIMIT) && defined(HAVE_SETRLIMIT) */
+#else /* HAVE_GETRLIMIT && HAVE_SETRLIMIT */
static CURLcode test_lib518(char *URL)
{
return TEST_ERR_MAJOR_BAD; /* skip test */
}
-#endif /* defined(HAVE_GETRLIMIT) && defined(HAVE_SETRLIMIT) */
+#endif /* HAVE_GETRLIMIT && HAVE_SETRLIMIT */
{
int i;
for(i = 0; i < sockets->count; ++i) {
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Warith-conversion"
#endif
FD_SET(sockets->sockets[i], fdset);
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic pop
#endif
if(*maxFd < sockets->sockets[i] + 1) {
return res;
}
-#else /* defined(HAVE_GETRLIMIT) && defined(HAVE_SETRLIMIT) */
+#else /* HAVE_GETRLIMIT && HAVE_SETRLIMIT */
static CURLcode test_lib537(char *URL)
{
return TEST_ERR_MAJOR_BAD; /* skip test */
}
-#endif /* defined(HAVE_GETRLIMIT) && defined(HAVE_SETRLIMIT) */
+#endif /* HAVE_GETRLIMIT && HAVE_SETRLIMIT */
{
int i;
for(i = 0; i < sockets->count; ++i) {
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Warith-conversion"
#endif
FD_SET(sockets->sockets[i], fdset);
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic pop
#endif
if(*maxFd < sockets->sockets[i] + 1) {
FD_ZERO(&fds_err);
/* there's always a socket to wait for */
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Warith-conversion"
#endif
FD_SET(sockfd, &fds_read);
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic pop
#endif
while(argc > arg) {
if(!strcmp("--version", argv[arg])) {
printf("resolve IPv4%s\n",
-#if defined(CURLRES_IPV6)
+#ifdef CURLRES_IPV6
"/IPv6"
#else
""
return 0;
}
else if(!strcmp("--ipv6", argv[arg])) {
-#if defined(CURLRES_IPV6)
+#ifdef CURLRES_IPV6
ipv_inuse = "IPv6";
use_ipv6 = TRUE;
arg++;
else if(!strcmp("--ipv4", argv[arg])) {
/* for completeness, we support this option as well */
ipv_inuse = "IPv4";
-#if defined(CURLRES_IPV6)
+#ifdef CURLRES_IPV6
use_ipv6 = FALSE;
#endif
arg++;
puts("Usage: resolve [option] <host>\n"
" --version\n"
" --ipv4"
-#if defined(CURLRES_IPV6)
+#ifdef CURLRES_IPV6
"\n --ipv6"
#endif
);
return 2;
#endif
-#if defined(CURLRES_IPV6)
+#ifdef CURLRES_IPV6
if(use_ipv6) {
/* Check that the system has IPv6 enabled before checking the resolver */
curl_socket_t s = socket(PF_INET6, SOCK_DGRAM, 0);
FD_ZERO(&fds_write);
FD_ZERO(&fds_err);
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Warith-conversion"
#endif
FD_SET((curl_socket_t)fileno(stdin), &fds_read);
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic pop
#endif
/* server mode */
sockfd = listenfd;
/* there's always a socket to wait for */
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Warith-conversion"
#endif
FD_SET(sockfd, &fds_read);
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic pop
#endif
maxfd = (int)sockfd;
}
else {
/* there's always a socket to wait for */
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Warith-conversion"
#endif
FD_SET(sockfd, &fds_read);
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic pop
#endif
maxfd = (int)sockfd;
sockfd = *sockfdp;
/* sockfd turns CURL_SOCKET_BAD when our connection has been closed */
if(CURL_SOCKET_BAD != sockfd) {
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Warith-conversion"
#endif
FD_SET(sockfd, &fds_read);
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic pop
#endif
maxfd = (int)sockfd;
FD_ZERO(&fds_err);
/* there's always a socket to wait for */
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Warith-conversion"
#endif
FD_SET(sockfd, &fds_read);
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic pop
#endif
for(i = 0; i < 2; i++) {
if(c[i].used) {
curl_socket_t fd = c[i].clientfd;
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Warith-conversion"
#endif
FD_SET(fd, &fds_read);
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic pop
#endif
if((int)fd > maxfd)
maxfd = (int)fd;
fd = c[i].remotefd;
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Warith-conversion"
#endif
FD_SET(fd, &fds_read);
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic pop
#endif
if((int)fd > maxfd)
FD_ZERO(&input);
FD_ZERO(&output);
got = 0;
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Warith-conversion"
#endif
FD_SET(sock, &input);
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic pop
#endif
do {
timeout.tv_sec = 1; /* 1000 ms */
FD_ZERO(&output);
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Warith-conversion"
#endif
FD_SET(serverfd, &output);
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic pop
#endif
while(1) {
/* listener socket is monitored to allow client to establish
secondary tunnel only when this tunnel is not established
and primary one is fully operational */
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Warith-conversion"
#endif
FD_SET(rootfd, &input);
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic pop
#endif
maxfd = rootfd;
if(clientfd[i] != CURL_SOCKET_BAD) {
if(poll_client_rd[i]) {
/* unless told not to do so, monitor readability */
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Warith-conversion"
#endif
FD_SET(clientfd[i], &input);
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic pop
#endif
if(clientfd[i] > maxfd)
if(poll_client_wr[i] && toc[i]) {
/* unless told not to do so, monitor writability
if there is data ready to be sent to client */
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Warith-conversion"
#endif
FD_SET(clientfd[i], &output);
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic pop
#endif
if(clientfd[i] > maxfd)
if(serverfd[i] != CURL_SOCKET_BAD) {
if(poll_server_rd[i]) {
/* unless told not to do so, monitor readability */
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Warith-conversion"
#endif
FD_SET(serverfd[i], &input);
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic pop
#endif
if(serverfd[i] > maxfd)
if(poll_server_wr[i] && tos[i]) {
/* unless told not to do so, monitor writability
if there is data ready to be sent to server */
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Warith-conversion"
#endif
FD_SET(serverfd[i], &output);
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic pop
#endif
if(serverfd[i] > maxfd)
for(socket_idx = 0; socket_idx < num_sockets; ++socket_idx) {
/* Listen on all sockets */
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Warith-conversion"
#endif
FD_SET(all_sockets[socket_idx], &input);
-#if defined(__DJGPP__)
+#ifdef __DJGPP__
#pragma GCC diagnostic pop
#endif
if(all_sockets[socket_idx] > maxfd)
curl_socklen_t fromaddrlen;
for(;;) {
-#if defined(HAVE_IOCTLSOCKET_CAMEL_FIONBIO)
+#ifdef HAVE_IOCTLSOCKET_CAMEL_FIONBIO
long i;
(void)IoctlSocket(f, FIONBIO, &i);
#elif defined(HAVE_IOCTLSOCKET)
buffer);
curlx_dyn_free(&canonical_path);
}
-#endif /* !defined(CURL_DISABLE_HTTP) && !defined(CURL_DISABLE_AWS) */
+#endif /* !CURL_DISABLE_HTTP && !CURL_DISABLE_AWS */
UNITTEST_END_SIMPLE
}
buffer);
curlx_dyn_free(&canonical_query);
}
-#endif /* !defined(CURL_DISABLE_HTTP) && !defined(CURL_DISABLE_AWS) */
+#endif /* !CURL_DISABLE_HTTP && !CURL_DISABLE_AWS */
UNITTEST_END_SIMPLE
}
"ECDHE-RSA-CHACHA20-POLY1305" },
{ 0xCCA9, "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256",
"ECDHE-ECDSA-CHACHA20-POLY1305" },
-#if defined(USE_MBEDTLS)
+#ifdef USE_MBEDTLS
{ 0x002F, "TLS_RSA_WITH_AES_128_CBC_SHA",
"AES128-SHA" },
{ 0x0035, "TLS_RSA_WITH_AES_256_CBC_SHA",
{ 0xC030, "ECDHE-RSA-AES256-GCM-SHA384"},
{ 0xCCA9, "ECDHE-ECDSA-CHACHA20-POLY1305"},
{ 0xCCA8, "ECDHE-RSA-CHACHA20-POLY1305"},
-#if defined(USE_MBEDTLS)
+#ifdef USE_MBEDTLS
{ 0x009E, "DHE-RSA-AES128-GCM-SHA256"},
{ 0x009F, "DHE-RSA-AES256-GCM-SHA384"},
#else
{ 0x0000, "DHE-RSA-AES128-GCM-SHA256"},
{ 0x0000, "DHE-RSA-AES256-GCM-SHA384"},
#endif
-#if defined(USE_MBEDTLS)
+#ifdef USE_MBEDTLS
{ 0xCCAA, "DHE-RSA-CHACHA20-POLY1305"},
#else
{ 0x0000, "DHE-RSA-CHACHA20-POLY1305"},
#endif
-#if defined(USE_MBEDTLS)
+#ifdef USE_MBEDTLS
{ 0xC023, "ECDHE-ECDSA-AES128-SHA256" },
{ 0xC027, "ECDHE-RSA-AES128-SHA256" },
{ 0xC009, "ECDHE-ECDSA-AES128-SHA" },
{ 0x0000, "ECDHE-ECDSA-AES256-SHA" },
{ 0x0000, "ECDHE-RSA-AES256-SHA" },
#endif
-#if defined(USE_MBEDTLS)
+#ifdef USE_MBEDTLS
{ 0x0067, "DHE-RSA-AES128-SHA256" },
{ 0x006B, "DHE-RSA-AES256-SHA256" },
#else
{ 0x0000, "DHE-RSA-AES128-SHA256" },
{ 0x0000, "DHE-RSA-AES256-SHA256" },
#endif
-#if defined(USE_MBEDTLS)
+#ifdef USE_MBEDTLS
{ 0x009C, "AES128-GCM-SHA256" },
{ 0x009D, "AES256-GCM-SHA384" },
{ 0x003C, "AES128-SHA256" },
j++;
}
}
-#endif /* defined(USE_MBEDTLS) || defined(USE_RUSTLS) */
+#endif /* USE_MBEDTLS || USE_RUSTLS */
UNITTEST_END_SIMPLE
}
projects / thirdparty / curl.git / commitdiff
