X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=lib%2Fmemcached_connect.c;h=d1b2dcabf1244ff51dd37117ab0bfa1f716f3c28;hb=347434b799ba94bd621df9a1d277ff8a36157f21;hp=34613ddd13a7a1007a8ec45b3bbdd2ed69170911;hpb=c11af7ccccd3260444da4f575022de655d2ffc26;p=awesomized%2Flibmemcached diff --git a/lib/memcached_connect.c b/lib/memcached_connect.c index 34613ddd..d1b2dcab 100644 --- a/lib/memcached_connect.c +++ b/lib/memcached_connect.c @@ -1,76 +1,189 @@ #include "common.h" -#include -#include -#include -#include -#include +static memcached_return set_hostinfo(memcached_server_st *server) +{ + 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; + if (server->type == MEMCACHED_CONNECTION_UDP) + { + hints.ai_protocol= IPPROTO_UDP; + hints.ai_socktype= SOCK_DGRAM; + } + else + { + hints.ai_socktype= SOCK_STREAM; + hints.ai_protocol= IPPROTO_TCP; + } -memcached_return memcached_real_connect(memcached_st *ptr, unsigned int server_key) + e= getaddrinfo(server->hostname, str_port, &hints, &ai); + if (e != 0) + { + WATCHPOINT_STRING(server->hostname); + WATCHPOINT_STRING(gai_strerror(e)); + return MEMCACHED_HOST_LOOKUP_FAILURE; + } + + if (server->address_info) + freeaddrinfo(server->address_info); + server->address_info= ai; + + return MEMCACHED_SUCCESS; +} + +static memcached_return unix_socket_connect(memcached_server_st *ptr) { - struct sockaddr_in localAddr, servAddr; - struct hostent *h; + struct sockaddr_un servAddr; + socklen_t addrlen; - if (ptr->hosts[server_key].fd == -1) + if (ptr->fd == -1) { - /* Old connection junk still is in the structure */ - assert(ptr->hosts[server_key].stack_responses == 0); + if ((ptr->fd= socket(AF_UNIX, SOCK_STREAM, 0)) < 0) + { + ptr->cached_errno= errno; + return MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE; + } + + memset(&servAddr, 0, sizeof (struct sockaddr_un)); + servAddr.sun_family= AF_UNIX; + strcpy(servAddr.sun_path, ptr->hostname); /* Copy filename */ - if ((h= gethostbyname(ptr->hosts[server_key].hostname)) == NULL) + addrlen= strlen(servAddr.sun_path) + sizeof(servAddr.sun_family); + +test_connect: + if (connect(ptr->fd, + (struct sockaddr *)&servAddr, + sizeof(servAddr)) < 0) { - ptr->my_errno= h_errno; - return MEMCACHED_HOST_LOCKUP_FAILURE; + switch (errno) { + /* We are spinning waiting on connect */ + case EALREADY: + case EINPROGRESS: + case EINTR: + goto test_connect; + case EISCONN: /* We were spinning waiting on connect */ + break; + default: + WATCHPOINT_ERRNO(errno); + ptr->cached_errno= errno; + return MEMCACHED_ERRNO; + } } + } + return MEMCACHED_SUCCESS; +} + +static memcached_return network_connect(memcached_server_st *ptr) +{ + if (ptr->fd == -1) + { + struct addrinfo *use; + + /* Old connection junk still is in the structure */ + WATCHPOINT_ASSERT(ptr->cursor_active == 0); + + if (ptr->sockaddr_inited == MEMCACHED_NOT_ALLOCATED || + (!(ptr->root->flags & MEM_USE_CACHE_LOOKUPS))) + { + memcached_return rc; - servAddr.sin_family= h->h_addrtype; - memcpy((char *) &servAddr.sin_addr.s_addr, h->h_addr_list[0], h->h_length); - servAddr.sin_port = htons(ptr->hosts[server_key].port); + rc= set_hostinfo(ptr); + if (rc != MEMCACHED_SUCCESS) + return rc; + ptr->sockaddr_inited= MEMCACHED_ALLOCATED; + } + use= ptr->address_info; /* Create the socket */ - if ((ptr->hosts[server_key].fd= socket(AF_INET, SOCK_STREAM, 0)) < 0) + if ((ptr->fd= socket(use->ai_family, + use->ai_socktype, + use->ai_protocol)) < 0) { - ptr->my_errno= errno; + ptr->cached_errno= errno; + WATCHPOINT_ERRNO(errno); return MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE; } - /* bind any port number */ - localAddr.sin_family = AF_INET; - localAddr.sin_addr.s_addr = htonl(INADDR_ANY); - localAddr.sin_port = htons(0); + if (ptr->type == MEMCACHED_CONNECTION_UDP) + return MEMCACHED_SUCCESS; - /* For the moment, not getting a nonblocking mode will note be fatal */ - if (ptr->flags & MEM_NO_BLOCK) + if (ptr->root->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; + struct timeval waittime; + + waittime.tv_sec= 10; + waittime.tv_usec= 0; + + linger.l_onoff= 1; + linger.l_linger= MEMCACHED_DEFAULT_TIMEOUT; + error= setsockopt(ptr->fd, SOL_SOCKET, SO_LINGER, + &linger, (socklen_t)sizeof(struct linger)); + WATCHPOINT_ASSERT(error == 0); + + error= setsockopt(ptr->fd, SOL_SOCKET, SO_SNDTIMEO, + &waittime, (socklen_t)sizeof(struct timeval)); + WATCHPOINT_ASSERT(error == 0); + + error= setsockopt(ptr->fd, SOL_SOCKET, SO_RCVTIMEO, + &waittime, (socklen_t)sizeof(struct timeval)); + WATCHPOINT_ASSERT(error == 0); } - if (ptr->flags & MEM_TCP_NODELAY) + if (ptr->root->flags & MEM_TCP_NODELAY) { int flag= 1; + int error; + + error= setsockopt(ptr->fd, IPPROTO_TCP, TCP_NODELAY, + &flag, (socklen_t)sizeof(int)); + WATCHPOINT_ASSERT(error == 0); + } + + if (ptr->root->send_size) + { + int error; - setsockopt(ptr->hosts[server_key].fd, IPPROTO_TCP, TCP_NODELAY, - &flag, (socklen_t)sizeof(int)); + error= setsockopt(ptr->fd, SOL_SOCKET, SO_SNDBUF, + &ptr->root->send_size, (socklen_t)sizeof(int)); + WATCHPOINT_ASSERT(error == 0); } - if (ptr->send_size) + if (ptr->root->recv_size) { - setsockopt(ptr->hosts[server_key].fd, SOL_SOCKET, SO_SNDBUF, - &ptr->send_size, (socklen_t)sizeof(int)); + int error; + + error= setsockopt(ptr->fd, SOL_SOCKET, SO_SNDBUF, + &ptr->root->recv_size, (socklen_t)sizeof(int)); + WATCHPOINT_ASSERT(error == 0); } - if (ptr->recv_size) + /* For the moment, not getting a nonblocking mode will not be fatal */ + if (ptr->root->flags & MEM_NO_BLOCK) { - setsockopt(ptr->hosts[server_key].fd, SOL_SOCKET, SO_SNDBUF, - &ptr->recv_size, (socklen_t)sizeof(int)); + int flags; + + flags= fcntl(ptr->fd, F_GETFL, 0); + if (flags != -1) + { + (void)fcntl(ptr->fd, F_SETFL, flags | O_NONBLOCK); + } } + /* connect to server */ test_connect: - if (connect(ptr->hosts[server_key].fd, (struct sockaddr *) &servAddr, sizeof(servAddr)) < 0) + if (connect(ptr->fd, + use->ai_addr, + use->ai_addrlen) < 0) { switch (errno) { /* We are spinning waiting on connect */ @@ -81,39 +194,47 @@ test_connect: case EISCONN: /* We were spinning waiting on connect */ break; default: - ptr->my_errno= errno; + ptr->cached_errno= errno; + WATCHPOINT_ERRNO(ptr->cached_errno); + close(ptr->fd); + ptr->fd= -1; return MEMCACHED_ERRNO; } - ptr->connected++; } - assert(ptr->hosts[server_key].stack_responses == 0); + + WATCHPOINT_ASSERT(ptr->cursor_active == 0); } return MEMCACHED_SUCCESS; } -memcached_return memcached_connect(memcached_st *ptr, unsigned int server_key) +memcached_return memcached_connect(memcached_server_st *ptr) { - memcached_return rc; + memcached_return rc= MEMCACHED_NO_SERVERS; LIBMEMCACHED_MEMCACHED_CONNECT_START(); - if (ptr->connected == ptr->number_of_hosts) - return MEMCACHED_SUCCESS; - - if (!ptr->hosts) - return MEMCACHED_NO_SERVERS; - /* We need to clean up the multi startup piece */ - if (server_key) - rc= memcached_real_connect(ptr, server_key); - else + switch (ptr->type) { - unsigned int x; - - for (x= 0; x < ptr->number_of_hosts; x++) - rc= memcached_real_connect(ptr, x); + case MEMCACHED_CONNECTION_UNKNOWN: + WATCHPOINT_ASSERT(0); + rc= MEMCACHED_NOT_SUPPORTED; + break; + case MEMCACHED_CONNECTION_UDP: + case MEMCACHED_CONNECTION_TCP: + rc= network_connect(ptr); + break; + case MEMCACHED_CONNECTION_UNIX_SOCKET: + rc= unix_socket_connect(ptr); + break; + default: + WATCHPOINT_ASSERT(0); } + + if (rc != MEMCACHED_SUCCESS) + WATCHPOINT_ERROR(rc); + LIBMEMCACHED_MEMCACHED_CONNECT_END(); return rc;