lib: remove 'conn->data' completely
The Curl_easy pointer struct entry in connectdata is now gone. Just
before commit 215db086e0 landed on January 8, 2021 there were 919
references to conn->data.
Closes #6608
This commit is contained in:
Daniel Stenberg
parent
a59c33ceff
commit
cfff12a0b3
@ -466,7 +466,6 @@ Curl_conncache_extract_bundle(struct Curl_easy *data,
|
||||
data->state.conn_cache->num_conn--;
|
||||
DEBUGF(infof(data, "The cache now contains %zu members\n",
|
||||
data->state.conn_cache->num_conn));
|
||||
conn_candidate->data = data; /* associate! */
|
||||
}
|
||||
|
||||
return conn_candidate;
|
||||
@ -529,7 +528,6 @@ Curl_conncache_extract_oldest(struct Curl_easy *data)
|
||||
connc->num_conn--;
|
||||
DEBUGF(infof(data, "The cache now contains %zu members\n",
|
||||
connc->num_conn));
|
||||
conn_candidate->data = data; /* associate! */
|
||||
}
|
||||
CONNCACHE_UNLOCK(data);
|
||||
|
||||
|
||||
@ -1448,11 +1448,9 @@ curl_socket_t Curl_getconnectinfo(struct Curl_easy *data,
|
||||
}
|
||||
|
||||
c = find.found;
|
||||
if(connp) {
|
||||
if(connp)
|
||||
/* only store this if the caller cares for it */
|
||||
*connp = c;
|
||||
c->data = data;
|
||||
}
|
||||
return c->sock[FIRSTSOCKET];
|
||||
}
|
||||
return CURL_SOCKET_BAD;
|
||||
|
||||
12
lib/easy.c
12
lib/easy.c
@ -1052,8 +1052,6 @@ CURLcode curl_easy_pause(struct Curl_easy *data, int action)
|
||||
unsigned int i;
|
||||
unsigned int count = data->state.tempcount;
|
||||
struct tempbuf writebuf[3]; /* there can only be three */
|
||||
struct connectdata *conn = data->conn;
|
||||
struct Curl_easy *saved_data = NULL;
|
||||
|
||||
/* copy the structs to allow for immediate re-pausing */
|
||||
for(i = 0; i < data->state.tempcount; i++) {
|
||||
@ -1062,12 +1060,6 @@ CURLcode curl_easy_pause(struct Curl_easy *data, int action)
|
||||
}
|
||||
data->state.tempcount = 0;
|
||||
|
||||
/* set the connection's current owner */
|
||||
if(conn->data != data) {
|
||||
saved_data = conn->data;
|
||||
conn->data = data;
|
||||
}
|
||||
|
||||
for(i = 0; i < count; i++) {
|
||||
/* even if one function returns error, this loops through and frees
|
||||
all buffers */
|
||||
@ -1078,10 +1070,6 @@ CURLcode curl_easy_pause(struct Curl_easy *data, int action)
|
||||
Curl_dyn_free(&writebuf[i].b);
|
||||
}
|
||||
|
||||
/* recover previous owner of the connection */
|
||||
if(saved_data)
|
||||
conn->data = saved_data;
|
||||
|
||||
if(result)
|
||||
return result;
|
||||
}
|
||||
|
||||
36
lib/multi.c
36
lib/multi.c
@ -562,8 +562,6 @@ static CURLcode multi_done(struct Curl_easy *data,
|
||||
/* Stop if multi_done() has already been called */
|
||||
return CURLE_OK;
|
||||
|
||||
conn->data = data; /* ensure the connection uses this transfer now */
|
||||
|
||||
/* Stop the resolver and free its own resources (but not dns_entry yet). */
|
||||
Curl_resolver_kill(data);
|
||||
|
||||
@ -604,16 +602,13 @@ static CURLcode multi_done(struct Curl_easy *data,
|
||||
Curl_detach_connnection(data);
|
||||
if(CONN_INUSE(conn)) {
|
||||
/* Stop if still used. */
|
||||
/* conn->data must not remain pointing to this transfer since it is going
|
||||
away! Find another to own it! */
|
||||
conn->data = conn->easyq.head->ptr;
|
||||
CONNCACHE_UNLOCK(data);
|
||||
DEBUGF(infof(data, "Connection still in use %zu, "
|
||||
"no more multi_done now!\n",
|
||||
conn->easyq.size));
|
||||
return CURLE_OK;
|
||||
}
|
||||
conn->data = NULL; /* the connection now has no owner */
|
||||
|
||||
data->state.done = TRUE; /* called just now! */
|
||||
|
||||
if(conn->dns_entry) {
|
||||
@ -718,7 +713,6 @@ CURLMcode curl_multi_remove_handle(struct Curl_multi *multi,
|
||||
{
|
||||
struct Curl_easy *easy = data;
|
||||
bool premature;
|
||||
bool easy_owns_conn;
|
||||
struct Curl_llist_element *e;
|
||||
|
||||
/* First, make some basic checks that the CURLM handle is a good handle */
|
||||
@ -741,8 +735,6 @@ CURLMcode curl_multi_remove_handle(struct Curl_multi *multi,
|
||||
return CURLM_RECURSIVE_API_CALL;
|
||||
|
||||
premature = (data->mstate < CURLM_STATE_COMPLETED) ? TRUE : FALSE;
|
||||
easy_owns_conn = (data->conn && (data->conn->data == easy)) ?
|
||||
TRUE : FALSE;
|
||||
|
||||
/* If the 'state' is not INIT or COMPLETED, we might need to do something
|
||||
nice to put the easy_handle in a good known state when this returns. */
|
||||
@ -757,24 +749,16 @@ CURLMcode curl_multi_remove_handle(struct Curl_multi *multi,
|
||||
data->mstate < CURLM_STATE_COMPLETED) {
|
||||
/* Set connection owner so that the DONE function closes it. We can
|
||||
safely do this here since connection is killed. */
|
||||
data->conn->data = easy;
|
||||
streamclose(data->conn, "Removed with partial response");
|
||||
easy_owns_conn = TRUE;
|
||||
}
|
||||
|
||||
if(data->conn) {
|
||||
/* multi_done() clears the association between the easy handle and the
|
||||
connection.
|
||||
|
||||
/* we must call multi_done() here (if we still own the connection) so that
|
||||
we don't leave a half-baked one around */
|
||||
if(easy_owns_conn) {
|
||||
|
||||
/* multi_done() clears the association between the easy handle and the
|
||||
connection.
|
||||
|
||||
Note that this ignores the return code simply because there's
|
||||
nothing really useful to do with it anyway! */
|
||||
(void)multi_done(data, data->result, premature);
|
||||
}
|
||||
Note that this ignores the return code simply because there's
|
||||
nothing really useful to do with it anyway! */
|
||||
(void)multi_done(data, data->result, premature);
|
||||
}
|
||||
|
||||
/* The timer must be shut down before data->multi is set to NULL, else the
|
||||
@ -984,12 +968,6 @@ static int multi_getsock(struct Curl_easy *data,
|
||||
if(!conn)
|
||||
return 0;
|
||||
|
||||
if(data->mstate > CURLM_STATE_CONNECT &&
|
||||
data->mstate < CURLM_STATE_COMPLETED) {
|
||||
/* Set up ownership correctly */
|
||||
data->conn->data = data;
|
||||
}
|
||||
|
||||
switch(data->mstate) {
|
||||
default:
|
||||
return 0;
|
||||
@ -1397,7 +1375,6 @@ static CURLcode multi_do(struct Curl_easy *data, bool *done)
|
||||
|
||||
DEBUGASSERT(conn);
|
||||
DEBUGASSERT(conn->handler);
|
||||
DEBUGASSERT(conn->data == data);
|
||||
|
||||
if(conn->handler->do_it)
|
||||
/* generic protocol-specific function pointer set in curl_connect() */
|
||||
@ -1584,7 +1561,6 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
|
||||
DEBUGASSERT(data->conn);
|
||||
if(!data->conn)
|
||||
return CURLM_INTERNAL_ERROR;
|
||||
data->conn->data = data;
|
||||
}
|
||||
|
||||
if(data->conn &&
|
||||
|
||||
42
lib/url.c
42
lib/url.c
@ -992,12 +992,12 @@ static bool extract_if_dead(struct connectdata *conn,
|
||||
/* briefly attach the connection to this transfer for the purpose of
|
||||
checking it */
|
||||
Curl_attach_connnection(data, conn);
|
||||
conn->data = data; /* find the way back if necessary */
|
||||
|
||||
state = conn->handler->connection_check(data, conn, CONNCHECK_ISDEAD);
|
||||
dead = (state & CONNRESULT_DEAD);
|
||||
/* detach the connection again */
|
||||
Curl_detach_connnection(data);
|
||||
conn->data = NULL; /* clear it again */
|
||||
|
||||
}
|
||||
else {
|
||||
/* Use the general method for determining the death of a connection */
|
||||
@ -1098,13 +1098,13 @@ ConnectionExists(struct Curl_easy *data,
|
||||
|
||||
#ifdef USE_NTLM
|
||||
bool wantNTLMhttp = ((data->state.authhost.want &
|
||||
(CURLAUTH_NTLM | CURLAUTH_NTLM_WB)) &&
|
||||
(needle->handler->protocol & PROTO_FAMILY_HTTP));
|
||||
(CURLAUTH_NTLM | CURLAUTH_NTLM_WB)) &&
|
||||
(needle->handler->protocol & PROTO_FAMILY_HTTP));
|
||||
#ifndef CURL_DISABLE_PROXY
|
||||
bool wantProxyNTLMhttp = (needle->bits.proxy_user_passwd &&
|
||||
((data->state.authproxy.want &
|
||||
(CURLAUTH_NTLM | CURLAUTH_NTLM_WB)) &&
|
||||
(needle->handler->protocol & PROTO_FAMILY_HTTP)));
|
||||
((data->state.authproxy.want &
|
||||
(CURLAUTH_NTLM | CURLAUTH_NTLM_WB)) &&
|
||||
(needle->handler->protocol & PROTO_FAMILY_HTTP)));
|
||||
#else
|
||||
bool wantProxyNTLMhttp = FALSE;
|
||||
#endif
|
||||
@ -1272,17 +1272,19 @@ ConnectionExists(struct Curl_easy *data,
|
||||
}
|
||||
#endif
|
||||
|
||||
DEBUGASSERT(!check->data || GOOD_EASY_HANDLE(check->data));
|
||||
|
||||
if(!canmultiplex && check->data)
|
||||
if(!canmultiplex && CONN_INUSE(check))
|
||||
/* this request can't be multiplexed but the checked connection is
|
||||
already in use so we skip it */
|
||||
continue;
|
||||
|
||||
if(check->data && (check->data->multi != needle->data->multi))
|
||||
/* this could be subject for multiplex use, but only if they belong to
|
||||
* the same multi handle */
|
||||
continue;
|
||||
if(CONN_INUSE(check)) {
|
||||
/* Subject for multiplex use if 'checks' belongs to the same multi
|
||||
handle as 'data' is. */
|
||||
struct Curl_llist_element *e = check->easyq.head;
|
||||
struct Curl_easy *entry = e->ptr;
|
||||
if(entry->multi != data->multi)
|
||||
continue;
|
||||
}
|
||||
|
||||
if(needle->localdev || needle->localport) {
|
||||
/* If we are bound to a specific local end (IP+port), we must not
|
||||
@ -1441,7 +1443,7 @@ ConnectionExists(struct Curl_easy *data,
|
||||
continue;
|
||||
}
|
||||
else if(multiplexed >=
|
||||
Curl_multi_max_concurrent_streams(needle->data->multi)) {
|
||||
Curl_multi_max_concurrent_streams(data->multi)) {
|
||||
infof(data, "client side MAX_CONCURRENT_STREAMS reached"
|
||||
", skip (%zu)\n",
|
||||
multiplexed);
|
||||
@ -1465,7 +1467,6 @@ ConnectionExists(struct Curl_easy *data,
|
||||
|
||||
if(chosen) {
|
||||
/* mark it as used before releasing the lock */
|
||||
chosen->data = data; /* own it! */
|
||||
Curl_attach_connnection(data, chosen);
|
||||
CONNCACHE_UNLOCK(data);
|
||||
*usethis = chosen;
|
||||
@ -1680,9 +1681,6 @@ static struct connectdata *allocate_conn(struct Curl_easy *data)
|
||||
/* Store current time to give a baseline to keepalive connection times. */
|
||||
conn->keepalive = Curl_now();
|
||||
|
||||
conn->data = data; /* Setup the association between this connection
|
||||
and the Curl_easy */
|
||||
|
||||
#ifndef CURL_DISABLE_PROXY
|
||||
conn->http_proxy.proxytype = data->set.proxytype;
|
||||
conn->socks_proxy.proxytype = CURLPROXY_SOCKS4;
|
||||
@ -3405,8 +3403,6 @@ static void reuse_conn(struct Curl_easy *data,
|
||||
allocated in vain and is targeted for destruction */
|
||||
Curl_free_primary_ssl_config(&old_conn->ssl_config);
|
||||
|
||||
conn->data = data;
|
||||
|
||||
/* get the user+password information from the old_conn struct since it may
|
||||
* be new for this request even when we re-use an existing connection */
|
||||
conn->bits.user_passwd = old_conn->bits.user_passwd;
|
||||
@ -3494,7 +3490,6 @@ static void reuse_conn(struct Curl_easy *data,
|
||||
* @param async is set TRUE when an async DNS resolution is pending
|
||||
* @see Curl_setup_conn()
|
||||
*
|
||||
* *NOTE* this function assigns the conn->data pointer!
|
||||
*/
|
||||
|
||||
static CURLcode create_conn(struct Curl_easy *data,
|
||||
@ -3976,10 +3971,7 @@ out:
|
||||
* create_conn() is all done.
|
||||
*
|
||||
* Curl_setup_conn() also handles reused connections
|
||||
*
|
||||
* conn->data MUST already have been setup fine (in create_conn)
|
||||
*/
|
||||
|
||||
CURLcode Curl_setup_conn(struct Curl_easy *data,
|
||||
bool *protocol_done)
|
||||
{
|
||||
|
||||
@ -911,10 +911,6 @@ struct connstate {
|
||||
* unique for an entire connection.
|
||||
*/
|
||||
struct connectdata {
|
||||
/* 'data' is the CURRENT Curl_easy using this connection -- take great
|
||||
caution that this might very well vary between different times this
|
||||
connection is used! */
|
||||
struct Curl_easy *data;
|
||||
struct connstate cnnct;
|
||||
struct Curl_llist_element bundle_node; /* conncache */
|
||||
|
||||
|
||||
@ -5,7 +5,8 @@
|
||||
* | (__| |_| | _ <| |___
|
||||
* \___|\___/|_| \_\_____|
|
||||
*
|
||||
* Copyright (C) 2020, Jacob Hoffman-Andrews, <github@hoffman-andrews.com>
|
||||
* Copyright (C) 2020 - 2021, Jacob Hoffman-Andrews,
|
||||
* <github@hoffman-andrews.com>
|
||||
*
|
||||
* This software is licensed as described in the file COPYING, which
|
||||
* you should have received as part of this distribution. The terms
|
||||
@ -61,10 +62,8 @@ static CURLcode map_error(rustls_result r)
|
||||
static bool
|
||||
cr_data_pending(const struct connectdata *conn, int sockindex)
|
||||
{
|
||||
struct Curl_easy *data = conn->data;
|
||||
const struct ssl_connect_data *connssl = &conn->ssl[sockindex];
|
||||
struct ssl_backend_data *backend = connssl->backend;
|
||||
infof(data, "rustls_data_pending %d\n", backend->data_pending);
|
||||
return backend->data_pending;
|
||||
}
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user