X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fconnect.cc;h=5d180d185e0208004270c707887a51499e26b91b;hb=558dbc482b4285c064b15b7d6889a7e2860c96f2;hp=34e72f76b34231f520b8c170933a9df57f44adf2;hpb=146cc15e812ae3d737b1cc49d56cfdbaaf915440;p=awesomized%2Flibmemcached diff --git a/libmemcached/connect.cc b/libmemcached/connect.cc index 34e72f76..5d180d18 100644 --- a/libmemcached/connect.cc +++ b/libmemcached/connect.cc @@ -42,7 +42,11 @@ #include #include -static memcached_return_t connect_poll(memcached_server_st *server) +#ifndef SOCK_CLOEXEC +#define SOCK_CLOEXEC 0 +#endif + +static memcached_return_t connect_poll(org::libmemcached::Instance* server) { struct pollfd fds[1]; fds[0].fd= server->fd; @@ -135,7 +139,7 @@ static memcached_return_t connect_poll(memcached_server_st *server) return memcached_set_errno(*server, get_socket_errno(), MEMCACHED_AT); } -static memcached_return_t set_hostinfo(memcached_server_st *server) +static memcached_return_t set_hostinfo(org::libmemcached::Instance* server) { assert(server->type != MEMCACHED_CONNECTION_UNIX_SOCKET); if (server->address_info) @@ -146,8 +150,8 @@ 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 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; } @@ -169,7 +173,8 @@ static memcached_return_t set_hostinfo(memcached_server_st *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)) { @@ -177,19 +182,49 @@ static memcached_return_t set_hostinfo(memcached_server_st *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))); } } @@ -199,7 +234,7 @@ static memcached_return_t set_hostinfo(memcached_server_st *server) return MEMCACHED_SUCCESS; } -static inline void set_socket_nonblocking(memcached_server_st *server) +static inline void set_socket_nonblocking(org::libmemcached::Instance* server) { #ifdef WIN32 u_long arg= 1; @@ -236,7 +271,7 @@ static inline void set_socket_nonblocking(memcached_server_st *server) #endif } -static void set_socket_options(memcached_server_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()"); @@ -246,29 +281,31 @@ static void set_socket_options(memcached_server_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 @@ -279,11 +316,14 @@ static void set_socket_options(memcached_server_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 @@ -296,6 +336,7 @@ static void set_socket_options(memcached_server_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); } @@ -305,6 +346,7 @@ static void set_socket_options(memcached_server_st *server) int error= setsockopt(server->fd, IPPROTO_TCP, TCP_NODELAY, &flag, (socklen_t)sizeof(int)); + (void)(error); assert(error == 0); } @@ -314,6 +356,7 @@ static void set_socket_options(memcached_server_st *server) int error= setsockopt(server->fd, SOL_SOCKET, SO_KEEPALIVE, &flag, (socklen_t)sizeof(int)); + (void)(error); assert(error == 0); } @@ -322,6 +365,7 @@ static void set_socket_options(memcached_server_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 @@ -330,6 +374,7 @@ static void set_socket_options(memcached_server_st *server) { int error= setsockopt(server->fd, SOL_SOCKET, SO_SNDBUF, &server->root->send_size, (socklen_t)sizeof(int)); + (void)(error); assert(error == 0); } @@ -337,6 +382,7 @@ static void set_socket_options(memcached_server_st *server) { int error= setsockopt(server->fd, SOL_SOCKET, SO_RCVBUF, &server->root->recv_size, (socklen_t)sizeof(int)); + (void)(error); assert(error == 0); } @@ -345,7 +391,7 @@ static void set_socket_options(memcached_server_st *server) set_socket_nonblocking(server); } -static memcached_return_t unix_socket_connect(memcached_server_st *server) +static memcached_return_t unix_socket_connect(org::libmemcached::Instance* server) { #ifndef WIN32 WATCHPOINT_ASSERT(server->fd == INVALID_SOCKET); @@ -396,12 +442,12 @@ static memcached_return_t unix_socket_connect(memcached_server_st *server) #endif } -static memcached_return_t network_connect(memcached_server_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. @@ -410,24 +456,7 @@ static memcached_return_t network_connect(memcached_server_st *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)) { @@ -451,13 +480,30 @@ static memcached_return_t network_connect(memcached_server_st *server) continue; } + int type= server->address_info_next->ai_socktype; + if (HAVE_SOCK_CLOEXEC) + { + type|= SOCK_CLOEXEC; + } + if ((server->fd= socket(server->address_info_next->ai_family, - server->address_info_next->ai_socktype, + type, server->address_info_next->ai_protocol)) < 0) { return memcached_set_errno(*server, get_socket_errno(), NULL); } + if (HAVE_SOCK_CLOEXEC == 0) + { +#ifdef FD_CLOEXEC + int rval; + do + { + rval= fcntl (server->fd, F_SETFD, FD_CLOEXEC); + } while (rval == -1 && (errno == EINTR or errno == EAGAIN)); +#endif + } + set_socket_options(server); /* connect to server */ @@ -533,7 +579,7 @@ static memcached_return_t network_connect(memcached_server_st *server) if (memcached_has_current_error(*server)) { - return memcached_server_error_return(server); + return memcached_instance_error_return(server); } if (timeout_error_occured and server->state < MEMCACHED_SERVER_STATE_IN_PROGRESS) @@ -551,7 +597,7 @@ static memcached_return_t network_connect(memcached_server_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); @@ -618,8 +664,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; @@ -674,7 +721,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) @@ -683,7 +731,7 @@ static memcached_return_t _memcached_connect(memcached_server_write_instance_st if (memcached_has_current_error(*server)) { memcached_mark_server_for_timeout(server); - assert(memcached_failed(memcached_server_error_return(server))); + assert(memcached_failed(memcached_instance_error_return(server))); } else { @@ -696,7 +744,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); } } @@ -704,12 +752,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); }