X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Ferror.cc;h=f4ce85d0c70498383518502eb8d46950de0091a3;hb=bf8213041709c75147393c8bd6b51b8f9e064f7c;hp=1ca355b82231ac424fbbc89fb5bc1d50d9d1c8e4;hpb=387c65c94bec4333da574771fc82a40deabbc3e2;p=m6w6%2Flibmemcached diff --git a/libmemcached/error.cc b/libmemcached/error.cc index 1ca355b8..f4ce85d0 100644 --- a/libmemcached/error.cc +++ b/libmemcached/error.cc @@ -36,7 +36,9 @@ */ #include +#include #include +#include #define MAX_ERROR_LENGTH 2048 struct memcached_error_t @@ -50,9 +52,9 @@ struct memcached_error_t char message[MAX_ERROR_LENGTH]; }; -static void _set(memcached_server_st& server, memcached_st& memc) +static void _set(org::libmemcached::Instance& server, Memcached& memc) { - if (server.error_messages && server.error_messages->query_id != server.root->query_id) + if (server.error_messages and server.error_messages->query_id != server.root->query_id) { memcached_error_free(server); } @@ -106,6 +108,11 @@ static void _set(memcached_st& memc, memcached_string_t *str, memcached_return_t rc= MEMCACHED_CONNECTION_FAILURE; } + if (rc == MEMCACHED_ERRNO and local_errno == ECONNRESET) + { + rc= MEMCACHED_CONNECTION_FAILURE; + } + if (local_errno == EINVAL) { rc= MEMCACHED_INVALID_ARGUMENTS; @@ -134,48 +141,51 @@ static void _set(memcached_st& memc, memcached_string_t *str, memcached_return_t if (local_errno) { -#ifdef STRERROR_R_CHAR_P +#if defined(STRERROR_R_CHAR_P) && STRERROR_R_CHAR_P errmsg_ptr= strerror_r(local_errno, errmsg, sizeof(errmsg)); -#else +#elif defined(HAVE_STRERROR_R) && HAVE_STRERROR_R strerror_r(local_errno, errmsg, sizeof(errmsg)); errmsg_ptr= errmsg; +#elif defined(HAVE_STRERROR) && HAVE_STRERROR + snprintf(errmsg, sizeof(errmsg), "%s", strerror(local_errno)); + errmsg_ptr= errmsg; #endif } if (str and str->size and local_errno) { - error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%lu) %s(%s), %.*s -> %s", - long(error->root), + error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %s(%s), %.*s -> %s", + error->root, memcached_strerror(&memc, rc), errmsg_ptr, memcached_string_printf(*str), at); } else if (local_errno) { - error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%lu) %s(%s) -> %s", - long(error->root), + error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %s(%s) -> %s", + error->root, memcached_strerror(&memc, rc), errmsg_ptr, at); } else if (rc == MEMCACHED_PARSE_ERROR and str and str->size) { - error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%lu) %.*s -> %s", - long(error->root), + error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %.*s -> %s", + error->root, int(str->size), str->c_str, at); } else if (str and str->size) { - error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%lu) %s, %.*s -> %s", - long(error->root), + error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %s, %.*s -> %s", + error->root, memcached_strerror(&memc, rc), int(str->size), str->c_str, at); } else { - error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%lu) %s -> %s", - long(error->root), + error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %s -> %s", + error->root, memcached_strerror(&memc, rc), at); } @@ -204,14 +214,19 @@ memcached_return_t memcached_set_error(memcached_st& memc, memcached_return_t rc return memcached_set_error(memc, rc, at, tmp); } -memcached_return_t memcached_set_error(memcached_server_st& self, memcached_return_t rc, const char *at, const char *str, size_t length) +memcached_return_t memcached_set_error(org::libmemcached::Instance& self, memcached_return_t rc, const char *at, const char *str, size_t length) { assert_msg(rc != MEMCACHED_ERRNO, "Programmer error, MEMCACHED_ERRNO was set to be returned to client"); - assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a memcached_server_st"); + assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a Instance"); + memcached_string_t tmp= { str, length }; return memcached_set_error(self, rc, at, tmp); } +#ifndef __INTEL_COMPILER +#pragma GCC diagnostic ignored "-Wformat-nonliteral" +#endif + memcached_return_t memcached_set_error(memcached_st& memc, memcached_return_t rc, const char *at, memcached_string_t& str) { assert_msg(rc != MEMCACHED_ERRNO, "Programmer error, MEMCACHED_ERRNO was set to be returned to client"); @@ -239,32 +254,50 @@ memcached_return_t memcached_set_parser_error(memcached_st& memc, return memcached_set_error(memc, MEMCACHED_PARSE_ERROR, at, buffer, length); } -memcached_return_t memcached_set_error(memcached_server_st& self, memcached_return_t rc, const char *at, memcached_string_t& str) +static inline size_t append_host_to_string(org::libmemcached::Instance& self, char* buffer, const size_t buffer_length) +{ + size_t size= 0; + switch (self.type) + { + case MEMCACHED_CONNECTION_TCP: + case MEMCACHED_CONNECTION_UDP: + size+= snprintf(buffer, buffer_length, " host: %s:%d", + self.hostname, int(self.port())); + break; + + case MEMCACHED_CONNECTION_UNIX_SOCKET: + size+= snprintf(buffer, buffer_length, " socket: %s", + self.hostname); + break; + } + + return size; +} + +memcached_return_t memcached_set_error(org::libmemcached::Instance& self, memcached_return_t rc, const char *at, memcached_string_t& str) { assert_msg(rc != MEMCACHED_ERRNO, "Programmer error, MEMCACHED_ERRNO was set to be returned to client"); - assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a memcached_server_st"); - if (memcached_fatal(rc) == false) + assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a org::libmemcached::Instance"); + if (memcached_fatal(rc) == false and rc != MEMCACHED_CLIENT_ERROR) { return rc; } char hostname_port_message[MAX_ERROR_LENGTH]; - int size; + char* hostname_port_message_ptr= hostname_port_message; + int size= 0; if (str.size) { - size= snprintf(hostname_port_message, sizeof(hostname_port_message), "%.*s, host: %s:%d", - memcached_string_printf(str), - self.hostname, int(self.port)); - } - else - { - size= snprintf(hostname_port_message, sizeof(hostname_port_message), "host: %s:%d", - self.hostname, int(self.port)); + size= snprintf(hostname_port_message_ptr, sizeof(hostname_port_message), "%.*s, ", + memcached_string_printf(str)); + hostname_port_message_ptr+= size; } - memcached_string_t error_host= { hostname_port_message, size }; + size+= append_host_to_string(self, hostname_port_message_ptr, sizeof(hostname_port_message) -size); + + memcached_string_t error_host= { hostname_port_message, size_t(size) }; - assert(self.root); + assert_msg(self.root, "Programmer error, root was not set on instance"); if (self.root == NULL) { return rc; @@ -274,20 +307,21 @@ memcached_return_t memcached_set_error(memcached_server_st& self, memcached_retu _set(self, (*self.root)); assert(self.root->error_messages); assert(self.error_messages); + assert(self.error_messages->rc == self.root->error_messages->rc); return rc; } -memcached_return_t memcached_set_error(memcached_server_st& self, memcached_return_t rc, const char *at) +memcached_return_t memcached_set_error(org::libmemcached::Instance& self, memcached_return_t rc, const char *at) { - assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a memcached_server_st"); + assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a org::libmemcached::Instance"); if (memcached_fatal(rc) == false) { return rc; } - char hostname_port[NI_MAXHOST +NI_MAXSERV + sizeof("host : ")]; - int size= snprintf(hostname_port, sizeof(hostname_port), "host: %s:%d", self.hostname, int(self.port)); + char hostname_port[MEMCACHED_NI_MAXHOST +MEMCACHED_NI_MAXSERV + sizeof("host : ")]; + size_t size= append_host_to_string(self, hostname_port, sizeof(hostname_port)); memcached_string_t error_host= { hostname_port, size}; @@ -321,7 +355,7 @@ memcached_return_t memcached_set_errno(memcached_st& self, int local_errno, cons return memcached_set_errno(self, local_errno, at, tmp); } -memcached_return_t memcached_set_errno(memcached_server_st& self, int local_errno, const char *at, const char *str, size_t length) +memcached_return_t memcached_set_errno(org::libmemcached::Instance& self, int local_errno, const char *at, const char *str, size_t length) { memcached_string_t tmp= { str, length }; return memcached_set_errno(self, local_errno, at, tmp); @@ -353,7 +387,7 @@ memcached_return_t memcached_set_errno(memcached_st& memc, int local_errno, cons return rc; } -memcached_return_t memcached_set_errno(memcached_server_st& self, int local_errno, const char *at, memcached_string_t& str) +memcached_return_t memcached_set_errno(org::libmemcached::Instance& self, int local_errno, const char *at, memcached_string_t& str) { if (local_errno == 0) { @@ -361,18 +395,13 @@ memcached_return_t memcached_set_errno(memcached_server_st& self, int local_errn } char hostname_port_message[MAX_ERROR_LENGTH]; - int size; + char* hostname_port_message_ptr= hostname_port_message; + size_t size= 0; if (str.size) { - size= snprintf(hostname_port_message, sizeof(hostname_port_message), "%.*s, host: %s:%d", - memcached_string_printf(str), - self.hostname, int(self.port)); - } - else - { - size= snprintf(hostname_port_message, sizeof(hostname_port_message), "host: %s:%d", - self.hostname, int(self.port)); + size= snprintf(hostname_port_message_ptr, sizeof(hostname_port_message), "%.*s, ", memcached_string_printf(str)); } + size+= append_host_to_string(self, hostname_port_message_ptr, sizeof(hostname_port_message) -size); memcached_string_t error_host= { hostname_port_message, size }; @@ -385,10 +414,19 @@ memcached_return_t memcached_set_errno(memcached_server_st& self, int local_errn _set(*self.root, &error_host, rc, at, local_errno); _set(self, (*self.root)); +#if 0 + if (self.root->error_messages->rc != self.error_messages->rc) + { + fprintf(stderr, "%s:%d %s != %s\n", __FILE__, __LINE__, + memcached_strerror(NULL, self.root->error_messages->rc), + memcached_strerror(NULL, self.error_messages->rc)); + } +#endif + return rc; } -memcached_return_t memcached_set_errno(memcached_server_st& self, int local_errno, const char *at) +memcached_return_t memcached_set_errno(org::libmemcached::Instance& self, int local_errno, const char *at) { if (local_errno == 0) { @@ -396,8 +434,7 @@ memcached_return_t memcached_set_errno(memcached_server_st& self, int local_errn } char hostname_port_message[MAX_ERROR_LENGTH]; - int size = snprintf(hostname_port_message, sizeof(hostname_port_message), "host: %s:%d", - self.hostname, int(self.port)); + size_t size= append_host_to_string(self, hostname_port_message, sizeof(hostname_port_message)); memcached_string_t error_host= { hostname_port_message, size }; @@ -432,8 +469,9 @@ static void _error_print(const memcached_error_t *error) _error_print(error->next); } -void memcached_error_print(const memcached_st *self) +void memcached_error_print(const memcached_st *shell) { + const Memcached* self= memcached2Memcached(shell); if (self == NULL) { return; @@ -443,7 +481,7 @@ void memcached_error_print(const memcached_st *self) for (uint32_t x= 0; x < memcached_server_count(self); x++) { - memcached_server_instance_st instance= memcached_server_instance_by_position(self, x); + org::libmemcached::Instance* instance= memcached_instance_by_position(self, x); _error_print(instance->error_messages); } @@ -451,21 +489,12 @@ void memcached_error_print(const memcached_st *self) static void _error_free(memcached_error_t *error) { - if (not error) + if (error) { - return; - } - - _error_free(error->next); + _error_free(error->next); - if (error && error->root) - { libmemcached_free(error->root, error); } - else if (error) - { - free(error); - } } void memcached_error_free(memcached_st& self) @@ -474,30 +503,42 @@ void memcached_error_free(memcached_st& self) self.error_messages= NULL; } +void memcached_error_free(org::libmemcached::Instance& self) +{ + _error_free(self.error_messages); + self.error_messages= NULL; +} + void memcached_error_free(memcached_server_st& self) { _error_free(self.error_messages); self.error_messages= NULL; } -const char *memcached_last_error_message(memcached_st *memc) +const char *memcached_error(const memcached_st *memc) { - if (memc == NULL) - { - return memcached_strerror(memc, MEMCACHED_INVALID_ARGUMENTS); - } + return memcached_last_error_message(memc); +} - if (memc->error_messages == NULL) +const char *memcached_last_error_message(const memcached_st *shell) +{ + const Memcached* memc= memcached2Memcached(shell); + if (memc) { - return memcached_strerror(memc, MEMCACHED_SUCCESS); - } + if (memc->error_messages) + { + if (memc->error_messages->size == 0) + { + return memc->error_messages->message; + } - if (memc->error_messages->size == 0) - { - return memcached_strerror(memc, memc->error_messages->rc); + return memcached_strerror(memc, memc->error_messages->rc); + } + + return memcached_strerror(memc, MEMCACHED_SUCCESS); } - return memc->error_messages->message; + return memcached_strerror(memc, MEMCACHED_INVALID_ARGUMENTS); } bool memcached_has_current_error(memcached_st &memc) @@ -512,34 +553,36 @@ bool memcached_has_current_error(memcached_st &memc) return false; } -bool memcached_has_current_error(memcached_server_st& server) +bool memcached_has_current_error(org::libmemcached::Instance& server) { return memcached_has_current_error(*(server.root)); } -memcached_return_t memcached_last_error(memcached_st *memc) +memcached_return_t memcached_last_error(const memcached_st *shell) { - if (memc == NULL) + const Memcached* memc= memcached2Memcached(shell); + if (memc) { - return MEMCACHED_INVALID_ARGUMENTS; - } + if (memc->error_messages) + { + return memc->error_messages->rc; + } - if (not memc->error_messages) - { return MEMCACHED_SUCCESS; } - return memc->error_messages->rc; + return MEMCACHED_INVALID_ARGUMENTS; } -int memcached_last_error_errno(memcached_st *memc) +int memcached_last_error_errno(const memcached_st *shell) { + const Memcached* memc= memcached2Memcached(shell); if (memc == NULL) { return 0; } - if (not memc->error_messages) + if (memc->error_messages == NULL) { return 0; } @@ -547,19 +590,19 @@ int memcached_last_error_errno(memcached_st *memc) return memc->error_messages->local_errno; } -const char *memcached_server_error(memcached_server_instance_st server) +const char *memcached_server_error(const memcached_server_instance_st server) { if (server == NULL) { return NULL; } - if (not server->error_messages) + if (server->error_messages == NULL) { return memcached_strerror(server->root, MEMCACHED_SUCCESS); } - if (not server->error_messages->size) + if (server->error_messages->size == 0) { return memcached_strerror(server->root, server->error_messages->rc); } @@ -568,7 +611,7 @@ const char *memcached_server_error(memcached_server_instance_st server) } -memcached_error_t *memcached_error_copy(const memcached_server_st& server) +memcached_error_t *memcached_error_copy(const org::libmemcached::Instance& server) { if (server.error_messages == NULL) { @@ -596,3 +639,18 @@ memcached_return_t memcached_server_error_return(memcached_server_instance_st pt return MEMCACHED_SUCCESS; } + +memcached_return_t memcached_instance_error_return(org::libmemcached::Instance* instance) +{ + if (instance == NULL) + { + return MEMCACHED_INVALID_ARGUMENTS; + } + + if (instance and instance->error_messages) + { + return instance->error_messages->rc; + } + + return MEMCACHED_SUCCESS; +}