X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fconnect.cc;h=65be51a07f9a2c509f7dba7bc6c11043e358bc1a;hb=7997ff8f76b3df9c1644e96c8096eb42e553f788;hp=1ace3fd8c72b47a39f1dc683d98df5375c5fdbe4;hpb=f47caf2833675cce0b62a6e4ffd6764c1490a8b4;p=awesomized%2Flibmemcached

diff --git a/libmemcached/connect.cc b/libmemcached/connect.cc
index 1ace3fd8..65be51a0 100644
--- a/libmemcached/connect.cc
+++ b/libmemcached/connect.cc
@@ -43,7 +43,15 @@
 #include <sys/time.h>
 
 #ifndef SOCK_CLOEXEC 
-#define SOCK_CLOEXEC 0
+#  define SOCK_CLOEXEC 0
+#endif
+
+#ifndef SOCK_NONBLOCK 
+#  define SOCK_NONBLOCK 0
+#endif
+
+#ifndef FD_CLOEXEC
+# define FD_CLOEXEC 0
 #endif
 
 static memcached_return_t connect_poll(org::libmemcached::Instance* server)
@@ -173,7 +181,8 @@ static memcached_return_t set_hostinfo(org::libmemcached::Instance* server)
     hints.ai_protocol= IPPROTO_TCP;
   }
 
-  server->address_info= NULL;
+  assert(server->address_info == NULL);
+  assert(server->address_info_next == NULL);
   int errcode;
   switch(errcode= getaddrinfo(server->hostname, str_port, &hints, &server->address_info))
   {
@@ -181,19 +190,49 @@ static memcached_return_t set_hostinfo(org::libmemcached::Instance* server)
     break;
 
   case EAI_AGAIN:
+    if (server->address_info)
+    {
+      freeaddrinfo(server->address_info);
+      server->address_info= NULL;
+      server->address_info_next= NULL;
+    }
     return memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT, memcached_string_make_from_cstr(gai_strerror(errcode)));
 
   case EAI_SYSTEM:
+    if (server->address_info)
+    {
+      freeaddrinfo(server->address_info);
+      server->address_info= NULL;
+      server->address_info_next= NULL;
+    }
     return memcached_set_errno(*server, errno, MEMCACHED_AT, memcached_literal_param("getaddrinfo(EAI_SYSTEM)"));
 
   case EAI_BADFLAGS:
+    if (server->address_info)
+    {
+      freeaddrinfo(server->address_info);
+      server->address_info= NULL;
+      server->address_info_next= NULL;
+    }
     return memcached_set_error(*server, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT, memcached_literal_param("getaddrinfo(EAI_BADFLAGS)"));
 
   case EAI_MEMORY:
+    if (server->address_info)
+    {
+      freeaddrinfo(server->address_info);
+      server->address_info= NULL;
+      server->address_info_next= NULL;
+    }
     return memcached_set_error(*server, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT, memcached_literal_param("getaddrinfo(EAI_MEMORY)"));
 
   default:
     {
+      if (server->address_info)
+      {
+        freeaddrinfo(server->address_info);
+        server->address_info= NULL;
+        server->address_info_next= NULL;
+      }
       return memcached_set_error(*server, MEMCACHED_HOST_LOOKUP_FAILURE, MEMCACHED_AT, memcached_string_make_from_cstr(gai_strerror(errcode)));
     }
   }
@@ -214,28 +253,31 @@ static inline void set_socket_nonblocking(org::libmemcached::Instance* server)
 #else
   int flags;
 
-  do
-  {
-    flags= fcntl(server->fd, F_GETFL, 0);
-  } while (flags == -1 && (errno == EINTR || errno == EAGAIN));
-
-  if (flags == -1)
+  if (SOCK_NONBLOCK == 0)
   {
-    memcached_set_errno(*server, errno, NULL);
-  }
-  else if ((flags & O_NONBLOCK) == 0)
-  {
-    int rval;
-
     do
     {
-      rval= fcntl(server->fd, F_SETFL, flags | O_NONBLOCK);
-    } while (rval == -1 && (errno == EINTR or errno == EAGAIN));
+      flags= fcntl(server->fd, F_GETFL, 0);
+    } while (flags == -1 && (errno == EINTR || errno == EAGAIN));
 
-    if (rval == -1)
+    if (flags == -1)
     {
       memcached_set_errno(*server, errno, NULL);
     }
+    else if ((flags & O_NONBLOCK) == 0)
+    {
+      int rval;
+
+      do
+      {
+        rval= fcntl(server->fd, F_SETFL, flags | O_NONBLOCK);
+      } while (rval == -1 && (errno == EINTR or errno == EAGAIN));
+
+      if (rval == -1)
+      {
+        memcached_set_errno(*server, errno, NULL);
+      }
+    }
   }
 #endif
 }
@@ -250,27 +292,27 @@ static void set_socket_options(org::libmemcached::Instance* server)
   }
 
 #ifdef HAVE_SNDTIMEO
