+ // For memory allocation we use our error since it is a bit more specific
+ if (local_errno == ENOMEM and rc == MEMCACHED_ERRNO)
+ {
+ rc= MEMCACHED_MEMORY_ALLOCATION_FAILURE;
+ }
+
+ if (rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE)
+ {
+ local_errno= ENOMEM;
+ }
+
+ if (rc == MEMCACHED_ERRNO and not local_errno)
+ {
+ local_errno= errno;
+ rc= MEMCACHED_ERRNO;
+ }
+
+ if (rc == MEMCACHED_ERRNO and local_errno == ENOTCONN)
+ {
+ rc= MEMCACHED_CONNECTION_FAILURE;
+ }
+
+ if (rc == MEMCACHED_ERRNO and local_errno == ECONNRESET)
+ {
+ rc= MEMCACHED_CONNECTION_FAILURE;
+ }
+
+ if (local_errno == EINVAL)
+ {
+ rc= MEMCACHED_INVALID_ARGUMENTS;
+ }
+
+ if (local_errno == ECONNREFUSED)
+ {
+ rc= MEMCACHED_CONNECTION_FAILURE;
+ }
+
+ if (rc == MEMCACHED_TIMEOUT)
+ {
+ }
+
+ memcached_error_t *error= libmemcached_xmalloc(&memc, memcached_error_t);
+ if (error == NULL) // Bad business if this happens
+ {
+ assert_msg(error, "libmemcached_xmalloc() failed to allocate a memcached_error_t");
+ return;
+ }
+
+ error->root= &memc;
+ error->query_id= memc.query_id;
+ error->rc= rc;
+ error->local_errno= local_errno;
+
+ // MEMCACHED_CLIENT_ERROR is a special case because it is an error coming from the server
+ if (rc == MEMCACHED_CLIENT_ERROR)
+ {
+ assert(str);
+ assert(str->size);
+ if (str and str->size)
+ {
+ assert(error->local_errno == 0);
+ error->local_errno= 0;
+
+ error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %.*s",
+ error->root,
+ int(str->size), str->c_str);
+ }
+ }
+ else if (local_errno)
+ {
+ const char *errmsg_ptr;
+ char errmsg[MAX_ERROR_LENGTH];
+ errmsg[0]= 0;
+ errmsg_ptr= errmsg;
+
+#if defined(STRERROR_R_CHAR_P) && STRERROR_R_CHAR_P
+ errmsg_ptr= strerror_r(local_errno, errmsg, sizeof(errmsg));
+#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