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

   1 #include "common.h"
   2 #include <netdb.h>
   3 #include <poll.h>
   4 #include <sys/time.h>
   5
   6 static memcached_return set_hostinfo(memcached_server_st *server)
   7 {
   8   struct addrinfo *ai;
   9   struct addrinfo hints;
  10   int e;
  11   char str_port[NI_MAXSERV];
  12
  13   sprintf(str_port, "%u", server->port);
  14
  15   memset(&hints, 0, sizeof(hints));
  16
  17  // hints.ai_family= AF_INET;
  18   if (server->type == MEMCACHED_CONNECTION_UDP)
  19   {
  20     hints.ai_protocol= IPPROTO_UDP;
  21     hints.ai_socktype= SOCK_DGRAM;
  22   }
  23   else
  24   {
  25     hints.ai_socktype= SOCK_STREAM;
  26     hints.ai_protocol= IPPROTO_TCP;
  27   }
  28
  29   e= getaddrinfo(server->hostname, str_port, &hints, &ai);
  30   if (e != 0)
  31   {
  32     WATCHPOINT_STRING(server->hostname);
  33     WATCHPOINT_STRING(gai_strerror(e));
  34     return MEMCACHED_HOST_LOOKUP_FAILURE;
  35   }
  36
  37   if (server->address_info)
  38   {
  39     freeaddrinfo(server->address_info);
  40     server->address_info= NULL;
  41   }
  42   server->address_info= ai;
  43
  44   return MEMCACHED_SUCCESS;
  45 }
  46
  47 static memcached_return set_socket_options(memcached_server_st *ptr)
  48 {
  49   WATCHPOINT_ASSERT(ptr->fd != -1);
  50
  51   if (ptr->type == MEMCACHED_CONNECTION_UDP)
  52     return MEMCACHED_SUCCESS;
  53
  54 #ifdef HAVE_SNDTIMEO
  55   if (ptr->root->snd_timeout)
  56   {
  57     int error;
  58     struct timeval waittime;
  59
  60     waittime.tv_sec= 0;
  61     waittime.tv_usec= ptr->root->snd_timeout;
  62
  63     error= setsockopt(ptr->fd, SOL_SOCKET, SO_SNDTIMEO,
  64                       &waittime, (socklen_t)sizeof(struct timeval));
  65     WATCHPOINT_ASSERT(error == 0);
  66   }
  67 #endif
  68
  69 #ifdef HAVE_RCVTIMEO
  70   if (ptr->root->rcv_timeout)
  71   {
  72     int error;
  73     struct timeval waittime;
  74
  75     waittime.tv_sec= 0;
  76     waittime.tv_usec= ptr->root->rcv_timeout;
  77
  78     error= setsockopt(ptr->fd, SOL_SOCKET, SO_RCVTIMEO,
  79                       &waittime, (socklen_t)sizeof(struct timeval));
  80     WATCHPOINT_ASSERT(error == 0);
  81   }
  82 #endif
  83
  84   {
  85     int error;
  86     struct linger linger;
  87
  88     linger.l_onoff= 1;
  89     linger.l_linger= MEMCACHED_DEFAULT_TIMEOUT;
  90     error= setsockopt(ptr->fd, SOL_SOCKET, SO_LINGER,
  91                       &linger, (socklen_t)sizeof(struct linger));
  92     WATCHPOINT_ASSERT(error == 0);
  93   }
  94
  95   if (ptr->root->flags & MEM_TCP_NODELAY)
  96   {
  97     int flag= 1;
  98     int error;
  99
 100     error= setsockopt(ptr->fd, IPPROTO_TCP, TCP_NODELAY,
 101                       &flag, (socklen_t)sizeof(int));
 102     WATCHPOINT_ASSERT(error == 0);
 103   }
 104
 105   if (ptr->root->send_size)
 106   {
 107     int error;
 108
 109     error= setsockopt(ptr->fd, SOL_SOCKET, SO_SNDBUF,
 110                       &ptr->root->send_size, (socklen_t)sizeof(int));
 111     WATCHPOINT_ASSERT(error == 0);
 112   }
 113
 114   if (ptr->root->recv_size)
 115   {
 116     int error;
 117
 118     error= setsockopt(ptr->fd, SOL_SOCKET, SO_RCVBUF,
 119                       &ptr->root->recv_size, (socklen_t)sizeof(int));
 120     WATCHPOINT_ASSERT(error == 0);
 121   }
 122
 123   /* For the moment, not getting a nonblocking mode will not be fatal */
 124   if ((ptr->root->flags & MEM_NO_BLOCK) || ptr->root->connect_timeout)
 125   {
 126     int flags;
 127
 128     flags= fcntl(ptr->fd, F_GETFL, 0);
 129     unlikely (flags != -1)
 130     {
 131       (void)fcntl(ptr->fd, F_SETFL, flags | O_NONBLOCK);
 132     }
 133   }
 134
 135   return MEMCACHED_SUCCESS;
 136 }
 137
 138 static memcached_return unix_socket_connect(memcached_server_st *ptr)
 139 {
 140   struct sockaddr_un servAddr;
 141   socklen_t addrlen;
 142
 143   if (ptr->fd == -1)
 144   {
 145     if ((ptr->fd= socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
 146     {
 147       ptr->cached_errno= errno;
 148       return MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE;
 149     }
 150
 151     memset(&servAddr, 0, sizeof (struct sockaddr_un));
 152     servAddr.sun_family= AF_UNIX;
 153     strcpy(servAddr.sun_path, ptr->hostname); /* Copy filename */
 154
 155     addrlen= strlen(servAddr.sun_path) + sizeof(servAddr.sun_family);
 156
 157 test_connect:
 158     if (connect(ptr->fd,
 159                 (struct sockaddr *)&servAddr,
 160                 sizeof(servAddr)) < 0)
 161     {
 162       switch (errno)
 163       {
 164       case EINPROGRESS:
 165       case EALREADY:
 166       case EINTR:
 167         goto test_connect;
 168       case EISCONN: /* We were spinning waiting on connect */
 169         break;
 170       default:
 171         WATCHPOINT_ERRNO(errno);
 172         ptr->cached_errno= errno;
 173         return MEMCACHED_ERRNO;
 174       }
 175     }
 176   }
 177
 178   WATCHPOINT_ASSERT(ptr->fd != -1);
 179   return MEMCACHED_SUCCESS;
 180 }
 181
 182 static memcached_return network_connect(memcached_server_st *ptr)
 183 {
 184   if (ptr->fd == -1)
 185   {
 186     struct addrinfo *use;
 187
 188     if (!ptr->sockaddr_inited ||
 189         (!(ptr->root->flags & MEM_USE_CACHE_LOOKUPS)))
 190     {
 191       memcached_return rc;
 192
 193       rc= set_hostinfo(ptr);
 194       if (rc != MEMCACHED_SUCCESS)
 195         return rc;
 196       ptr->sockaddr_inited= true;
 197     }
 198
 199     use= ptr->address_info;
 200     /* Create the socket */
 201     while (use != NULL)
 202     {
 203       /* Memcache server does not support IPV6 in udp mode, so skip if not ipv4 */
 204       if (ptr->type == MEMCACHED_CONNECTION_UDP && use->ai_family != AF_INET)
 205       {
 206         use= use->ai_next;
 207         continue;
 208       }
 209
 210       if ((ptr->fd= socket(use->ai_family,
 211                            use->ai_socktype,
 212                            use->ai_protocol)) < 0)
 213       {
 214         ptr->cached_errno= errno;
 215         WATCHPOINT_ERRNO(errno);
 216         return MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE;
 217       }
 218
 219       (void)set_socket_options(ptr);
 220
 221       int flags= 0;
 222       if (ptr->root->connect_timeout)
 223       {
 224         flags= fcntl(ptr->fd, F_GETFL, 0);
 225         if (flags != -1 && !(flags & O_NONBLOCK))
 226           (void)fcntl(ptr->fd, F_SETFL, flags | O_NONBLOCK);
 227       }
 228
 229       /* connect to server */
 230       while (ptr->fd != -1 &&
 231              connect(ptr->fd, use->ai_addr, use->ai_addrlen) < 0)
 232       {
 233         ptr->cached_errno= errno;
 234         if (errno == EINPROGRESS || /* nonblocking mode - first return, */
 235             errno == EALREADY) /* nonblocking mode - subsequent returns */
 236         {
 237           struct pollfd fds[1];
 238           fds[0].fd = ptr->fd;
 239           fds[0].events = POLLOUT;
 240           int error= poll(fds, 1, ptr->root->connect_timeout);
 241
 242           if (error != 1 || fds[0].revents & POLLERR)
 243           {
 244             if (fds[0].revents & POLLERR)
 245             {
 246               int err;
 247               socklen_t len = sizeof (err);
 248               (void)getsockopt(ptr->fd, SOL_SOCKET, SO_ERROR, &err, &len);
 249               ptr->cached_errno= (err == 0) ? errno : err;
 250             }
 251
 252             (void)close(ptr->fd);
 253             ptr->fd= -1;
 254           }
 255         }
 256         else if (errno == EISCONN) /* we are connected :-) */
 257         {
 258           break;
 259         }
 260         else if (errno != EINTR)
 261         {
 262           (void)close(ptr->fd);
 263           ptr->fd= -1;
 264           break;
 265         }
 266       }
 267
 268       if (ptr->fd != -1)
 269       {
 270         /* restore flags */
 271         if (ptr->root->connect_timeout && (ptr->root->flags & MEM_NO_BLOCK) == 0)
 272           (void)fcntl(ptr->fd, F_SETFL, flags & ~O_NONBLOCK);
 273
 274         WATCHPOINT_ASSERT(ptr->cursor_active == 0);
 275         ptr->server_failure_counter= 0;
 276         return MEMCACHED_SUCCESS;
 277       }
 278       use = use->ai_next;
 279     }
 280   }
 281
 282   if (ptr->fd == -1)
 283   {
 284     /* Failed to connect. schedule next retry */
 285     if (ptr->root->retry_timeout)
 286     {
 287       struct timeval next_time;
 288
 289       if (gettimeofday(&next_time, NULL) == 0)
 290         ptr->next_retry= next_time.tv_sec + ptr->root->retry_timeout;
 291     }
 292     ptr->server_failure_counter+= 1;
 293     if (ptr->cached_errno == 0)
 294       return MEMCACHED_TIMEOUT;
 295     return MEMCACHED_ERRNO; /* The last error should be from connect() */
 296   }
 297
 298   ptr->server_failure_counter= 0;
 299   return MEMCACHED_SUCCESS; /* The last error should be from connect() */
 300 }
 301
 302
 303 memcached_return memcached_connect(memcached_server_st *ptr)
 304 {
 305   memcached_return rc= MEMCACHED_NO_SERVERS;
 306   LIBMEMCACHED_MEMCACHED_CONNECT_START();
 307
 308   /* both retry_timeout and server_failure_limit must be set in order to delay retrying a server on error. */
 309   WATCHPOINT_ASSERT(ptr->root);
 310   if (ptr->root->retry_timeout && ptr->root->server_failure_limit)
 311   {
 312     struct timeval next_time;
 313
 314     gettimeofday(&next_time, NULL);
 315
 316     /* if we've had too many consecutive errors on this server, mark it dead. */
 317     if (ptr->server_failure_counter > ptr->root->server_failure_limit)
 318     {
 319       ptr->next_retry= next_time.tv_sec + ptr->root->retry_timeout;
 320       ptr->server_failure_counter= 0;
 321     }
 322
 323     if (next_time.tv_sec < ptr->next_retry)
 324     {
 325       if (memcached_behavior_get(ptr->root, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS))
 326         run_distribution(ptr->root);
 327
 328       return MEMCACHED_SERVER_MARKED_DEAD;
 329     }
 330   }
 331
 332   /* We need to clean up the multi startup piece */
 333   switch (ptr->type)
 334   {
 335   case MEMCACHED_CONNECTION_UNKNOWN:
 336     WATCHPOINT_ASSERT(0);
 337     rc= MEMCACHED_NOT_SUPPORTED;
 338     break;
 339   case MEMCACHED_CONNECTION_UDP:
 340   case MEMCACHED_CONNECTION_TCP:
 341     rc= network_connect(ptr);
 342     break;
 343   case MEMCACHED_CONNECTION_UNIX_SOCKET:
 344     rc= unix_socket_connect(ptr);
 345     break;
 346   default:
 347     WATCHPOINT_ASSERT(0);
 348   }
 349
 350   LIBMEMCACHED_MEMCACHED_CONNECT_END();
 351
 352   return rc;
 353 }