diff options
Diffstat (limited to 'lib')
| -rw-r--r-- | lib/multi.c | 594 |
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"); } } |