X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fconnect.cc;h=b59c0ecbbf781a4a2a1b37668c2b8c039c892f64;hb=e23d774aaee5cf66ff4dc563f5b0a2cad293dd82;hp=aa2c7def7e4904c7f769d43bdf4c459be9333ee7;hpb=f9b74a208522a12dca6ee9c894c6782920860b88;p=awesomized%2Flibmemcached diff --git a/libmemcached/connect.cc b/libmemcached/connect.cc index aa2c7def..b59c0ecb 100644 --- a/libmemcached/connect.cc +++ b/libmemcached/connect.cc @@ -52,11 +52,24 @@ # define FD_CLOEXEC 0 #endif +#ifndef SO_NOSIGPIPE +# define SO_NOSIGPIPE 0 +#endif + +#ifndef TCP_NODELAY +# define TCP_NODELAY 0 +#endif + +#ifndef TCP_KEEPIDLE +# define TCP_KEEPIDLE 0 +#endif + static memcached_return_t connect_poll(org::libmemcached::Instance* server) { struct pollfd fds[1]; fds[0].fd= server->fd; - fds[0].events= POLLOUT; + fds[0].events= server->events(); + fds[0].revents= 0; size_t loop_max= 5; @@ -118,6 +131,10 @@ static memcached_return_t connect_poll(org::libmemcached::Instance* server) return memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT); } +#if 0 + server->revents(fds[0].revents); +#endif + if (fds[0].revents & POLLERR or fds[0].revents & POLLHUP or fds[0].revents & POLLNVAL) @@ -281,13 +298,38 @@ static inline void set_socket_nonblocking(org::libmemcached::Instance* server) #endif } -static void set_socket_options(org::libmemcached::Instance* server) +static bool set_socket_options(org::libmemcached::Instance* server) { assert_msg(server->fd != INVALID_SOCKET, "invalid socket was passed to set_socket_options()"); +#ifdef HAVE_FCNTL + // If SOCK_CLOEXEC exists then we don't need to call the following + if (SOCK_CLOEXEC == 0) + { + if (FD_CLOEXEC) + { + int flags; + do + { + flags= fcntl(server->fd, F_GETFD, 0); + } while (flags == -1 and (errno == EINTR or errno == EAGAIN)); + + if (flags != -1) + { + int rval; + do + { + rval= fcntl (server->fd, F_SETFD, flags | FD_CLOEXEC); + } while (rval == -1 && (errno == EINTR or errno == EAGAIN)); + // we currently ignore the case where rval is -1 + } + } + } +#endif + if (memcached_is_udp(server->root)) { - return; + return true; } #ifdef HAVE_SNDTIMEO @@ -321,7 +363,8 @@ static void set_socket_options(org::libmemcached::Instance* server) #endif -#if defined(__MACH__) && defined(__APPLE__) || defined(__FreeBSD__) +#if defined(SO_NOSIGPIPE) + if (SO_NOSIGPIPE) { int set= 1; int error= setsockopt(server->fd, SOL_SOCKET, SO_NOSIGPIPE, (void *)&set, sizeof(int)); @@ -350,14 +393,17 @@ static void set_socket_options(org::libmemcached::Instance* server) assert(error == 0); } - if (server->root->flags.tcp_nodelay) + if (TCP_NODELAY) { - int flag= 1; + if (server->root->flags.tcp_nodelay) + { + int flag= 1; - int error= setsockopt(server->fd, IPPROTO_TCP, TCP_NODELAY, - (char*)&flag, (socklen_t)sizeof(int)); - (void)(error); - assert(error == 0); + int error= setsockopt(server->fd, IPPROTO_TCP, TCP_NODELAY, + (char*)&flag, (socklen_t)sizeof(int)); + (void)(error); + assert(error == 0); + } } if (server->root->flags.tcp_keepalive) @@ -370,15 +416,16 @@ static void set_socket_options(org::libmemcached::Instance* server) assert(error == 0); } -#ifdef TCP_KEEPIDLE - if (server->root->tcp_keepidle > 0) + if (TCP_KEEPIDLE) { - int error= setsockopt(server->fd, IPPROTO_TCP, TCP_KEEPIDLE, - (char*)&server->root->tcp_keepidle, (socklen_t)sizeof(int)); - (void)(error); - assert(error == 0); + if (server->root->tcp_keepidle > 0) + { + int error= setsockopt(server->fd, IPPROTO_TCP, TCP_KEEPIDLE, + (char*)&server->root->tcp_keepidle, (socklen_t)sizeof(int)); + (void)(error); + assert(error == 0); + } } -#endif if (server->root->send_size > 0) { @@ -398,6 +445,8 @@ static void set_socket_options(org::libmemcached::Instance* server) /* libmemcached will always use nonblocking IO to avoid write deadlocks */ set_socket_nonblocking(server); + + return true; } static memcached_return_t unix_socket_connect(org::libmemcached::Instance* server) @@ -405,49 +454,56 @@ static memcached_return_t unix_socket_connect(org::libmemcached::Instance* serve #ifndef WIN32 WATCHPOINT_ASSERT(server->fd == INVALID_SOCKET); - int type= SOCK_STREAM; - if (SOCK_CLOEXEC) - { - type|= SOCK_CLOEXEC; - } + do { + int type= SOCK_STREAM; + if (SOCK_CLOEXEC) + { + type|= SOCK_CLOEXEC; + } - if (SOCK_NONBLOCK) - { - type|= SOCK_NONBLOCK; - } + 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; - } + if ((server->fd= socket(AF_UNIX, type, 0)) < 0) + { + return memcached_set_errno(*server, errno, NULL); + } - struct sockaddr_un servAddr; + struct sockaddr_un servAddr; - memset(&servAddr, 0, sizeof (struct sockaddr_un)); - servAddr.sun_family= AF_UNIX; - strncpy(servAddr.sun_path, server->hostname, sizeof(servAddr.sun_path)); /* Copy filename */ + memset(&servAddr, 0, sizeof (struct sockaddr_un)); + servAddr.sun_family= AF_UNIX; + strncpy(servAddr.sun_path, server->hostname, sizeof(servAddr.sun_path)); /* Copy filename */ - do { if (connect(server->fd, (struct sockaddr *)&servAddr, sizeof(servAddr)) < 0) { switch (errno) { case EINPROGRESS: case EALREADY: + server->events(POLLOUT); + break; + case EINTR: + (void)closesocket(server->fd); + server->fd= INVALID_SOCKET; continue; case EISCONN: /* We were spinning waiting on connect */ { assert(0); // Programmer error - break; + (void)closesocket(server->fd); + server->fd= INVALID_SOCKET; + continue; } default: WATCHPOINT_ERRNO(errno); - memcached_set_errno(*server, errno, MEMCACHED_AT); - return MEMCACHED_CONNECTION_FAILURE; + (void)closesocket(server->fd); + server->fd= INVALID_SOCKET; + return memcached_set_errno(*server, errno, MEMCACHED_AT); } } } while (0); @@ -520,22 +576,11 @@ static memcached_return_t network_connect(org::libmemcached::Instance* server) return memcached_set_errno(*server, get_socket_errno(), NULL); } -#ifdef HAVE_FCNTL - // If SOCK_CLOEXEC exists then we don't need to call the following - if (SOCK_CLOEXEC == 0) + if (set_socket_options(server) == false) { - if (FD_CLOEXEC) - { - int rval; - do - { - rval= fcntl (server->fd, F_SETFD, FD_CLOEXEC); - } while (rval == -1 && (errno == EINTR or errno == EAGAIN)); - } + (void)closesocket(server->fd); + return MEMCACHED_CONNECTION_FAILURE; } -#endif - - set_socket_options(server); /* connect to server */ if ((connect(server->fd, server->address_info_next->ai_addr, server->address_info_next->ai_addrlen) != SOCKET_ERROR)) @@ -558,6 +603,7 @@ static memcached_return_t network_connect(org::libmemcached::Instance* server) case EINPROGRESS: // nonblocking mode - first return case EALREADY: // nonblocking mode - subsequent returns { + server->events(POLLOUT); server->state= MEMCACHED_SERVER_STATE_IN_PROGRESS; memcached_return_t rc= connect_poll(server); @@ -585,6 +631,9 @@ static memcached_return_t network_connect(org::libmemcached::Instance* server) server->fd= INVALID_SOCKET; continue; + case ECONNREFUSED: + // Probably not running service + default: break; } @@ -784,16 +833,6 @@ static memcached_return_t _memcached_connect(org::libmemcached::Instance* server return rc; } -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(org::libmemcached::Instance* server) { return _memcached_connect(server, true);