git.m6w6.name Git - m6w6/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(org::libmemcached::Instance* server)
  68 {
  69   struct pollfd fds[1];
  70   fds[0].fd= server->fd;
  71   fds[0].events= POLLOUT;
  72
  73   size_t loop_max= 5;
  74
  75   if (server->root->poll_timeout == 0)
  76   {
  77     return memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT);
  78   }
  79
  80   while (--loop_max) // Should only loop on cases of ERESTART or EINTR
  81   {
  82     int number_of;
  83     if ((number_of= poll(fds, 1, server->root->connect_timeout)) <= 0)
  84     {
  85       if (number_of == -1)
  86       {
  87         int local_errno= get_socket_errno(); // We cache in case closesocket() modifies errno
  88         switch (local_errno)
  89         {
  90 #ifdef TARGET_OS_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, memcached_literal_param("RLIMIT_NOFILE exceeded, or if OSX the timeout value was invalid"));
 102
 103         default: // This should not happen
 104           if (fds[0].revents & POLLERR)
 105           {
 106             int err;
 107             socklen_t len= sizeof(err);
 108             if (getsockopt(server->fd, SOL_SOCKET, SO_ERROR, (char*)&err, &len) == 0)
 109             {
 110               if (err == 0)
 111               {
 112                 // This should never happen, if it does? Punt.
 113                 continue;
 114               }
 115               local_errno= err;
 116             }
 117           }
 118
 119           assert_msg(server->fd != INVALID_SOCKET, "poll() was passed an invalid file descriptor");
 120           (void)closesocket(server->fd);
 121           server->fd= INVALID_SOCKET;
 122           server->state= MEMCACHED_SERVER_STATE_NEW;
 123
 124           return memcached_set_errno(*server, local_errno, MEMCACHED_AT);
 125         }
 126       }
 127       assert(number_of == 0);
 128
 129       server->io_wait_count.timeouts++;
 130       return memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT);
 131     }
 132
 133     if (fds[0].revents & POLLERR or
 134         fds[0].revents & POLLHUP or
 135         fds[0].revents & POLLNVAL)
 136     {
 137       int err;
 138       socklen_t len= sizeof (err);
 139       if (getsockopt(fds[0].fd, SOL_SOCKET, SO_ERROR, (char*)&err, &len) == 0)
 140       {
 141         // We check the value to see what happened wth the socket.
 142         if (err == 0)
 143         {
 144           return MEMCACHED_SUCCESS;
 145         }
 146         errno= err;
 147       }
 148
 149       return memcached_set_errno(*server, err, MEMCACHED_AT);
 150     }
 151     assert(fds[0].revents & POLLIN or fds[0].revents & POLLOUT);
 152
 153     return MEMCACHED_SUCCESS;
 154   }
 155
 156   // This should only be possible from ERESTART or EINTR;
 157   return memcached_set_errno(*server, get_socket_errno(), MEMCACHED_AT);
 158 }
 159
 160 static memcached_return_t set_hostinfo(org::libmemcached::Instance* server)
 161 {
 162   assert(server->type != MEMCACHED_CONNECTION_UNIX_SOCKET);
 163   if (server->address_info)
 164   {
 165     freeaddrinfo(server->address_info);
 166     server->address_info= NULL;
 167     server->address_info_next= NULL;
 168   }
 169
 170   char str_port[MEMCACHED_NI_MAXSERV];
 171   int length= snprintf(str_port, MEMCACHED_NI_MAXSERV, "%u", uint32_t(server->port()));
 172   if (length >= MEMCACHED_NI_MAXSERV or length <= 0)
 173   {
 174     return memcached_set_error(*server, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT,
 175                                memcached_literal_param("snprintf(NI_MAXSERV)"));
 176   }
 177
 178   struct addrinfo hints;
 179   memset(&hints, 0, sizeof(struct addrinfo));
 180
 181 #if 0
 182   hints.ai_family= AF_INET;
 183 #endif
 184   if (memcached_is_udp(server->root))
 185   {
 186     hints.ai_protocol= IPPROTO_UDP;
 187     hints.ai_socktype= SOCK_DGRAM;
 188   }
 189   else
 190   {
 191     hints.ai_socktype= SOCK_STREAM;
 192     hints.ai_protocol= IPPROTO_TCP;
 193   }
 194
 195   assert(server->address_info == NULL);
 196   assert(server->address_info_next == NULL);
 197   int errcode;
 198   switch(errcode= getaddrinfo(server->hostname, str_port, &hints, &server->address_info))
 199   {
 200   case 0:
 201     break;
 202
 203   case EAI_AGAIN:
 204     if (server->address_info)
 205     {
 206       freeaddrinfo(server->address_info);
 207       server->address_info= NULL;
 208       server->address_info_next= NULL;
 209     }
 210     return memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT, memcached_string_make_from_cstr(gai_strerror(errcode)));
 211
 212   case EAI_SYSTEM:
 213     if (server->address_info)
 214     {
 215       freeaddrinfo(server->address_info);
 216       server->address_info= NULL;
 217       server->address_info_next= NULL;
 218     }
 219     return memcached_set_errno(*server, errno, MEMCACHED_AT, memcached_literal_param("getaddrinfo(EAI_SYSTEM)"));
 220
 221   case EAI_BADFLAGS:
 222     if (server->address_info)
 223     {
 224       freeaddrinfo(server->address_info);
 225       server->address_info= NULL;
 226       server->address_info_next= NULL;
 227     }
 228     return memcached_set_error(*server, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT, memcached_literal_param("getaddrinfo(EAI_BADFLAGS)"));
 229
 230   case EAI_MEMORY:
 231     if (server->address_info)
 232     {
 233       freeaddrinfo(server->address_info);
 234       server->address_info= NULL;
 235       server->address_info_next= NULL;
 236     }
 237     return memcached_set_error(*server, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT, memcached_literal_param("getaddrinfo(EAI_MEMORY)"));
 238
 239   default:
 240     {
 241       if (server->address_info)
 242       {
 243         freeaddrinfo(server->address_info);
 244         server->address_info= NULL;
 245         server->address_info_next= NULL;
 246       }
 247       return memcached_set_error(*server, MEMCACHED_HOST_LOOKUP_FAILURE, MEMCACHED_AT, memcached_string_make_from_cstr(gai_strerror(errcode)));
 248     }
 249   }
 250   server->address_info_next= server->address_info;
 251   server->state= MEMCACHED_SERVER_STATE_ADDRINFO;
 252
 253   return MEMCACHED_SUCCESS;
 254 }
 255
 256 static inline void set_socket_nonblocking(org::libmemcached::Instance* server)
 257 {
 258 #ifdef WIN32
 259   u_long arg= 1;
 260   if (ioctlsocket(server->fd, FIONBIO, &arg) == SOCKET_ERROR)
 261   {
 262     memcached_set_errno(*server, get_socket_errno(), NULL);
 263   }
 264 #else
 265   int flags;
 266
 267   if (SOCK_NONBLOCK == 0)
 268   {
 269     do
 270     {
 271       flags= fcntl(server->fd, F_GETFL, 0);
 272     } while (flags == -1 && (errno == EINTR || errno == EAGAIN));
 273
 274     if (flags == -1)
 275     {
 276       memcached_set_errno(*server, errno, NULL);
 277     }
 278     else if ((flags & O_NONBLOCK) == 0)
 279     {
 280       int rval;
 281
 282       do
 283       {
 284         rval= fcntl(server->fd, F_SETFL, flags | O_NONBLOCK);
 285       } while (rval == -1 && (errno == EINTR or errno == EAGAIN));
 286
 287       if (rval == -1)
 288       {
 289         memcached_set_errno(*server, errno, NULL);
 290       }
 291     }
 292   }
 293 #endif
 294 }
 295
 296 static bool set_socket_options(org::libmemcached::Instance* server)
 297 {
 298   assert_msg(server->fd != INVALID_SOCKET, "invalid socket was passed to set_socket_options()");
 299
 300 #ifdef HAVE_FCNTL
 301   // If SOCK_CLOEXEC exists then we don't need to call the following
 302   if (SOCK_CLOEXEC == 0)
 303   {
 304     if (FD_CLOEXEC)
 305     {
 306       int flags;
 307       do
 308       {
 309         flags= fcntl(server->fd, F_GETFD, 0);
 310       } while (flags == -1 and (errno == EINTR or errno == EAGAIN));
 311
 312       if (flags != -1)
 313       {
 314         int rval;
 315         do
 316         {
 317           rval= fcntl (server->fd, F_SETFD, flags | FD_CLOEXEC);
 318         } while (rval == -1 && (errno == EINTR or errno == EAGAIN));
 319         // we currently ignore the case where rval is -1
 320       }
 321     }
 322   }
 323 #endif
 324
 325   if (memcached_is_udp(server->root))
 326   {
 327     return true;
 328   }
 329
 330 #ifdef HAVE_SNDTIMEO
 331   if (server->root->snd_timeout > 0)
 332   {
 333     struct timeval waittime;
 334
 335     waittime.tv_sec= server->root->snd_timeout / 1000000;
 336     waittime.tv_usec= server->root->snd_timeout % 1000000;
 337
 338     int error= setsockopt(server->fd, SOL_SOCKET, SO_SNDTIMEO,
 339                           (char*)&waittime, (socklen_t)sizeof(struct timeval));
 340     (void)error;
 341     assert(error == 0);
 342   }
 343 #endif
 344
 345 #ifdef HAVE_RCVTIMEO
 346   if (server->root->rcv_timeout > 0)
 347   {
 348     struct timeval waittime;
 349
 350     waittime.tv_sec= server->root->rcv_timeout / 1000000;
 351     waittime.tv_usec= server->root->rcv_timeout % 1000000;
 352
 353     int error= setsockopt(server->fd, SOL_SOCKET, SO_RCVTIMEO,
 354                           (char*)&waittime, (socklen_t)sizeof(struct timeval));
 355     (void)(error);
 356     assert(error == 0);
 357   }
 358 #endif
 359
 360
 361 #if defined(SO_NOSIGPIPE)
 362   if (SO_NOSIGPIPE)
 363   {
 364     int set= 1;
 365     int error= setsockopt(server->fd, SOL_SOCKET, SO_NOSIGPIPE, (void *)&set, sizeof(int));
 366
 367     assert(error == 0);
 368
 369     // This is not considered a fatal error
 370     if (error == -1)
 371     {
 372 #if 0
 373       perror("setsockopt(SO_NOSIGPIPE)");
 374 #endif
 375     }
 376   }
 377 #endif
 378
 379   if (server->root->flags.no_block)
 380   {
 381     struct linger linger;
 382
 383     linger.l_onoff= 1;
 384     linger.l_linger= 0; /* By default on close() just drop the socket */
 385     int error= setsockopt(server->fd, SOL_SOCKET, SO_LINGER,
 386                           (char*)&linger, (socklen_t)sizeof(struct linger));
 387     (void)(error);
 388     assert(error == 0);
 389   }
 390
 391   if (TCP_NODELAY)
 392   {
 393     if (server->root->flags.tcp_nodelay)
 394     {
 395       int flag= 1;
 396
 397       int error= setsockopt(server->fd, IPPROTO_TCP, TCP_NODELAY,
 398                             (char*)&flag, (socklen_t)sizeof(int));
 399       (void)(error);
 400       assert(error == 0);
 401     }
 402   }
 403
 404   if (server->root->flags.tcp_keepalive)
 405   {
 406     int flag= 1;
 407
 408     int error= setsockopt(server->fd, SOL_SOCKET, SO_KEEPALIVE,
 409                           (char*)&flag, (socklen_t)sizeof(int));
 410     (void)(error);
 411     assert(error == 0);
 412   }
 413
 414   if (TCP_KEEPIDLE)
 415   {
 416     if (server->root->tcp_keepidle > 0)
 417     {
 418       int error= setsockopt(server->fd, IPPROTO_TCP, TCP_KEEPIDLE,
 419                             (char*)&server->root->tcp_keepidle, (socklen_t)sizeof(int));
 420       (void)(error);
 421       assert(error == 0);
 422     }
 423   }
 424
 425   if (server->root->send_size > 0)
 426   {
 427     int error= setsockopt(server->fd, SOL_SOCKET, SO_SNDBUF,
 428                           (char*)&server->root->send_size, (socklen_t)sizeof(int));
 429     (void)(error);
 430     assert(error == 0);
 431   }
 432
 433   if (server->root->recv_size > 0)
 434   {
 435     int error= setsockopt(server->fd, SOL_SOCKET, SO_RCVBUF,
 436                           (char*)&server->root->recv_size, (socklen_t)sizeof(int));
 437     (void)(error);
 438     assert(error == 0);
 439   }
 440
 441   /* libmemcached will always use nonblocking IO to avoid write deadlocks */
 442   set_socket_nonblocking(server);
 443
 444   return true;
 445 }
 446
 447 static memcached_return_t unix_socket_connect(org::libmemcached::Instance* server)
 448 {
 449 #ifndef WIN32
 450   WATCHPOINT_ASSERT(server->fd == INVALID_SOCKET);
 451
 452   int type= SOCK_STREAM;
 453   if (SOCK_CLOEXEC)
 454   {
 455     type|= SOCK_CLOEXEC;
 456   }
 457
 458   if (SOCK_NONBLOCK)
 459   {
 460     type|= SOCK_NONBLOCK;
 461   }
 462
 463   if ((server->fd= socket(AF_UNIX, type, 0)) < 0)
 464   {
 465     return memcached_set_errno(*server, errno, NULL);
 466   }
 467
 468   struct sockaddr_un servAddr;
 469
 470   memset(&servAddr, 0, sizeof (struct sockaddr_un));
 471   servAddr.sun_family= AF_UNIX;
 472   strncpy(servAddr.sun_path, server->hostname, sizeof(servAddr.sun_path)); /* Copy filename */
 473
 474   do {
 475     if (connect(server->fd, (struct sockaddr *)&servAddr, sizeof(servAddr)) < 0)
 476     {
 477       switch (errno)
 478       {
 479       case EINPROGRESS:
 480       case EALREADY:
 481       case EINTR:
 482         continue;
 483
 484       case EISCONN: /* We were spinning waiting on connect */
 485         {
 486           assert(0); // Programmer error
 487           break;
 488         }
 489
 490       default:
 491         WATCHPOINT_ERRNO(errno);
 492         return memcached_set_errno(*server, errno, MEMCACHED_AT);
 493       }
 494     }
 495   } while (0);
 496   server->state= MEMCACHED_SERVER_STATE_CONNECTED;
 497
 498   WATCHPOINT_ASSERT(server->fd != INVALID_SOCKET);
 499
 500   return MEMCACHED_SUCCESS;
 501 #else
 502   (void)server;
 503   return MEMCACHED_NOT_SUPPORTED;
 504 #endif
 505 }
 506
 507 static memcached_return_t network_connect(org::libmemcached::Instance* server)
 508 {
 509   bool timeout_error_occured= false;
 510
 511   WATCHPOINT_ASSERT(server->fd == INVALID_SOCKET);
 512   WATCHPOINT_ASSERT(server->cursor_active_ == 0);
 513
 514   /*
 515     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.
 516   */
 517   if (server->address_info == NULL or server->address_info_next == NULL)
 518   {
 519     WATCHPOINT_ASSERT(server->state == MEMCACHED_SERVER_STATE_NEW);
 520     server->address_info_next= NULL;
 521     memcached_return_t rc= set_hostinfo(server);
 522
 523     if (memcached_failed(rc))
 524     {
 525       return rc;
 526     }
 527   }
 528
 529   if (server->address_info_next == NULL)
 530   {
 531     server->address_info_next= server->address_info;
 532     server->state= MEMCACHED_SERVER_STATE_ADDRINFO;
 533   }
 534
 535   /* Create the socket */
 536   while (server->address_info_next and server->fd == INVALID_SOCKET)
 537   {
 538     /* Memcache server does not support IPV6 in udp mode, so skip if not ipv4 */
 539     if (memcached_is_udp(server->root) and server->address_info_next->ai_family != AF_INET)
 540     {
 541       server->address_info_next= server->address_info_next->ai_next;
 542       continue;
 543     }
 544
 545     int type= server->address_info_next->ai_socktype;
 546     if (SOCK_CLOEXEC)
 547     {
 548       type|= SOCK_CLOEXEC;
 549     }
 550
 551     if (SOCK_NONBLOCK)
 552     {
 553       type|= SOCK_NONBLOCK;
 554     }
 555
 556     server->fd= socket(server->address_info_next->ai_family,
 557                        type,
 558                        server->address_info_next->ai_protocol);
 559
 560     if (int(server->fd) == SOCKET_ERROR)
 561     {
 562       return memcached_set_errno(*server, get_socket_errno(), NULL);
 563     }
 564
 565     if (set_socket_options(server) == false)
 566     {
 567       (void)closesocket(server->fd);
 568       return MEMCACHED_CONNECTION_FAILURE;
 569     }
 570
 571     /* connect to server */
 572     if ((connect(server->fd, server->address_info_next->ai_addr, server->address_info_next->ai_addrlen) != SOCKET_ERROR))
 573     {
 574       server->state= MEMCACHED_SERVER_STATE_CONNECTED;
 575       return MEMCACHED_SUCCESS;
 576     }
 577
 578     /* An error occurred */
 579     switch (get_socket_errno())
 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->state= MEMCACHED_SERVER_STATE_IN_PROGRESS;
 593         memcached_return_t rc= connect_poll(server);
 594
 595         if (memcached_success(rc))
 596         {
 597           server->state= MEMCACHED_SERVER_STATE_CONNECTED;
 598           return MEMCACHED_SUCCESS;
 599         }
 600
 601         // A timeout here is treated as an error, we will not retry
 602         if (rc == MEMCACHED_TIMEOUT)
 603         {
 604           timeout_error_occured= true;
 605         }
 606       }
 607       break;
 608
 609     case EISCONN: // we are connected :-)
 610       WATCHPOINT_ASSERT(0); // This is a programmer's error
 611       break;
 612
 613     case EINTR: // Special case, we retry ai_addr
 614       WATCHPOINT_ASSERT(server->fd != INVALID_SOCKET);
 615       (void)closesocket(server->fd);
 616       server->fd= INVALID_SOCKET;
 617       continue;
 618
 619     default:
 620       break;
 621     }
 622
 623     WATCHPOINT_ASSERT(server->fd != INVALID_SOCKET);
 624     (void)closesocket(server->fd);
 625     server->fd= INVALID_SOCKET;
 626     server->address_info_next= server->address_info_next->ai_next;
 627   }
 628
 629   WATCHPOINT_ASSERT(server->fd == INVALID_SOCKET);
 630
 631   if (timeout_error_occured)
 632   {
 633     if (server->fd != INVALID_SOCKET)
 634     {
 635       (void)closesocket(server->fd);
 636       server->fd= INVALID_SOCKET;
 637     }
 638   }
 639
 640   WATCHPOINT_STRING("Never got a good file descriptor");
 641
 642   if (memcached_has_current_error(*server))
 643   {
 644     return memcached_instance_error_return(server);
 645   }
 646
 647   if (timeout_error_occured and server->state < MEMCACHED_SERVER_STATE_IN_PROGRESS)
 648   {
 649     return memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT);
 650   }
 651
 652   return memcached_set_error(*server, MEMCACHED_CONNECTION_FAILURE, MEMCACHED_AT); /* The last error should be from connect() */
 653 }
 654
 655
 656 /*
 657   backoff_handling()
 658
 659   Based on time/failure count fail the connect without trying. This prevents waiting in a state where
 660   we get caught spending cycles just waiting.
 661 */
 662 static memcached_return_t backoff_handling(org::libmemcached::Instance* server, bool& in_timeout)
 663 {
 664   struct timeval curr_time;
 665   bool _gettime_success= (gettimeofday(&curr_time, NULL) == 0);
 666
 667   /*
 668     If we hit server_failure_limit then something is completely wrong about the server.
 669
 670     1) If autoeject is enabled we do that.
 671     2) If not? We go into timeout again, there is much else to do :(
 672   */
 673   if (server->server_failure_counter >= server->root->server_failure_limit)
 674   {
 675     /*
 676       We just auto_eject if we hit this point
 677     */
 678     if (_is_auto_eject_host(server->root))
 679     {
 680       set_last_disconnected_host(server);
 681
 682       // Retry dead servers if requested
 683       if (_gettime_success and server->root->dead_timeout > 0)
 684       {
 685         server->next_retry= curr_time.tv_sec +server->root->dead_timeout;
 686
 687         // We only retry dead servers once before assuming failure again
 688         server->server_failure_counter= server->root->server_failure_limit -1;
 689       }
 690
 691       memcached_return_t rc;
 692       if (memcached_failed(rc= run_distribution((memcached_st *)server->root)))
 693       {
 694         return memcached_set_error(*server, rc, MEMCACHED_AT, memcached_literal_param("Backoff handling failed during run_distribution"));
 695       }
 696
 697       return memcached_set_error(*server, MEMCACHED_SERVER_MARKED_DEAD, MEMCACHED_AT);
 698     }
 699
 700     server->state= MEMCACHED_SERVER_STATE_IN_TIMEOUT;
 701
 702     // Sanity check/setting
 703     if (server->next_retry == 0)
 704     {
 705       server->next_retry= 1;
 706     }
 707   }
 708
 709   if (server->state == MEMCACHED_SERVER_STATE_IN_TIMEOUT)
 710   {
 711     /*
 712       If next_retry is less then our current time, then we reset and try everything again.
 713     */
 714     if (_gettime_success and server->next_retry < curr_time.tv_sec)
 715     {
 716       server->state= MEMCACHED_SERVER_STATE_NEW;
 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(org::libmemcached::Instance* 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 (LIBMEMCACHED_WITH_SASL_SUPPORT)
 765     {
 766       if (server->fd != INVALID_SOCKET and server->root->sasl.callbacks)
 767       {
 768         rc= memcached_sasl_authenticate_connection(server);
 769         fprintf(stderr, "%s:%d %s\n", __FILE__, __LINE__, memcached_strerror(NULL, rc));
 770         if (memcached_failed(rc) and server->fd != INVALID_SOCKET)
 771         {
 772           WATCHPOINT_ASSERT(server->fd != INVALID_SOCKET);
 773           (void)closesocket(server->fd);
 774           server->fd= INVALID_SOCKET;
 775         }
 776       }
 777     }
 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_try(org::libmemcached::Instance* server)
 819 {
 820   if (server and server->root and server->root->state.is_parsing)
 821   {
 822     return MEMCACHED_SUCCESS;
 823   }
 824
 825   return _memcached_connect(server, false);
 826 }
 827
 828 memcached_return_t memcached_connect(org::libmemcached::Instance* server)
 829 {
 830   return _memcached_connect(server, true);
 831 }