multi: s/easy/data

With everything being struct SessionHandle pointers now, this rename
makes multi.c use the library-wide practise of calling that pointer
'data' instead of the previously used 'easy'.

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");
     }
   }