X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fconnect.cc;h=7044306e6908cfe864fedb4835084c170a2900c0;hb=91e92172731fe8a37e562a165d25a312569aff44;hp=707f7344387af9fbe1661387294d1de7c01a6a94;hpb=805884743f76a5c4dad8ad20e6033630a92e71df;p=m6w6%2Flibmemcached

diff --git a/libmemcached/connect.cc b/libmemcached/connect.cc
index 707f7344..7044306e 100644
--- a/libmemcached/connect.cc
+++ b/libmemcached/connect.cc
@@ -37,7 +37,6 @@
 
 
 #include <libmemcached/common.h>
-#include <cassert>
 #include <ctime>
 #include <sys/time.h>
 
@@ -49,18 +48,14 @@ static memcached_return_t connect_poll(memcached_server_st *ptr)
 
   size_t loop_max= 5;
 
-  while (--loop_max) // Should only loop on cases of ERESTART or EINTR
+  if (ptr->root->poll_timeout == 0)
   {
-    int error;
-    if (ptr->root->poll_timeout)
-    {
-      error= poll(fds, 1, ptr->root->connect_timeout);
-    }
-    else
-    {
-      error= 0;
-    }
+    return memcached_set_error(*ptr, MEMCACHED_TIMEOUT, MEMCACHED_AT);
+  }
 
+  while (--loop_max) // Should only loop on cases of ERESTART or EINTR
+  {
+    int error= poll(fds, 1, ptr->root->connect_timeout);
     switch (error)
     {
     case 1:
@@ -83,7 +78,6 @@ static memcached_return_t connect_poll(memcached_server_st *ptr)
       }
 
     default: // A real error occurred and we need to completely bail
-      WATCHPOINT_ERRNO(get_socket_errno());
       switch (get_socket_errno())
       {
 #ifdef TARGET_OS_LINUX
@@ -105,13 +99,14 @@ static memcached_return_t connect_poll(memcached_server_st *ptr)
           int err;
           socklen_t len= sizeof (err);
           (void)getsockopt(ptr->fd, SOL_SOCKET, SO_ERROR, &err, &len);
-          ptr->cached_errno= (err == 0) ? get_socket_errno() : err;
+          memcached_set_errno(*ptr, (err == 0) ? get_socket_errno() : err, MEMCACHED_AT);
         }
         else
         {
-          ptr->cached_errno= get_socket_errno();
+          memcached_set_errno(*ptr, get_socket_errno(), MEMCACHED_AT);
         }
 
+        assert_msg(ptr->fd != INVALID_SOCKET, "poll() was passed an invalid file descriptor");
         (void)closesocket(ptr->fd);
         ptr->fd= INVALID_SOCKET;
         ptr->state= MEMCACHED_SERVER_STATE_NEW;
@@ -127,7 +122,6 @@ static memcached_return_t connect_poll(memcached_server_st *ptr)
 
 static memcached_return_t set_hostinfo(memcached_server_st *server)
 {
-  assert(! server->address_info); // We cover the case where a programming mistake has been made.
   if (server->address_info)
   {
     freeaddrinfo(server->address_info);
@@ -138,7 +132,9 @@ static memcached_return_t set_hostinfo(memcached_server_st *server)
   char str_port[NI_MAXSERV];
   int length= snprintf(str_port, NI_MAXSERV, "%u", (uint32_t)server->port);
   if (length >= NI_MAXSERV || length < 0)
+  {
     return MEMCACHED_FAILURE;
+  }
 
   struct addrinfo hints;
   memset(&hints, 0, sizeof(struct addrinfo));
@@ -177,8 +173,6 @@ static memcached_return_t set_hostinfo(memcached_server_st *server)
 
   default:
     {
-      WATCHPOINT_STRING(server->hostname);
-      WATCHPOINT_STRING(gai_strerror(e));
       return memcached_set_error(*server, MEMCACHED_HOST_LOOKUP_FAILURE, MEMCACHED_AT, memcached_string_make_from_cstr(gai_strerror(errcode)));
     }
   }
@@ -227,10 +221,12 @@ static inline void set_socket_nonblocking(memcached_server_st *ptr)
 
 static void set_socket_options(memcached_server_st *ptr)
 {
-  WATCHPOINT_ASSERT(ptr->fd != -1);
+  assert_msg(ptr->fd != -1, "invalid socket was passed to set_socket_options()");
 
   if (ptr->type == MEMCACHED_CONNECTION_UDP)
+  {
     return;
+  }
 
 #ifdef HAVE_SNDTIMEO
   if (ptr->root->snd_timeout)
@@ -350,7 +346,8 @@ static memcached_return_t unix_socket_connect(memcached_server_st *ptr)
 
   if ((ptr->fd= socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
   {
-    return memcached_set_errno(*ptr, errno, NULL);
+    memcached_set_errno(*ptr, errno, NULL);
+    return MEMCACHED_CONNECTION_FAILURE;
   }
 
   struct sockaddr_un servAddr;
@@ -377,7 +374,8 @@ static memcached_return_t unix_socket_connect(memcached_server_st *ptr)
 
       default:
         WATCHPOINT_ERRNO(errno);
-        return memcached_set_errno(*ptr, errno, MEMCACHED_AT);
+        memcached_set_errno(*ptr, errno, MEMCACHED_AT);
+        return MEMCACHED_CONNECTION_FAILURE;
       }
     }
   } while (0);
@@ -407,7 +405,9 @@ static memcached_return_t network_connect(memcached_server_st *ptr)
     while (--counter)
     {
       if ((rc= set_hostinfo(ptr)) != MEMCACHED_TIMEOUT)
+      {
         break;
+      }
 
 #ifndef WIN32
       struct timespec dream, rem;
@@ -482,15 +482,16 @@ static memcached_return_t network_connect(memcached_server_st *ptr)
       break;
 
     case EINTR: // Special case, we retry ai_addr
+      WATCHPOINT_ASSERT(ptr->fd != INVALID_SOCKET);
       (void)closesocket(ptr->fd);
       ptr->fd= INVALID_SOCKET;
-      ptr->state= MEMCACHED_SERVER_STATE_NEW;
       continue;
 
     default:
       break;
     }
 
+    WATCHPOINT_ASSERT(ptr->fd != INVALID_SOCKET);
     (void)closesocket(ptr->fd);
     ptr->fd= INVALID_SOCKET;
     ptr->address_info_next= ptr->address_info_next->ai_next;
@@ -514,11 +515,20 @@ static memcached_return_t network_connect(memcached_server_st *ptr)
     struct timeval next_time;
 
     if (gettimeofday(&next_time, NULL) == 0)
+    {
       ptr->next_retry= next_time.tv_sec + ptr->root->retry_timeout;
+    }
+  }
+  
+  if (memcached_has_current_error(*ptr))
+  {
+    return memcached_server_error_return(ptr);
   }
 
-  if (timeout_error_occured)
+  if (timeout_error_occured and ptr->state < MEMCACHED_SERVER_STATE_IN_PROGRESS)
+  {
     return memcached_set_error(*ptr, MEMCACHED_TIMEOUT, MEMCACHED_AT);
+  }
 
   return memcached_set_error(*ptr, MEMCACHED_CONNECTION_FAILURE, MEMCACHED_AT); /* The last error should be from connect() */
 }
