*/
#include <libmemcached/common.h>
+#include <cstdarg>
#define MAX_ERROR_LENGTH 2048
struct memcached_error_t
}
if (memc.error_messages == NULL)
+ {
return;
+ }
memcached_error_t *error= (struct memcached_error_t *)libmemcached_malloc(&memc, sizeof(struct memcached_error_t));
- if (not error) // Bad business if this happens
+ if (error == NULL) // Bad business if this happens
+ {
return;
+ }
memcpy(error, memc.error_messages, sizeof(memcached_error_t));
error->next= server.error_messages;
static void _set(memcached_st& memc, memcached_string_t *str, memcached_return_t &rc, const char *at, int local_errno= 0)
{
- (void)at;
if (memc.error_messages && memc.error_messages->query_id != memc.query_id)
{
memcached_error_free(memc);
}
memcached_error_t *error= (struct memcached_error_t *)libmemcached_malloc(&memc, sizeof(struct memcached_error_t));
- if (not error) // Bad business if this happens
+ if (error == NULL) // Bad business if this happens
+ {
return;
+ }
error->root= &memc;
error->query_id= memc.query_id;
errmsg_ptr,
at);
}
+ else if (rc == MEMCACHED_PARSE_ERROR and str and str->size)
+ {
+ error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "%.*s -> %s",
+ int(str->size), str->c_str, at);
+ }
else if (str and str->size)
{
error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "%s, %.*s -> %s",
{
assert_msg(rc != MEMCACHED_ERRNO, "Programmer error, MEMCACHED_ERRNO was set to be returned to client");
if (memcached_success(rc))
- return MEMCACHED_SUCCESS;
+ {
+ return rc;
+ }
_set(memc, &str, rc, at);
return rc;
}
+memcached_return_t memcached_set_parser_error(memcached_st& memc,
+ const char *at,
+ const char *format, ...)
+{
+ va_list args;
+
+ char buffer[BUFSIZ];
+ va_start(args, format);
+ int length= vsnprintf(buffer, sizeof(buffer), format, args);
+ va_end(args);
+
+ 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)
{
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_success(rc))
- return MEMCACHED_SUCCESS;
+ {
+ return rc;
+ }
char hostname_port_message[MAX_ERROR_LENGTH];
int size;
memcached_string_t error_host= { hostname_port_message, size };
- if (not self.root)
+ assert(self.root);
+ if (self.root == NULL)
+ {
return rc;
+ }
_set(*self.root, &error_host, rc, at);
_set(self, (*self.root));
+ assert(self.root->error_messages);
+ assert(self.error_messages);
return rc;
}
memcached_return_t memcached_set_error(memcached_server_st& self, memcached_return_t rc, const char *at)
{
- 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_success(rc))
- return MEMCACHED_SUCCESS;
+ {
+ 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));
memcached_string_t error_host= { hostname_port, size};
- if (not self.root)
+ if (self.root == NULL)
+ {
return rc;
+ }
_set(*self.root, &error_host, rc, at);
_set(self, *self.root);
{
assert_msg(rc != MEMCACHED_ERRNO, "Programmer error, MEMCACHED_ERRNO was set to be returned to client");
if (memcached_success(rc))
- return MEMCACHED_SUCCESS;
+ {
+ return rc;
+ }
_set(self, NULL, rc, at);
memcached_return_t memcached_set_errno(memcached_st& self, int local_errno, const char *at)
{
- if (not local_errno)
+ if (local_errno == 0)
+ {
return MEMCACHED_SUCCESS;
+ }
memcached_return_t rc= MEMCACHED_ERRNO;
_set(self, NULL, rc, at, local_errno);
memcached_return_t memcached_set_errno(memcached_st& memc, int local_errno, const char *at, memcached_string_t& str)
{
- if (not local_errno)
+ if (local_errno == 0)
+ {
return MEMCACHED_SUCCESS;
+ }
memcached_return_t rc= MEMCACHED_ERRNO;
_set(memc, &str, rc, at, local_errno);
memcached_return_t memcached_set_errno(memcached_server_st& self, int local_errno, const char *at, memcached_string_t& str)
{
- if (not local_errno)
+ if (local_errno == 0)
+ {
return MEMCACHED_SUCCESS;
+ }
char hostname_port_message[MAX_ERROR_LENGTH];
int size;
memcached_return_t memcached_set_errno(memcached_server_st& self, int local_errno, const char *at)
{
- if (not local_errno)
+ if (local_errno == 0)
+ {
return MEMCACHED_SUCCESS;
+ }
char hostname_port_message[MAX_ERROR_LENGTH];
int size = snprintf(hostname_port_message, sizeof(hostname_port_message), "host: %s:%d",
static void _error_print(const memcached_error_t *error)
{
- if (not error)
+ if (error == NULL)
+ {
return;
+ }
- if (not error->size)
+ if (error->size == 0)
{
fprintf(stderr, "%s\n", memcached_strerror(NULL, error->rc) );
}
static void _error_free(memcached_error_t *error)
{
if (not error)
+ {
return;
+ }
_error_free(error->next);
const char *memcached_last_error_message(memcached_st *memc)
{
- if (not memc)
+ if (memc == NULL)
+ {
return memcached_strerror(memc, MEMCACHED_INVALID_ARGUMENTS);
+ }
- if (not memc->error_messages)
+ if (memc->error_messages == NULL)
+ {
return memcached_strerror(memc, MEMCACHED_SUCCESS);
+ }
- if (not memc->error_messages->size)
+ if (memc->error_messages->size == 0)
+ {
return memcached_strerror(memc, memc->error_messages->rc);
+ }
return memc->error_messages->message;
}
memcached_return_t memcached_last_error(memcached_st *memc)
{
- if (not memc)
+ if (memc == NULL)
+ {
return MEMCACHED_INVALID_ARGUMENTS;
+ }
if (not memc->error_messages)
return MEMCACHED_SUCCESS;
int memcached_last_error_errno(memcached_st *memc)
{
- if (not memc)
+ if (memc == NULL)
+ {
return 0;
+ }
if (not memc->error_messages)
+ {
return 0;
+ }
return memc->error_messages->local_errno;
}
const char *memcached_server_error(memcached_server_instance_st server)
{
- if (not server)
- return memcached_strerror(server->root, MEMCACHED_INVALID_ARGUMENTS);
+ if (server == NULL)
+ {
+ return NULL;
+ }
if (not server->error_messages)
return memcached_strerror(server->root, MEMCACHED_SUCCESS);
memcached_error_t *memcached_error_copy(const memcached_server_st& server)
{
- if (not server.error_messages)
+ if (server.error_messages == NULL)
+ {
return NULL;
+ }
memcached_error_t *error= (memcached_error_t *)libmemcached_malloc(server.root, sizeof(memcached_error_t));
memcpy(error, server.error_messages, sizeof(memcached_error_t));
memcached_return_t memcached_server_error_return(memcached_server_instance_st ptr)
{
+ if (ptr == NULL)
+ {
+ return MEMCACHED_INVALID_ARGUMENTS;
+ }
+
if (ptr and ptr->error_messages)
{
return ptr->error_messages->rc;
}
- return MEMCACHED_FAILURE;
+ return MEMCACHED_SUCCESS;
}