X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=lib%2Fmemcached_connect.c;h=f5acadfa6c61892a5261a4ff6f4179bb078465b9;hb=3bd95102380ff8d9f2599f0965c09776344d0691;hp=0135fc9a31f66bb723bb29a3174d8753a8618089;hpb=d283f47cade6fcd1256e738057667fbcca7b06c1;p=m6w6%2Flibmemcached

diff --git a/lib/memcached_connect.c b/lib/memcached_connect.c
index 0135fc9a..f5acadfa 100644
--- a/lib/memcached_connect.c
+++ b/lib/memcached_connect.c
@@ -1,41 +1,30 @@
 #include "common.h"
 
-#include <fcntl.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/un.h>
-#include <netinet/tcp.h>
-#include <netdb.h>
-
 static memcached_return set_hostinfo(memcached_server_st *server)
 {
-  struct hostent *h;
-#ifdef HAVE_GETHOSTBYNAME_R
-  struct hostent h_static;
-  char buffer[SMALL_STRING_LEN];
-  int tmp_error;
-
-  if (gethostbyname_r(server->hostname,
-                      &h_static, buffer, SMALL_STRING_LEN, 
-                      &h, &tmp_error))
-  {
-    WATCHPOINT_STRING(server->hostname);
-    WATCHPOINT_STRING(hstrerror(tmp_error));
-    return MEMCACHED_HOST_LOOKUP_FAILURE;
-  }
-#else
-  if ((h= gethostbyname(server->hostname)) == NULL)
+  struct addrinfo *ai;
+  struct addrinfo hints;
+  int e;
+  char str_port[NI_MAXSERV];
+
+  sprintf(str_port, "%u", server->port);
+
+  memset(&hints, 0, sizeof(hints));
+  hints.ai_family= AF_INET;
+  hints.ai_socktype= SOCK_STREAM;
+  hints.ai_protocol= 0;
+
+  e= getaddrinfo(server->hostname, str_port, &hints, &ai);
+  if (e != 0)
   {
     WATCHPOINT_STRING(server->hostname);
-    WATCHPOINT_STRING(hstrerror(h_errno));
+    WATCHPOINT_STRING(gai_strerror(e));
     return MEMCACHED_HOST_LOOKUP_FAILURE;
   }
-#endif
-
-  server->servAddr.sin_family= h->h_addrtype;
-  memcpy((char *) &server->servAddr.sin_addr.s_addr, h->h_addr_list[0], h->h_length);
 
-  server->servAddr.sin_port = htons(server->port);
+  if (server->address_info)
+    freeaddrinfo(server->address_info);
+  server->address_info= ai;
 
   return MEMCACHED_SUCCESS;
 }
@@ -73,6 +62,7 @@ test_connect:
       case EISCONN: /* We were spinning waiting on connect */
         break;
       default:
+        WATCHPOINT_ERRNO(errno);
         ptr->cached_errno= errno;
         return MEMCACHED_ERRNO;
       }
@@ -122,6 +112,7 @@ static memcached_return tcp_connect(memcached_st *ptr, unsigned int server_key)
   {
     /* Old connection junk still is in the structure */
     WATCHPOINT_ASSERT(ptr->hosts[server_key].stack_responses == 0);
+    struct addrinfo *use;
 
     if (ptr->hosts[server_key].sockaddr_inited == MEMCACHED_NOT_ALLOCATED || 
         (!(ptr->flags & MEM_USE_CACHE_LOOKUPS)))
@@ -133,49 +124,76 @@ static memcached_return tcp_connect(memcached_st *ptr, unsigned int server_key)
         return rc;
       ptr->hosts[server_key].sockaddr_inited= MEMCACHED_ALLOCATED;
     }
+    use= ptr->hosts[server_key].address_info;
 
     /* Create the socket */
