To match the majority of usage in source.
Closes #21618
CURLE_USE_SSL_FAILED, /* 64 - Requested FTP SSL level failed */
CURLE_SEND_FAIL_REWIND, /* 65 - Sending the data requires a rewind
that failed */
- CURLE_SSL_ENGINE_INITFAILED, /* 66 - failed to initialise ENGINE */
+ CURLE_SSL_ENGINE_INITFAILED, /* 66 - failed to initialize ENGINE */
CURLE_LOGIN_DENIED, /* 67 - user, password or similar was not
accepted and we failed to login */
CURLE_TFTP_NOTFOUND, /* 68 - file not found on server */
cpool->idata = idata;
cpool->share = share;
- cpool->initialised = TRUE;
+ cpool->initialized = TRUE;
}
/* Return the "first" connection in the pool or NULL. */
void Curl_cpool_destroy(struct cpool *cpool)
{
- if(cpool && cpool->initialised && cpool->idata) {
+ if(cpool && cpool->initialized && cpool->idata) {
struct connectdata *conn;
struct Curl_sigpipe_ctx pipe_ctx;
struct Curl_easy *idata; /* internal handle for maintenance */
struct Curl_share *share; /* != NULL if pool belongs to share */
BIT(locked);
- BIT(initialised);
+ BIT(initialized);
};
/* Init the pool, pass multi only if pool is owned by it.
DEBUGASSERT(multi);
cshutdn->multi = multi;
Curl_llist_init(&cshutdn->list, NULL);
- cshutdn->initialised = TRUE;
+ cshutdn->initialized = TRUE;
return 0; /* good */
}
void Curl_cshutdn_destroy(struct cshutdn *cshutdn,
struct Curl_easy *data)
{
- if(cshutdn->initialised && data) {
+ if(cshutdn->initialized && data) {
int timeout_ms = 0;
/* for testing, run graceful shutdown */
#ifdef DEBUGBUILD
struct cshutdn {
struct Curl_llist list; /* connections being shut down */
struct Curl_multi *multi; /* the multi owning this */
- BIT(initialised);
+ BIT(initialized);
};
/* Init as part of the given multi handle. */
typedef EVP_MD_CTX *Curl_sha512_256_ctx;
/**
- * Initialise structure for SHA-512/256 calculation.
+ * Initialize structure for SHA-512/256 calculation.
*
* @param context the calculation context
* @return CURLE_OK if succeed,
typedef struct sha512_256_ctx Curl_sha512_256_ctx;
/**
- * Initialise structure for SHA-512/256 calculation.
+ * Initialize structure for SHA-512/256 calculation.
*
* @param context the calculation context
* @return always CURLE_OK
typedef struct Curl_sha512_256ctx Curl_sha512_256_ctx;
/**
- * Initialise structure for SHA-512/256 calculation.
+ * Initialize structure for SHA-512/256 calculation.
*
* @param context the calculation context
* @return always CURLE_OK
ctx->H[6] = UINT64_C(0x2B0199FC2C85B8AA);
ctx->H[7] = UINT64_C(0x0EB72DDC81C52CA2);
- /* Initialise number of bytes and high part of number of bits. */
+ /* Initialize number of bytes and high part of number of bits. */
ctx->count = UINT64_C(0);
ctx->count_bits_hi = UINT64_C(0);
case CURL_LOCK_DATA_CONNECT:
/* It is safe to set this option several times on a share. */
- if(!share->cpool.initialised) {
+ if(!share->cpool.initialized) {
Curl_cpool_init(&share->cpool, share->admin, share, 103);
}
break;
p = "Winsock library is not ready";
break;
case WSANOTINITIALISED:
- p = "Winsock library not initialised";
+ p = "Winsock library not initialized";
break;
case WSAVERNOTSUPPORTED:
p = "Winsock version not supported";
static CURLcode imap_parse_url_path(struct Curl_easy *data,
struct IMAP *imap)
{
- /* The imap struct is already initialised in imap_connect() */
+ /* The imap struct is already initialized in imap_connect() */
CURLcode result = CURLE_OK;
const char *begin = &data->state.up.path[1]; /* skip leading slash */
const char *ptr = begin;
/* initialize stuff to prepare for reading a fresh new response */
void Curl_pp_init(struct pingpong *pp, const struct curltime *pnow)
{
- DEBUGASSERT(!pp->initialised);
+ DEBUGASSERT(!pp->initialized);
pp->nread_resp = 0;
pp->response = *pnow; /* start response time-out */
pp->pending_resp = TRUE;
curlx_dyn_init(&pp->sendbuf, DYN_PINGPPONG_CMD);
curlx_dyn_init(&pp->recvbuf, DYN_PINGPPONG_CMD);
- pp->initialised = TRUE;
+ pp->initialized = TRUE;
}
/***********************************************************************
CURLcode Curl_pp_disconnect(struct pingpong *pp)
{
- if(pp->initialised) {
+ if(pp->initialized) {
curlx_dyn_free(&pp->sendbuf);
curlx_dyn_free(&pp->recvbuf);
memset(pp, 0, sizeof(*pp));
CURLcode (*statemachine)(struct Curl_easy *data, struct connectdata *conn);
bool (*endofresp)(struct Curl_easy *data, struct connectdata *conn,
const char *ptr, size_t len, int *code);
- BIT(initialised);
+ BIT(initialized);
BIT(pending_resp); /* set TRUE when a server response is pending or in
progress, and is cleared once the last response is
read */
*/
static CURLcode pop3_parse_url_path(struct Curl_easy *data)
{
- /* The POP3 struct is already initialised in pop3_connect() */
+ /* The POP3 struct is already initialized in pop3_connect() */
struct POP3 *pop3 = Curl_meta_get(data, CURL_META_POP3_EASY);
const char *path = &data->state.up.path[1]; /* skip leading path */
pop3c->preftype = POP3_TYPE_ANY;
Curl_sasl_init(&pop3c->sasl, data, &saslpop3);
- /* Initialise the pingpong layer */
+ /* Initialize the pingpong layer */
Curl_pp_init(pp, Curl_pgrs_now(data));
/* Parse the URL options */
#define CURL_EASY_POLLSET_MAGIC 0x7a657370
#endif
-/* allocate and initialise */
+/* allocate and initialize */
struct easy_pollset *Curl_pollset_create(void);
/* Initialize before first use */
static CURLcode smtp_parse_url_path(struct Curl_easy *data,
struct smtp_conn *smtpc)
{
- /* The SMTP struct is already initialised in smtp_connect() */
+ /* The SMTP struct is already initialized in smtp_connect() */
const char *path = &data->state.up.path[1]; /* skip leading path */
char localhost[HOSTNAME_MAX + 1];
*
* smtp_perform_ehlo()
*
- * Sends the EHLO command to not only initialise communication with the ESMTP
+ * Sends the EHLO command to not only initialize communication with the ESMTP
* server but to also obtain a list of server side supported capabilities.
*/
static CURLcode smtp_perform_ehlo(struct Curl_easy *data,
*
* smtp_perform_helo()
*
- * Sends the HELO command to initialise communication with the SMTP server.
+ * Sends the HELO command to initialize communication with the SMTP server.
*/
static CURLcode smtp_perform_helo(struct Curl_easy *data,
struct smtp_conn *smtpc)
/* Initialize the SASL storage */
Curl_sasl_init(&smtpc->sasl, data, &saslsmtp);
- /* Initialise the pingpong layer */
+ /* Initialize the pingpong layer */
Curl_pp_init(&smtpc->pp, Curl_pgrs_now(data));
/* Parse the URL options */
#ifndef CURL_DISABLE_SOCKETPAIR
-/* return < 0 for failure to initialise */
+/* return < 0 for failure to initialize */
int Curl_wakeup_init(curl_socket_t socks[2], bool nonblocking);
void Curl_wakeup_destroy(curl_socket_t socks[2]);
sspi_recv_token.cbBuffer = 0;
if(check_sspi_err(data, status, "InitializeSecurityContext")) {
- failf(data, "Failed to initialise security context.");
+ failf(data, "Failed to initialize security context.");
return socks5_free_token(&sspi_send_token, CURLE_COULDNT_CONNECT);
}
return "Can not set SSL crypto engine as default";
case CURLE_SSL_ENGINE_INITFAILED:
- return "Failed to initialise SSL crypto engine";
+ return "Failed to initialize SSL crypto engine";
case CURLE_SEND_ERROR:
return "Failed sending data to the peer";
static void auth_digest_get_qop_values(const char *options, int *value)
{
struct Curl_str out;
- /* Initialise the output */
+ /* Initialize the output */
*value = 0;
while(!curlx_str_until(&options, &out, 32, ',')) {
if(digest->nonce)
before = TRUE;
- /* Clean up any former leftovers and initialise to defaults */
+ /* Clean up any former leftovers and initialize to defaults */
Curl_auth_digest_cleanup(digest);
for(;;) {
(void)service;
(void)host;
- /* Clean up any former leftovers and initialise to defaults */
+ /* Clean up any former leftovers and initialize to defaults */
Curl_auth_cleanup_ntlm(ntlm);
ntlmbuf = curl_maprintf(NTLMSSP_SIGNATURE "%c"
const char *service = Curl_creds_has_sasl_service(creds) ?
Curl_creds_sasl_service(creds) : default_service;
- /* Clean up any former leftovers and initialise to defaults */
+ /* Clean up any former leftovers and initialize to defaults */
Curl_auth_cleanup_ntlm(ntlm);
/* Query the security package for NTLM */
DEBUGASSERT(max_pkts > 0);
for(pkts = 0, total_nread = 0, calls = 0; pkts < max_pkts;) {
- /* fully initialise this on each call to `recvmsg()`. There seem to
+ /* fully initialize this on each call to `recvmsg()`. There seem to
* operating systems out there that mess with `msg_iov.iov_len`. */
memset(&msg, 0, sizeof(msg));
msg_iov.iov_base = buf;
static void sshc_cleanup(struct ssh_conn *sshc)
{
- if(sshc->initialised) {
+ if(sshc->initialized) {
if(sshc->sftp_file) {
sftp_close(sshc->sftp_file);
sshc->sftp_file = NULL;
curlx_dyn_free(&sshc->readdir_buf);
curlx_safefree(sshc->readdir_linkPath);
SSH_STRING_FREE_CHAR(sshc->homedir);
- sshc->initialised = FALSE;
+ sshc->initialized = FALSE;
}
}
return CURLE_OUT_OF_MEMORY;
curlx_dyn_init(&sshc->readdir_buf, CURL_PATH_MAX * 2);
- sshc->initialised = TRUE;
+ sshc->initialized = TRUE;
if(Curl_conn_meta_set(conn, CURL_META_SSH_CONN, sshc, myssh_conn_dtor))
return CURLE_OUT_OF_MEMORY;
const char *readdir_filename; /* points within readdir_attrs */
const char *readdir_longentry;
char *readdir_tmp;
- BIT(initialised);
+ BIT(initialized);
#elif defined(USE_LIBSSH2)
LIBSSH2_SESSION *ssh_session; /* Secure Shell session */
LIBSSH2_CHANNEL *ssh_channel; /* Secure Shell channel handle */
char buf[256];
ENGINE_free(e);
- failf(data, "Failed to initialise SSL Engine '%s': %s",
+ failf(data, "Failed to initialize SSL Engine '%s': %s",
name, ossl_strerror(ERR_get_error(), buf, sizeof(buf)));
result = CURLE_SSL_ENGINE_INITFAILED;
e = NULL;
FILESIZE_EXCEEDED <maximum file size exceeded>
USE_SSL_FAILED <requested FTP SSL level failed>
SEND_FAIL_REWIND <sending data requires a rewind that failed>
-SSL_ENGINE_INITFAILED <failed to initialise ENGINE>
+SSL_ENGINE_INITFAILED <failed to initialize ENGINE>
LOGIN_DENIED <user or password not accepted. failed to login>
TFTP_NOTFOUND <file not found on server>
TFTP_PERM <permission problem on server>
_djstat_flags |= _STAT_INODE | _STAT_EXEC_MAGIC | _STAT_DIRSIZE;
#endif
- /* Initialise the global config */
+ /* Initialize the global config */
global->showerror = FALSE; /* show errors when silent */
global->styled_output = TRUE; /* enable detection */
global->parallel_max = PARALLEL_DEFAULT;
}
else {
if(global->libcurl) {
- /* Initialise the libcurl source output */
+ /* Initialize the libcurl source output */
result = easysrc_init();
}
e63: Maximum file size exceeded
e64: Requested SSL level failed
e65: Send failed since rewinding of the data stream failed
-e66: Failed to initialise SSL crypto engine
+e66: Failed to initialize SSL crypto engine
e67: Login denied
e68: TFTP: File Not Found
e69: TFTP: Access Violation