X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fconnect.cc;h=7efdd8fe6d52f3a5b89e9ddaaf94e91d4064a557;hb=195a733bb0bb3d989abfd1c828f25e8c309cbb7b;hp=1ace3fd8c72b47a39f1dc683d98df5375c5fdbe4;hpb=f47caf2833675cce0b62a6e4ffd6764c1490a8b4;p=m6w6%2Flibmemcached diff --git a/libmemcached/connect.cc b/libmemcached/connect.cc index 1ace3fd8..7efdd8fe 100644 --- a/libmemcached/connect.cc +++ b/libmemcached/connect.cc @@ -39,11 +39,17 @@ #include #include -#include -#include #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) @@ -87,7 +93,7 @@ static memcached_return_t connect_poll(org::libmemcached::Instance* server) { int err; socklen_t len= sizeof(err); - if (getsockopt(server->fd, SOL_SOCKET, SO_ERROR, &err, &len) == 0) + if (getsockopt(server->fd, SOL_SOCKET, SO_ERROR, (char*)&err, &len) == 0) { if (err == 0) { @@ -118,7 +124,7 @@ static memcached_return_t connect_poll(org::libmemcached::Instance* server) { int err; socklen_t len= sizeof (err); - if (getsockopt(fds[0].fd, SOL_SOCKET, SO_ERROR, &err, &len) == 0) + if (getsockopt(fds[0].fd, SOL_SOCKET, SO_ERROR, (char*)&err, &len) == 0) { // We check the value to see what happened wth the socket. if (err == 0) @@ -173,7 +179,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 +188,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 +251,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,30 +290,30 @@ 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); + (char*)&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)); + (char*)&waittime, (socklen_t)sizeof(struct timeval)); (void)(error); assert(error == 0); } @@ -285,11 +325,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 @@ -301,7 +344,7 @@ static void set_socket_options(org::libmemcached::Instance* server) linger.l_onoff= 1; 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)); + (char*)&linger, (socklen_t)sizeof(struct linger)); (void)(error); assert(error == 0); } @@ -311,7 +354,7 @@ static void set_socket_options(org::libmemcached::Instance* server) int flag= 1; int error= setsockopt(server->fd, IPPROTO_TCP, TCP_NODELAY, - &flag, (socklen_t)sizeof(int)); + (char*)&flag, (socklen_t)sizeof(int)); (void)(error); assert(error == 0); } @@ -321,7 +364,7 @@ static void set_socket_options(org::libmemcached::Instance* server) int flag= 1; int error= setsockopt(server->fd, SOL_SOCKET, SO_KEEPALIVE, - &flag, (socklen_t)sizeof(int)); + (char*)&flag, (socklen_t)sizeof(int)); (void)(error); assert(error == 0); } @@ -330,7 +373,7 @@ static void set_socket_options(org::libmemcached::Instance* server) if (server->root->tcp_keepidle > 0) { int error= setsockopt(server->fd, IPPROTO_TCP, TCP_KEEPIDLE, - &server->root->tcp_keepidle, (socklen_t)sizeof(int)); + (char*)&server->root->tcp_keepidle, (socklen_t)sizeof(int)); (void)(error); assert(error == 0); } @@ -339,7 +382,7 @@ static void set_socket_options(org::libmemcached::Instance* server) if (server->root->send_size > 0) { int error= setsockopt(server->fd, SOL_SOCKET, SO_SNDBUF, - &server->root->send_size, (socklen_t)sizeof(int)); + (char*)&server->root->send_size, (socklen_t)sizeof(int)); (void)(error); assert(error == 0); } @@ -347,12 +390,11 @@ static void set_socket_options(org::libmemcached::Instance* server) if (server->root->recv_size > 0) { int error= setsockopt(server->fd, SOL_SOCKET, SO_RCVBUF, - &server->root->recv_size, (socklen_t)sizeof(int)); + (char*)&server->root->recv_size, (socklen_t)sizeof(int)); (void)(error); assert(error == 0); } - /* libmemcached will always use nonblocking IO to avoid write deadlocks */ set_socket_nonblocking(server); } @@ -362,7 +404,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 +475,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,28 +500,39 @@ 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 ((server->fd= socket(server->address_info_next->ai_family, - type, - server->address_info_next->ai_protocol)) < 0) + if (SOCK_NONBLOCK) + { + type|= SOCK_NONBLOCK; + } + + server->fd= socket(server->address_info_next->ai_family, + type, + server->address_info_next->ai_protocol); + + if (int(server->fd) == SOCKET_ERROR) { return memcached_set_errno(*server, get_socket_errno(), NULL); } - if (HAVE_SOCK_CLOEXEC == 0) +#ifdef HAVE_FCNTL + // 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)); + } } +#endif set_socket_options(server); @@ -687,6 +734,7 @@ static memcached_return_t _memcached_connect(org::libmemcached::Instance* server if (server->fd != INVALID_SOCKET and server->root->sasl.callbacks) { rc= memcached_sasl_authenticate_connection(server); + fprintf(stderr, "%s:%d %s\n", __FILE__, __LINE__, memcached_strerror(NULL, rc)); if (memcached_failed(rc) and server->fd != INVALID_SOCKET) { WATCHPOINT_ASSERT(server->fd != INVALID_SOCKET); @@ -737,6 +785,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); }