#include <libmemcached/common.h>
-#include <assert.h>
+#include <cassert>
+#include <ctime>
#include <sys/time.h>
-#include <time.h>
static memcached_return_t connect_poll(memcached_server_st *ptr)
{
hints.ai_protocol= IPPROTO_TCP;
}
- uint32_t counter= 5;
- while (--counter)
+ int errcode;
+ switch(errcode= getaddrinfo(server->hostname, str_port, &hints, &server->address_info))
{
- int errcode;
- switch(errcode= getaddrinfo(server->hostname, str_port, &hints, &server->address_info))
- {
- case 0:
- break;
- case EAI_AGAIN:
- if (counter > 1)
- {
-#ifndef WIN32
- struct timespec dream, rem;
+ case 0:
+ break;
- dream.tv_nsec= 1000;
- dream.tv_sec= 0;
+ case EAI_AGAIN:
+ return memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT, memcached_string_make_from_cstr(gai_strerror(errcode)));
- nanosleep(&dream, &rem);
-#endif
- continue;
- }
- else
- {
- return memcached_set_error_string(*server, MEMCACHED_HOST_LOOKUP_FAILURE, gai_strerror(errcode), strlen(gai_strerror(errcode)));
- }
+ case EAI_SYSTEM:
+ return memcached_set_errno(*server, errno, MEMCACHED_AT, memcached_literal_param("getaddrinfo(EAI_SYSTEM)"));
- case EAI_SYSTEM:
- {
- static memcached_string_t mesg= { memcached_string_make("getaddrinfo") };
- return memcached_set_errno(*server, errno, &mesg);
- }
- case EAI_BADFLAGS:
- return memcached_set_error_string(*server, MEMCACHED_HOST_LOOKUP_FAILURE, memcached_literal_param("getaddrinfo(EAI_BADFLAGS)"));
+ case EAI_BADFLAGS:
+ return memcached_set_error(*server, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT, memcached_literal_param("getaddrinfo(EAI_BADFLAGS)"));
- case EAI_MEMORY:
- return memcached_set_error_string(*server, MEMCACHED_ERRNO, memcached_literal_param("getaddrinfo(EAI_MEMORY)"));
+ case EAI_MEMORY:
+ return memcached_set_error(*server, MEMCACHED_ERRNO, MEMCACHED_AT, memcached_literal_param("getaddrinfo(EAI_MEMORY)"));
- default:
- {
- WATCHPOINT_STRING(server->hostname);
- WATCHPOINT_STRING(gai_strerror(e));
- return memcached_set_error_string(*server, MEMCACHED_HOST_LOOKUP_FAILURE, gai_strerror(errcode), strlen(gai_strerror(errcode)));
- }
+ default:
+ {
+ WATCHPOINT_STRING(server->hostname);
+ WATCHPOINT_STRING(gai_strerror(e));
+ return memcached_set_error(*server, MEMCACHED_HOST_LOOKUP_FAILURE, MEMCACHED_AT, memcached_string_make_from_cstr(gai_strerror(errcode)));
}
}
-
server->address_info_next= server->address_info;
return MEMCACHED_SUCCESS;
if ((ptr->fd= socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
{
- ptr->cached_errno= errno;
- return MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE;
+ return memcached_set_errno(*ptr, errno, NULL);
}
struct sockaddr_un servAddr;
}
}
- WATCHPOINT_ASSERT(ptr->fd != -1);
+ WATCHPOINT_ASSERT(ptr->fd != INVALID_SOCKET);
return MEMCACHED_SUCCESS;
#else
WATCHPOINT_ASSERT(ptr->fd == INVALID_SOCKET);
WATCHPOINT_ASSERT(ptr->cursor_active == 0);
- if (! ptr->address_info)
+ if (not ptr->address_info)
{
- memcached_return_t rc= set_hostinfo(ptr);
- if (rc != MEMCACHED_SUCCESS)
+ memcached_return_t rc;
+ uint32_t counter= 5;
+ while (--counter)
+ {
+ if ((rc= set_hostinfo(ptr)) != MEMCACHED_TIMEOUT)
+ break;
+
+#ifndef WIN32
+ struct timespec dream, rem;
+
+ dream.tv_nsec= 1000;
+ dream.tv_sec= 0;
+
+ nanosleep(&dream, &rem);
+#endif
+ }
+
+ if (memcached_failed(rc))
return rc;
}
ptr->address_info_next->ai_socktype,
ptr->address_info_next->ai_protocol)) < 0)
{
- ptr->cached_errno= get_socket_errno();
- WATCHPOINT_ERRNO(get_socket_errno());
- return MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE;
+ return memcached_set_errno(*ptr, get_socket_errno(), NULL);
}
(void)set_socket_options(ptr);
return MEMCACHED_SUCCESS; /* The last error should be from connect() */
}
-void set_last_disconnected_host(memcached_server_write_instance_st ptr)
+void set_last_disconnected_host(memcached_server_write_instance_st self)
{
// const_cast
- memcached_st *root= (memcached_st *)ptr->root;
+ memcached_st *root= (memcached_st *)self->root;
#if 0
- WATCHPOINT_STRING(ptr->hostname);
- WATCHPOINT_NUMBER(ptr->port);
- WATCHPOINT_ERRNO(ptr->cached_errno);
+ WATCHPOINT_STRING(self->hostname);
+ WATCHPOINT_NUMBER(self->port);
+ WATCHPOINT_ERRNO(self->cached_errno);
#endif
- if (root->last_disconnected_server)
- memcached_server_free(root->last_disconnected_server);
- root->last_disconnected_server= memcached_server_clone(NULL, ptr);
+ memcached_server_free(root->last_disconnected_server);
+ root->last_disconnected_server= memcached_server_clone(NULL, self);
}
memcached_return_t memcached_connect(memcached_server_write_instance_st ptr)
{
set_last_disconnected_host(ptr);
- return MEMCACHED_SERVER_MARKED_DEAD;
+ return memcached_set_error(*ptr, MEMCACHED_SERVER_MARKED_DEAD, MEMCACHED_AT);
}
}
run_distribution((memcached_st *)ptr->root);
}
- return MEMCACHED_SERVER_MARKED_DEAD;
+ return memcached_set_error(*ptr, MEMCACHED_SERVER_MARKED_DEAD, MEMCACHED_AT);
}
/* We need to clean up the multi startup piece */
WATCHPOINT_ASSERT(0);
rc= MEMCACHED_NOT_SUPPORTED;
break;
+
case MEMCACHED_CONNECTION_UDP:
case MEMCACHED_CONNECTION_TCP:
rc= network_connect(ptr);
if (ptr->fd != INVALID_SOCKET && ptr->root->sasl.callbacks)
{
rc= memcached_sasl_authenticate_connection(ptr);
- if (rc != MEMCACHED_SUCCESS)
+ if (memcached_failed(rc))
{
(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 (rc == MEMCACHED_SUCCESS)
+ if (memcached_success(rc))
{
ptr->server_failure_counter= 0;
ptr->next_retry= 0;
}
else
{
+ memcached_set_error(*ptr, rc, MEMCACHED_AT);
ptr->server_failure_counter++;
-
set_last_disconnected_host(ptr);
}