aboutsummaryrefslogtreecommitdiff
path: root/lib
diff options
context:
space:
mode:
Diffstat (limited to 'lib')
-rw-r--r--lib/multi.c594
1 files changed, 295 insertions, 299 deletions
diff --git a/lib/multi.c b/lib/multi.c
index 15e0e06db..306b76955 100644
--- a/lib/multi.c
+++ b/lib/multi.c
@@ -68,7 +68,7 @@
((x) && (((struct SessionHandle *)(x))->magic == CURLEASY_MAGIC_NUMBER))
static void singlesocket(struct Curl_multi *multi,
- struct SessionHandle *easy);
+ struct SessionHandle *data);
static int update_timer(struct Curl_multi *multi);
static bool isHandleAtHead(struct SessionHandle *handle,
@@ -105,7 +105,7 @@ static const char * const statename[]={
static void multi_freetimeout(void *a, void *b);
/* always use this function to change state, to make debugging easier */
-static void mstate(struct SessionHandle *easy, CURLMstate state
+static void mstate(struct SessionHandle *data, CURLMstate state
#ifdef DEBUGBUILD
, int lineno
#endif
@@ -114,29 +114,29 @@ static void mstate(struct SessionHandle *easy, CURLMstate state
#ifdef DEBUGBUILD
long connection_id = -5000;
#endif
- CURLMstate oldstate = easy->mstate;
+ CURLMstate oldstate = data->mstate;
if(oldstate == state)
/* don't bother when the new state is the same as the old state */
return;
- easy->mstate = state;
+ data->mstate = state;
#ifdef DEBUGBUILD
- if(easy->mstate >= CURLM_STATE_CONNECT_PEND &&
- easy->mstate < CURLM_STATE_COMPLETED) {
- if(easy->easy_conn)
- connection_id = easy->easy_conn->connection_id;
+ if(data->mstate >= CURLM_STATE_CONNECT_PEND &&
+ data->mstate < CURLM_STATE_COMPLETED) {
+ if(data->easy_conn)
+ connection_id = data->easy_conn->connection_id;
- infof(easy,
+ infof(data,
"STATE: %s => %s handle %p; line %d (connection #%ld) \n",
- statename[oldstate], statename[easy->mstate],
- (void *)easy, lineno, connection_id);
+ statename[oldstate], statename[data->mstate],
+ (void *)data, lineno, connection_id);
}
#endif
if(state == CURLM_STATE_COMPLETED)
/* changing to COMPLETED means there's one less easy handle 'alive' */
- easy->multi->num_alive--;
+ data->multi->num_alive--;
}
#ifndef DEBUGBUILD
@@ -501,7 +501,7 @@ static void debug_print_sock_hash(void *p)
struct Curl_sh_entry *sh = (struct Curl_sh_entry *)p;
fprintf(stderr, " [easy %p/magic %x/socket %d]",
- (void *)sh->easy, sh->easy->magic, (int)sh->socket);
+ (void *)sh->data, sh->data->magic, (int)sh->socket);
}
#endif
@@ -521,9 +521,9 @@ CURLMcode curl_multi_remove_handle(CURLM *multi_handle,
return CURLM_BAD_EASY_HANDLE;
if(easy) {
- bool premature = (easy->mstate < CURLM_STATE_COMPLETED) ? TRUE : FALSE;
- bool easy_owns_conn = (easy->easy_conn &&
- (easy->easy_conn->data == easy)) ?
+ bool premature = (data->mstate < CURLM_STATE_COMPLETED) ? TRUE : FALSE;
+ bool easy_owns_conn = (data->easy_conn &&
+ (data->easy_conn->data == easy)) ?
TRUE : FALSE;
/* If the 'state' is not INIT or COMPLETED, we might need to do something
@@ -533,24 +533,24 @@ CURLMcode curl_multi_remove_handle(CURLM *multi_handle,
alive connections when this is removed */
multi->num_alive--;
- if(easy->easy_conn &&
- (easy->easy_conn->send_pipe->size +
- easy->easy_conn->recv_pipe->size > 1) &&
- easy->mstate > CURLM_STATE_WAITDO &&
- easy->mstate < CURLM_STATE_COMPLETED) {
+ if(data->easy_conn &&
+ (data->easy_conn->send_pipe->size +
+ data->easy_conn->recv_pipe->size > 1) &&
+ data->mstate > CURLM_STATE_WAITDO &&
+ data->mstate < CURLM_STATE_COMPLETED) {
/* If the handle is in a pipeline and has started sending off its
request but not received its response yet, we need to close
connection. */
- easy->easy_conn->bits.close = TRUE;
+ data->easy_conn->bits.close = TRUE;
/* Set connection owner so that Curl_done() closes it.
We can sefely do this here since connection is killed. */
- easy->easy_conn->data = easy;
+ data->easy_conn->data = easy;
}
- /* The timer must be shut down before easy->multi is set to NULL,
+ /* The timer must be shut down before data->multi is set to NULL,
else the timenode will remain in the splay tree after
curl_easy_cleanup is called. */
- Curl_expire(easy, 0);
+ Curl_expire(data, 0);
/* destroy the timeout list that is held in the easy handle */
if(data->state.timeoutlist) {
@@ -558,13 +558,13 @@ CURLMcode curl_multi_remove_handle(CURLM *multi_handle,
data->state.timeoutlist = NULL;
}
- if(easy->dns.hostcachetype == HCACHE_MULTI) {
+ if(data->dns.hostcachetype == HCACHE_MULTI) {
/* stop using the multi handle's DNS cache */
- easy->dns.hostcache = NULL;
- easy->dns.hostcachetype = HCACHE_NONE;
+ data->dns.hostcache = NULL;
+ data->dns.hostcachetype = HCACHE_NONE;
}
- if(easy->easy_conn) {
+ if(data->easy_conn) {
/* we must call Curl_done() here (if we still "own it") so that we don't
leave a half-baked one around */
@@ -575,30 +575,30 @@ CURLMcode curl_multi_remove_handle(CURLM *multi_handle,
Note that this ignores the return code simply because there's
nothing really useful to do with it anyway! */
- (void)Curl_done(&easy->easy_conn, easy->result, premature);
+ (void)Curl_done(&data->easy_conn, data->result, premature);
}
else
/* Clear connection pipelines, if Curl_done above was not called */
- Curl_getoff_all_pipelines(easy, easy->easy_conn);
+ Curl_getoff_all_pipelines(data, data->easy_conn);
}
/* as this was using a shared connection cache we clear the pointer
to that since we're not part of that multi handle anymore */
- easy->state.conn_cache = NULL;
+ data->state.conn_cache = NULL;
/* change state without using multistate(), only to make singlesocket() do
what we want */
- easy->mstate = CURLM_STATE_COMPLETED;
+ data->mstate = CURLM_STATE_COMPLETED;
singlesocket(multi, easy); /* to let the application know what sockets
that vanish with this handle */
/* Remove the association between the connection and the handle */
- if(easy->easy_conn) {
- easy->easy_conn->data = NULL;
- easy->easy_conn = NULL;
+ if(data->easy_conn) {
+ data->easy_conn->data = NULL;
+ data->easy_conn = NULL;
}
- easy_addmulti(easy, NULL); /* clear the association to this multi
+ easy_addmulti(data, NULL); /* clear the association to this multi
handle */
{
@@ -618,16 +618,16 @@ CURLMcode curl_multi_remove_handle(CURLM *multi_handle,
}
/* make the previous node point to our next */
- if(easy->prev)
- easy->prev->next = easy->next;
+ if(data->prev)
+ data->prev->next = data->next;
else
- multi->easyp = easy->next; /* point to first node */
+ multi->easyp = data->next; /* point to first node */
/* make our next point to our previous node */
- if(easy->next)
- easy->next->prev = easy->prev;
+ if(data->next)
+ data->next->prev = data->prev;
else
- multi->easylp = easy->prev; /* point to last node */
+ multi->easylp = data->prev; /* point to last node */
/* NOTE NOTE NOTE
We do not touch the easy handle here! */
@@ -678,7 +678,7 @@ static int domore_getsock(struct connectdata *conn,
}
/* returns bitmapped flags for this handle and its sockets */
-static int multi_getsock(struct SessionHandle *easy,
+static int multi_getsock(struct SessionHandle *data,
curl_socket_t *socks, /* points to numsocks number
of sockets */
int numsocks)
@@ -688,16 +688,16 @@ static int multi_getsock(struct SessionHandle *easy,
happen when this is called from curl_multi_remove_handle() =>
singlesocket() => multi_getsock().
*/
- if(easy->state.pipe_broke || !easy->easy_conn)
+ if(data->state.pipe_broke || !data->easy_conn)
return 0;
- if(easy->mstate > CURLM_STATE_CONNECT &&
- easy->mstate < CURLM_STATE_COMPLETED) {
+ if(data->mstate > CURLM_STATE_CONNECT &&
+ data->mstate < CURLM_STATE_COMPLETED) {
/* Set up ownership correctly */
- easy->easy_conn->data = easy;
+ data->easy_conn->data = data;
}
- switch(easy->mstate) {
+ switch(data->mstate) {
default:
#if 0 /* switch back on these cases to get the compiler to check for all enums
to be present */
@@ -715,28 +715,28 @@ static int multi_getsock(struct SessionHandle *easy,
return 0;
case CURLM_STATE_WAITRESOLVE:
- return Curl_resolver_getsock(easy->easy_conn, socks, numsocks);
+ return Curl_resolver_getsock(data->easy_conn, socks, numsocks);
case CURLM_STATE_PROTOCONNECT:
- return Curl_protocol_getsock(easy->easy_conn, socks, numsocks);
+ return Curl_protocol_getsock(data->easy_conn, socks, numsocks);
case CURLM_STATE_DO:
case CURLM_STATE_DOING:
- return Curl_doing_getsock(easy->easy_conn, socks, numsocks);
+ return Curl_doing_getsock(data->easy_conn, socks, numsocks);
case CURLM_STATE_WAITPROXYCONNECT:
case CURLM_STATE_WAITCONNECT:
- return waitconnect_getsock(easy->easy_conn, socks, numsocks);
+ return waitconnect_getsock(data->easy_conn, socks, numsocks);
case CURLM_STATE_DO_MORE:
- return domore_getsock(easy->easy_conn, socks, numsocks);
+ return domore_getsock(data->easy_conn, socks, numsocks);
case CURLM_STATE_DO_DONE: /* since is set after DO is completed, we switch
to waiting for the same as the *PERFORM
states */
case CURLM_STATE_PERFORM:
case CURLM_STATE_WAITPERFORM:
- return Curl_single_getsock(easy->easy_conn, socks, numsocks);
+ return Curl_single_getsock(data->easy_conn, socks, numsocks);
}
}
@@ -749,7 +749,7 @@ CURLMcode curl_multi_fdset(CURLM *multi_handle,
Some easy handles may not have connected to the remote host yet,
and then we must make sure that is done. */
struct Curl_multi *multi=(struct Curl_multi *)multi_handle;
- struct SessionHandle *easy;
+ struct SessionHandle *data;
int this_max_fd=-1;
curl_socket_t sockbunch[MAX_SOCKSPEREASYHANDLE];
int bitmap;
@@ -759,9 +759,9 @@ CURLMcode curl_multi_fdset(CURLM *multi_handle,
if(!GOOD_MULTI_HANDLE(multi))
return CURLM_BAD_HANDLE;
- easy=multi->easyp;
- while(easy) {
- bitmap = multi_getsock(easy, sockbunch, MAX_SOCKSPEREASYHANDLE);
+ data=multi->easyp;
+ while(data) {
+ bitmap = multi_getsock(data, sockbunch, MAX_SOCKSPEREASYHANDLE);
for(i=0; i< MAX_SOCKSPEREASYHANDLE; i++) {
curl_socket_t s = CURL_SOCKET_BAD;
@@ -783,7 +783,7 @@ CURLMcode curl_multi_fdset(CURLM *multi_handle,
}
}
- easy = easy->next; /* check next handle */
+ data = data->next; /* check next handle */
}
*max_fd = this_max_fd;
@@ -798,7 +798,7 @@ CURLMcode curl_multi_wait(CURLM *multi_handle,
int *ret)
{
struct Curl_multi *multi=(struct Curl_multi *)multi_handle;
- struct SessionHandle *easy;
+ struct SessionHandle *data;
curl_socket_t sockbunch[MAX_SOCKSPEREASYHANDLE];
int bitmap;
unsigned int i;
@@ -818,9 +818,9 @@ CURLMcode curl_multi_wait(CURLM *multi_handle,
timeout_ms = (int)timeout_internal;
/* Count up how many fds we have from the multi handle */
- easy=multi->easyp;
- while(easy) {
- bitmap = multi_getsock(easy, sockbunch, MAX_SOCKSPEREASYHANDLE);
+ data=multi->easyp;
+ while(data) {
+ bitmap = multi_getsock(data, sockbunch, MAX_SOCKSPEREASYHANDLE);
for(i=0; i< MAX_SOCKSPEREASYHANDLE; i++) {
curl_socket_t s = CURL_SOCKET_BAD;
@@ -838,7 +838,7 @@ CURLMcode curl_multi_wait(CURLM *multi_handle,
}
}
- easy = easy->next; /* check next handle */
+ data = data->next; /* check next handle */
}
curlfds = nfds; /* number of internal file descriptors */
@@ -856,9 +856,9 @@ CURLMcode curl_multi_wait(CURLM *multi_handle,
if(curlfds) {
/* Add the curl handles to our pollfds first */
- easy=multi->easyp;
- while(easy) {
- bitmap = multi_getsock(easy, sockbunch, MAX_SOCKSPEREASYHANDLE);
+ data=multi->easyp;
+ while(data) {
+ bitmap = multi_getsock(data, sockbunch, MAX_SOCKSPEREASYHANDLE);
for(i=0; i< MAX_SOCKSPEREASYHANDLE; i++) {
curl_socket_t s = CURL_SOCKET_BAD;
@@ -880,7 +880,7 @@ CURLMcode curl_multi_wait(CURLM *multi_handle,
}
}
- easy = easy->next; /* check next handle */
+ data = data->next; /* check next handle */
}
}
@@ -932,7 +932,7 @@ CURLMcode curl_multi_wait(CURLM *multi_handle,
static CURLMcode multi_runsingle(struct Curl_multi *multi,
struct timeval now,
- struct SessionHandle *easy)
+ struct SessionHandle *data)
{
struct Curl_message *msg = NULL;
bool connected;
@@ -942,15 +942,12 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
bool done = FALSE;
CURLMcode result = CURLM_OK;
struct SingleRequest *k;
- struct SessionHandle *data;
long timeout_ms;
int control;
- if(!GOOD_EASY_HANDLE(easy))
+ if(!GOOD_EASY_HANDLE(data))
return CURLM_BAD_EASY_HANDLE;
- data = easy;
-
do {
/* this is a single-iteration do-while loop just to allow a
break to skip to the end of it */
@@ -960,51 +957,51 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
we're using gets cleaned up and we're left with nothing. */
if(data->state.pipe_broke) {
infof(data, "Pipe broke: handle 0x%p, url = %s\n",
- (void *)easy, data->state.path);
+ (void *)data, data->state.path);
- if(easy->mstate < CURLM_STATE_COMPLETED) {
+ if(data->mstate < CURLM_STATE_COMPLETED) {
/* Head back to the CONNECT state */
- multistate(easy, CURLM_STATE_CONNECT);
+ multistate(data, CURLM_STATE_CONNECT);
result = CURLM_CALL_MULTI_PERFORM;
- easy->result = CURLE_OK;
+ data->result = CURLE_OK;
}
data->state.pipe_broke = FALSE;
- easy->easy_conn = NULL;
+ data->easy_conn = NULL;
break;
}
- if(!easy->easy_conn &&
- easy->mstate > CURLM_STATE_CONNECT &&
- easy->mstate < CURLM_STATE_DONE) {
- /* In all these states, the code will blindly access 'easy->easy_conn'
+ if(!data->easy_conn &&
+ data->mstate > CURLM_STATE_CONNECT &&
+ data->mstate < CURLM_STATE_DONE) {
+ /* In all these states, the code will blindly access 'data->easy_conn'
so this is precaution that it isn't NULL. And it silences static
analyzers. */
- failf(data, "In state %d with no easy_conn, bail out!\n", easy->mstate);
+ failf(data, "In state %d with no easy_conn, bail out!\n", data->mstate);
return CURLM_INTERNAL_ERROR;
}
- if(easy->easy_conn && easy->mstate > CURLM_STATE_CONNECT &&
- easy->mstate < CURLM_STATE_COMPLETED)
+ if(data->easy_conn && data->mstate > CURLM_STATE_CONNECT &&
+ data->mstate < CURLM_STATE_COMPLETED)
/* Make sure we set the connection's current owner */
- easy->easy_conn->data = data;
+ data->easy_conn->data = data;
- if(easy->easy_conn &&
- (easy->mstate >= CURLM_STATE_CONNECT) &&
- (easy->mstate < CURLM_STATE_COMPLETED)) {
+ if(data->easy_conn &&
+ (data->mstate >= CURLM_STATE_CONNECT) &&
+ (data->mstate < CURLM_STATE_COMPLETED)) {
/* we need to wait for the connect state as only then is the start time
stored, but we must not check already completed handles */
timeout_ms = Curl_timeleft(data, &now,
- (easy->mstate <= CURLM_STATE_WAITDO)?
+ (data->mstate <= CURLM_STATE_WAITDO)?
TRUE:FALSE);
if(timeout_ms < 0) {
/* Handle timed out */
- if(easy->mstate == CURLM_STATE_WAITRESOLVE)
+ if(data->mstate == CURLM_STATE_WAITRESOLVE)
failf(data, "Resolving timed out after %ld milliseconds",
Curl_tvdiff(now, data->progress.t_startsingle));
- else if(easy->mstate == CURLM_STATE_WAITCONNECT)
+ else if(data->mstate == CURLM_STATE_WAITCONNECT)
failf(data, "Connection timed out after %ld milliseconds",
Curl_tvdiff(now, data->progress.t_startsingle));
else {
@@ -1018,21 +1015,21 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
/* Force the connection closed because the server could continue to
send us stuff at any time. (The disconnect_conn logic used below
doesn't work at this point). */
- easy->easy_conn->bits.close = TRUE;
- easy->result = CURLE_OPERATION_TIMEDOUT;
- multistate(easy, CURLM_STATE_COMPLETED);
+ data->easy_conn->bits.close = TRUE;
+ data->result = CURLE_OPERATION_TIMEDOUT;
+ multistate(data, CURLM_STATE_COMPLETED);
break;
}
}
- switch(easy->mstate) {
+ switch(data->mstate) {
case CURLM_STATE_INIT:
/* init this transfer. */
- easy->result=Curl_pretransfer(data);
+ data->result=Curl_pretransfer(data);
- if(CURLE_OK == easy->result) {
+ if(CURLE_OK == data->result) {
/* after init, go CONNECT */
- multistate(easy, CURLM_STATE_CONNECT);
+ multistate(data, CURLM_STATE_CONNECT);
result = CURLM_CALL_MULTI_PERFORM;
}
break;
@@ -1045,25 +1042,25 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
case CURLM_STATE_CONNECT:
/* Connect. We want to get a connection identifier filled in. */
Curl_pgrsTime(data, TIMER_STARTSINGLE);
- easy->result = Curl_connect(data, &easy->easy_conn,
+ data->result = Curl_connect(data, &data->easy_conn,
&async, &protocol_connect);
- if(CURLE_NO_CONNECTION_AVAILABLE == easy->result) {
+ if(CURLE_NO_CONNECTION_AVAILABLE == data->result) {
/* There was no connection available. We will go to the pending
state and wait for an available connection. */
- multistate(easy, CURLM_STATE_CONNECT_PEND);
- easy->result = CURLE_OK;
+ multistate(data, CURLM_STATE_CONNECT_PEND);
+ data->result = CURLE_OK;
break;
}
- if(CURLE_OK == easy->result) {
+ if(CURLE_OK == data->result) {
/* Add this handle to the send or pend pipeline */
- easy->result = Curl_add_handle_to_pipeline(data, easy->easy_conn);
- if(CURLE_OK != easy->result)
+ data->result = Curl_add_handle_to_pipeline(data, data->easy_conn);
+ if(CURLE_OK != data->result)
disconnect_conn = TRUE;
else {
if(async)
/* We're now waiting for an asynchronous name lookup */
- multistate(easy, CURLM_STATE_WAITRESOLVE);
+ multistate(data, CURLM_STATE_WAITRESOLVE);
else {
/* after the connect has been sent off, go WAITCONNECT unless the
protocol connect is already done and we can go directly to
@@ -1071,15 +1068,15 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
result = CURLM_CALL_MULTI_PERFORM;
if(protocol_connect)
- multistate(easy, multi->pipelining_enabled?
+ multistate(data, multi->pipelining_enabled?
CURLM_STATE_WAITDO:CURLM_STATE_DO);
else {
#ifndef CURL_DISABLE_HTTP
- if(easy->easy_conn->tunnel_state[FIRSTSOCKET] == TUNNEL_CONNECT)
- multistate(easy, CURLM_STATE_WAITPROXYCONNECT);
+ if(data->easy_conn->tunnel_state[FIRSTSOCKET] == TUNNEL_CONNECT)
+ multistate(data, CURLM_STATE_WAITPROXYCONNECT);
else
#endif
- multistate(easy, CURLM_STATE_WAITCONNECT);
+ multistate(data, CURLM_STATE_WAITCONNECT);
}
}
}
@@ -1092,7 +1089,7 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
struct Curl_dns_entry *dns = NULL;
/* check if we have the name resolved by now */
- easy->result = Curl_resolver_is_resolved(easy->easy_conn, &dns);
+ data->result = Curl_resolver_is_resolved(data->easy_conn, &dns);
/* Update sockets here, because the socket(s) may have been
closed and the application thus needs to be told, even if it
@@ -1100,36 +1097,36 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
down. If the name has not yet been resolved, it is likely
that new sockets have been opened in an attempt to contact
another resolver. */
- singlesocket(multi, easy);
+ singlesocket(multi, data);
if(dns) {
/* Perform the next step in the connection phase, and then move on
to the WAITCONNECT state */
- easy->result = Curl_async_resolved(easy->easy_conn,
+ data->result = Curl_async_resolved(data->easy_conn,
&protocol_connect);
- if(CURLE_OK != easy->result)
+ if(CURLE_OK != data->result)
/* if Curl_async_resolved() returns failure, the connection struct
is already freed and gone */
- easy->easy_conn = NULL; /* no more connection */
+ data->easy_conn = NULL; /* no more connection */
else {
/* call again please so that we get the next socket setup */
result = CURLM_CALL_MULTI_PERFORM;
if(protocol_connect)
- multistate(easy, multi->pipelining_enabled?
+ multistate(data, multi->pipelining_enabled?
CURLM_STATE_WAITDO:CURLM_STATE_DO);
else {
#ifndef CURL_DISABLE_HTTP
- if(easy->easy_conn->tunnel_state[FIRSTSOCKET] == TUNNEL_CONNECT)
- multistate(easy, CURLM_STATE_WAITPROXYCONNECT);
+ if(data->easy_conn->tunnel_state[FIRSTSOCKET] == TUNNEL_CONNECT)
+ multistate(data, CURLM_STATE_WAITPROXYCONNECT);
else
#endif
- multistate(easy, CURLM_STATE_WAITCONNECT);
+ multistate(data, CURLM_STATE_WAITCONNECT);
}
}
}
- if(CURLE_OK != easy->result) {
+ if(CURLE_OK != data->result) {
/* failure detected */
disconnect_conn = TRUE;
break;
@@ -1140,40 +1137,40 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
#ifndef CURL_DISABLE_HTTP
case CURLM_STATE_WAITPROXYCONNECT:
/* this is HTTP-specific, but sending CONNECT to a proxy is HTTP... */
- easy->result = Curl_http_connect(easy->easy_conn, &protocol_connect);
+ data->result = Curl_http_connect(data->easy_conn, &protocol_connect);
- if(easy->easy_conn->bits.proxy_connect_closed) {
+ if(data->easy_conn->bits.proxy_connect_closed) {
/* reset the error buffer */
if(data->set.errorbuffer)
data->set.errorbuffer[0] = '\0';
data->state.errorbuf = FALSE;
- easy->result = CURLE_OK;
+ data->result = CURLE_OK;
result = CURLM_CALL_MULTI_PERFORM;
- multistate(easy, CURLM_STATE_CONNECT);
+ multistate(data, CURLM_STATE_CONNECT);
}
- else if(CURLE_OK == easy->result) {
- if(easy->easy_conn->tunnel_state[FIRSTSOCKET] == TUNNEL_COMPLETE)
- multistate(easy, CURLM_STATE_WAITCONNECT);
+ else if(CURLE_OK == data->result) {
+ if(data->easy_conn->tunnel_state[FIRSTSOCKET] == TUNNEL_COMPLETE)
+ multistate(data, CURLM_STATE_WAITCONNECT);
}
break;
#endif
case CURLM_STATE_WAITCONNECT:
/* awaiting a completion of an asynch connect */
- easy->result = Curl_is_connected(easy->easy_conn,
+ data->result = Curl_is_connected(data->easy_conn,
FIRSTSOCKET,
&connected);
if(connected) {
- if(!easy->result)
+ if(!data->result)
/* if everything is still fine we do the protocol-specific connect
setup */
- easy->result = Curl_protocol_connect(easy->easy_conn,
+ data->result = Curl_protocol_connect(data->easy_conn,
&protocol_connect);
}
- if(CURLE_OK != easy->result) {
+ if(CURLE_OK != data->result) {
/* failure detected */
/* Just break, the cleaning up is handled all in one place */
disconnect_conn = TRUE;
@@ -1188,16 +1185,16 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
BUT if we are using a proxy we must change to WAITPROXYCONNECT
*/
#ifndef CURL_DISABLE_HTTP
- if(easy->easy_conn->tunnel_state[FIRSTSOCKET] == TUNNEL_CONNECT)
- multistate(easy, CURLM_STATE_WAITPROXYCONNECT);
+ if(data->easy_conn->tunnel_state[FIRSTSOCKET] == TUNNEL_CONNECT)
+ multistate(data, CURLM_STATE_WAITPROXYCONNECT);
else
#endif
- multistate(easy, CURLM_STATE_PROTOCONNECT);
+ multistate(data, CURLM_STATE_PROTOCONNECT);
}
else
/* after the connect has completed, go WAITDO or DO */
- multistate(easy, multi->pipelining_enabled?
+ multistate(data, multi->pipelining_enabled?
CURLM_STATE_WAITDO:CURLM_STATE_DO);
result = CURLM_CALL_MULTI_PERFORM;
@@ -1206,18 +1203,18 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
case CURLM_STATE_PROTOCONNECT:
/* protocol-specific connect phase */
- easy->result = Curl_protocol_connecting(easy->easy_conn,
+ data->result = Curl_protocol_connecting(data->easy_conn,
&protocol_connect);
- if((easy->result == CURLE_OK) && protocol_connect) {
+ if((data->result == CURLE_OK) && protocol_connect) {
/* after the connect has completed, go WAITDO or DO */
- multistate(easy, multi->pipelining_enabled?
+ multistate(data, multi->pipelining_enabled?
CURLM_STATE_WAITDO:CURLM_STATE_DO);
result = CURLM_CALL_MULTI_PERFORM;
}
- else if(easy->result) {
+ else if(data->result) {
/* failure detected */
Curl_posttransfer(data);
- Curl_done(&easy->easy_conn, easy->result, TRUE);
+ Curl_done(&data->easy_conn, data->result, TRUE);
disconnect_conn = TRUE;
}
break;
@@ -1226,18 +1223,18 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
/* Wait for our turn to DO when we're pipelining requests */
#ifdef DEBUGBUILD
infof(data, "WAITDO: Conn %ld send pipe %zu inuse %s athead %s\n",
- easy->easy_conn->connection_id,
- easy->easy_conn->send_pipe->size,
- easy->easy_conn->writechannel_inuse?"TRUE":"FALSE",
+ data->easy_conn->connection_id,
+ data->easy_conn->send_pipe->size,
+ data->easy_conn->writechannel_inuse?"TRUE":"FALSE",
isHandleAtHead(data,
- easy->easy_conn->send_pipe)?"TRUE":"FALSE");
+ data->easy_conn->send_pipe)?"TRUE":"FALSE");
#endif
- if(!easy->easy_conn->writechannel_inuse &&
+ if(!data->easy_conn->writechannel_inuse &&
isHandleAtHead(data,
- easy->easy_conn->send_pipe)) {
+ data->easy_conn->send_pipe)) {
/* Grab the channel */
- easy->easy_conn->writechannel_inuse = TRUE;
- multistate(easy, CURLM_STATE_DO);
+ data->easy_conn->writechannel_inuse = TRUE;
+ multistate(data, CURLM_STATE_DO);
result = CURLM_CALL_MULTI_PERFORM;
}
break;
@@ -1245,51 +1242,51 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
case CURLM_STATE_DO:
if(data->set.connect_only) {
/* keep connection open for application to use the socket */
- easy->easy_conn->bits.close = FALSE;
- multistate(easy, CURLM_STATE_DONE);
- easy->result = CURLE_OK;
+ data->easy_conn->bits.close = FALSE;
+ multistate(data, CURLM_STATE_DONE);
+ data->result = CURLE_OK;
result = CURLM_CALL_MULTI_PERFORM;
}
else {
/* Perform the protocol's DO action */
- easy->result = Curl_do(&easy->easy_conn, &dophase_done);
+ data->result = Curl_do(&data->easy_conn, &dophase_done);
- /* When Curl_do() returns failure, easy->easy_conn might be NULL! */
+ /* When Curl_do() returns failure, data->easy_conn might be NULL! */
- if(CURLE_OK == easy->result) {
+ if(CURLE_OK == data->result) {
if(!dophase_done) {
/* some steps needed for wildcard matching */
if(data->set.wildcardmatch) {
struct WildcardData *wc = &data->wildcard;
if(wc->state == CURLWC_DONE || wc->state == CURLWC_SKIP) {
/* skip some states if it is important */
- Curl_done(&easy->easy_conn, CURLE_OK, FALSE);
- multistate(easy, CURLM_STATE_DONE);
+ Curl_done(&data->easy_conn, CURLE_OK, FALSE);
+ multistate(data, CURLM_STATE_DONE);
result = CURLM_CALL_MULTI_PERFORM;
break;
}
}
/* DO was not completed in one function call, we must continue
DOING... */
- multistate(easy, CURLM_STATE_DOING);
+ multistate(data, CURLM_STATE_DOING);
result = CURLM_OK;
}
/* after DO, go DO_DONE... or DO_MORE */
- else if(easy->easy_conn->bits.do_more) {
+ else if(data->easy_conn->bits.do_more) {
/* we're supposed to do more, but we need to sit down, relax
and wait a little while first */
- multistate(easy, CURLM_STATE_DO_MORE);
+ multistate(data, CURLM_STATE_DO_MORE);
result = CURLM_OK;
}
else {
/* we're done with the DO, now DO_DONE */
- multistate(easy, CURLM_STATE_DO_DONE);
+ multistate(data, CURLM_STATE_DO_DONE);
result = CURLM_CALL_MULTI_PERFORM;
}
}
- else if((CURLE_SEND_ERROR == easy->result) &&
- easy->easy_conn->bits.reuse) {
+ else if((CURLE_SEND_ERROR == data->result) &&
+ data->easy_conn->bits.reuse) {
/*
* In this situation, a connection that we were trying to use
* may have unexpectedly died. If possible, send the connection
@@ -1300,17 +1297,17 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
CURLcode drc;
bool retry = FALSE;
- drc = Curl_retry_request(easy->easy_conn, &newurl);
+ drc = Curl_retry_request(data->easy_conn, &newurl);
if(drc) {
/* a failure here pretty much implies an out of memory */
- easy->result = drc;
+ data->result = drc;
disconnect_conn = TRUE;
}
else
retry = (newurl)?TRUE:FALSE;
Curl_posttransfer(data);
- drc = Curl_done(&easy->easy_conn, easy->result, FALSE);
+ drc = Curl_done(&data->easy_conn, data->result, FALSE);
/* When set to retry the connection, we must to go back to
* the CONNECT state */
@@ -1319,19 +1316,19 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
follow = FOLLOW_RETRY;
drc = Curl_follow(data, newurl, follow);
if(drc == CURLE_OK) {
- multistate(easy, CURLM_STATE_CONNECT);
+ multistate(data, CURLM_STATE_CONNECT);
result = CURLM_CALL_MULTI_PERFORM;
- easy->result = CURLE_OK;
+ data->result = CURLE_OK;
}
else {
/* Follow failed */
- easy->result = drc;
+ data->result = drc;
free(newurl);
}
}
else {
/* done didn't return OK or SEND_ERROR */
- easy->result = drc;
+ data->result = drc;
free(newurl);
}
}
@@ -1343,8 +1340,8 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
else {
/* failure detected */
Curl_posttransfer(data);
- if(easy->easy_conn)
- Curl_done(&easy->easy_conn, easy->result, FALSE);
+ if(data->easy_conn)
+ Curl_done(&data->easy_conn, data->result, FALSE);
disconnect_conn = TRUE;
}
}
@@ -1352,12 +1349,12 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
case CURLM_STATE_DOING:
/* we continue DOING until the DO phase is complete */
- easy->result = Curl_protocol_doing(easy->easy_conn,
+ data->result = Curl_protocol_doing(data->easy_conn,
&dophase_done);
- if(CURLE_OK == easy->result) {
+ if(CURLE_OK == data->result) {
if(dophase_done) {
/* after DO, go DO_DONE or DO_MORE */
- multistate(easy, easy->easy_conn->bits.do_more?
+ multistate(data, data->easy_conn->bits.do_more?
CURLM_STATE_DO_MORE:
CURLM_STATE_DO_DONE);
result = CURLM_CALL_MULTI_PERFORM;
@@ -1366,7 +1363,7 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
else {
/* failure detected */
Curl_posttransfer(data);
- Curl_done(&easy->easy_conn, easy->result, FALSE);
+ Curl_done(&data->easy_conn, data->result, FALSE);
disconnect_conn = TRUE;
}
break;
@@ -1375,15 +1372,15 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
/*
* When we are connected, DO MORE and then go DO_DONE
*/
- easy->result = Curl_do_more(easy->easy_conn, &control);
+ data->result = Curl_do_more(data->easy_conn, &control);
/* No need to remove this handle from the send pipeline here since that
is done in Curl_done() */
- if(CURLE_OK == easy->result) {
+ if(CURLE_OK == data->result) {
if(control) {
/* if positive, advance to DO_DONE
if negative, go back to DOING */
- multistate(easy, control==1?
+ multistate(data, control==1?
CURLM_STATE_DO_DONE:
CURLM_STATE_DOING);
result = CURLM_CALL_MULTI_PERFORM;
@@ -1395,54 +1392,54 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
else {
/* failure detected */
Curl_posttransfer(data);
- Curl_done(&easy->easy_conn, easy->result, FALSE);
+ Curl_done(&data->easy_conn, data->result, FALSE);
disconnect_conn = TRUE;
}
break;
case CURLM_STATE_DO_DONE:
/* Move ourselves from the send to recv pipeline */
- Curl_move_handle_from_send_to_recv_pipe(data, easy->easy_conn);
+ Curl_move_handle_from_send_to_recv_pipe(data, data->easy_conn);
/* Check if we can move pending requests to send pipe */
Curl_multi_process_pending_handles(multi);
- multistate(easy, CURLM_STATE_WAITPERFORM);
+ multistate(data, CURLM_STATE_WAITPERFORM);
result = CURLM_CALL_MULTI_PERFORM;
break;
case CURLM_STATE_WAITPERFORM:
/* Wait for our turn to PERFORM */
- if(!easy->easy_conn->readchannel_inuse &&
+ if(!data->easy_conn->readchannel_inuse &&
isHandleAtHead(data,
- easy->easy_conn->recv_pipe)) {
+ data->easy_conn->recv_pipe)) {
/* Grab the channel */
- easy->easy_conn->readchannel_inuse = TRUE;
- multistate(easy, CURLM_STATE_PERFORM);
+ data->easy_conn->readchannel_inuse = TRUE;
+ multistate(data, CURLM_STATE_PERFORM);
result = CURLM_CALL_MULTI_PERFORM;
}
#ifdef DEBUGBUILD
else {
infof(data, "WAITPERFORM: Conn %ld recv pipe %zu inuse %s athead %s\n",
- easy->easy_conn->connection_id,
- easy->easy_conn->recv_pipe->size,
- easy->easy_conn->readchannel_inuse?"TRUE":"FALSE",
+ data->easy_conn->connection_id,
+ data->easy_conn->recv_pipe->size,
+ data->easy_conn->readchannel_inuse?"TRUE":"FALSE",
isHandleAtHead(data,
- easy->easy_conn->recv_pipe)?"TRUE":"FALSE");
+ data->easy_conn->recv_pipe)?"TRUE":"FALSE");
}
#endif
break;
case CURLM_STATE_TOOFAST: /* limit-rate exceeded in either direction */
/* if both rates are within spec, resume transfer */
- if(Curl_pgrsUpdate(easy->easy_conn))
- easy->result = CURLE_ABORTED_BY_CALLBACK;
+ if(Curl_pgrsUpdate(data->easy_conn))
+ data->result = CURLE_ABORTED_BY_CALLBACK;
else
- easy->result = Curl_speedcheck(data, now);
+ data->result = Curl_speedcheck(data, now);
if(( (data->set.max_send_speed == 0) ||
(data->progress.ulspeed < data->set.max_send_speed )) &&
( (data->set.max_recv_speed == 0) ||
(data->progress.dlspeed < data->set.max_recv_speed)))
- multistate(easy, CURLM_STATE_PERFORM);
+ multistate(data, CURLM_STATE_PERFORM);
break;
case CURLM_STATE_PERFORM:
@@ -1455,7 +1452,7 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
(data->progress.ulspeed > data->set.max_send_speed)) {
int buffersize;
- multistate(easy, CURLM_STATE_TOOFAST);
+ multistate(data, CURLM_STATE_TOOFAST);
/* calculate upload rate-limitation timeout. */
buffersize = (int)(data->set.buffer_size ?
@@ -1471,7 +1468,7 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
(data->progress.dlspeed > data->set.max_recv_speed)) {
int buffersize;
- multistate(easy, CURLM_STATE_TOOFAST);
+ multistate(data, CURLM_STATE_TOOFAST);
/* Calculate download rate-limitation timeout. */
buffersize = (int)(data->set.buffer_size ?
@@ -1483,38 +1480,38 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
}
/* read/write data if it is ready to do so */
- easy->result = Curl_readwrite(easy->easy_conn, &done);
+ data->result = Curl_readwrite(data->easy_conn, &done);
k = &data->req;
if(!(k->keepon & KEEP_RECV)) {
/* We're done receiving */
- easy->easy_conn->readchannel_inuse = FALSE;
+ data->easy_conn->readchannel_inuse = FALSE;
}
if(!(k->keepon & KEEP_SEND)) {
/* We're done sending */
- easy->easy_conn->writechannel_inuse = FALSE;
+ data->easy_conn->writechannel_inuse = FALSE;
}
- if(done || (easy->result == CURLE_RECV_ERROR)) {
+ if(done || (data->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
* we wanted to use it, so figure out if that is indeed the case.
*/
- CURLcode ret = Curl_retry_request(easy->easy_conn, &newurl);
+ CURLcode ret = Curl_retry_request(data->easy_conn, &newurl);
if(!ret)
retry = (newurl)?TRUE:FALSE;
if(retry) {
/* if we are to retry, set the result to OK and consider the
request as done */
- easy->result = CURLE_OK;
+ data->result = CURLE_OK;
done = TRUE;
}
}
- if(easy->result) {
+ if(data->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
@@ -1523,11 +1520,11 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
* happened in the data connection.
*/
- if(!(easy->easy_conn->handler->flags & PROTOPT_DUAL))
- easy->easy_conn->bits.close = TRUE;
+ if(!(data->easy_conn->handler->flags & PROTOPT_DUAL))
+ data->easy_conn->bits.close = TRUE;
Curl_posttransfer(data);
- Curl_done(&easy->easy_conn, easy->result, FALSE);
+ Curl_done(&data->easy_conn, data->result, FALSE);
}
else if(done) {
followtype follow=FOLLOW_NONE;
@@ -1536,11 +1533,11 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
Curl_posttransfer(data);
/* we're no longer receiving */
- Curl_removeHandleFromPipeline(data, easy->easy_conn->recv_pipe);
+ Curl_removeHandleFromPipeline(data, data->easy_conn->recv_pipe);
/* expire the new receiving pipeline head */
- if(easy->easy_conn->recv_pipe->head)
- Curl_expire(easy->easy_conn->recv_pipe->head->ptr, 1);
+ if(data->easy_conn->recv_pipe->head)
+ Curl_expire(data->easy_conn->recv_pipe->head->ptr, 1);
/* Check if we can move pending requests to send pipe */
Curl_multi_process_pending_handles(multi);
@@ -1557,11 +1554,11 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
}
else
follow = FOLLOW_RETRY;
- easy->result = Curl_done(&easy->easy_conn, CURLE_OK, FALSE);
- if(CURLE_OK == easy->result) {
- easy->result = Curl_follow(data, newurl, follow);
- if(CURLE_OK == easy->result) {
- multistate(easy, CURLM_STATE_CONNECT);
+ data->result = Curl_done(&data->easy_conn, CURLE_OK, FALSE);
+ if(CURLE_OK == data->result) {
+ data->result = Curl_follow(data, newurl, follow);
+ if(CURLE_OK == data->result) {
+ multistate(data, CURLM_STATE_CONNECT);
result = CURLM_CALL_MULTI_PERFORM;
newurl = NULL; /* handed over the memory ownership to
Curl_follow(), make sure we don't free() it
@@ -1579,14 +1576,14 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
free(newurl);
newurl = data->req.location;
data->req.location = NULL;
- easy->result = Curl_follow(data, newurl, FOLLOW_FAKE);
- if(CURLE_OK == easy->result)
+ data->result = Curl_follow(data, newurl, FOLLOW_FAKE);
+ if(CURLE_OK == data->result)
newurl = NULL; /* allocation was handed over Curl_follow() */
else
disconnect_conn = TRUE;
}
- multistate(easy, CURLM_STATE_DONE);
+ multistate(data, CURLM_STATE_DONE);
result = CURLM_CALL_MULTI_PERFORM;
}
}
@@ -1598,14 +1595,14 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
case CURLM_STATE_DONE:
- if(easy->easy_conn) {
+ if(data->easy_conn) {
/* Remove ourselves from the receive pipeline, if we are there. */
Curl_removeHandleFromPipeline(data,
- easy->easy_conn->recv_pipe);
+ data->easy_conn->recv_pipe);
/* Check if we can move pending requests to send pipe */
Curl_multi_process_pending_handles(multi);
- if(easy->easy_conn->bits.stream_was_rewound) {
+ if(data->easy_conn->bits.stream_was_rewound) {
/* This request read past its response boundary so we quickly let
the other requests consume those bytes since there is no
guarantee that the socket will become active again */
@@ -1613,15 +1610,15 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
}
/* post-transfer command */
- easy->result = Curl_done(&easy->easy_conn, CURLE_OK, FALSE);
+ data->result = Curl_done(&data->easy_conn, CURLE_OK, FALSE);
/*
* If there are other handles on the pipeline, Curl_done won't set
* easy_conn to NULL. In such a case, curl_multi_remove_handle() can
* access free'd data, if the connection is free'd and the handle
* removed before we perform the processing in CURLM_STATE_COMPLETED
*/
- if(easy->easy_conn)
- easy->easy_conn = NULL;
+ if(data->easy_conn)
+ data->easy_conn = NULL;
}
if(data->set.wildcardmatch) {
@@ -1629,14 +1626,14 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
/* if a wildcard is set and we are not ending -> lets start again
with CURLM_STATE_INIT */
result = CURLM_CALL_MULTI_PERFORM;
- multistate(easy, CURLM_STATE_INIT);
+ multistate(data, CURLM_STATE_INIT);
break;
}
}
/* after we have DONE what we're supposed to do, go COMPLETED, and
it doesn't matter what the Curl_done() returned! */
- multistate(easy, CURLM_STATE_COMPLETED);
+ multistate(data, CURLM_STATE_COMPLETED);
break;
@@ -1648,7 +1645,7 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
/* Important: reset the conn pointer so that we don't point to memory
that could be freed anytime */
- easy->easy_conn = NULL;
+ data->easy_conn = NULL;
Curl_expire(data, 0); /* stop all timers */
break;
@@ -1660,8 +1657,8 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
return CURLM_INTERNAL_ERROR;
}
- if(easy->mstate < CURLM_STATE_COMPLETED) {
- if(CURLE_OK != easy->result) {
+ if(data->mstate < CURLM_STATE_COMPLETED) {
+ if(CURLE_OK != data->result) {
/*
* If an error was returned, and we aren't in completed state now,
* then we go to completed and consider this transfer aborted.
@@ -1672,59 +1669,59 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
data->state.pipe_broke = FALSE;
- if(easy->easy_conn) {
+ if(data->easy_conn) {
/* if this has a connection, unsubscribe from the pipelines */
- easy->easy_conn->writechannel_inuse = FALSE;
- easy->easy_conn->readchannel_inuse = FALSE;
+ data->easy_conn->writechannel_inuse = FALSE;
+ data->easy_conn->readchannel_inuse = FALSE;
Curl_removeHandleFromPipeline(data,
- easy->easy_conn->send_pipe);
+ data->easy_conn->send_pipe);
Curl_removeHandleFromPipeline(data,
- easy->easy_conn->recv_pipe);
+ data->easy_conn->recv_pipe);
/* Check if we can move pending requests to send pipe */
Curl_multi_process_pending_handles(multi);
if(disconnect_conn) {
/* disconnect properly */
- Curl_disconnect(easy->easy_conn, /* dead_connection */ FALSE);
+ Curl_disconnect(data->easy_conn, /* dead_connection */ FALSE);
/* This is where we make sure that the easy_conn pointer is reset.
We don't have to do this in every case block above where a
failure is detected */
- easy->easy_conn = NULL;
+ data->easy_conn = NULL;
}
}
- else if(easy->mstate == CURLM_STATE_CONNECT) {
+ else if(data->mstate == CURLM_STATE_CONNECT) {
/* Curl_connect() failed */
(void)Curl_posttransfer(data);
}
- multistate(easy, CURLM_STATE_COMPLETED);
+ multistate(data, CURLM_STATE_COMPLETED);
}
/* if there's still a connection to use, call the progress function */
- else if(easy->easy_conn && Curl_pgrsUpdate(easy->easy_conn)) {
+ else if(data->easy_conn && Curl_pgrsUpdate(data->easy_conn)) {
/* aborted due to progress callback return code must close the
connection */
- easy->easy_conn->bits.close = TRUE;
+ data->easy_conn->bits.close = TRUE;
/* if not yet in DONE state, go there, otherwise COMPLETED */
- multistate(easy, (easy->mstate < CURLM_STATE_DONE)?
+ multistate(data, (data->mstate < CURLM_STATE_DONE)?
CURLM_STATE_DONE: CURLM_STATE_COMPLETED);
result = CURLM_CALL_MULTI_PERFORM;
}
}
} WHILE_FALSE; /* just to break out from! */
- if(CURLM_STATE_COMPLETED == easy->mstate) {
+ if(CURLM_STATE_COMPLETED == data->mstate) {
/* now fill in the Curl_message with this info */
- msg = &easy->msg;
+ msg = &data->msg;
msg->extmsg.msg = CURLMSG_DONE;
msg->extmsg.easy_handle = data;
- msg->extmsg.data.result = easy->result;
+ msg->extmsg.data.result = data->result;
result = multi_addmsg(multi, msg);
- multistate(easy, CURLM_STATE_MSGSENT);
+ multistate(data, CURLM_STATE_MSGSENT);
}
return result;
@@ -1734,7 +1731,7 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
CURLMcode curl_multi_perform(CURLM *multi_handle, int *running_handles)
{
struct Curl_multi *multi=(struct Curl_multi *)multi_handle;
- struct SessionHandle *easy;
+ struct SessionHandle *data;
CURLMcode returncode=CURLM_OK;
struct Curl_tree *t;
struct timeval now = Curl_tvnow();
@@ -1742,12 +1739,12 @@ CURLMcode curl_multi_perform(CURLM *multi_handle, int *running_handles)
if(!GOOD_MULTI_HANDLE(multi))
return CURLM_BAD_HANDLE;
- easy=multi->easyp;
- while(easy) {
+ data=multi->easyp;
+ while(data) {
CURLMcode result;
- struct WildcardData *wc = &easy->wildcard;
+ struct WildcardData *wc = &data->wildcard;
- if(easy->set.wildcardmatch) {
+ if(data->set.wildcardmatch) {
if(!wc->filelist) {
CURLcode ret = Curl_wildcard_init(wc); /* init wildcard structures */
if(ret)
@@ -1756,10 +1753,10 @@ CURLMcode curl_multi_perform(CURLM *multi_handle, int *running_handles)
}
do
- result = multi_runsingle(multi, now, easy);
+ result = multi_runsingle(multi, now, data);
while(CURLM_CALL_MULTI_PERFORM == result);
- if(easy->set.wildcardmatch) {
+ if(data->set.wildcardmatch) {
/* destruct wildcard structures if it is needed */
if(wc->state == CURLWC_DONE || result)
Curl_wildcard_dtor(wc);
@@ -1768,7 +1765,7 @@ CURLMcode curl_multi_perform(CURLM *multi_handle, int *running_handles)
if(result)
returncode = result;
- easy = easy->next; /* operate on next handle */
+ data = data->next; /* operate on next handle */
}
/*
@@ -1815,8 +1812,8 @@ static void close_all_connections(struct Curl_multi *multi)
CURLMcode curl_multi_cleanup(CURLM *multi_handle)
{
struct Curl_multi *multi=(struct Curl_multi *)multi_handle;
- struct SessionHandle *easy;
- struct SessionHandle *nexteasy;
+ struct SessionHandle *data;
+ struct SessionHandle *nextdata;
if(GOOD_MULTI_HANDLE(multi)) {
multi->type = 0; /* not good anymore */
@@ -1844,22 +1841,22 @@ CURLMcode curl_multi_cleanup(CURLM *multi_handle)
multi->msglist = NULL;
/* remove all easy handles */
- easy = multi->easyp;
- while(easy) {
- nexteasy=easy->next;
- if(easy->dns.hostcachetype == HCACHE_MULTI) {
+ data = multi->easyp;
+ while(data) {
+ nextdata=data->next;
+ if(data->dns.hostcachetype == HCACHE_MULTI) {
/* clear out the usage of the shared DNS cache */
- Curl_hostcache_clean(easy, easy->dns.hostcache);
- easy->dns.hostcache = NULL;
- easy->dns.hostcachetype = HCACHE_NONE;
+ Curl_hostcache_clean(data, data->dns.hostcache);
+ data->dns.hostcache = NULL;
+ data->dns.hostcachetype = HCACHE_NONE;
}
/* Clear the pointer to the connection cache */
- easy->state.conn_cache = NULL;
+ data->state.conn_cache = NULL;
- easy_addmulti(easy, NULL); /* clear the association */
+ easy_addmulti(data, NULL); /* clear the association */
- easy = nexteasy;
+ data = nextdata;
}
Curl_hash_destroy(multi->hostcache);
@@ -1920,7 +1917,7 @@ CURLMsg *curl_multi_info_read(CURLM *multi_handle, int *msgs_in_queue)
* call the callback accordingly.
*/
static void singlesocket(struct Curl_multi *multi,
- struct SessionHandle *easy)
+ struct SessionHandle *data)
{
curl_socket_t socks[MAX_SOCKSPEREASYHANDLE];
int i;
@@ -1935,7 +1932,7 @@ static void singlesocket(struct Curl_multi *multi,
/* Fill in the 'current' struct with the state as it is now: what sockets to
supervise and for what actions */
- curraction = multi_getsock(easy, socks, MAX_SOCKSPEREASYHANDLE);
+ curraction = multi_getsock(data, socks, MAX_SOCKSPEREASYHANDLE);
/* We have 0 .. N sockets already and we get to know about the 0 .. M
sockets we should have from now on. Detect the differences, remove no
@@ -1965,7 +1962,7 @@ static void singlesocket(struct Curl_multi *multi,
}
else {
/* this is a socket we didn't have before, add it! */
- entry = sh_addentry(multi->sockhash, s, easy);
+ entry = sh_addentry(multi->sockhash, s, data);
if(!entry)
/* fatal */
return;
@@ -1973,7 +1970,7 @@ static void singlesocket(struct Curl_multi *multi,
/* we know (entry != NULL) at this point, see the logic above */
if(multi->socket_cb)
- multi->socket_cb(easy,
+ multi->socket_cb(data,
s,
action,
multi->socket_userp,
@@ -1986,9 +1983,9 @@ static void singlesocket(struct Curl_multi *multi,
/* when we've walked over all the sockets we should have right now, we must
make sure to detect sockets that are removed */
- for(i=0; i< easy->numsocks; i++) {
+ for(i=0; i< data->numsocks; i++) {
int j;
- s = easy->sockets[i];
+ s = data->sockets[i];
for(j=0; j<num; j++) {
if(s == socks[j]) {
/* this is still supervised */
@@ -2006,7 +2003,7 @@ static void singlesocket(struct Curl_multi *multi,
/* check if the socket to be removed serves a connection which has
other easy-s in a pipeline. In this case the socket should not be
removed. */
- struct connectdata *easy_conn = easy->easy_conn;
+ struct connectdata *easy_conn = data->easy_conn;
if(easy_conn) {
if(easy_conn->recv_pipe && easy_conn->recv_pipe->size > 1) {
/* the handle should not be removed from the pipe yet */
@@ -2015,8 +2012,8 @@ static void singlesocket(struct Curl_multi *multi,
/* Update the sockhash entry to instead point to the next in line
for the recv_pipe, or the first (in case this particular easy
isn't already) */
- if(entry->easy == easy) {
- if(isHandleAtHead(easy, easy_conn->recv_pipe))
+ if(entry->easy == data) {
+ if(isHandleAtHead(data, easy_conn->recv_pipe))
entry->easy = easy_conn->recv_pipe->head->next->ptr;
else
entry->easy = easy_conn->recv_pipe->head->ptr;
@@ -2029,8 +2026,8 @@ static void singlesocket(struct Curl_multi *multi,
/* Update the sockhash entry to instead point to the next in line
for the send_pipe, or the first (in case this particular easy
isn't already) */
- if(entry->easy == easy) {
- if(isHandleAtHead(easy, easy_conn->send_pipe))
+ if(entry->easy == data) {
+ if(isHandleAtHead(data, easy_conn->send_pipe))
entry->easy = easy_conn->send_pipe->head->next->ptr;
else
entry->easy = easy_conn->send_pipe->head->ptr;
@@ -2051,7 +2048,7 @@ static void singlesocket(struct Curl_multi *multi,
if(remove_sock_from_hash) {
/* in this case 'entry' is always non-NULL */
if(multi->socket_cb)
- multi->socket_cb(easy,
+ multi->socket_cb(data,
s,
CURL_POLL_REMOVE,
multi->socket_userp,
@@ -2062,8 +2059,8 @@ static void singlesocket(struct Curl_multi *multi,
}
}
- memcpy(easy->sockets, socks, num*sizeof(curl_socket_t));
- easy->numsocks = num;
+ memcpy(data->sockets, socks, num*sizeof(curl_socket_t));
+ data->numsocks = num;
}
/*
@@ -2172,16 +2169,15 @@ static CURLMcode multi_socket(struct Curl_multi *multi,
struct timeval now = Curl_tvnow();
if(checkall) {
- struct SessionHandle *easy;
/* *perform() deals with running_handles on its own */
result = curl_multi_perform(multi, running_handles);
/* walk through each easy handle and do the socket state change magic
and callbacks */
- easy=multi->easyp;
- while(easy) {
- singlesocket(multi, easy);
- easy = easy->next;
+ data=multi->easyp;
+ while(data) {
+ singlesocket(multi, data);
+ data = data->next;
}
/* or should we fall-through and do the timer-based stuff? */
@@ -2706,16 +2702,16 @@ struct curl_llist *Curl_multi_pipelining_server_bl(struct Curl_multi *multi)
void Curl_multi_process_pending_handles(struct Curl_multi *multi)
{
- struct SessionHandle *easy;
+ struct SessionHandle *data;
- easy=multi->easyp;
- while(easy) {
- if(easy->mstate == CURLM_STATE_CONNECT_PEND) {
- multistate(easy, CURLM_STATE_CONNECT);
+ data=multi->easyp;
+ while(data) {
+ if(data->mstate == CURLM_STATE_CONNECT_PEND) {
+ multistate(data, CURLM_STATE_CONNECT);
/* Make sure that the handle will be processed soonish. */
- Curl_expire(easy, 1);
+ Curl_expire(data, 1);
}
- easy = easy->next; /* operate on next handle */
+ data = data->next; /* operate on next handle */
}
}
@@ -2723,18 +2719,18 @@ void Curl_multi_process_pending_handles(struct Curl_multi *multi)
void Curl_multi_dump(const struct Curl_multi *multi_handle)
{
struct Curl_multi *multi=(struct Curl_multi *)multi_handle;
- struct SessionHandle *easy;
+ struct SessionHandle *data;
int i;
fprintf(stderr, "* Multi status: %d handles, %d alive\n",
multi->num_easy, multi->num_alive);
- for(easy=multi->easyp; easy; easy = easy->next) {
- if(easy->mstate < CURLM_STATE_COMPLETED) {
+ for(data=multi->easyp; data; data = data->next) {
+ if(data->mstate < CURLM_STATE_COMPLETED) {
/* only display handles that are not completed */
fprintf(stderr, "handle %p, state %s, %d sockets\n",
- (void *)easy,
- statename[easy->mstate], easy->numsocks);
- for(i=0; i < easy->numsocks; i++) {
- curl_socket_t s = easy->sockets[i];
+ (void *)data,
+ statename[data->mstate], data->numsocks);
+ for(i=0; i < data->numsocks; i++) {
+ curl_socket_t s = data->sockets[i];
struct Curl_sh_entry *entry =
Curl_hash_pick(multi->sockhash, (char *)&s, sizeof(s));
@@ -2747,7 +2743,7 @@ void Curl_multi_dump(const struct Curl_multi *multi_handle)
entry->action&CURL_POLL_IN?"RECVING":"",
entry->action&CURL_POLL_OUT?"SENDING":"");
}
- if(easy->numsocks)
+ if(data->numsocks)
fprintf(stderr, "\n");
}
}