X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=lib%2Fmemcached_connect.c;h=d1b2dcabf1244ff51dd37117ab0bfa1f716f3c28;hb=801d7d586a32b5f2d4af430b68acd8e97a2a5321;hp=0135fc9a31f66bb723bb29a3174d8753a8618089;hpb=d283f47cade6fcd1256e738057667fbcca7b06c1;p=m6w6%2Flibmemcached diff --git a/lib/memcached_connect.c b/lib/memcached_connect.c index 0135fc9a..d1b2dcab 100644 --- a/lib/memcached_connect.c +++ b/lib/memcached_connect.c @@ -1,53 +1,51 @@ #include "common.h" -#include -#include -#include -#include -#include -#include - static memcached_return set_hostinfo(memcached_server_st *server) { - struct hostent *h; -#ifdef HAVE_GETHOSTBYNAME_R - struct hostent h_static; - char buffer[SMALL_STRING_LEN]; - int tmp_error; - - if (gethostbyname_r(server->hostname, - &h_static, buffer, SMALL_STRING_LEN, - &h, &tmp_error)) + 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) { - WATCHPOINT_STRING(server->hostname); - WATCHPOINT_STRING(hstrerror(tmp_error)); - return MEMCACHED_HOST_LOOKUP_FAILURE; + hints.ai_protocol= IPPROTO_UDP; + hints.ai_socktype= SOCK_DGRAM; } -#else - if ((h= gethostbyname(server->hostname)) == NULL) + else + { + hints.ai_socktype= SOCK_STREAM; + hints.ai_protocol= IPPROTO_TCP; + } + + e= getaddrinfo(server->hostname, str_port, &hints, &ai); + if (e != 0) { WATCHPOINT_STRING(server->hostname); - WATCHPOINT_STRING(hstrerror(h_errno)); + WATCHPOINT_STRING(gai_strerror(e)); return MEMCACHED_HOST_LOOKUP_FAILURE; } -#endif - server->servAddr.sin_family= h->h_addrtype; - memcpy((char *) &server->servAddr.sin_addr.s_addr, h->h_addr_list[0], h->h_length); - - server->servAddr.sin_port = htons(server->port); + if (server->address_info) + freeaddrinfo(server->address_info); + server->address_info= ai; return MEMCACHED_SUCCESS; } -static memcached_return unix_socket_connect(memcached_st *ptr, unsigned int server_key) +static memcached_return unix_socket_connect(memcached_server_st *ptr) { struct sockaddr_un servAddr; socklen_t addrlen; - if (ptr->hosts[server_key].fd == -1) + if (ptr->fd == -1) { - if ((ptr->hosts[server_key].fd= socket(AF_UNIX, SOCK_STREAM, 0)) < 0) + if ((ptr->fd= socket(AF_UNIX, SOCK_STREAM, 0)) < 0) { ptr->cached_errno= errno; return MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE; @@ -55,12 +53,12 @@ static memcached_return unix_socket_connect(memcached_st *ptr, unsigned int serv memset(&servAddr, 0, sizeof (struct sockaddr_un)); servAddr.sun_family= AF_UNIX; - strcpy(servAddr.sun_path, ptr->hosts[server_key].hostname); /* Copy filename */ + strcpy(servAddr.sun_path, ptr->hostname); /* Copy filename */ addrlen= strlen(servAddr.sun_path) + sizeof(servAddr.sun_family); test_connect: - if (connect(ptr->hosts[server_key].fd, + if (connect(ptr->fd, (struct sockaddr *)&servAddr, sizeof(servAddr)) < 0) { @@ -73,109 +71,119 @@ test_connect: case EISCONN: /* We were spinning waiting on connect */ break; default: + WATCHPOINT_ERRNO(errno); ptr->cached_errno= errno; return MEMCACHED_ERRNO; } - ptr->connected++; } } return MEMCACHED_SUCCESS; } -static memcached_return udp_connect(memcached_st *ptr, unsigned int server_key) +static memcached_return network_connect(memcached_server_st *ptr) { - if (ptr->hosts[server_key].fd == -1) + if (ptr->fd == -1) { + struct addrinfo *use; + /* Old connection junk still is in the structure */ - WATCHPOINT_ASSERT(ptr->hosts[server_key].stack_responses == 0); - - /* - If we have not allocated the hosts object. - Or if the cache has not been set. - */ - if (ptr->hosts[server_key].sockaddr_inited == MEMCACHED_NOT_ALLOCATED || - (!(ptr->flags & MEM_USE_CACHE_LOOKUPS))) + WATCHPOINT_ASSERT(ptr->cursor_active == 0); + + if (ptr->sockaddr_inited == MEMCACHED_NOT_ALLOCATED || + (!(ptr->root->flags & MEM_USE_CACHE_LOOKUPS))) { memcached_return rc; - rc= set_hostinfo(&ptr->hosts[server_key]); + rc= set_hostinfo(ptr); if (rc != MEMCACHED_SUCCESS) return rc; - - ptr->hosts[server_key].sockaddr_inited= MEMCACHED_ALLOCATED; + ptr->sockaddr_inited= MEMCACHED_ALLOCATED; } + use= ptr->address_info; /* Create the socket */ - if ((ptr->hosts[server_key].fd= socket(AF_INET, SOCK_DGRAM, 0)) < 0) + if ((ptr->fd= socket(use->ai_family, + use->ai_socktype, + use->ai_protocol)) < 0) { ptr->cached_errno= errno; + WATCHPOINT_ERRNO(errno); return MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE; } - } - return MEMCACHED_SUCCESS; -} + if (ptr->type == MEMCACHED_CONNECTION_UDP) + return MEMCACHED_SUCCESS; -static memcached_return tcp_connect(memcached_st *ptr, unsigned int server_key) -{ - if (ptr->hosts[server_key].fd == -1) - { - /* Old connection junk still is in the structure */ - WATCHPOINT_ASSERT(ptr->hosts[server_key].stack_responses == 0); - - if (ptr->hosts[server_key].sockaddr_inited == MEMCACHED_NOT_ALLOCATED || - (!(ptr->flags & MEM_USE_CACHE_LOOKUPS))) + if (ptr->root->flags & MEM_NO_BLOCK) { - memcached_return rc; - - rc= set_hostinfo(&ptr->hosts[server_key]); - if (rc != MEMCACHED_SUCCESS) - return rc; - ptr->hosts[server_key].sockaddr_inited= MEMCACHED_ALLOCATED; + 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); } - /* Create the socket */ - if ((ptr->hosts[server_key].fd= socket(AF_INET, SOCK_STREAM, 0)) < 0) + if (ptr->root->flags & MEM_TCP_NODELAY) { - ptr->cached_errno= errno; - return MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE; + int flag= 1; + int error; + + error= setsockopt(ptr->fd, IPPROTO_TCP, TCP_NODELAY, + &flag, (socklen_t)sizeof(int)); + WATCHPOINT_ASSERT(error == 0); } - /* For the moment, not getting a nonblocking mode will note be fatal */ - if (ptr->flags & MEM_NO_BLOCK) + if (ptr->root->send_size) { - int flags; + int error; - 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); + error= setsockopt(ptr->fd, SOL_SOCKET, SO_SNDBUF, + &ptr->root->send_size, (socklen_t)sizeof(int)); + WATCHPOINT_ASSERT(error == 0); } - if (ptr->flags & MEM_TCP_NODELAY) + if (ptr->root->recv_size) { - int flag= 1; + 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->recv_size, (socklen_t)sizeof(int)); + WATCHPOINT_ASSERT(error == 0); } - if (ptr->send_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->send_size, (socklen_t)sizeof(int)); - } + int flags; - if (ptr->recv_size) - { - setsockopt(ptr->hosts[server_key].fd, SOL_SOCKET, SO_SNDBUF, - &ptr->recv_size, (socklen_t)sizeof(int)); + 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 *)&ptr->hosts[server_key].servAddr, - sizeof(struct sockaddr)) < 0) + if (connect(ptr->fd, + use->ai_addr, + use->ai_addrlen) < 0) { switch (errno) { /* We are spinning waiting on connect */ @@ -187,44 +195,41 @@ test_connect: break; default: ptr->cached_errno= errno; + WATCHPOINT_ERRNO(ptr->cached_errno); + close(ptr->fd); + ptr->fd= -1; return MEMCACHED_ERRNO; } - ptr->connected++; } - WATCHPOINT_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_NO_SERVERS; LIBMEMCACHED_MEMCACHED_CONNECT_START(); - if (ptr->connected == ptr->number_of_hosts && ptr->number_of_hosts) - return MEMCACHED_SUCCESS; - - if (ptr->hosts == NULL || ptr->number_of_hosts == 0) - return MEMCACHED_NO_SERVERS; - /* We need to clean up the multi startup piece */ - switch (ptr->hosts[server_key].type) + switch (ptr->type) { case MEMCACHED_CONNECTION_UNKNOWN: WATCHPOINT_ASSERT(0); rc= MEMCACHED_NOT_SUPPORTED; break; case MEMCACHED_CONNECTION_UDP: - rc= udp_connect(ptr, server_key); - break; case MEMCACHED_CONNECTION_TCP: - rc= tcp_connect(ptr, server_key); + rc= network_connect(ptr); break; case MEMCACHED_CONNECTION_UNIX_SOCKET: - rc= unix_socket_connect(ptr, server_key); + rc= unix_socket_connect(ptr); break; + default: + WATCHPOINT_ASSERT(0); } if (rc != MEMCACHED_SUCCESS)