X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=lib%2Fmemcached_connect.c;h=68b9c9398b82dc49d3ef6bee7dea479942dac5d7;hb=583fff6ac27c305e31e2b4b906f4e0702e26fee6;hp=516b5db346482e24500854deef4fbc0c4267aef5;hpb=a95ca4ad9c0f9d23c8a83bd337acdecc221021ef;p=awesomized%2Flibmemcached diff --git a/lib/memcached_connect.c b/lib/memcached_connect.c index 516b5db3..68b9c939 100644 --- a/lib/memcached_connect.c +++ b/lib/memcached_connect.c @@ -1,93 +1,179 @@ #include "common.h" -memcached_return memcached_server_add(memcached_st *ptr, char *hostname, unsigned int port) +#include +#include +#include +#include +#include +#include + +static memcached_return unix_socket_connect(memcached_st *ptr, unsigned int server_key) { - memcached_server_st *new_host_list; - char *new_hostname; - LIBMEMCACHED_MEMCACHED_SERVER_ADD_START(); + struct sockaddr_un servAddr; + socklen_t addrlen; - if (!port) - port= MEMCACHED_DEFAULT_PORT; + if (ptr->hosts[server_key].fd == -1) + { + if ((ptr->hosts[server_key].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->hosts[server_key].hostname); + + addrlen= strlen(servAddr.sun_path) + sizeof(servAddr.sun_family); + +test_connect: + if (connect(ptr->hosts[server_key].fd, (struct sockaddr *)&servAddr, sizeof(servAddr)) < 0) + { + 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: + ptr->cached_errno= errno; + return MEMCACHED_ERRNO; + } + ptr->connected++; + } + } + return MEMCACHED_SUCCESS; +} + +static memcached_return tcp_connect(memcached_st *ptr, unsigned int server_key) +{ + struct sockaddr_in servAddr; + struct hostent *h; - if (!hostname) - hostname= "localhost"; + 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) + { + ptr->cached_errno= h_errno; + return MEMCACHED_HOST_LOCKUP_FAILURE; + } - new_host_list= (memcached_server_st *)realloc(ptr->hosts, sizeof(memcached_server_st) * (ptr->number_of_hosts+1)); - if (!new_host_list) - return MEMCACHED_MEMORY_ALLOCATION_FAILURE; - memset(&new_host_list[ptr->number_of_hosts], 0, sizeof(memcached_server_st)); - - if (!new_host_list) - return MEMCACHED_MEMORY_ALLOCATION_FAILURE; + 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); - ptr->hosts= new_host_list; + /* Create the socket */ + if ((ptr->hosts[server_key].fd= socket(AF_INET, SOCK_STREAM, 0)) < 0) + { + ptr->cached_errno= errno; + return MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE; + } - new_hostname= - (char *)malloc(sizeof(char) * (strlen(hostname)+1)); - if (!new_hostname) - return MEMCACHED_MEMORY_ALLOCATION_FAILURE; + /* For the moment, not getting a nonblocking mode will note be fatal */ + if (ptr->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); + } - memset(new_hostname, 0, strlen(hostname)+1); - memcpy(new_hostname, hostname, strlen(hostname)); - ptr->hosts[ptr->number_of_hosts].hostname= new_hostname; - ptr->hosts[ptr->number_of_hosts].port= port; - ptr->hosts[ptr->number_of_hosts].fd= -1; - ptr->number_of_hosts++; + if (ptr->flags & MEM_TCP_NODELAY) + { + int flag= 1; - LIBMEMCACHED_MEMCACHED_SERVER_ADD_END(); + setsockopt(ptr->hosts[server_key].fd, IPPROTO_TCP, TCP_NODELAY, + &flag, (socklen_t)sizeof(int)); + } + + if (ptr->send_size) + { + setsockopt(ptr->hosts[server_key].fd, SOL_SOCKET, SO_SNDBUF, + &ptr->send_size, (socklen_t)sizeof(int)); + } + + if (ptr->recv_size) + { + setsockopt(ptr->hosts[server_key].fd, SOL_SOCKET, SO_SNDBUF, + &ptr->recv_size, (socklen_t)sizeof(int)); + } + + /* connect to server */ +test_connect: + if (connect(ptr->hosts[server_key].fd, (struct sockaddr *)&servAddr, sizeof(servAddr)) < 0) + { + 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: + ptr->cached_errno= errno; + return MEMCACHED_ERRNO; + } + ptr->connected++; + } + WATCHPOINT_ASSERT(ptr->hosts[server_key].stack_responses == 0); + } return MEMCACHED_SUCCESS; } -memcached_return memcached_connect(memcached_st *ptr) -{ - unsigned int x; - struct sockaddr_in localAddr, servAddr; - struct hostent *h; +memcached_return memcached_connect(memcached_st *ptr, unsigned int server_key) +{ + 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; - } - for (x= 0; x < ptr->number_of_hosts; x++) + /* We need to clean up the multi startup piece */ + if (server_key) + rc= tcp_connect(ptr, server_key); + else { - if (ptr->hosts[x].fd == -1) - { - if ((h= gethostbyname(ptr->hosts[x].hostname)) == NULL) - return MEMCACHED_HOST_LOCKUP_FAILURE; - - 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[x].port); - - /* Create the socket */ - if ((ptr->hosts[0].fd= socket(AF_INET, SOCK_STREAM, 0)) < 0) - return MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE; - + unsigned int x; - /* bind any port number */ - localAddr.sin_family = AF_INET; - localAddr.sin_addr.s_addr = htonl(INADDR_ANY); - localAddr.sin_port = htons(0); - - if (bind(ptr->hosts[0].fd, (struct sockaddr *) &localAddr, sizeof(localAddr)) < 0) - return(MEMCACHED_CONNECTION_BIND_FAILURE); - - /* connect to server */ - if (connect(ptr->hosts[0].fd, (struct sockaddr *) &servAddr, sizeof(servAddr)) < 0) - return MEMCACHED_HOST_LOCKUP_FAILURE; - - ptr->connected++; + for (x= 0; x < ptr->number_of_hosts; x++) + { + memcached_return possible_rc; + + possible_rc= MEMCACHED_NOT_SUPPORTED; /* Remove warning */ + + 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 MEMCACHED_SUCCESS; + return rc; }