-    if ((ptr->hosts[server_key].fd= socket(AF_INET, SOCK_STREAM, 0)) < 0)
+    if ((ptr->hosts[server_key].fd= socket(use->ai_family, 
+                                           use->ai_socktype, 
+                                           use->ai_protocol)) < 0)
     {
       ptr->cached_errno= errno;
+      WATCHPOINT_ERRNO(errno);
       return MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE;
     }
 
-    /* For the moment, not getting a nonblocking mode will note be fatal */
     if (ptr->flags & MEM_NO_BLOCK)
     {
-      int flags;
-
-      flags= fcntl(ptr->hosts[server_key].fd, F_GETFL, 0);
-      if (flags != -1)
-        (void)fcntl(ptr->hosts[server_key].fd, F_SETFL, flags | O_NONBLOCK);
+      int error;
+      struct linger linger;
+
+      linger.l_onoff= 1; 
+      linger.l_linger= MEMCACHED_DEFAULT_TIMEOUT; 
+      error= setsockopt(ptr->hosts[server_key].fd, SOL_SOCKET, SO_LINGER, 
+                        &linger, (socklen_t)sizeof(struct linger));
+      WATCHPOINT_ASSERT(error == 0);
     }
 
     if (ptr->flags & MEM_TCP_NODELAY)
     {
       int flag= 1;
+      int error;
 
-      setsockopt(ptr->hosts[server_key].fd, IPPROTO_TCP, TCP_NODELAY, 
-                 &flag, (socklen_t)sizeof(int));
+      error= setsockopt(ptr->hosts[server_key].fd, IPPROTO_TCP, TCP_NODELAY, 
+                        &flag, (socklen_t)sizeof(int));
+      WATCHPOINT_ASSERT(error == 0);
     }
 
     if (ptr->send_size)
     {
-      setsockopt(ptr->hosts[server_key].fd, SOL_SOCKET, SO_SNDBUF, 
-                 &ptr->send_size, (socklen_t)sizeof(int));
+      int error;
+
+      error= setsockopt(ptr->hosts[server_key].fd, SOL_SOCKET, SO_SNDBUF, 
+                        &ptr->send_size, (socklen_t)sizeof(int));
+      WATCHPOINT_ASSERT(error == 0);
     }
 
     if (ptr->recv_size)
     {
-      setsockopt(ptr->hosts[server_key].fd, SOL_SOCKET, SO_SNDBUF, 
-                 &ptr->recv_size, (socklen_t)sizeof(int));
+      int error;
+
+      error= setsockopt(ptr->hosts[server_key].fd, SOL_SOCKET, SO_SNDBUF, 
+                        &ptr->recv_size, (socklen_t)sizeof(int));
+      WATCHPOINT_ASSERT(error == 0);
+    }
+
+    /* For the moment, not getting a nonblocking mode will not be fatal */
+    if (ptr->flags & MEM_NO_BLOCK)
+    {
+      int flags;
+
+      flags= fcntl(ptr->hosts[server_key].fd, F_GETFL, 0);
+      if (flags != -1)
+      {
+        (void)fcntl(ptr->hosts[server_key].fd, F_SETFL, flags | O_NONBLOCK);
+      }
     }
 
+
     /* connect to server */
 test_connect:
     if (connect(ptr->hosts[server_key].fd, 
-                (struct sockaddr *)&ptr->hosts[server_key].servAddr, 
-                sizeof(struct sockaddr)) < 0)
+                use->ai_addr, 
+                use->ai_addrlen) < 0)
     {
       switch (errno) {
         /* We are spinning waiting on connect */
@@ -187,10 +205,12 @@ test_connect:
         break;
       default:
         ptr->cached_errno= errno;
+        WATCHPOINT_ERRNO(ptr->cached_errno);
         return MEMCACHED_ERRNO;
       }
       ptr->connected++;
     }
+
     WATCHPOINT_ASSERT(ptr->hosts[server_key].stack_responses == 0);
   }