git.m6w6.name Git - awesomized/libmemcached/blob - libmemcached/connect.cc

   1 /*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
   2  *
   3  *  Libmemcached library
   4  *
   5  *  Copyright (C) 2011 Data Differential, http://datadifferential.com/
   6  *  Copyright (C) 2006-2010 Brian Aker All rights reserved.
   7  *
   8  *  Redistribution and use in source and binary forms, with or without
   9  *  modification, are permitted provided that the following conditions are
  10  *  met:
  11  *
  12  *      * Redistributions of source code must retain the above copyright
  13  *  notice, this list of conditions and the following disclaimer.
  14  *
  15  *      * Redistributions in binary form must reproduce the above
  16  *  copyright notice, this list of conditions and the following disclaimer
  17  *  in the documentation and/or other materials provided with the
  18  *  distribution.
  19  *
  20  *      * The names of its contributors may not be used to endorse or
  21  *  promote products derived from this software without specific prior
  22  *  written permission.
  23  *
  24  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  25  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  26  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  27  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  28  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  29  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  30  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  31  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  32  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  33  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  34  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  35  *
  36  */
  37
  38
  39 #include <libmemcached/common.h>
  40
  41 #include <cassert>
  42
  43 #ifndef SOCK_CLOEXEC
  44 #  define SOCK_CLOEXEC 0
  45 #endif
  46
  47 #ifndef SOCK_NONBLOCK
  48 # define SOCK_NONBLOCK 0
  49 #endif
  50
  51 #ifndef FD_CLOEXEC
  52 # define FD_CLOEXEC 0
  53 #endif
  54
  55 #ifndef SO_NOSIGPIPE
  56 # define SO_NOSIGPIPE 0
  57 #endif
  58
  59 #ifndef TCP_NODELAY
  60 # define TCP_NODELAY 0
  61 #endif
  62
  63 #ifndef TCP_KEEPIDLE
  64 # define TCP_KEEPIDLE 0
  65 #endif
  66
  67 static memcached_return_t connect_poll(memcached_instance_st* server, const int connection_error)
  68 {
  69   struct pollfd fds[1];
  70   fds[0].fd= server->fd;
  71   fds[0].events= server->events();
  72   fds[0].revents= 0;
  73
  74   size_t loop_max= 5;
  75
  76   if (server->root->poll_timeout == 0)
  77   {
  78     return memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT,
  79                                memcached_literal_param("The time to wait for a connection to be established was set to zero which produces a timeout to every call to poll()."));
  80   }
  81
  82   while (--loop_max) // Should only loop on cases of ERESTART or EINTR
  83   {
  84     int number_of;
  85     if ((number_of= poll(fds, 1, server->root->connect_timeout)) == -1)
  86     {
  87       int local_errno= get_socket_errno(); // We cache in case closesocket() modifies errno
  88       switch (local_errno)
  89       {
  90 #ifdef __linux__
  91       case ERESTART:
  92 #endif
  93       case EINTR:
  94         continue;
  95
  96       case EFAULT:
  97       case ENOMEM:
  98         return memcached_set_error(*server, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT);
  99
 100       case EINVAL:
 101         return memcached_set_error(*server, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT,
 102                                    memcached_literal_param("RLIMIT_NOFILE exceeded, or if OSX the timeout value was invalid"));
 103
 104       default: // This should not happen
 105         break;
 106       }
 107
 108       assert_msg(server->fd != INVALID_SOCKET, "poll() was passed an invalid file descriptor");
 109       server->reset_socket();
 110       server->state= MEMCACHED_SERVER_STATE_NEW;
 111
 112       return memcached_set_errno(*server, local_errno, MEMCACHED_AT);
 113     }
 114
 115     if (number_of == 0)
 116     {
 117       if (connection_error == EINPROGRESS)
 118       {
 119         int err;
 120         socklen_t len= sizeof(err);
 121         if (getsockopt(server->fd, SOL_SOCKET, SO_ERROR, (char*)&err, &len) == -1)
 122         {
 123           return memcached_set_errno(*server, errno, MEMCACHED_AT, memcached_literal_param("getsockopt() error'ed while looking for error connect_poll(EINPROGRESS)"));
 124         }
 125
 126         // If Zero, my hero, we just fail to a generic MEMCACHED_TIMEOUT error
 127         if (err != 0)
 128         {
 129           return memcached_set_errno(*server, err, MEMCACHED_AT, memcached_literal_param("getsockopt() found the error from poll() after connect() returned EINPROGRESS."));
 130         }
 131       }
 132
 133       return  memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT, memcached_literal_param("(number_of == 0)"));
 134     }
 135
 136     assert (number_of == 1);
 137
 138     if (fds[0].revents & POLLERR or
 139         fds[0].revents & POLLHUP or
 140         fds[0].revents & POLLNVAL)
 141     {
 142       int err;
 143       socklen_t len= sizeof (err);
 144       if (getsockopt(fds[0].fd, SOL_SOCKET, SO_ERROR, (char*)&err, &len) == -1)
 145       {
 146         return memcached_set_errno(*server, errno, MEMCACHED_AT, memcached_literal_param("getsockopt() errored while looking up error state from poll()"));
 147       }
 148
 149       // We check the value to see what happened wth the socket.
 150       if (err == 0) // Should not happen
 151       {
 152         return MEMCACHED_SUCCESS;
 153       }
 154       errno= err;
 155
 156       return memcached_set_errno(*server, err, MEMCACHED_AT, memcached_literal_param("getsockopt() found the error from poll() during connect."));
 157     }
 158     assert(fds[0].revents & POLLOUT);
 159
 160     if (fds[0].revents & POLLOUT and connection_error == EINPROGRESS)
 161     {
 162       int err;
 163       socklen_t len= sizeof(err);
 164       if (getsockopt(server->fd, SOL_SOCKET, SO_ERROR, (char*)&err, &len) == -1)
 165       {
 166         return memcached_set_errno(*server, errno, MEMCACHED_AT);
 167       }
 168
 169       if (err == 0)
 170       {
 171         return MEMCACHED_SUCCESS;
 172       }
 173
 174       return memcached_set_errno(*server, err, MEMCACHED_AT, memcached_literal_param("getsockopt() found the error from poll() after connect() returned EINPROGRESS."));
 175     }
 176
 177     break; // We only have the loop setup for errno types that require restart
 178   }
 179
 180   // This should only be possible from ERESTART or EINTR;
 181   return memcached_set_errno(*server, connection_error, MEMCACHED_AT, memcached_literal_param("connect_poll() was exhausted"));
 182 }
 183
 184 static memcached_return_t set_hostinfo(memcached_instance_st* server)
 185 {
 186   assert(server->type != MEMCACHED_CONNECTION_UNIX_SOCKET);
 187   server->clear_addrinfo();
 188
 189   char str_port[MEMCACHED_NI_MAXSERV]= { 0 };
 190   errno= 0;
 191   int length= snprintf(str_port, MEMCACHED_NI_MAXSERV, "%u", uint32_t(server->port()));
 192   if (length >= MEMCACHED_NI_MAXSERV or length <= 0 or errno != 0)
 193   {
 194     return memcached_set_error(*server, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT,
 195                                memcached_literal_param("snprintf(NI_MAXSERV)"));
 196   }
 197
 198   struct addrinfo hints;
 199   memset(&hints, 0, sizeof(struct addrinfo));
 200
 201   hints.ai_family= AF_UNSPEC;
 202   if (memcached_is_udp(server->root))
 203   {
 204     hints.ai_protocol= IPPROTO_UDP;
 205     hints.ai_socktype= SOCK_DGRAM;
 206   }
 207   else
 208   {
 209     hints.ai_socktype= SOCK_STREAM;
 210     hints.ai_protocol= IPPROTO_TCP;
 211   }
 212
 213   assert(server->address_info == NULL);
 214   assert(server->address_info_next == NULL);
 215   int errcode;
 216   assert(server->hostname());
 217   switch(errcode= getaddrinfo(server->hostname(), str_port, &hints, &server->address_info))
 218   {
 219   case 0:
 220     server->address_info_next= server->address_info;
 221     server->state= MEMCACHED_SERVER_STATE_ADDRINFO;
 222     break;
 223
 224   case EAI_AGAIN:
 225     return memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT, memcached_string_make_from_cstr(gai_strerror(errcode)));
 226
 227   case EAI_SYSTEM:
 228     server->clear_addrinfo();
 229     return memcached_set_errno(*server, errno, MEMCACHED_AT, memcached_literal_param("getaddrinfo(EAI_SYSTEM)"));
 230
 231   case EAI_BADFLAGS:
 232     server->clear_addrinfo();
 233     return memcached_set_error(*server, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT, memcached_literal_param("getaddrinfo(EAI_BADFLAGS)"));
 234
 235   case EAI_MEMORY:
 236     server->clear_addrinfo();
 237     return memcached_set_error(*server, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT, memcached_literal_param("getaddrinfo(EAI_MEMORY)"));
 238
 239   default:
 240     {
 241       server->clear_addrinfo();
 242       return memcached_set_error(*server, MEMCACHED_HOST_LOOKUP_FAILURE, MEMCACHED_AT, memcached_string_make_from_cstr(gai_strerror(errcode)));
 243     }
 244   }
 245
 246   return MEMCACHED_SUCCESS;
 247 }
 248
 249 static inline void set_socket_nonblocking(memcached_instance_st* server)
 250 {
 251 #if defined(_WIN32)
 252   u_long arg= 1;
 253   if (ioctlsocket(server->fd, FIONBIO, &arg) == SOCKET_ERROR)
 254   {
 255     memcached_set_errno(*server, get_socket_errno(), NULL);
 256   }
 257 #else
 258   int flags;
 259
 260   if (SOCK_NONBLOCK == 0)
 261   {
 262     do
 263     {
 264       flags= fcntl(server->fd, F_GETFL, 0);
 265     } while (flags == -1 && (errno == EINTR || errno == EAGAIN));
 266
 267     if (flags == -1)
 268     {
 269       memcached_set_errno(*server, errno, NULL);
 270     }
 271     else if ((flags & O_NONBLOCK) == 0)
 272     {
 273       int rval;
 274
 275       do
 276       {
 277         rval= fcntl(server->fd, F_SETFL, flags | O_NONBLOCK);
 278       } while (rval == -1 && (errno == EINTR or errno == EAGAIN));
 279
 280       if (rval == -1)
 281       {
 282         memcached_set_errno(*server, errno, NULL);
 283       }
 284     }
 285   }
 286 #endif
 287 }
 288
 289 static bool set_socket_options(memcached_instance_st* server)
 290 {
 291   assert_msg(server->fd != INVALID_SOCKET, "invalid socket was passed to set_socket_options()");
 292
 293 #ifdef HAVE_FCNTL
 294   // If SOCK_CLOEXEC exists then we don't need to call the following
 295   if (SOCK_CLOEXEC == 0)
 296   {
 297     if (FD_CLOEXEC != 0)
 298     {
 299       int flags;
 300       do
 301       {
 302         flags= fcntl(server->fd, F_GETFD, 0);
 303       } while (flags == -1 and (errno == EINTR or errno == EAGAIN));
 304
 305       if (flags != -1)
 306       {
 307         int rval;
 308         do
 309         {
 310           rval= fcntl (server->fd, F_SETFD, flags | FD_CLOEXEC);
 311         } while (rval == -1 && (errno == EINTR or errno == EAGAIN));
 312         // we currently ignore the case where rval is -1
 313       }
 314     }
 315   }
 316 #endif
 317
 318   if (memcached_is_udp(server->root))
 319   {
 320     return true;
 321   }
 322
 323 #ifdef HAVE_SNDTIMEO
 324   if (server->root->snd_timeout > 0)
 325   {
 326     struct timeval waittime;
 327
 328     waittime.tv_sec= server->root->snd_timeout / 1000000;
 329     waittime.tv_usec= server->root->snd_timeout % 1000000;
 330
 331     int error= setsockopt(server->fd, SOL_SOCKET, SO_SNDTIMEO,
 332                           (char*)&waittime, (socklen_t)sizeof(struct timeval));
 333     (void)error;
 334     assert(error == 0);
 335   }
 336 #endif
 337
 338 #ifdef HAVE_RCVTIMEO
 339   if (server->root->rcv_timeout > 0)
 340   {
 341     struct timeval waittime;
 342
 343     waittime.tv_sec= server->root->rcv_timeout / 1000000;
 344     waittime.tv_usec= server->root->rcv_timeout % 1000000;
 345
 346     int error= setsockopt(server->fd, SOL_SOCKET, SO_RCVTIMEO,
 347                           (char*)&waittime, (socklen_t)sizeof(struct timeval));
 348     (void)(error);
 349     assert(error == 0);
 350   }
 351 #endif
 352
 353
 354 #if defined(_WIN32)
 355 #else
 356 # if defined(SO_NOSIGPIPE)
 357   if (SO_NOSIGPIPE)
 358   {
 359     int set= 1;
 360     int error= setsockopt(server->fd, SOL_SOCKET, SO_NOSIGPIPE, (void *)&set, sizeof(int));
 361
 362     assert(error == 0);
 363
 364     // This is not considered a fatal error
 365     if (error == -1)
 366     {
 367 #if 0
 368       perror("setsockopt(SO_NOSIGPIPE)");
 369 #endif
 370     }
 371   }
 372 # endif // SO_NOSIGPIPE
 373 #endif // _WIN32
 374
 375   if (server->root->flags.no_block)
 376   {
 377     struct linger linger;
 378
 379     linger.l_onoff= 1;
 380     linger.l_linger= 0; /* By default on close() just drop the socket */
 381     int error= setsockopt(server->fd, SOL_SOCKET, SO_LINGER,
 382                           (char*)&linger, (socklen_t)sizeof(struct linger));
 383     (void)(error);
 384     assert(error == 0);
 385   }
 386
 387   if (TCP_NODELAY)
 388   {
 389     if (server->root->flags.tcp_nodelay)
 390     {
 391       int flag= 1;
 392
 393       int error= setsockopt(server->fd, IPPROTO_TCP, TCP_NODELAY,
 394                             (char*)&flag, (socklen_t)sizeof(int));
 395       (void)(error);
 396       assert(error == 0);
 397     }
 398   }
 399
 400   if (server->root->flags.tcp_keepalive)
 401   {
 402     int flag= 1;
 403
 404     int error= setsockopt(server->fd, SOL_SOCKET, SO_KEEPALIVE,
 405                           (char*)&flag, (socklen_t)sizeof(int));
 406     (void)(error);
 407     assert(error == 0);
 408   }
 409
 410   if (TCP_KEEPIDLE)
 411   {
 412     if (server->root->tcp_keepidle > 0)
 413     {
 414       int error= setsockopt(server->fd, IPPROTO_TCP, TCP_KEEPIDLE,
 415                             (char*)&server->root->tcp_keepidle, (socklen_t)sizeof(int));
 416       (void)(error);
 417       assert(error == 0);
 418     }
 419   }
 420
 421   if (server->root->send_size > 0)
 422   {
 423     int error= setsockopt(server->fd, SOL_SOCKET, SO_SNDBUF,
 424                           (char*)&server->root->send_size, (socklen_t)sizeof(int));
 425     (void)(error);
 426     assert(error == 0);
 427   }
 428
 429   if (server->root->recv_size > 0)
 430   {
 431     int error= setsockopt(server->fd, SOL_SOCKET, SO_RCVBUF,
 432                           (char*)&server->root->recv_size, (socklen_t)sizeof(int));
 433     (void)(error);
 434     assert(error == 0);
 435   }
 436
 437   /* libmemcached will always use nonblocking IO to avoid write deadlocks */
 438   set_socket_nonblocking(server);
 439
 440   return true;
 441 }
 442
 443 static memcached_return_t unix_socket_connect(memcached_instance_st* server)
 444 {
 445 #ifndef _WIN32
 446   WATCHPOINT_ASSERT(server->fd == INVALID_SOCKET);
 447
 448   do {
 449     int type= SOCK_STREAM;
 450     if (SOCK_CLOEXEC != 0)
 451     {
 452       type|= SOCK_CLOEXEC;
 453     }
 454
 455     if (SOCK_NONBLOCK != 0)
 456     {
 457       type|= SOCK_NONBLOCK;
 458     }
 459
 460     if ((server->fd= socket(AF_UNIX, type, 0)) == -1)
 461     {
 462       return memcached_set_errno(*server, errno, NULL);
 463     }
 464
 465     struct sockaddr_un servAddr;
 466
 467     memset(&servAddr, 0, sizeof (struct sockaddr_un));
 468     servAddr.sun_family= AF_UNIX;
 469     strncpy(servAddr.sun_path, server->hostname(), sizeof(servAddr.sun_path)); /* Copy filename */
 470
 471     if (connect(server->fd, (struct sockaddr *)&servAddr, sizeof(servAddr)) == -1)
 472     {
 473       switch (errno)
 474       {
 475       case EINPROGRESS:
 476       case EALREADY:
 477         server->events(POLLOUT);
 478         break;
 479
 480       case EINTR:
 481         server->reset_socket();
 482         continue;
 483
 484       case EISCONN: /* We were spinning waiting on connect */
 485         {
 486           assert(0); // Programmer error
 487           server->reset_socket();
 488           continue;
 489         }
 490
 491       default:
 492         WATCHPOINT_ERRNO(errno);
 493         server->reset_socket();
 494         return memcached_set_errno(*server, errno, MEMCACHED_AT);
 495       }
 496     }
 497   } while (0);
 498   server->state= MEMCACHED_SERVER_STATE_CONNECTED;
 499
 500   WATCHPOINT_ASSERT(server->fd != INVALID_SOCKET);
 501
 502   return MEMCACHED_SUCCESS;
 503 #else
 504   (void)server;
 505   return MEMCACHED_NOT_SUPPORTED;
 506 #endif
 507 }
 508
 509 static memcached_return_t network_connect(memcached_instance_st* server)
 510 {
 511   bool timeout_error_occured= false;
 512
 513   WATCHPOINT_ASSERT(server->fd == INVALID_SOCKET);
 514   WATCHPOINT_ASSERT(server->cursor_active_ == 0);
 515
 516   /*
 517     We want to check both of these because if address_info_next has been fully tried, we want to do a new lookup to make sure we have picked up on any new DNS information.
 518   */
 519   if (server->address_info == NULL or server->address_info_next == NULL)
 520   {
 521     WATCHPOINT_ASSERT(server->state == MEMCACHED_SERVER_STATE_NEW);
 522     server->address_info_next= NULL;
 523     memcached_return_t rc= set_hostinfo(server);
 524
 525     if (memcached_failed(rc))
 526     {
 527       return rc;
 528     }
 529   }
 530
 531   assert(server->address_info_next);
 532   assert(server->address_info);
 533
 534   /* Create the socket */
 535   while (server->address_info_next and server->fd == INVALID_SOCKET)
 536   {
 537     /* Memcache server does not support IPV6 in udp mode, so skip if not ipv4 */
 538     if (memcached_is_udp(server->root) and server->address_info_next->ai_family != AF_INET)
 539     {
 540       server->address_info_next= server->address_info_next->ai_next;
 541       continue;
 542     }
 543
 544     int type= server->address_info_next->ai_socktype;
 545     if (SOCK_CLOEXEC != 0)
 546     {
 547       type|= SOCK_CLOEXEC;
 548     }
 549
 550     if (SOCK_NONBLOCK != 0)
 551     {
 552       type|= SOCK_NONBLOCK;
 553     }
 554
 555     server->fd= socket(server->address_info_next->ai_family,
 556                        type,
 557                        server->address_info_next->ai_protocol);
 558
 559     if (int(server->fd) == SOCKET_ERROR)
 560     {
 561       return memcached_set_errno(*server, get_socket_errno(), NULL);
 562     }
 563
 564     if (set_socket_options(server) == false)
 565     {
 566       server->reset_socket();
 567       return MEMCACHED_CONNECTION_FAILURE;
 568     }
 569
 570     /* connect to server */
 571     if ((connect(server->fd, server->address_info_next->ai_addr, server->address_info_next->ai_addrlen) != SOCKET_ERROR))
 572     {
 573       server->state= MEMCACHED_SERVER_STATE_CONNECTED;
 574       return MEMCACHED_SUCCESS;
 575     }
 576
 577     /* An error occurred */
 578     int local_error= get_socket_errno();
 579     switch (local_error)
 580     {
 581     case ETIMEDOUT:
 582       timeout_error_occured= true;
 583       break;
 584
 585     case EAGAIN:
 586 #if EWOULDBLOCK != EAGAIN
 587     case EWOULDBLOCK:
 588 #endif
 589     case EINPROGRESS: // nonblocking mode - first return
 590     case EALREADY: // nonblocking mode - subsequent returns
 591       {
 592         server->events(POLLOUT);
 593         server->state= MEMCACHED_SERVER_STATE_IN_PROGRESS;
 594         memcached_return_t rc= connect_poll(server, local_error);
 595
 596         if (memcached_success(rc))
 597         {
 598           server->state= MEMCACHED_SERVER_STATE_CONNECTED;
 599           return MEMCACHED_SUCCESS;
 600         }
 601
 602         // A timeout here is treated as an error, we will not retry
 603         if (rc == MEMCACHED_TIMEOUT)
 604         {
 605           timeout_error_occured= true;
 606         }
 607       }
 608       break;
 609
 610     case EISCONN: // we are connected :-)
 611       WATCHPOINT_ASSERT(0); // This is a programmer's error
 612       break;
 613
 614     case EINTR: // Special case, we retry ai_addr
 615       WATCHPOINT_ASSERT(server->fd != INVALID_SOCKET);
 616       server->reset_socket();
 617       continue;
 618
 619     case ECONNREFUSED:
 620       // Probably not running service
 621
 622     default:
 623       break;
 624     }
 625
 626     WATCHPOINT_ASSERT(server->fd != INVALID_SOCKET);
 627     server->reset_socket();
 628     server->address_info_next= server->address_info_next->ai_next;
 629   }
 630
 631   WATCHPOINT_ASSERT(server->fd == INVALID_SOCKET);
 632
 633   if (timeout_error_occured)
 634   {
 635     server->reset_socket();
 636   }
 637
 638   WATCHPOINT_STRING("Never got a good file descriptor");
 639
 640   if (memcached_has_current_error(*server))
 641   {
 642     return memcached_instance_error_return(server);
 643   }
 644
 645   if (timeout_error_occured and server->state < MEMCACHED_SERVER_STATE_IN_PROGRESS)
 646   {
 647     return memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT,
 648                                memcached_literal_param("if (timeout_error_occured and server->state < MEMCACHED_SERVER_STATE_IN_PROGRESS)"));
 649   }
 650
 651   return memcached_set_error(*server, MEMCACHED_CONNECTION_FAILURE, MEMCACHED_AT); /* The last error should be from connect() */
 652 }
 653
 654
 655 /*
 656   backoff_handling()
 657
 658   Based on time/failure count fail the connect without trying. This prevents waiting in a state where
 659   we get caught spending cycles just waiting.
 660 */
 661 static memcached_return_t backoff_handling(memcached_instance_st* server, bool& in_timeout)
 662 {
 663   struct timeval curr_time;
 664   bool _gettime_success= (gettimeofday(&curr_time, NULL) == 0);
 665
 666   /*
 667     If we hit server_failure_limit then something is completely wrong about the server.
 668
 669     1) If autoeject is enabled we do that.
 670     2) If not? We go into timeout again, there is much else to do :(
 671   */
 672   if (server->server_failure_counter >= server->root->server_failure_limit)
 673   {
 674     /*
 675       We just auto_eject if we hit this point
 676     */
 677     if (_is_auto_eject_host(server->root))
 678     {
 679       set_last_disconnected_host(server);
 680
 681       // Retry dead servers if requested
 682       if (_gettime_success and server->root->dead_timeout > 0)
 683       {
 684         server->next_retry= curr_time.tv_sec +server->root->dead_timeout;
 685
 686         // We only retry dead servers once before assuming failure again
 687         server->server_failure_counter= server->root->server_failure_limit -1;
 688       }
 689
 690       memcached_return_t rc;
 691       if (memcached_failed(rc= run_distribution((memcached_st *)server->root)))
 692       {
 693         return memcached_set_error(*server, rc, MEMCACHED_AT, memcached_literal_param("Backoff handling failed during run_distribution"));
 694       }
 695
 696       return memcached_set_error(*server, MEMCACHED_SERVER_MARKED_DEAD, MEMCACHED_AT);
 697     }
 698
 699     server->state= MEMCACHED_SERVER_STATE_IN_TIMEOUT;
 700
 701     // Sanity check/setting
 702     if (server->next_retry == 0)
 703     {
 704       server->next_retry= 1;
 705     }
 706   }
 707
 708   if (server->state == MEMCACHED_SERVER_STATE_IN_TIMEOUT)
 709   {
 710     /*
 711       If next_retry is less then our current time, then we reset and try everything again.
 712     */
 713     if (_gettime_success and server->next_retry < curr_time.tv_sec)
 714     {
 715       server->state= MEMCACHED_SERVER_STATE_NEW;
 716       server->server_timeout_counter= 0;
 717     }
 718     else
 719     {
 720       return memcached_set_error(*server, MEMCACHED_SERVER_TEMPORARILY_DISABLED, MEMCACHED_AT);
 721     }
 722
 723     in_timeout= true;
 724   }
 725
 726   return MEMCACHED_SUCCESS;
 727 }
 728
 729 static memcached_return_t _memcached_connect(memcached_instance_st* server, const bool set_last_disconnected)
 730 {
 731   assert(server);
 732   if (server->fd != INVALID_SOCKET)
 733   {
 734     return MEMCACHED_SUCCESS;
 735   }
 736
 737   LIBMEMCACHED_MEMCACHED_CONNECT_START();
 738
 739   bool in_timeout= false;
 740   memcached_return_t rc;
 741   if (memcached_failed(rc= backoff_handling(server, in_timeout)))
 742   {
 743     set_last_disconnected_host(server);
 744     return rc;
 745   }
 746
 747   if (LIBMEMCACHED_WITH_SASL_SUPPORT and server->root->sasl.callbacks and memcached_is_udp(server->root))
 748   {
 749     return memcached_set_error(*server, MEMCACHED_INVALID_HOST_PROTOCOL, MEMCACHED_AT, memcached_literal_param("SASL is not supported for UDP connections"));
 750   }
 751
 752   if (server->hostname()[0] == '/')
 753   {
 754     server->type= MEMCACHED_CONNECTION_UNIX_SOCKET;
 755   }
 756
 757   /* We need to clean up the multi startup piece */
 758   switch (server->type)
 759   {
 760   case MEMCACHED_CONNECTION_UDP:
 761   case MEMCACHED_CONNECTION_TCP:
 762     rc= network_connect(server);
 763
 764 #if defined(LIBMEMCACHED_WITH_SASL_SUPPORT)
 765     if (LIBMEMCACHED_WITH_SASL_SUPPORT)
 766     {
 767       if (server->fd != INVALID_SOCKET and server->root->sasl.callbacks)
 768       {
 769         rc= memcached_sasl_authenticate_connection(server);
 770         if (memcached_failed(rc) and server->fd != INVALID_SOCKET)
 771         {
 772           WATCHPOINT_ASSERT(server->fd != INVALID_SOCKET);
 773           server->reset_socket();
 774         }
 775       }
 776     }
 777 #endif
 778     break;
 779
 780   case MEMCACHED_CONNECTION_UNIX_SOCKET:
 781     rc= unix_socket_connect(server);
 782     break;
 783   }
 784
 785   if (memcached_success(rc))
 786   {
 787     server->mark_server_as_clean();
 788     memcached_version_instance(server);
 789     return rc;
 790   }
 791   else if (set_last_disconnected)
 792   {
 793     set_last_disconnected_host(server);
 794     if (memcached_has_current_error(*server))
 795     {
 796       memcached_mark_server_for_timeout(server);
 797       assert(memcached_failed(memcached_instance_error_return(server)));
 798     }
 799     else
 800     {
 801       memcached_set_error(*server, rc, MEMCACHED_AT);
 802       memcached_mark_server_for_timeout(server);
 803     }
 804
 805     LIBMEMCACHED_MEMCACHED_CONNECT_END();
 806
 807     if (in_timeout)
 808     {
 809       char buffer[1024];
 810       int snprintf_length= snprintf(buffer, sizeof(buffer), "%s:%d", server->hostname(), int(server->port()));
 811       return memcached_set_error(*server, MEMCACHED_SERVER_TEMPORARILY_DISABLED, MEMCACHED_AT, buffer, snprintf_length);
 812     }
 813   }
 814
 815   return rc;
 816 }
 817
 818 memcached_return_t memcached_connect(memcached_instance_st* server)
 819 {
 820   return _memcached_connect(server, true);
 821 }