struct memcached_error_st
{
memcached_st *root;
+ uint64_t query_id;
struct memcached_error_st *next;
memcached_return_t rc;
int local_errno;
char c_str[];
};
-static memcached_error_st *_set(memcached_st *memc, memcached_string_t *str)
+static void _set(memcached_st *memc, memcached_string_t *str, const memcached_return_t rc, const int local_errno)
{
+ WATCHPOINT_ASSERT(memc);
if (! memc)
- return NULL;
+ return;
+
+ if (memc->error_messages && memc->error_messages->query_id != memc->query_id)
+ {
+ memcached_error_free(memc);
+ }
memcached_error_st *error;
error= (struct memcached_error_st *)libmemcached_malloc(memc, sizeof(struct memcached_error_st) +(str ? str->size :0) +1);
if (! error)
- return NULL;
+ return;
error->root= memc;
+ error->query_id= memc->query_id;
+ error->rc= rc;
+ error->local_errno= local_errno;
if (str)
{
error->size= str->size;
memcpy(error->c_str, str->c_str, str->size);
+ error->c_str[str->size]= 0;
+ }
+ else
+ {
+ error->size= 0;
}
- error->c_str[(str ? str->size :0)]= 0;
error->next= memc->error_messages;
memc->error_messages= error;
+}
- return error;
+memcached_return_t memcached_set_error_string(memcached_st *memc, memcached_return_t rc, const char *str, size_t length)
+{
+ memcached_string_t tmp;
+ tmp.c_str= str;
+ tmp.size= length;
+ return memcached_set_error(memc, rc, &tmp);
}
memcached_return_t memcached_set_error(memcached_st *memc, memcached_return_t rc, memcached_string_t *str)
if (rc == MEMCACHED_SUCCESS)
return MEMCACHED_SUCCESS;
- memcached_error_st *error= _set(memc, str);
-
- if (error)
- {
- error->local_errno= 0;
- error->rc= rc;
- }
+ _set(memc, str, rc, 0);
return rc;
}
memcached_return_t memcached_set_errno(memcached_st *memc, int local_errno, memcached_string_t *str)
{
- memcached_error_st *error= _set(memc, str);
+ _set(memc, str, MEMCACHED_ERRNO, local_errno);
+
+ return MEMCACHED_ERRNO;
+}
+
+static void _error_print(const memcached_error_st *error)
+{
+ if (! error)
+ return;
- if (error)
+ if (! error->size)
{
- error->local_errno= local_errno;
- error->rc= MEMCACHED_ERRNO;
+ fprintf(stderr, "%s\n", memcached_strerror(NULL, error->rc) );
}
+ else
+ {
+ fprintf(stderr, "%s %s\n", memcached_strerror(NULL, error->rc), error->c_str);
+ }
+
+ _error_print(error->next);
+}
- return error->rc;
+void memcached_error_print(const memcached_st *self)
+{
+ if (! self)
+ return;
+
+ _error_print(self->error_messages);
}
static void _error_free(memcached_error_st *error)
if (! memc->error_messages)
return memcached_strerror(memc, MEMCACHED_SUCCESS);
- if (! memc->error_messages->c_str)
+ if (! memc->error_messages->size)
{
return memcached_strerror(memc, memc->error_messages->rc);
}
return memc->error_messages->rc;
}
-memcached_return_t memcached_last_error_errno(memcached_st *memc)
+int memcached_last_error_errno(memcached_st *memc)
{
if (! memc)
- return MEMCACHED_INVALID_ARGUMENTS;
+ return 0;
if (! memc->error_messages)
- return MEMCACHED_SUCCESS;
+ return 0;
return memc->error_messages->local_errno;
}