#include <libmemcached/common.h>
-#include <cassert>
#include <ctime>
#include <sys/time.h>
}
default: // A real error occurred and we need to completely bail
- WATCHPOINT_ERRNO(get_socket_errno());
switch (get_socket_errno())
{
#ifdef TARGET_OS_LINUX
int err;
socklen_t len= sizeof (err);
(void)getsockopt(ptr->fd, SOL_SOCKET, SO_ERROR, &err, &len);
- ptr->cached_errno= (err == 0) ? get_socket_errno() : err;
+ memcached_set_errno(*ptr, (err == 0) ? get_socket_errno() : err, MEMCACHED_AT);
}
else
{
- ptr->cached_errno= get_socket_errno();
+ memcached_set_errno(*ptr, get_socket_errno(), MEMCACHED_AT);
}
- WATCHPOINT_ASSERT(ptr->fd != INVALID_SOCKET);
+ assert_msg(ptr->fd != INVALID_SOCKET, "poll() was passed an invalid file descriptor");
(void)closesocket(ptr->fd);
ptr->fd= INVALID_SOCKET;
ptr->state= MEMCACHED_SERVER_STATE_NEW;
static memcached_return_t set_hostinfo(memcached_server_st *server)
{
- WATCHPOINT_ASSERT(not server->address_info); // We cover the case where a programming mistake has been made.
if (server->address_info)
{
freeaddrinfo(server->address_info);
char str_port[NI_MAXSERV];
int length= snprintf(str_port, NI_MAXSERV, "%u", (uint32_t)server->port);
- if (length >= NI_MAXSERV || length < 0)
+ if (length >= NI_MAXSERV or length < 0)
+ {
return MEMCACHED_FAILURE;
+ }
struct addrinfo hints;
memset(&hints, 0, sizeof(struct addrinfo));
default:
{
- WATCHPOINT_STRING(server->hostname);
- WATCHPOINT_STRING(gai_strerror(errcode));
return memcached_set_error(*server, MEMCACHED_HOST_LOOKUP_FAILURE, MEMCACHED_AT, memcached_string_make_from_cstr(gai_strerror(errcode)));
}
}
static void set_socket_options(memcached_server_st *ptr)
{
- WATCHPOINT_ASSERT(ptr->fd != -1);
+ assert_msg(ptr->fd != -1, "invalid socket was passed to set_socket_options()");
if (ptr->type == MEMCACHED_CONNECTION_UDP)
+ {
return;
+ }
#ifdef HAVE_SNDTIMEO
if (ptr->root->snd_timeout)
if ((ptr->fd= socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
{
- return memcached_set_errno(*ptr, errno, NULL);
+ memcached_set_errno(*ptr, errno, NULL);
+ return MEMCACHED_CONNECTION_FAILURE;
}
struct sockaddr_un servAddr;
default:
WATCHPOINT_ERRNO(errno);
- return memcached_set_errno(*ptr, errno, MEMCACHED_AT);
+ memcached_set_errno(*ptr, errno, MEMCACHED_AT);
+ return MEMCACHED_CONNECTION_FAILURE;
}
}
} while (0);
while (--counter)
{
if ((rc= set_hostinfo(ptr)) != MEMCACHED_TIMEOUT)
+ {
break;
+ }
#ifndef WIN32
struct timespec dream, rem;
if ((connect(ptr->fd, ptr->address_info_next->ai_addr, ptr->address_info_next->ai_addrlen) != SOCKET_ERROR))
{
ptr->state= MEMCACHED_SERVER_STATE_CONNECTED;
- break; // Success
+ return MEMCACHED_SUCCESS;
}
/* An error occurred */
struct timeval next_time;
if (gettimeofday(&next_time, NULL) == 0)
+ {
ptr->next_retry= next_time.tv_sec + ptr->root->retry_timeout;
+ }
+ }
+
+ if (memcached_has_current_error(*ptr))
+ {
+ return memcached_server_error_return(ptr);
}
- if (timeout_error_occured)
+ if (timeout_error_occured and ptr->state < MEMCACHED_SERVER_STATE_IN_PROGRESS)
+ {
return memcached_set_error(*ptr, MEMCACHED_TIMEOUT, MEMCACHED_AT);
+ }
return memcached_set_error(*ptr, MEMCACHED_CONNECTION_FAILURE, MEMCACHED_AT); /* The last error should be from connect() */
}
// const_cast
memcached_st *root= (memcached_st *)self->root;
-#if 0
- WATCHPOINT_STRING(self->hostname);
- WATCHPOINT_NUMBER(self->port);
- WATCHPOINT_ERRNO(self->cached_errno);
-#endif
memcached_server_free(root->last_disconnected_server);
root->last_disconnected_server= memcached_server_clone(NULL, self);
}
memcached_return_t rc= MEMCACHED_NO_SERVERS;
if (ptr->fd != INVALID_SOCKET)
+ {
return MEMCACHED_SUCCESS;
+ }
LIBMEMCACHED_MEMCACHED_CONNECT_START();
/* We need to clean up the multi startup piece */
switch (ptr->type)
{
- case MEMCACHED_CONNECTION_UNKNOWN:
- WATCHPOINT_ASSERT(0);
- rc= MEMCACHED_NOT_SUPPORTED;
- break;
-
case MEMCACHED_CONNECTION_UDP:
case MEMCACHED_CONNECTION_TCP:
rc= network_connect(ptr);
-#ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
- if (ptr->fd != INVALID_SOCKET and ptr->root->sasl.callbacks)
+ if (LIBMEMCACHED_WITH_SASL_SUPPORT)
{
- rc= memcached_sasl_authenticate_connection(ptr);
- if (memcached_failed(rc) and ptr->fd != INVALID_SOCKET)
+ if (ptr->fd != INVALID_SOCKET and ptr->root->sasl.callbacks)
{
- WATCHPOINT_ASSERT(ptr->fd != INVALID_SOCKET);
- (void)closesocket(ptr->fd);
- ptr->fd= INVALID_SOCKET;
+ rc= memcached_sasl_authenticate_connection(ptr);
+ if (memcached_failed(rc) and ptr->fd != INVALID_SOCKET)
+ {
+ WATCHPOINT_ASSERT(ptr->fd != INVALID_SOCKET);
+ (void)closesocket(ptr->fd);
+ ptr->fd= INVALID_SOCKET;
+ }
}
}
-#endif
break;
case MEMCACHED_CONNECTION_UNIX_SOCKET:
rc= unix_socket_connect(ptr);
break;
-
- case MEMCACHED_CONNECTION_MAX:
- default:
- WATCHPOINT_ASSERT(0);
}
if (memcached_success(rc))
ptr->server_failure_counter= 0;
ptr->next_retry= 0;
}
+ else if (memcached_has_current_error(*ptr))
+ {
+ ptr->server_failure_counter++;
+ set_last_disconnected_host(ptr);
+ }
else
{
memcached_set_error(*ptr, rc, MEMCACHED_AT);