git.m6w6.name Git - awesomized/libmemcached/blob - libmemcached/error.cc

   1 /*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
   2  *
   3  *  LibMemcached
   4  *
   5  *  Copyright (C) 2011 Data Differential, http://datadifferential.com/
   6  *  All rights reserved.
   7  *
   8  *  Redistribution and use in source and binary forms, with or without
   9  *  modification, are permitted provided that the following conditions are
  10  *  met:
  11  *
  12  *      * Redistributions of source code must retain the above copyright
  13  *  notice, this list of conditions and the following disclaimer.
  14  *
  15  *      * Redistributions in binary form must reproduce the above
  16  *  copyright notice, this list of conditions and the following disclaimer
  17  *  in the documentation and/or other materials provided with the
  18  *  distribution.
  19  *
  20  *      * The names of its contributors may not be used to endorse or
  21  *  promote products derived from this software without specific prior
  22  *  written permission.
  23  *
  24  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  25  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  26  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  27  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  28  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  29  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  30  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  31  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  32  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  33  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  34  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  35  *
  36  */
  37
  38 #include <libmemcached/common.h>
  39 #include <cassert>
  40
  41 #define MAX_ERROR_LENGTH 2048
  42 struct memcached_error_t
  43 {
  44   memcached_st *root;
  45   uint64_t query_id;
  46   struct memcached_error_t *next;
  47   memcached_return_t rc;
  48   int local_errno;
  49   size_t size;
  50   char message[MAX_ERROR_LENGTH];
  51 };
  52
  53 static void _set(memcached_server_st& server, memcached_st& memc)
  54 {
  55   if (server.error_messages && server.error_messages->query_id != server.root->query_id)
  56   {
  57     memcached_error_free(server);
  58   }
  59
  60   if (memc.error_messages == NULL)
  61     return;
  62
  63   memcached_error_t *error= (struct memcached_error_t *)libmemcached_malloc(&memc, sizeof(struct memcached_error_t));
  64   if (not error) // Bad business if this happens
  65     return;
  66
  67   memcpy(error, memc.error_messages, sizeof(memcached_error_t));
  68   error->next= server.error_messages;
  69   server.error_messages= error;
  70 }
  71
  72 static void _set(memcached_st& memc, memcached_string_t *str, memcached_return_t &rc, const char *at, int local_errno= 0)
  73 {
  74   (void)at;
  75   if (memc.error_messages && memc.error_messages->query_id != memc.query_id)
  76   {
  77     memcached_error_free(memc);
  78   }
  79
  80   // For memory allocation we use our error since it is a bit more specific
  81   if (local_errno == ENOMEM and rc == MEMCACHED_ERRNO)
  82   {
  83     rc= MEMCACHED_MEMORY_ALLOCATION_FAILURE;
  84   }
  85
  86   if (rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE)
  87   {
  88     local_errno= ENOMEM;
  89   }
  90
  91   if (rc == MEMCACHED_ERRNO and not local_errno)
  92   {
  93     local_errno= errno;
  94     rc= MEMCACHED_ERRNO;
  95   }
  96
  97   if (rc == MEMCACHED_ERRNO and local_errno == ENOTCONN)
  98   {
  99     rc= MEMCACHED_CONNECTION_FAILURE;
 100   }
 101
 102   if (local_errno == EINVAL)
 103   {
 104     rc= MEMCACHED_INVALID_ARGUMENTS;
 105   }
 106
 107   if (local_errno == ECONNREFUSED)
 108   {
 109     rc= MEMCACHED_CONNECTION_FAILURE;
 110   }
 111
 112   memcached_error_t *error= (struct memcached_error_t *)libmemcached_malloc(&memc, sizeof(struct memcached_error_t));
 113   if (not error) // Bad business if this happens
 114     return;
 115
 116   error->root= &memc;
 117   error->query_id= memc.query_id;
 118   error->rc= rc;
 119   error->local_errno= local_errno;
 120
 121   const char *errmsg_ptr;
 122   char errmsg[MAX_ERROR_LENGTH];
 123   errmsg[0]= 0;
 124   errmsg_ptr= errmsg;
 125
 126   if (local_errno)
 127   {
 128 #ifdef STRERROR_R_CHAR_P
 129     errmsg_ptr= strerror_r(local_errno, errmsg, sizeof(errmsg));
 130 #else
 131     strerror_r(local_errno, errmsg, sizeof(errmsg));
 132     errmsg_ptr= errmsg;
 133 #endif
 134   }
 135
 136
 137   if (str and str->size and local_errno)
 138   {
 139     error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "%s(%s), %.*s -> %s",
 140                                memcached_strerror(&memc, rc),
 141                                errmsg_ptr,
 142                                memcached_string_printf(*str), at);
 143   }
 144   else if (local_errno)
 145   {
 146     error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "%s(%s) -> %s",
 147                                memcached_strerror(&memc, rc),
 148                                errmsg_ptr,
 149                                at);
 150   }
 151   else if (str and str->size)
 152   {
 153     error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "%s, %.*s -> %s",
 154                                memcached_strerror(&memc, rc),
 155                                int(str->size), str->c_str, at);
 156   }
 157   else
 158   {
 159     error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "%s -> %s",
 160                                memcached_strerror(&memc, rc), at);
 161   }
 162
 163   error->next= memc.error_messages;
 164   memc.error_messages= error;
 165 }
 166
 167 memcached_return_t memcached_set_error(memcached_st& memc, memcached_return_t rc, const char *at, const char *str, size_t length)
 168 {
 169   assert(rc != MEMCACHED_ERRNO);
 170   memcached_string_t tmp= { str, length };
 171   return memcached_set_error(memc, rc, at, tmp);
 172 }
 173
 174 memcached_return_t memcached_set_error(memcached_server_st& self, memcached_return_t rc, const char *at, const char *str, size_t length)
 175 {
 176   assert(rc != MEMCACHED_ERRNO);
 177   memcached_string_t tmp= { str, length };
 178   return memcached_set_error(self, rc, at, tmp);
 179 }
 180
 181 memcached_return_t memcached_set_error(memcached_st& memc, memcached_return_t rc, const char *at, memcached_string_t& str)
 182 {
 183   assert(rc != MEMCACHED_ERRNO);
 184   if (memcached_success(rc))
 185     return MEMCACHED_SUCCESS;
 186
 187   _set(memc, &str, rc, at);
 188
 189   return rc;
 190 }
 191
 192 memcached_return_t memcached_set_error(memcached_server_st& self, memcached_return_t rc, const char *at, memcached_string_t& str)
 193 {
 194   assert(rc != MEMCACHED_ERRNO);
 195   if (memcached_success(rc))
 196     return MEMCACHED_SUCCESS;
 197
 198   char hostname_port_message[MAX_ERROR_LENGTH];
 199   int size;
 200   if (str.size)
 201   {
 202     size= snprintf(hostname_port_message, sizeof(hostname_port_message), "%.*s, host: %s:%d",
 203                    memcached_string_printf(str),
 204                    self.hostname, int(self.port));
 205   }
 206   else
 207   {
 208     size= snprintf(hostname_port_message, sizeof(hostname_port_message), "host: %s:%d",
 209                    self.hostname, int(self.port));
 210   }
 211
 212   memcached_string_t error_host= { hostname_port_message, size };
 213
 214   if (not self.root)
 215     return rc;
 216
 217   _set(*self.root, &error_host, rc, at);
 218   _set(self, (*self.root));
 219
 220   return rc;
 221 }
 222
 223 memcached_return_t memcached_set_error(memcached_server_st& self, memcached_return_t rc, const char *at)
 224 {
 225   assert(rc != MEMCACHED_ERRNO);
 226   if (memcached_success(rc))
 227     return MEMCACHED_SUCCESS;
 228
 229   char hostname_port[NI_MAXHOST +NI_MAXSERV + sizeof("host : ")];
 230   int size= snprintf(hostname_port, sizeof(hostname_port), "host: %s:%d", self.hostname, int(self.port));
 231
 232   memcached_string_t error_host= { hostname_port, size};
 233
 234   if (not self.root)
 235     return rc;
 236
 237   _set(*self.root, &error_host, rc, at);
 238   _set(self, *self.root);
 239
 240   return rc;
 241 }
 242
 243 memcached_return_t memcached_set_error(memcached_st& self, memcached_return_t rc, const char *at)
 244 {
 245   assert(rc != MEMCACHED_ERRNO);
 246   if (memcached_success(rc))
 247     return MEMCACHED_SUCCESS;
 248
 249   _set(self, NULL, rc, at);
 250
 251   return rc;
 252 }
 253
 254 memcached_return_t memcached_set_errno(memcached_st& self, int local_errno, const char *at, const char *str, size_t length)
 255 {
 256   memcached_string_t tmp= { str, length };
 257   return memcached_set_errno(self, local_errno, at, tmp);
 258 }
 259
 260 memcached_return_t memcached_set_errno(memcached_server_st& self, int local_errno, const char *at, const char *str, size_t length)
 261 {
 262   memcached_string_t tmp= { str, length };
 263   return memcached_set_errno(self, local_errno, at, tmp);
 264 }
 265
 266 memcached_return_t memcached_set_errno(memcached_st& self, int local_errno, const char *at)
 267 {
 268   if (not local_errno)
 269     return MEMCACHED_SUCCESS;
 270
 271   memcached_return_t rc= MEMCACHED_ERRNO;
 272   _set(self, NULL, rc, at, local_errno);
 273
 274   return rc;
 275 }
 276
 277 memcached_return_t memcached_set_errno(memcached_st& memc, int local_errno, const char *at, memcached_string_t& str)
 278 {
 279   if (not local_errno)
 280     return MEMCACHED_SUCCESS;
 281
 282   memcached_return_t rc= MEMCACHED_ERRNO;
 283   _set(memc, &str, rc, at, local_errno);
 284
 285   return rc;
 286 }
 287
 288 memcached_return_t memcached_set_errno(memcached_server_st& self, int local_errno, const char *at, memcached_string_t& str)
 289 {
 290   if (not local_errno)
 291     return MEMCACHED_SUCCESS;
 292
 293   char hostname_port_message[MAX_ERROR_LENGTH];
 294   int size;
 295   if (str.size)
 296   {
 297     size= snprintf(hostname_port_message, sizeof(hostname_port_message), "%.*s, host: %s:%d",
 298                    memcached_string_printf(str),
 299                    self.hostname, int(self.port));
 300   }
 301   else
 302   {
 303     size= snprintf(hostname_port_message, sizeof(hostname_port_message), "host: %s:%d",
 304                    self.hostname, int(self.port));
 305   }
 306
 307   memcached_string_t error_host= { hostname_port_message, size };
 308
 309   memcached_return_t rc= MEMCACHED_ERRNO;
 310   if (not self.root)
 311     return rc;
 312
 313   _set(*self.root, &error_host, rc, at, local_errno);
 314   _set(self, (*self.root));
 315
 316   return rc;
 317 }
 318
 319 memcached_return_t memcached_set_errno(memcached_server_st& self, int local_errno, const char *at)
 320 {
 321   if (not local_errno)
 322     return MEMCACHED_SUCCESS;
 323
 324   char hostname_port_message[MAX_ERROR_LENGTH];
 325   int size = snprintf(hostname_port_message, sizeof(hostname_port_message), "host: %s:%d",
 326                       self.hostname, int(self.port));
 327
 328   memcached_string_t error_host= { hostname_port_message, size };
 329
 330   memcached_return_t rc= MEMCACHED_ERRNO;
 331   if (not self.root)
 332     return rc;
 333
 334   _set(*self.root, &error_host, rc, at, local_errno);
 335   _set(self, (*self.root));
 336
 337   return rc;
 338 }
 339
 340 static void _error_print(const memcached_error_t *error)
 341 {
 342   if (not error)
 343     return;
 344
 345   if (not error->size)
 346   {
 347     fprintf(stderr, "%s\n", memcached_strerror(NULL, error->rc) );
 348   }
 349   else
 350   {
 351     fprintf(stderr, "%s %s\n", memcached_strerror(NULL, error->rc), error->message);
 352   }
 353
 354   _error_print(error->next);
 355 }
 356
 357 void memcached_error_print(const memcached_st *self)
 358 {
 359   if (not self)
 360     return;
 361
 362   _error_print(self->error_messages);
 363 }
 364
 365 static void _error_free(memcached_error_t *error)
 366 {
 367   if (not error)
 368     return;
 369
 370   _error_free(error->next);
 371
 372   if (error && error->root)
 373   {
 374     libmemcached_free(error->root, error);
 375   }
 376   else if (error)
 377   {
 378     free(error);
 379   }
 380 }
 381
 382 void memcached_error_free(memcached_st& self)
 383 {
 384   _error_free(self.error_messages);
 385   self.error_messages= NULL;
 386 }
 387
 388 void memcached_error_free(memcached_server_st& self)
 389 {
 390   _error_free(self.error_messages);
 391   self.error_messages= NULL;
 392 }
 393
 394 const char *memcached_last_error_message(memcached_st *memc)
 395 {
 396   if (not memc)
 397     return memcached_strerror(memc, MEMCACHED_INVALID_ARGUMENTS);
 398
 399   if (not memc->error_messages)
 400     return memcached_strerror(memc, MEMCACHED_SUCCESS);
 401
 402   if (not memc->error_messages->size)
 403     return memcached_strerror(memc, memc->error_messages->rc);
 404
 405   return memc->error_messages->message;
 406 }
 407
 408
 409 bool memcached_has_current_error(memcached_st &memc)
 410 {
 411   if (memc.error_messages
 412       and memc.error_messages->query_id == memc.query_id
 413       and memcached_failed(memc.error_messages->rc))
 414   {
 415     return true;
 416   }
 417
 418   return false;
 419 }
 420
 421 memcached_return_t memcached_last_error(memcached_st *memc)
 422 {
 423   if (not memc)
 424     return MEMCACHED_INVALID_ARGUMENTS;
 425
 426   if (not memc->error_messages)
 427     return MEMCACHED_SUCCESS;
 428
 429   return memc->error_messages->rc;
 430 }
 431
 432 int memcached_last_error_errno(memcached_st *memc)
 433 {
 434   if (not memc)
 435     return 0;
 436
 437   if (not memc->error_messages)
 438     return 0;
 439
 440   return memc->error_messages->local_errno;
 441 }
 442
 443 const char *memcached_server_error(memcached_server_instance_st server)
 444 {
 445   if (not server)
 446     return memcached_strerror(server->root, MEMCACHED_INVALID_ARGUMENTS);
 447
 448   if (not server->error_messages)
 449     return memcached_strerror(server->root, MEMCACHED_SUCCESS);
 450
 451   if (not server->error_messages->size)
 452     return memcached_strerror(server->root, server->error_messages->rc);
 453
 454   return server->error_messages->message;
 455 }
 456
 457
 458 memcached_error_t *memcached_error_copy(const memcached_server_st& server)
 459 {
 460   if (not server.error_messages)
 461     return NULL;
 462
 463   memcached_error_t *error= (memcached_error_t *)libmemcached_malloc(server.root, sizeof(memcached_error_t));
 464   memcpy(error, server.error_messages, sizeof(memcached_error_t));
 465   error->next= NULL;
 466
 467   return error;
 468 }
 469
 470 memcached_return_t memcached_server_error_return(memcached_server_instance_st ptr)
 471 {
 472   if (ptr and ptr->error_messages)
 473   {
 474     return ptr->error_messages->rc;
 475   }
 476
 477   return MEMCACHED_FAILURE;
 478 }