git.m6w6.name Git - m6w6/libmemcached/blob - lib/memcached_connect.c

   1 #include "common.h"
   2
   3 static memcached_return set_hostinfo(memcached_server_st *server)
   4 {
   5   struct addrinfo *ai;
   6   struct addrinfo hints;
   7   int e;
   8   char str_port[NI_MAXSERV];
   9
  10   sprintf(str_port, "%u", server->port);
  11
  12   memset(&hints, 0, sizeof(hints));
  13   hints.ai_family= AF_INET;
  14   hints.ai_socktype= SOCK_STREAM;
  15   hints.ai_protocol= IPPROTO_TCP;
  16
  17   e= getaddrinfo(server->hostname, str_port, &hints, &ai);
  18   if (e != 0)
  19   {
  20     WATCHPOINT_STRING(server->hostname);
  21     WATCHPOINT_STRING(gai_strerror(e));
  22     return MEMCACHED_HOST_LOOKUP_FAILURE;
  23   }
  24
  25   if (server->address_info)
  26     freeaddrinfo(server->address_info);
  27   server->address_info= ai;
  28
  29   return MEMCACHED_SUCCESS;
  30 }
  31
  32 static memcached_return unix_socket_connect(memcached_st *ptr, unsigned int server_key)
  33 {
  34   struct sockaddr_un servAddr;
  35   socklen_t addrlen;
  36
  37   if (ptr->hosts[server_key].fd == -1)
  38   {
  39     if ((ptr->hosts[server_key].fd= socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
  40     {
  41       ptr->cached_errno= errno;
  42       return MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE;
  43     }
  44
  45     memset(&servAddr, 0, sizeof (struct sockaddr_un));
  46     servAddr.sun_family= AF_UNIX;
  47     strcpy(servAddr.sun_path, ptr->hosts[server_key].hostname); /* Copy filename */
  48
  49     addrlen= strlen(servAddr.sun_path) + sizeof(servAddr.sun_family);
  50
  51 test_connect:
  52     if (connect(ptr->hosts[server_key].fd,
  53                 (struct sockaddr *)&servAddr,
  54                 sizeof(servAddr)) < 0)
  55     {
  56       switch (errno) {
  57         /* We are spinning waiting on connect */
  58       case EALREADY:
  59       case EINPROGRESS:
  60       case EINTR:
  61         goto test_connect;
  62       case EISCONN: /* We were spinning waiting on connect */
  63         break;
  64       default:
  65         WATCHPOINT_ERRNO(errno);
  66         ptr->cached_errno= errno;
  67         return MEMCACHED_ERRNO;
  68       }
  69       ptr->connected++;
  70     }
  71   }
  72   return MEMCACHED_SUCCESS;
  73 }
  74
  75 static memcached_return udp_connect(memcached_st *ptr, unsigned int server_key)
  76 {
  77   if (ptr->hosts[server_key].fd == -1)
  78   {
  79     /* Old connection junk still is in the structure */
  80     WATCHPOINT_ASSERT(ptr->hosts[server_key].cursor_active == 0);
  81
  82     /*
  83       If we have not allocated the hosts object.
  84       Or if the cache has not been set.
  85     */
  86     if (ptr->hosts[server_key].sockaddr_inited == MEMCACHED_NOT_ALLOCATED ||
  87         (!(ptr->flags & MEM_USE_CACHE_LOOKUPS)))
  88     {
  89       memcached_return rc;
  90
  91       rc= set_hostinfo(&ptr->hosts[server_key]);
  92       if (rc != MEMCACHED_SUCCESS)
  93         return rc;
  94
  95       ptr->hosts[server_key].sockaddr_inited= MEMCACHED_ALLOCATED;
  96     }
  97
  98     /* Create the socket */
  99     if ((ptr->hosts[server_key].fd= socket(AF_INET, SOCK_DGRAM, 0)) < 0)
 100     {
 101       ptr->cached_errno= errno;
 102       return MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE;
 103     }
 104   }
 105
 106   return MEMCACHED_SUCCESS;
 107 }
 108
 109 static memcached_return tcp_connect(memcached_st *ptr, unsigned int server_key)
 110 {
 111   if (ptr->hosts[server_key].fd == -1)
 112   {
 113     struct addrinfo *use;
 114
 115     /* Old connection junk still is in the structure */
 116     WATCHPOINT_ASSERT(ptr->hosts[server_key].cursor_active == 0);
 117
 118     if (ptr->hosts[server_key].sockaddr_inited == MEMCACHED_NOT_ALLOCATED ||
 119         (!(ptr->flags & MEM_USE_CACHE_LOOKUPS)))
 120     {
 121       memcached_return rc;
 122
 123       rc= set_hostinfo(&ptr->hosts[server_key]);
 124       if (rc != MEMCACHED_SUCCESS)
 125         return rc;
 126       ptr->hosts[server_key].sockaddr_inited= MEMCACHED_ALLOCATED;
 127     }
 128     use= ptr->hosts[server_key].address_info;
 129
 130     /* Create the socket */
 131     if ((ptr->hosts[server_key].fd= socket(use->ai_family,
 132                                            use->ai_socktype,
 133                                            use->ai_protocol)) < 0)
 134     {
 135       ptr->cached_errno= errno;
 136       WATCHPOINT_ERRNO(errno);
 137       return MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE;
 138     }
 139
 140     if (ptr->flags & MEM_NO_BLOCK)
 141     {
 142       int error;
 143       struct linger linger;
 144       struct timeval waittime;
 145
 146       waittime.tv_sec= 10;
 147       waittime.tv_usec= 0;
 148
 149       linger.l_onoff= 1;
 150       linger.l_linger= MEMCACHED_DEFAULT_TIMEOUT;
 151       error= setsockopt(ptr->hosts[server_key].fd, SOL_SOCKET, SO_LINGER,
 152                         &linger, (socklen_t)sizeof(struct linger));
 153       WATCHPOINT_ASSERT(error == 0);
 154
 155       error= setsockopt(ptr->hosts[server_key].fd, SOL_SOCKET, SO_SNDTIMEO,
 156                         &waittime, (socklen_t)sizeof(struct timeval));
 157       WATCHPOINT_ASSERT(error == 0);
 158
 159       error= setsockopt(ptr->hosts[server_key].fd, SOL_SOCKET, SO_RCVTIMEO,
 160                         &waittime, (socklen_t)sizeof(struct timeval));
 161       WATCHPOINT_ASSERT(error == 0);
 162     }
 163
 164     if (ptr->flags & MEM_TCP_NODELAY)
 165     {
 166       int flag= 1;
 167       int error;
 168
 169       error= setsockopt(ptr->hosts[server_key].fd, IPPROTO_TCP, TCP_NODELAY,
 170                         &flag, (socklen_t)sizeof(int));
 171       WATCHPOINT_ASSERT(error == 0);
 172     }
 173
 174     if (ptr->send_size)
 175     {
 176       int error;
 177
 178       error= setsockopt(ptr->hosts[server_key].fd, SOL_SOCKET, SO_SNDBUF,
 179                         &ptr->send_size, (socklen_t)sizeof(int));
 180       WATCHPOINT_ASSERT(error == 0);
 181     }
 182
 183     if (ptr->recv_size)
 184     {
 185       int error;
 186
 187       error= setsockopt(ptr->hosts[server_key].fd, SOL_SOCKET, SO_SNDBUF,
 188                         &ptr->recv_size, (socklen_t)sizeof(int));
 189       WATCHPOINT_ASSERT(error == 0);
 190     }
 191
 192     /* For the moment, not getting a nonblocking mode will not be fatal */
 193     if (ptr->flags & MEM_NO_BLOCK)
 194     {
 195       int flags;
 196
 197       flags= fcntl(ptr->hosts[server_key].fd, F_GETFL, 0);
 198       if (flags != -1)
 199       {
 200         (void)fcntl(ptr->hosts[server_key].fd, F_SETFL, flags | O_NONBLOCK);
 201       }
 202     }
 203
 204
 205     /* connect to server */
 206 test_connect:
 207     if (connect(ptr->hosts[server_key].fd,
 208                 use->ai_addr,
 209                 use->ai_addrlen) < 0)
 210     {
 211       switch (errno) {
 212         /* We are spinning waiting on connect */
 213       case EALREADY:
 214       case EINPROGRESS:
 215       case EINTR:
 216         goto test_connect;
 217       case EISCONN: /* We were spinning waiting on connect */
 218         break;
 219       default:
 220         ptr->cached_errno= errno;
 221         WATCHPOINT_ASSERT(errno == ECONNREFUSED);
 222         WATCHPOINT_ERRNO(ptr->cached_errno);
 223         close(ptr->hosts[server_key].fd);
 224         ptr->hosts[server_key].fd= -1;
 225         return MEMCACHED_ERRNO;
 226       }
 227       ptr->connected++;
 228     }
 229
 230     WATCHPOINT_ASSERT(ptr->hosts[server_key].cursor_active == 0);
 231   }
 232
 233   return MEMCACHED_SUCCESS;
 234 }
 235
 236
 237 memcached_return memcached_connect(memcached_st *ptr, unsigned int server_key)
 238 {
 239   memcached_return rc= MEMCACHED_NO_SERVERS;
 240   LIBMEMCACHED_MEMCACHED_CONNECT_START();
 241
 242   if (ptr->connected == ptr->number_of_hosts && ptr->number_of_hosts)
 243     return MEMCACHED_SUCCESS;
 244
 245   if (ptr->hosts == NULL || ptr->number_of_hosts == 0)
 246     return MEMCACHED_NO_SERVERS;
 247
 248   /* We need to clean up the multi startup piece */
 249   switch (ptr->hosts[server_key].type)
 250   {
 251   case MEMCACHED_CONNECTION_UNKNOWN:
 252     WATCHPOINT_ASSERT(0);
 253     rc= MEMCACHED_NOT_SUPPORTED;
 254     break;
 255   case MEMCACHED_CONNECTION_UDP:
 256     rc= udp_connect(ptr, server_key);
 257     break;
 258   case MEMCACHED_CONNECTION_TCP:
 259     rc= tcp_connect(ptr, server_key);
 260     break;
 261   case MEMCACHED_CONNECTION_UNIX_SOCKET:
 262     rc= unix_socket_connect(ptr, server_key);
 263     break;
 264   }
 265
 266   if (rc != MEMCACHED_SUCCESS)
 267     WATCHPOINT_ERROR(rc);
 268
 269   LIBMEMCACHED_MEMCACHED_CONNECT_END();
 270
 271   return rc;
 272 }