Fix

[awesomized/libmemcached] / libmemcached / connect.cc

diff --git a/libmemcached/connect.cc b/libmemcached/connect.cc
index a8a2c5a4631126cef98200eacfe263a7ab680579..8d027df27fc229b44659d59ef4144954335dd1f9 100644 (file)
--- a/libmemcached/connect.cc
+++ b/libmemcached/connect.cc
@@ -46,7 +46,7 @@
 #define SOCK_CLOEXEC 0
 #endif
 
-static memcached_return_t connect_poll(memcached_instance_st *server)
+static memcached_return_t connect_poll(org::libmemcached::Instance* server)
 {
   struct pollfd fds[1];
   fds[0].fd= server->fd;
@@ -139,7 +139,7 @@ static memcached_return_t connect_poll(memcached_instance_st *server)
   return memcached_set_errno(*server, get_socket_errno(), MEMCACHED_AT);
 }
 
-static memcached_return_t set_hostinfo(memcached_instance_st *server)
+static memcached_return_t set_hostinfo(org::libmemcached::Instance* server)
 {
   assert(server->type != MEMCACHED_CONNECTION_UNIX_SOCKET);
   if (server->address_info)
@@ -150,8 +150,8 @@ static memcached_return_t set_hostinfo(memcached_instance_st *server)
   }
 
   char str_port[NI_MAXSERV];
-  int length= snprintf(str_port, NI_MAXSERV, "%u", (uint32_t)server->port);
-  if (length >= NI_MAXSERV or length < 0)
+  int length= snprintf(str_port, NI_MAXSERV, "%u", uint32_t(server->port()));
+  if (length >= NI_MAXSERV or length <= 0)
   {
     return MEMCACHED_FAILURE;
   }
@@ -203,7 +203,7 @@ static memcached_return_t set_hostinfo(memcached_instance_st *server)
   return MEMCACHED_SUCCESS;
 }
 
-static inline void set_socket_nonblocking(memcached_instance_st *server)
+static inline void set_socket_nonblocking(org::libmemcached::Instance* server)
 {
 #ifdef WIN32
   u_long arg= 1;
@@ -240,7 +240,7 @@ static inline void set_socket_nonblocking(memcached_instance_st *server)
 #endif
 }
 
-static void set_socket_options(memcached_instance_st *server)
+static void set_socket_options(org::libmemcached::Instance* server)
 {
   assert_msg(server->fd != INVALID_SOCKET, "invalid socket was passed to set_socket_options()");
 
@@ -250,29 +250,31 @@ static void set_socket_options(memcached_instance_st *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));
+                          &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));
+    (void)(error);
     assert(error == 0);
   }
 #endif
@@ -283,11 +285,14 @@ static void set_socket_options(memcached_instance_st *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
@@ -300,6 +305,7 @@ static void set_socket_options(memcached_instance_st *server)
     linger.l_linger= 0; /* By default on close() just drop the socket */
     int error= setsockopt(server->fd, SOL_SOCKET, SO_LINGER,
                           &linger, (socklen_t)sizeof(struct linger));
+    (void)(error);
     assert(error == 0);
   }
 
@@ -309,6 +315,7 @@ static void set_socket_options(memcached_instance_st *server)
 
     int error= setsockopt(server->fd, IPPROTO_TCP, TCP_NODELAY,
                           &flag, (socklen_t)sizeof(int));
+    (void)(error);
     assert(error == 0);
   }
 
@@ -318,6 +325,7 @@ static void set_socket_options(memcached_instance_st *server)
 
     int error= setsockopt(server->fd, SOL_SOCKET, SO_KEEPALIVE,
                       &flag, (socklen_t)sizeof(int));
+    (void)(error);
     assert(error == 0);
   }
 
@@ -326,6 +334,7 @@ static void set_socket_options(memcached_instance_st *server)
   {
     int error= setsockopt(server->fd, IPPROTO_TCP, TCP_KEEPIDLE,
                           &server->root->tcp_keepidle, (socklen_t)sizeof(int));
+    (void)(error);
     assert(error == 0);
   }
 #endif
