X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=lib%2Fmemcached_connect.c;h=fffd2b88f34211101156545416cd35ef209997f1;hb=8d0cd77fc7bafd1f353bc7c50910b751766f931a;hp=116423cea9d98ce926f94684fb84e758a24f7aba;hpb=d6505b16fb85f77527934510d0395adfcbb66377;p=m6w6%2Flibmemcached diff --git a/lib/memcached_connect.c b/lib/memcached_connect.c index 116423ce..fffd2b88 100644 --- a/lib/memcached_connect.c +++ b/lib/memcached_connect.c @@ -3,38 +3,124 @@ #include #include #include +#include #include #include -memcached_return memcached_real_connect(memcached_st *ptr, unsigned int server_key) +static memcached_return set_hostinfo(memcached_server_st *server) { - struct sockaddr_in localAddr, servAddr; struct hostent *h; + if ((h= gethostbyname(server->hostname)) == NULL) + { + return MEMCACHED_HOST_LOCKUP_FAILURE; + } + + 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); + + return MEMCACHED_SUCCESS; +} + +static memcached_return unix_socket_connect(memcached_st *ptr, unsigned int server_key) +{ + struct sockaddr_un servAddr; + socklen_t addrlen; + if (ptr->hosts[server_key].fd == -1) { - if ((h= gethostbyname(ptr->hosts[server_key].hostname)) == NULL) + if ((ptr->hosts[server_key].fd= socket(AF_UNIX, SOCK_STREAM, 0)) < 0) { - ptr->my_errno= h_errno; - return MEMCACHED_HOST_LOCKUP_FAILURE; + 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); /* 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) + { + 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; +} - 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); +static memcached_return udp_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 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))) + { + memcached_return rc; + + rc= set_hostinfo(&ptr->hosts[server_key]); + if (rc != MEMCACHED_SUCCESS) + return rc; + + ptr->hosts[server_key].sockaddr_inited= MEMCACHED_ALLOCATED; + } /* Create the socket */ - if ((ptr->hosts[server_key].fd= socket(AF_INET, SOCK_STREAM, 0)) < 0) + if ((ptr->hosts[server_key].fd= socket(AF_INET, SOCK_DGRAM, 0)) < 0) { - ptr->my_errno= errno; + 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); - /* bind any port number */ - localAddr.sin_family = AF_INET; - localAddr.sin_addr.s_addr = htonl(INADDR_ANY); - localAddr.sin_port = htons(0); + if (ptr->hosts[server_key].servAddr.sin_family == 0) + { + memcached_return rc; + + rc= set_hostinfo(&ptr->hosts[server_key]); + if (rc != MEMCACHED_SUCCESS) + return rc; + } + + /* 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; + } /* For the moment, not getting a nonblocking mode will note be fatal */ if (ptr->flags & MEM_NO_BLOCK) @@ -54,9 +140,23 @@ memcached_return memcached_real_connect(memcached_st *ptr, unsigned int server_k &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) + if (connect(ptr->hosts[server_key].fd, + (struct sockaddr *)&ptr->hosts[server_key].servAddr, + sizeof(struct sockaddr)) < 0) { switch (errno) { /* We are spinning waiting on connect */ @@ -67,11 +167,12 @@ test_connect: case EISCONN: /* We were spinning waiting on connect */ break; default: - ptr->my_errno= errno; + ptr->cached_errno= errno; return MEMCACHED_ERRNO; } ptr->connected++; } + WATCHPOINT_ASSERT(ptr->hosts[server_key].stack_responses == 0); } return MEMCACHED_SUCCESS; @@ -80,24 +181,67 @@ test_connect: memcached_return memcached_connect(memcached_st *ptr, unsigned int server_key) { - memcached_return rc; + memcached_return rc= MEMCACHED_NO_SERVERS; LIBMEMCACHED_MEMCACHED_CONNECT_START(); - if (ptr->connected == ptr->number_of_hosts) + if (ptr->connected == ptr->number_of_hosts && ptr->number_of_hosts) return MEMCACHED_SUCCESS; - if (!ptr->hosts) + if (ptr->hosts == NULL || ptr->number_of_hosts == 0) return MEMCACHED_NO_SERVERS; /* We need to clean up the multi startup piece */ if (server_key) - rc= memcached_real_connect(ptr, server_key); + { + rc= tcp_connect(ptr, server_key); + switch (ptr->hosts[server_key].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); + break; + case MEMCACHED_CONNECTION_UNIX_SOCKET: + rc= unix_socket_connect(ptr, server_key); + break; + } + } else { unsigned int x; for (x= 0; x < ptr->number_of_hosts; x++) - rc= memcached_real_connect(ptr, x); + { + memcached_return possible_rc; + + possible_rc= MEMCACHED_NOT_SUPPORTED; /* Remove warning */ + + switch (ptr->hosts[x].type) + { + case MEMCACHED_CONNECTION_UNKNOWN: + WATCHPOINT_ASSERT(0); + possible_rc= MEMCACHED_NOT_SUPPORTED; + break; + case MEMCACHED_CONNECTION_UDP: + possible_rc= udp_connect(ptr, x); + 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();