X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=lib%2Fmemcached_connect.c;h=82a08ab7327ea513908d4fac32066e8d8743952f;hb=e1944ccd4d1e65f4192783fa9c564c9b747bb618;hp=025fdf6e00e589532a69f33b50ee790d01eba68b;hpb=131622cdc2710ecd9ad554ce7d08c6003fbdcf6e;p=m6w6%2Flibmemcached diff --git a/lib/memcached_connect.c b/lib/memcached_connect.c index 025fdf6e..82a08ab7 100644 --- a/lib/memcached_connect.c +++ b/lib/memcached_connect.c @@ -1,11 +1,33 @@ #include "common.h" -#include -#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; + hints.ai_socktype= SOCK_STREAM; + hints.ai_protocol= 0; + + 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_st *ptr, unsigned int server_key) { @@ -22,12 +44,14 @@ 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); + strcpy(servAddr.sun_path, ptr->hosts[server_key].hostname); /* Copy filename */ addrlen= strlen(servAddr.sun_path) + sizeof(servAddr.sun_family); test_connect: - if (connect(ptr->hosts[server_key].fd, (struct sockaddr *)&servAddr, sizeof(servAddr)) < 0) + if (connect(ptr->hosts[server_key].fd, + (struct sockaddr *)&servAddr, + sizeof(servAddr)) < 0) { switch (errno) { /* We are spinning waiting on connect */ @@ -38,6 +62,7 @@ test_connect: case EISCONN: /* We were spinning waiting on connect */ break; default: + WATCHPOINT_ERRNO(errno); ptr->cached_errno= errno; return MEMCACHED_ERRNO; } @@ -47,34 +72,71 @@ test_connect: return MEMCACHED_SUCCESS; } -static memcached_return tcp_connect(memcached_st *ptr, unsigned int server_key) +static memcached_return udp_connect(memcached_st *ptr, unsigned int server_key) { - struct sockaddr_in servAddr; - struct hostent *h; - 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 ((h= gethostbyname(ptr->hosts[server_key].hostname)) == NULL) + /* + 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))) { - ptr->cached_errno= h_errno; - return MEMCACHED_HOST_LOCKUP_FAILURE; + memcached_return rc; + + rc= set_hostinfo(&ptr->hosts[server_key]); + if (rc != MEMCACHED_SUCCESS) + return rc; + + ptr->hosts[server_key].sockaddr_inited= MEMCACHED_ALLOCATED; } - 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); + /* Create the socket */ + if ((ptr->hosts[server_key].fd= socket(AF_INET, SOCK_DGRAM, 0)) < 0) + { + ptr->cached_errno= errno; + return MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE; + } + } + + 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); + struct addrinfo *use; + + if (ptr->hosts[server_key].sockaddr_inited == MEMCACHED_NOT_ALLOCATED || + (!(ptr->flags & MEM_USE_CACHE_LOOKUPS))) + { + memcached_return rc; + + rc= set_hostinfo(&ptr->hosts[server_key]); + if (rc != MEMCACHED_SUCCESS) + return rc; + ptr->hosts[server_key].sockaddr_inited= MEMCACHED_ALLOCATED; + } + use= ptr->hosts[server_key].address_info; /* Create the socket */ - if ((ptr->hosts[server_key].fd= socket(AF_INET, SOCK_STREAM, 0)) < 0) + if ((ptr->hosts[server_key].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; } - /* For the moment, not getting a nonblocking mode will note be fatal */ + /* For the moment, not getting a nonblocking mode will not be fatal */ if (ptr->flags & MEM_NO_BLOCK) { int flags; @@ -106,7 +168,9 @@ static memcached_return tcp_connect(memcached_st *ptr, unsigned int server_key) /* connect to server */ test_connect: - if (connect(ptr->hosts[server_key].fd, (struct sockaddr *)&servAddr, sizeof(servAddr)) < 0) + if (connect(ptr->hosts[server_key].fd, + use->ai_addr, + use->ai_addrlen) < 0) { switch (errno) { /* We are spinning waiting on connect */ @@ -118,6 +182,7 @@ test_connect: break; default: ptr->cached_errno= errno; + WATCHPOINT_ERRNO(ptr->cached_errno); return MEMCACHED_ERRNO; } ptr->connected++; @@ -141,38 +206,26 @@ memcached_return memcached_connect(memcached_st *ptr, unsigned int server_key) return MEMCACHED_NO_SERVERS; /* We need to clean up the multi startup piece */ - if (server_key) - rc= tcp_connect(ptr, server_key); - else + switch (ptr->hosts[server_key].type) { - unsigned int x; - - for (x= 0; x < ptr->number_of_hosts; x++) - { - memcached_return possible_rc; + 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); + break; + case MEMCACHED_CONNECTION_UNIX_SOCKET: + rc= unix_socket_connect(ptr, server_key); + break; + } - possible_rc= MEMCACHED_NOT_SUPPORTED; /* Remove warning */ + if (rc != MEMCACHED_SUCCESS) + WATCHPOINT_ERROR(rc); - switch (ptr->hosts[x].type) - { - case MEMCACHED_CONNECTION_UNKNOWN: - case MEMCACHED_CONNECTION_UDP: - WATCHPOINT_ASSERT(0); - possible_rc= MEMCACHED_NOT_SUPPORTED; - break; - case MEMCACHED_CONNECTION_TCP: - possible_rc= tcp_connect(ptr, x); - break; - case MEMCACHED_CONNECTION_UNIX_SOCKET: - possible_rc= unix_socket_connect(ptr, x); - break; - } - rc= MEMCACHED_SUCCESS; - - if (possible_rc != MEMCACHED_SUCCESS) - rc= MEMCACHED_SOME_ERRORS; - } - } LIBMEMCACHED_MEMCACHED_CONNECT_END(); return rc;