@@ -334,6 +343,7 @@ static void set_socket_options(memcached_instance_st *server)
   {
     int error= setsockopt(server->fd, SOL_SOCKET, SO_SNDBUF,
                           &server->root->send_size, (socklen_t)sizeof(int));
+    (void)(error);
     assert(error == 0);
   }
 
@@ -341,6 +351,7 @@ static void set_socket_options(memcached_instance_st *server)
   {
     int error= setsockopt(server->fd, SOL_SOCKET, SO_RCVBUF,
                           &server->root->recv_size, (socklen_t)sizeof(int));
+    (void)(error);
     assert(error == 0);
   }
 
@@ -349,7 +360,7 @@ static void set_socket_options(memcached_instance_st *server)
   set_socket_nonblocking(server);
 }
 
-static memcached_return_t unix_socket_connect(memcached_instance_st *server)
+static memcached_return_t unix_socket_connect(org::libmemcached::Instance* server)
 {
 #ifndef WIN32
   WATCHPOINT_ASSERT(server->fd == INVALID_SOCKET);
@@ -400,12 +411,12 @@ static memcached_return_t unix_socket_connect(memcached_instance_st *server)
 #endif
 }
 
-static memcached_return_t network_connect(memcached_instance_st *server)
+static memcached_return_t network_connect(org::libmemcached::Instance* server)
 {
   bool timeout_error_occured= false;
 
   WATCHPOINT_ASSERT(server->fd == INVALID_SOCKET);
-  WATCHPOINT_ASSERT(server->cursor_active == 0);
+  WATCHPOINT_ASSERT(server->cursor_active_ == 0);
 
   /*
     We want to check both of these because if address_info_next has been fully tried, we want to do a new lookup to make sure we have picked up on any new DNS information.
@@ -572,7 +583,7 @@ static memcached_return_t network_connect(memcached_instance_st *server)
   Based on time/failure count fail the connect without trying. This prevents waiting in a state where
   we get caught spending cycles just waiting.
 */
-static memcached_return_t backoff_handling(memcached_server_write_instance_st server, bool& in_timeout)
+static memcached_return_t backoff_handling(org::libmemcached::Instance* server, bool& in_timeout)
 {
   struct timeval curr_time;
   bool _gettime_success= (gettimeofday(&curr_time, NULL) == 0);
@@ -639,8 +650,9 @@ static memcached_return_t backoff_handling(memcached_server_write_instance_st se
   return MEMCACHED_SUCCESS;
 }
 
-static memcached_return_t _memcached_connect(memcached_server_write_instance_st server, const bool set_last_disconnected)
+static memcached_return_t _memcached_connect(org::libmemcached::Instance* server, const bool set_last_disconnected)
 {
+  assert(server);
   if (server->fd != INVALID_SOCKET)
   {
     return MEMCACHED_SUCCESS;
@@ -695,7 +707,8 @@ static memcached_return_t _memcached_connect(memcached_server_write_instance_st
 
   if (memcached_success(rc))
   {
-    memcached_mark_server_as_clean(server);
+    server->mark_server_as_clean();
+    memcached_version_instance(server);
     return rc;
   }
   else if (set_last_disconnected)
@@ -717,7 +730,7 @@ static memcached_return_t _memcached_connect(memcached_server_write_instance_st
     if (in_timeout)
     {
       char buffer[1024];
-      int snprintf_length= snprintf(buffer, sizeof(buffer), "%s:%d", server->hostname, int(server->port));
+      int snprintf_length= snprintf(buffer, sizeof(buffer), "%s:%d", server->hostname, int(server->port()));
       return memcached_set_error(*server, MEMCACHED_SERVER_TEMPORARILY_DISABLED, MEMCACHED_AT, buffer, snprintf_length);
     }
   }
@@ -725,12 +738,17 @@ static memcached_return_t _memcached_connect(memcached_server_write_instance_st
   return rc;
 }
 
-memcached_return_t memcached_connect_try(memcached_server_write_instance_st 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);
 }
 
-memcached_return_t memcached_connect(memcached_server_write_instance_st server)
+memcached_return_t memcached_connect(org::libmemcached::Instance* server)
 {
   return _memcached_connect(server, true);
 }