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     if (strlen(server->hostname()) >= sizeof(servAddr.sun_path)) {
 470         return memcached_set_error(*server, MEMCACHED_UNIX_SOCKET_PATH_TOO_BIG, MEMCACHED_AT);
 471     }
 472     strncpy(servAddr.sun_path, server->hostname(), sizeof(servAddr.sun_path)-1); /* Copy filename */
 473
 474     if (connect(server->fd, (struct sockaddr *)&servAddr, sizeof(servAddr)) == -1)
 475     {
 476       switch (errno)
 477       {
 478       case EINPROGRESS:
 479       case EALREADY:
 480       case EAGAIN:
 481         server->events(POLLOUT);
 482         break;
 483
 484       case EINTR:
 485         server->reset_socket();
 486         continue;
 487
 488       case EISCONN: /* We were spinning waiting on connect */
 489         {
 490           assert(0); // Programmer error
 491           server->reset_socket();
 492           continue;
 493         }
 494
 495       default:
 496         WATCHPOINT_ERRNO(errno);
 497         server->reset_socket();
 498         return memcached_set_errno(*server, errno, MEMCACHED_AT);
 499       }
 500     }
 501   } while (0);
 502   server->state= MEMCACHED_SERVER_STATE_CONNECTED;
 503
 504   WATCHPOINT_ASSERT(server->fd != INVALID_SOCKET);
 505
 506   return MEMCACHED_SUCCESS;
 507 #else
 508   (void)server;
 509   return MEMCACHED_NOT_SUPPORTED;
 510 #endif
 511 }
 512
 513 static memcached_return_t network_connect(memcached_instance_st* server)
 514 {
 515   bool timeout_error_occured= false;
 516
 517   WATCHPOINT_ASSERT(server->fd == INVALID_SOCKET);
 518   WATCHPOINT_ASSERT(server->cursor_active_ == 0);
 519
 520   /*
 521     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.
 522   */
 523   if (server->address_info == NULL or server->address_info_next == NULL)
 524   {
 525     WATCHPOINT_ASSERT(server->state == MEMCACHED_SERVER_STATE_NEW);
 526     server->address_info_next= NULL;
 527     memcached_return_t rc= set_hostinfo(server);
 528
 529     if (memcached_failed(rc))
 530     {
 531       return rc;
 532     }
 533   }
 534
 535   assert(server->address_info_next);
 536   assert(server->address_info);
 537
 538   /* Create the socket */
 539   while (server->address_info_next and server->fd == INVALID_SOCKET)
 540   {
 541     int type= server->address_info_next->ai_socktype;
 542     if (SOCK_CLOEXEC != 0)
 543     {
 544       type|= SOCK_CLOEXEC;
 545     }
 546
 547     if (SOCK_NONBLOCK != 0)
 548     {
 549       type|= SOCK_NONBLOCK;
 550     }
 551
 552     server->fd= socket(server->address_info_next->ai_family,
 553                        type,
 554                        server->address_info_next->ai_protocol);
 555
 556     if (int(server->fd) == SOCKET_ERROR)
 557     {
 558       return memcached_set_errno(*server, get_socket_errno(), NULL);
 559     }
 560
 561     if (set_socket_options(server) == false)
 562     {
 563       server->reset_socket();
 564       return MEMCACHED_CONNECTION_FAILURE;
 565     }
 566
 567     /* connect to server */
 568     if ((connect(server->fd, server->address_info_next->ai_addr, server->address_info_next->ai_addrlen) != SOCKET_ERROR))
 569     {
 570       server->state= MEMCACHED_SERVER_STATE_CONNECTED;
 571       return MEMCACHED_SUCCESS;
 572     }
 573
 574     /* An error occurred */
 575     int local_error= get_socket_errno();
 576     switch (local_error)
 577     {
 578     case ETIMEDOUT:
 579       timeout_error_occured= true;
 580       break;
 581
 582     case EAGAIN:
 583 #if EWOULDBLOCK != EAGAIN
 584     case EWOULDBLOCK:
 585 #endif
 586     case EINPROGRESS: // nonblocking mode - first return
 587     case EALREADY: // nonblocking mode - subsequent returns
 588       {
 589         server->events(POLLOUT);
 590         server->state= MEMCACHED_SERVER_STATE_IN_PROGRESS;
 591         memcached_return_t rc= connect_poll(server, local_error);
 592
 593         if (memcached_success(rc))
 594         {
 595           server->state= MEMCACHED_SERVER_STATE_CONNECTED;
 596           return MEMCACHED_SUCCESS;
 597         }
 598
 599         // A timeout here is treated as an error, we will not retry
 600         if (rc == MEMCACHED_TIMEOUT)
 601         {
 602           timeout_error_occured= true;
 603         }
 604       }
 605       break;
 606
 607     case EISCONN: // we are connected :-)
 608       WATCHPOINT_ASSERT(0); // This is a programmer's error
 609       break;
 610
 611     case EINTR: // Special case, we retry ai_addr
 612       WATCHPOINT_ASSERT(server->fd != INVALID_SOCKET);
 613       server->reset_socket();
 614       continue;
 615
 616     case ECONNREFUSED:
 617       // Probably not running service
 618
 619     default:
 620       break;
 621     }
 622
 623     WATCHPOINT_ASSERT(server->fd != INVALID_SOCKET);
 624     server->reset_socket();
 625     server->address_info_next= server->address_info_next->ai_next;
 626   }
 627
 628   WATCHPOINT_ASSERT(server->fd == INVALID_SOCKET);
 629
 630   if (timeout_error_occured)
 631   {
 632     server->reset_socket();
 633   }
 634
 635   WATCHPOINT_STRING("Never got a good file descriptor");
 636
 637   if (memcached_has_current_error(*server))
 638   {
 639     return memcached_instance_error_return(server);
 640   }
 641
 642   if (timeout_error_occured and server->state < MEMCACHED_SERVER_STATE_IN_PROGRESS)
 643   {
 644     return memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT,
 645                                memcached_literal_param("if (timeout_error_occured and server->state < MEMCACHED_SERVER_STATE_IN_PROGRESS)"));
 646   }
 647
 648   return memcached_set_error(*server, MEMCACHED_CONNECTION_FAILURE, MEMCACHED_AT); /* The last error should be from connect() */
 649 }
 650
 651
 652 /*
 653   backoff_handling()
 654
 655   Based on time/failure count fail the connect without trying. This prevents waiting in a state where
 656   we get caught spending cycles just waiting.
 657 */
 658 static memcached_return_t backoff_handling(memcached_instance_st* server, bool& in_timeout)
 659 {
 660   struct timeval curr_time;
 661   bool _gettime_success= (gettimeofday(&curr_time, NULL) == 0);
 662
 663   /*
 664     If we hit server_failure_limit then something is completely wrong about the server.
 665
 666     1) If autoeject is enabled we do that.
 667     2) If not? We go into timeout again, there is much else to do :(
 668   */
 669   if (server->server_failure_counter >= server->root->server_failure_limit)
 670   {
 671     /*
 672       We just auto_eject if we hit this point
 673     */
 674     if (_is_auto_eject_host(server->root))
 675     {
 676       set_last_disconnected_host(server);
 677
 678       // Retry dead servers if requested
 679       if (_gettime_success and server->root->dead_timeout > 0)
 680       {
 681         server->next_retry= curr_time.tv_sec +server->root->dead_timeout;
 682
 683         // We only retry dead servers once before assuming failure again
 684         server->server_failure_counter= server->root->server_failure_limit -1;
 685       }
 686
 687       memcached_return_t rc;
 688       if (memcached_failed(rc= run_distribution((memcached_st *)server->root)))
 689       {
 690         return memcached_set_error(*server, rc, MEMCACHED_AT, memcached_literal_param("Backoff handling failed during run_distribution"));
 691       }
 692
 693       return memcached_set_error(*server, MEMCACHED_SERVER_MARKED_DEAD, MEMCACHED_AT);
 694     }
 695
 696     server->state= MEMCACHED_SERVER_STATE_IN_TIMEOUT;
 697
 698     // Sanity check/setting
 699     if (server->next_retry == 0)
 700     {
 701       server->next_retry= 1;
 702     }
 703   }
 704
 705   if (server->state == MEMCACHED_SERVER_STATE_IN_TIMEOUT)
 706   {
 707     /*
 708       If next_retry is less then our current time, then we reset and try everything again.
 709     */
 710     if (_gettime_success and server->next_retry < curr_time.tv_sec)
 711     {
 712       server->state= MEMCACHED_SERVER_STATE_NEW;
 713       server->server_timeout_counter= 0;
 714     }
 715     else
 716     {
 717       return memcached_set_error(*server, MEMCACHED_SERVER_TEMPORARILY_DISABLED, MEMCACHED_AT);
 718     }
 719
 720     in_timeout= true;
 721   }
 722
 723   return MEMCACHED_SUCCESS;
 724 }
 725
 726 static memcached_return_t _memcached_connect(memcached_instance_st* server, const bool set_last_disconnected)
 727 {
 728   assert(server);
 729   if (server->fd != INVALID_SOCKET)
 730   {
 731     return MEMCACHED_SUCCESS;
 732   }
 733
 734   LIBMEMCACHED_MEMCACHED_CONNECT_START();
 735
 736   bool in_timeout= false;
 737   memcached_return_t rc;
 738   if (memcached_failed(rc= backoff_handling(server, in_timeout)))
 739   {
 740     set_last_disconnected_host(server);
 741     return rc;
 742   }
 743
 744   if (LIBMEMCACHED_WITH_SASL_SUPPORT and server->root->sasl.callbacks and memcached_is_udp(server->root))
 745   {
 746     return memcached_set_error(*server, MEMCACHED_INVALID_HOST_PROTOCOL, MEMCACHED_AT, memcached_literal_param("SASL is not supported for UDP connections"));
 747   }
 748
 749   if (server->hostname()[0] == '/')
 750   {
 751     server->type= MEMCACHED_CONNECTION_UNIX_SOCKET;
 752   }
 753
 754   /* We need to clean up the multi startup piece */
 755   switch (server->type)
 756   {
 757   case MEMCACHED_CONNECTION_UDP:
 758   case MEMCACHED_CONNECTION_TCP:
 759     rc= network_connect(server);
 760
 761 #if defined(LIBMEMCACHED_WITH_SASL_SUPPORT)
 762     if (LIBMEMCACHED_WITH_SASL_SUPPORT)
 763     {
 764       if (server->fd != INVALID_SOCKET and server->root->sasl.callbacks)
 765       {
 766         rc= memcached_sasl_authenticate_connection(server);
 767         if (memcached_failed(rc) and server->fd != INVALID_SOCKET)
 768         {
 769           WATCHPOINT_ASSERT(server->fd != INVALID_SOCKET);
 770           server->reset_socket();
 771         }
 772       }
 773     }
 774 #endif
 775     break;
 776
 777   case MEMCACHED_CONNECTION_UNIX_SOCKET:
 778     rc= unix_socket_connect(server);
 779     break;
 780   }
 781
 782   if (memcached_success(rc))
 783   {
 784     server->mark_server_as_clean();
 785     memcached_version_instance(server);
 786     return rc;
 787   }
 788   else if (set_last_disconnected)
 789   {
 790     set_last_disconnected_host(server);
 791     if (memcached_has_current_error(*server))
 792     {
 793       memcached_mark_server_for_timeout(server);
 794       assert(memcached_failed(memcached_instance_error_return(server)));
 795     }
 796     else
 797     {
 798       memcached_set_error(*server, rc, MEMCACHED_AT);
 799       memcached_mark_server_for_timeout(server);
 800     }
 801
 802     LIBMEMCACHED_MEMCACHED_CONNECT_END();
 803
 804     if (in_timeout)
 805     {
 806       char buffer[1024];
 807       int snprintf_length= snprintf(buffer, sizeof(buffer), "%s:%d", server->hostname(), int(server->port()));
 808       return memcached_set_error(*server, MEMCACHED_SERVER_TEMPORARILY_DISABLED, MEMCACHED_AT, buffer, snprintf_length);
 809     }
 810   }
 811
 812   return rc;
 813 }
 814
 815 memcached_return_t memcached_connect(memcached_instance_st* server)
 816 {
 817   return _memcached_connect(server, true);
 818 }