@@ -528,11 +538,6 @@ void set_last_disconnected_host(memcached_server_write_instance_st self)
   // const_cast
   memcached_st *root= (memcached_st *)self->root;
 
-#if 0
-  WATCHPOINT_STRING(self->hostname);
-  WATCHPOINT_NUMBER(self->port);
-  WATCHPOINT_ERRNO(self->cached_errno);
-#endif
   memcached_server_free(root->last_disconnected_server);
   root->last_disconnected_server= memcached_server_clone(NULL, self);
 }
@@ -542,7 +547,9 @@ memcached_return_t memcached_connect(memcached_server_write_instance_st ptr)
   memcached_return_t rc= MEMCACHED_NO_SERVERS;
 
   if (ptr->fd != INVALID_SOCKET)
+  {
     return MEMCACHED_SUCCESS;
+  }
 
   LIBMEMCACHED_MEMCACHED_CONNECT_START();
 
@@ -592,11 +599,12 @@ memcached_return_t memcached_connect(memcached_server_write_instance_st ptr)
   case MEMCACHED_CONNECTION_TCP:
     rc= network_connect(ptr);
 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
-    if (ptr->fd != INVALID_SOCKET && ptr->root->sasl.callbacks)
+    if (ptr->fd != INVALID_SOCKET and ptr->root->sasl.callbacks)
     {
       rc= memcached_sasl_authenticate_connection(ptr);
-      if (memcached_failed(rc))
+      if (memcached_failed(rc) and ptr->fd != INVALID_SOCKET)
       {
+        WATCHPOINT_ASSERT(ptr->fd != INVALID_SOCKET);
         (void)closesocket(ptr->fd);
         ptr->fd= INVALID_SOCKET;
       }