the full request has been sent. */
data->req.start100 = Curl_now();
- /* clear userpwd and proxyuserpwd to avoid re-using old credentials
- * from re-used connections */
+ /* clear userpwd and proxyuserpwd to avoid reusing old credentials
+ * from reused connections */
Curl_safefree(data->state.aptr.userpwd);
Curl_safefree(data->state.aptr.proxyuserpwd);
return CURLE_OK;
if(data->info.httpproxycode/100 != 2) {
/* a non-2xx response and we have no next url to try. */
Curl_safefree(data->req.newurl);
- /* failure, close this connection to avoid re-use */
+ /* failure, close this connection to avoid reuse */
streamclose(conn, "proxy CONNECT failure");
h1_tunnel_go_state(cf, ts, H1_TUNNEL_FAILED, data);
failf(data, "CONNECT tunnel failed, response %d", data->req.httpcode);
if(port == 0)
break;
infof(data, "Bind to local port %d failed, trying next", port - 1);
- /* We re-use/clobber the port variable here below */
+ /* We reuse/clobber the port variable here below */
if(sock->sa_family == AF_INET)
si4->sin_port = ntohs(port);
#ifdef ENABLE_IPV6
*
* REALITY: it can't just create and destroy the multi handle that easily. It
* needs to keep it around since if this easy handle is used again by this
- * function, the same multi handle must be re-used so that the same pools and
+ * function, the same multi handle must be reused so that the same pools and
* caches can be used.
*
* DEBUG: if 'events' is set TRUE, this function will use a replacement engine
if(conn->bits.reuse && ftpc->entrypath &&
/* no need to go to entrypath when we have an absolute path */
!(ftpc->dirdepth && ftpc->dirs[0][0] == '/')) {
- /* This is a re-used connection. Since we change directory to where the
+ /* This is a reused connection. Since we change directory to where the
transfer is taking place, we must first get back to the original dir
where we ended up after login: */
ftpc->cwdcount = 0; /* we count this as the first path, then we add one
if(data->set.ftp_skip_ip) {
/* told to ignore the remotely given IP but instead use the host we used
for the control connection */
- infof(data, "Skip %u.%u.%u.%u for data connection, re-use %s instead",
+ infof(data, "Skip %u.%u.%u.%u for data connection, reuse %s instead",
ip[0], ip[1], ip[2], ip[3],
conn->host.name);
ftpc->newhost = strdup(control_address(conn));
if(data) {
/* the nature of most system is that IPv6 status doesn't come and go
during a program's lifetime so we only probe the first time and then we
- have the info kept for fast re-use */
+ have the info kept for fast reuse */
DEBUGASSERT(data);
DEBUGASSERT(data->multi);
if(data->multi->ipv6_up == IPV6_UNKNOWN) {
struct connectdata *conn = data->conn;
/* We default to persistent connections. We set this already in this connect
- function to make the re-use checks properly be able to check this bit. */
+ function to make the reuse checks properly be able to check this bit. */
connkeep(conn, "HTTP default");
return Curl_conn_connect(data, FIRSTSOCKET, FALSE, done);
*done = TRUE;
return CURLE_OK;
}
- /* We have a new url to load, but since we want to be able to re-use this
+ /* We have a new url to load, but since we want to be able to reuse this
connection properly, we read the full response in "ignore more" */
k->ignorebody = TRUE;
infof(data, "Ignoring the response-body");
data->info.httpcode = 304;
infof(data, "Simulate an HTTP 304 response");
/* we abort the transfer before it is completed == we ruin the
- re-use ability. Close the connection */
+ reuse ability. Close the connection */
streamclose(conn, "Simulated 304 handling");
return CURLE_OK;
}
altused ? altused : ""
);
- /* clear userpwd and proxyuserpwd to avoid re-using old credentials
- * from re-used connections */
+ /* clear userpwd and proxyuserpwd to avoid reusing old credentials
+ * from reused connections */
Curl_safefree(data->state.aptr.userpwd);
Curl_safefree(data->state.aptr.proxyuserpwd);
free(altused);
/* no data to transfer */
Curl_setup_transfer(data, -1, -1, FALSE, -1);
- connclose(conn, "LDAP connection always disable re-use");
+ connclose(conn, "LDAP connection always disable reuse");
return result;
}
if premature is TRUE, it means this connection was said to be DONE before
the entire request operation is complete and thus we can't know in what
- state it is for re-using, so we're forced to close it. In a perfect world
+ state it is for reusing, so we're forced to close it. In a perfect world
we can add code that keep track of if we really must close it here or not,
but currently we have no such detail knowledge.
*/
#endif
) || conn->bits.close
|| (premature && !Curl_conn_is_multiplex(conn, FIRSTSOCKET))) {
- DEBUGF(infof(data, "multi_done, not re-using connection=%"
+ DEBUGF(infof(data, "multi_done, not reusing connection=%"
CURL_FORMAT_CURL_OFF_T ", forbid=%d"
", close=%d, premature=%d, conn_multiplex=%d",
conn->connection_id,
if(done || (result == CURLE_RECV_ERROR)) {
/* If CURLE_RECV_ERROR happens early enough, we assume it was a race
- * condition and the server closed the re-used connection exactly when
+ * condition and the server closed the reused connection exactly when
* we wanted to use it, so figure out if that is indeed the case.
*/
CURLcode ret = Curl_retry_request(data, &newurl);
if(result) {
/*
* The transfer phase returned error, we mark the connection to get
- * closed to prevent being re-used. This is because we can't possibly
+ * closed to prevent being reused. This is because we can't possibly
* know if the connection is in a good shape or not now. Unless it is
* a protocol which uses two "channels" like FTP, as then the error
* happened in the data connection.
Curl_pgrsResetTransferSizes(data);
Curl_pgrsStartNow(data);
- /* In case the handle is re-used and an authentication method was picked
+ /* In case the handle is reused and an authentication method was picked
in the session we need to make sure we only use the one(s) we now
consider to be fine */
data->state.authhost.picked &= data->state.authhost.want;
&& (data->set.rtspreq != RTSPREQ_RECEIVE)
#endif
)
- /* We got no data, we attempted to re-use a connection. For HTTP this
+ /* We got no data, we attempted to reuse a connection. For HTTP this
can be a retry so we try again regardless if we expected a body.
For other protocols we only try again only if we expected a body.
infof(data, "Server doesn't support multiplex yet, wait");
*waitpipe = TRUE;
CONNCACHE_UNLOCK(data);
- return FALSE; /* no re-use */
+ return FALSE; /* no reuse */
}
infof(data, "Server doesn't support multiplex (yet)");
if(Curl_resolver_asynch() &&
/* primary_ip[0] is NUL only if the resolving of the name hasn't
- completed yet and until then we don't re-use this connection */
+ completed yet and until then we don't reuse this connection */
!check->primary_ip[0])
continue;
}
infof(data, "Server upgrade doesn't support multiplex yet, wait");
*waitpipe = TRUE;
CONNCACHE_UNLOCK(data);
- return FALSE; /* no re-use */
+ return FALSE; /* no reuse */
}
infof(data, "Server upgrade cannot be used");
continue; /* can't be used atm */
if(needle->localdev || needle->localport) {
/* If we are bound to a specific local end (IP+port), we must not
- re-use a random other one, although if we didn't ask for a
+ reuse a random other one, although if we didn't ask for a
particular one we can reuse one that was bound.
This comparison is a bit rough and too strict. Since the input
parameters can be specified in numerous ways and still end up the
same it would take a lot of processing to make it really accurate.
- Instead, this matching will assume that re-uses of bound connections
- will most likely also re-use the exact same binding parameters and
+ Instead, this matching will assume that reuses of bound connections
+ will most likely also reuse the exact same binding parameters and
missing out a few edge cases shouldn't hurt anyone very much.
*/
if((check->localport != needle->localport) ||
/*
* If this is supposed to use a proxy, we need to figure out the proxy
- * host name, so that we can re-use an existing connection
+ * host name, so that we can reuse an existing connection
* that may exist registered to the same proxy host.
*/
static CURLcode parse_proxy(struct Curl_easy *data,
/***********************************************************************
* If this is supposed to use a proxy, we need to figure out the proxy host
- * name, proxy type and port number, so that we can re-use an existing
+ * name, proxy type and port number, so that we can reuse an existing
* connection that may exist registered to the same proxy host.
***********************************************************************/
if(proxy || socksproxy) {
/* Resolve the name of the server or proxy */
if(conn->bits.reuse) {
/* We're reusing the connection - no need to resolve anything, and
- idnconvert_hostname() was called already in create_conn() for the re-use
+ idnconvert_hostname() was called already in create_conn() for the reuse
case. */
*async = FALSE;
return CURLE_OK;
struct connectdata *existing)
{
/* get the user+password information from the temp struct since it may
- * be new for this request even when we re-use an existing connection */
+ * be new for this request even when we reuse an existing connection */
if(temp->user) {
/* use the new user name and password though */
Curl_safefree(existing->user);
existing->hostname_resolve = temp->hostname_resolve;
temp->hostname_resolve = NULL;
- /* re-use init */
- existing->bits.reuse = TRUE; /* yes, we're re-using here */
+ /* reuse init */
+ existing->bits.reuse = TRUE; /* yes, we're reusing here */
conn_free(data, temp);
}
/**
- * create_conn() sets up a new connectdata struct, or re-uses an already
+ * create_conn() sets up a new connectdata struct, or reuses an already
* existing one, and resolves host name.
*
* if this function returns CURLE_OK and *async is set to TRUE, the resolve
/*************************************************************
* Check the current list of connections to see if we can
- * re-use an already existing one or if we have to create a
+ * reuse an already existing one or if we have to create a
* new one.
*************************************************************/
DEBUGASSERT(conn->passwd);
/* reuse_fresh is TRUE if we are told to use a new connection by force, but
- we only acknowledge this option if this is not a re-used connection
+ we only acknowledge this option if this is not a reused connection
already (which happens due to follow-location or during an HTTP
authentication phase). CONNECT_ONLY transfers also refuse reuse. */
if((data->set.reuse_fresh && !data->state.followlocation) ||
#endif
/* always modify bits.close with the connclose() and connkeep() macros! */
BIT(close); /* if set, we close the connection after this request */
- BIT(reuse); /* if set, this is a re-used connection */
+ BIT(reuse); /* if set, this is a reused connection */
BIT(altused); /* this is an alt-svc "redirect" */
BIT(conn_to_host); /* if set, this connection has a "connect to host"
that overrides the host in the URL */
/* 'dns_entry' is the particular host we use. This points to an entry in the
DNS cache and it will not get pruned while locked. It gets unlocked in
- multi_done(). This entry will be NULL if the connection is re-used as then
+ multi_done(). This entry will be NULL if the connection is reused as then
there is no name resolve done. */
struct Curl_dns_entry *dns_entry;
/* When this connection is created, store the conditions for the local end
bind. This is stored before the actual bind and before any connection is
made and will serve the purpose of being used for comparison reasons so
- that subsequent bound-requested connections aren't accidentally re-using
+ that subsequent bound-requested connections aren't accidentally reusing
wrong connections. */
char *localdev;
unsigned short localportrange;
BIT(verbose); /* output verbosity */
BIT(krb); /* Kerberos connection requested */
BIT(reuse_forbid); /* forbidden to be reused, close after use */
- BIT(reuse_fresh); /* do not re-use an existing connection */
+ BIT(reuse_fresh); /* do not reuse an existing connection */
BIT(no_signal); /* do not use any signal/alarm handler */
BIT(tcp_nodelay); /* whether to enable TCP_NODELAY or not */
BIT(ignorecl); /* ignore content length */
myssh_setup_connection(data, conn);
/* We default to persistent connections. We set this already in this connect
- function to make the re-use checks properly be able to check this bit. */
+ function to make the reuse checks properly be able to check this bit. */
connkeep(conn, "SSH default");
if(conn->handler->protocol & CURLPROTO_SCP) {
}
/* We default to persistent connections. We set this already in this connect
- function to make the re-use checks properly be able to check this bit. */
+ function to make the reuse checks properly be able to check this bit. */
connkeep(conn, "SSH default");
sshc = &conn->proto.sshc;
wssh_setup_connection(data, conn);
/* We default to persistent connections. We set this already in this connect
- function to make the re-use checks properly be able to check this bit. */
+ function to make the reuse checks properly be able to check this bit. */
connkeep(conn, "SSH default");
if(conn->handler->protocol & CURLPROTO_SCP) {
if(!Curl_ssl_getsessionid(cf, data, &session, NULL)) {
br_ssl_engine_set_session_parameters(&backend->ctx.eng, session);
session_set = 1;
- infof(data, "BearSSL: re-using session ID");
+ infof(data, "BearSSL: reusing session ID");
}
Curl_ssl_sessionid_unlock(data);
}
ssl_sessionid, ssl_idsize);
/* Informational message */
- infof(data, "SSL re-using session ID");
+ infof(data, "SSL reusing session ID");
}
Curl_ssl_sessionid_unlock(data);
}
failf(data, "mbedtls_ssl_set_session returned -0x%x", -ret);
return CURLE_SSL_CONNECT_ERROR;
}
- infof(data, "mbedTLS re-using session");
+ infof(data, "mbedTLS reusing session");
}
Curl_ssl_sessionid_unlock(data);
}
return CURLE_SSL_CONNECT_ERROR;
}
/* Informational message */
- infof(data, "SSL re-using session ID");
+ infof(data, "SSL reusing session ID");
}
Curl_ssl_sessionid_unlock(data);
}
Curl_ssl_sessionid_lock(data);
if(!Curl_ssl_getsessionid(cf, data, (void **)&old_cred, NULL)) {
backend->cred = old_cred;
- DEBUGF(infof(data, "schannel: re-using existing credential handle"));
+ DEBUGF(infof(data, "schannel: reusing existing credential handle"));
/* increment the reference counter of the credential/session handle */
backend->cred->refcount++;
}
#endif
- /* save the current session data for possible re-use */
+ /* save the current session data for possible reuse */
if(ssl_config->primary.sessionid) {
bool incache;
bool added = FALSE;
return CURLE_SSL_CONNECT_ERROR;
}
/* Informational message */
- infof(data, "SSL re-using session ID");
+ infof(data, "SSL reusing session ID");
}
/* If there isn't one, then let's make one up! This has to be done prior
to starting the handshake. */
DEBUGASSERT(ssl_config->primary.sessionid);
if(!ssl_config->primary.sessionid || !data->state.session)
- /* session ID re-use is disabled or the session cache has not been
+ /* session ID reuse is disabled or the session cache has not been
setup */
return TRUE;
infof(data, "Can't use session ID, going on without");
}
else
- infof(data, "SSL re-using session ID");
+ infof(data, "SSL reusing session ID");
}
Curl_ssl_sessionid_unlock(data);
}
# CSOURCES = $(CSRC1) $(CSRC2)
# libcurl has sources that provide functions named curlx_* that aren't part of
-# the official API, but we re-use the code here to avoid duplication.
+# the official API, but we reuse the code here to avoid duplication.
CURLX_CFILES = \
../lib/base64.c \
../lib/curl_multibyte.c \
ftp
</server>
<name>
-Two FTP downloads, with failed RETR but re-used control connection
+Two FTP downloads, with failed RETR but reused control connection
</name>
<command>
ftp://%HOSTIP:%FTPPORT/dir/%TESTNUMBER ftp://%HOSTIP:%FTPPORT/dir/%TESTNUMBER
http
</server>
<name>
-HTTP connection re-use with different credentials
+HTTP connection reuse with different credentials
</name>
<command>
http://%HOSTIP:%HTTPPORT/%TESTNUMBER -u user1:password1 --next http://%HOSTIP:%HTTPPORT/%TESTNUMBER0001 -u 2user:password2
HTTP
HTTP GET
HTTP NTLM auth
-connection re-use
+connection reuse
</keywords>
</info>
# Server-side
crypto
</features>
<name>
-HTTP with --anyauth and connection re-use
+HTTP with --anyauth and connection reuse
</name>
<command>
http://%HOSTIP:%HTTPPORT/%TESTNUMBER -u testuser:testpass --anyauth http://%HOSTIP:%HTTPPORT/%TESTNUMBER0003
HTTP
HTTP GET
HTTP NTLM auth
-connection re-use
+connection reuse
</keywords>
</info>
# Server-side
http
</server>
<name>
-HTTP with --anyauth (but no auth!) and connection re-use
+HTTP with --anyauth (but no auth!) and connection reuse
</name>
<command>
http://%HOSTIP:%HTTPPORT/%TESTNUMBER --anyauth http://%HOSTIP:%HTTPPORT/%TESTNUMBER0003
<info>
<keywords>
HTTP
-connection re-use
+connection reuse
persistent connection
CURLOPT_MAXLIFETIME_CONN
verbose logs
https-proxy
</server>
<name>
-FTP through HTTPS-proxy, with connection re-use
+FTP through HTTPS-proxy, with connection reuse
</name>
<command>
-p -x https://%HOSTIP:%HTTPSPROXYPORT ftp://ftp.site.thru.https.proxy:%FTPPORT/%TESTNUMBER --proxy-insecure ftp://ftp.site.thru.https.proxy:%FTPPORT/%TESTNUMBER0002
perl -MI18N::Langinfo=langinfo,CODESET -e 'die "Needs a UTF-8 locale" if (lc(langinfo(CODESET())) ne "utf-8");'
</precheck>
<name>
-Connection re-use with IDN host name
+Connection reuse with IDN host name
</name>
<command>
perl -MI18N::Langinfo=langinfo,CODESET -e 'die "Needs a UTF-8 locale" if (lc(langinfo(CODESET())) ne "utf-8");'
</precheck>
<name>
-Connection re-use with IDN host name over HTTP proxy
+Connection reuse with IDN host name over HTTP proxy
</name>
<command>
</tool>
<name>
-HTTP GET re-used handle with first header folded
+HTTP GET reused handle with first header folded
</name>
<command>
http://%HOSTIP:%HTTPPORT/%TESTNUMBER http://%HOSTIP:%HTTPPORT/%TESTNUMBER0002
http
</server>
<name>
-verify -w local/remote port+ip after connection re-use
+verify -w local/remote port+ip after connection reuse
</name>
<command>
http://%HOSTIP:%HTTPPORT/%TESTNUMBER http://%HOSTIP:%HTTPPORT/%TESTNUMBER -w 'local port == %{local_port}\nlocal ip == %{local_ip}\nremote_ip == %{remote_ip}\nremote_port == %{remote_port}\n'
http
</server>
<name>
-HTTP connection re-use and different credentials
+HTTP connection reuse and different credentials
</name>
<command>
IMAP
Clear Text
FETCH
-connection re-use
+connection reuse
</keywords>
</info>
POP3
Clear Text
RETR
-connection re-use
+connection reuse
</keywords>
</info>
SMTP
SASL
SASL AUTH PLAIN
-connection re-use
+connection reuse
RFC4616
RFC4954
</keywords>
projects / thirdparty / curl.git / commitdiff