-  if (server->root->snd_timeout)
+  if (server->root->snd_timeout > 0)
   {
     struct timeval waittime;
 
-    waittime.tv_sec= 0;
-    waittime.tv_usec= server->root->snd_timeout;
+    waittime.tv_sec= server->root->snd_timeout / 1000000;
+    waittime.tv_usec= server->root->snd_timeout % 1000000;
 
     int error= setsockopt(server->fd, SOL_SOCKET, SO_SNDTIMEO,
-                      &waittime, (socklen_t)sizeof(struct timeval));
-    (void)(error);
+                          &waittime, (socklen_t)sizeof(struct timeval));
+    (void)error;
     assert(error == 0);
   }
 #endif
 
 #ifdef HAVE_RCVTIMEO
-  if (server->root->rcv_timeout)
+  if (server->root->rcv_timeout > 0)
   {
     struct timeval waittime;
 
-    waittime.tv_sec= 0;
-    waittime.tv_usec= server->root->rcv_timeout;
+    waittime.tv_sec= server->root->rcv_timeout / 1000000;
+    waittime.tv_usec= server->root->rcv_timeout % 1000000;
 
     int error= setsockopt(server->fd, SOL_SOCKET, SO_RCVTIMEO,
                           &waittime, (socklen_t)sizeof(struct timeval));
@@ -285,11 +327,14 @@ static void set_socket_options(org::libmemcached::Instance* server)
     int set= 1;
     int error= setsockopt(server->fd, SOL_SOCKET, SO_NOSIGPIPE, (void *)&set, sizeof(int));
 
+    assert(error == 0);
+
     // This is not considered a fatal error
     if (error == -1)
     {
-      WATCHPOINT_ERRNO(get_socket_errno());
+#if 0
       perror("setsockopt(SO_NOSIGPIPE)");
+#endif
     }
   }
 #endif
@@ -352,7 +397,6 @@ static void set_socket_options(org::libmemcached::Instance* server)
     assert(error == 0);
   }
 
-
   /* libmemcached will always use nonblocking IO to avoid write deadlocks */
   set_socket_nonblocking(server);
 }
@@ -362,7 +406,18 @@ static memcached_return_t unix_socket_connect(org::libmemcached::Instance* serve
 #ifndef WIN32
   WATCHPOINT_ASSERT(server->fd == INVALID_SOCKET);
 
-  if ((server->fd= socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
+  int type= SOCK_STREAM;
+  if (SOCK_CLOEXEC)
+  {
+    type|= SOCK_CLOEXEC;
+  }
+
+  if (SOCK_NONBLOCK)
+  {
+    type|= SOCK_NONBLOCK;
+  }
+
+  if ((server->fd= socket(AF_UNIX, type, 0)) < 0)
   {
     memcached_set_errno(*server, errno, NULL);
     return MEMCACHED_CONNECTION_FAILURE;
@@ -422,24 +477,7 @@ static memcached_return_t network_connect(org::libmemcached::Instance* server)
   {
     WATCHPOINT_ASSERT(server->state == MEMCACHED_SERVER_STATE_NEW);
     server->address_info_next= NULL;
-    memcached_return_t rc;
-    uint32_t counter= 5;
-    while (--counter)
-    {
-      if ((rc= set_hostinfo(server)) != MEMCACHED_TIMEOUT)
-      {
-        break;
-      }
-
-#ifndef WIN32
-      struct timespec dream, rem;
-
-      dream.tv_nsec= 1000;
-      dream.tv_sec= 0;
-
-      nanosleep(&dream, &rem);
-#endif
-    }
+    memcached_return_t rc= set_hostinfo(server);
 
     if (memcached_failed(rc))
     {
@@ -464,11 +502,16 @@ static memcached_return_t network_connect(org::libmemcached::Instance* server)
     }
 
     int type= server->address_info_next->ai_socktype;
-    if (HAVE_SOCK_CLOEXEC)
+    if (SOCK_CLOEXEC)
     {
       type|= SOCK_CLOEXEC;
     }
 
+    if (SOCK_NONBLOCK)
+    {
+      type|= SOCK_NONBLOCK;
+    }
+
     if ((server->fd= socket(server->address_info_next->ai_family,
                             type,
                             server->address_info_next->ai_protocol)) < 0)
@@ -476,15 +519,17 @@ static memcached_return_t network_connect(org::libmemcached::Instance* server)
       return memcached_set_errno(*server, get_socket_errno(), NULL);
     }
 
-    if (HAVE_SOCK_CLOEXEC == 0)
+    // If SOCK_CLOEXEC exists then we don't need to call the following
+    if (SOCK_CLOEXEC == 0)
     {
-#ifdef FD_CLOEXEC
-      int rval;
-      do
+      if (FD_CLOEXEC)
       {
-        rval= fcntl (server->fd, F_SETFD, FD_CLOEXEC);
-      } while (rval == -1 && (errno == EINTR or errno == EAGAIN));
-#endif
+        int rval;
+        do
+        {
+          rval= fcntl (server->fd, F_SETFD, FD_CLOEXEC);
+        } while (rval == -1 && (errno == EINTR or errno == EAGAIN));
+      }
     }
 
     set_socket_options(server);
@@ -737,6 +782,11 @@ static memcached_return_t _memcached_connect(org::libmemcached::Instance* server
 
 memcached_return_t memcached_connect_try(org::libmemcached::Instance* server)
 {
+  if (server and server->root and server->root->state.is_parsing)
+  {
+    return MEMCACHED_SUCCESS;
+  }
+
   return _memcached_connect(server, false);
 }