git.m6w6.name Git - awesomized/libmemcached/blob - libmemcached/memcached_callback.c

   1 #include "common.h"
   2 #include <sys/types.h>
   3 #include <sys/socket.h>
   4 #include <netinet/tcp.h>
   5
   6 /*
   7   These functions provide data and function callback support
   8 */
   9
  10 memcached_return memcached_callback_set(memcached_st *ptr,
  11                                         memcached_callback flag,
  12                                         void *data)
  13 {
  14   switch (flag)
  15   {
  16   case MEMCACHED_CALLBACK_PREFIX_KEY:
  17     {
  18       char *key= (char *)data;
  19
  20       if (key)
  21       {
  22         size_t key_length= strlen(key);
  23
  24         if (memcached_key_test((char **)&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED)
  25         {
  26           return MEMCACHED_BAD_KEY_PROVIDED;
  27         }
  28
  29         if ((key_length > MEMCACHED_PREFIX_KEY_MAX_SIZE -1)
  30             || (strcpy(ptr->prefix_key, key) == NULL))
  31         {
  32           ptr->prefix_key_length= 0;
  33           return MEMCACHED_BAD_KEY_PROVIDED;
  34         }
  35         else
  36         {
  37           ptr->prefix_key_length= key_length;
  38         }
  39       }
  40       else
  41       {
  42         memset(ptr->prefix_key, 0, MEMCACHED_PREFIX_KEY_MAX_SIZE);
  43         ptr->prefix_key_length= 0;
  44       }
  45
  46       break;
  47     }
  48   case MEMCACHED_CALLBACK_USER_DATA:
  49     {
  50       ptr->user_data= data;
  51       break;
  52     }
  53   case MEMCACHED_CALLBACK_CLEANUP_FUNCTION:
  54     {
  55       memcached_cleanup_func func= *(memcached_cleanup_func *)&data;
  56       ptr->on_cleanup= func;
  57       break;
  58     }
  59   case MEMCACHED_CALLBACK_CLONE_FUNCTION:
  60     {
  61       memcached_clone_func func= *(memcached_clone_func *)&data;
  62       ptr->on_clone= func;
  63       break;
  64     }
  65   case MEMCACHED_CALLBACK_MALLOC_FUNCTION:
  66     {
  67       memcached_malloc_function func= *(memcached_malloc_function *)&data;
  68       ptr->call_malloc= func;
  69       break;
  70     }
  71   case MEMCACHED_CALLBACK_REALLOC_FUNCTION:
  72     {
  73       memcached_realloc_function func= *(memcached_realloc_function *)&data;
  74       ptr->call_realloc= func;
  75       break;
  76     }
  77   case MEMCACHED_CALLBACK_FREE_FUNCTION:
  78     {
  79       memcached_free_function func= *(memcached_free_function *)&data;
  80       ptr->call_free= func;
  81       break;
  82     }
  83   case MEMCACHED_CALLBACK_GET_FAILURE:
  84     {
  85       memcached_trigger_key func= *(memcached_trigger_key *)&data;
  86       ptr->get_key_failure= func;
  87       break;
  88     }
  89   case MEMCACHED_CALLBACK_DELETE_TRIGGER:
  90     {
  91       memcached_trigger_delete_key func= *(memcached_trigger_delete_key *)&data;
  92       ptr->delete_trigger= func;
  93       break;
  94     }
  95   default:
  96     return MEMCACHED_FAILURE;
  97   }
  98
  99   return MEMCACHED_SUCCESS;
 100 }
 101
 102 void *memcached_callback_get(memcached_st *ptr,
 103                              memcached_callback flag,
 104                              memcached_return *error)
 105 {
 106   memcached_return local_error;
 107
 108   if (!error)
 109     error = &local_error;
 110
 111   switch (flag)
 112   {
 113   case MEMCACHED_CALLBACK_PREFIX_KEY:
 114     {
 115       if (ptr->prefix_key[0] == 0)
 116       {
 117         *error= MEMCACHED_FAILURE;
 118         return NULL;
 119       }
 120       else
 121       {
 122         *error= MEMCACHED_SUCCESS;
 123         return (void *)ptr->prefix_key;
 124       }
 125     }
 126   case MEMCACHED_CALLBACK_USER_DATA:
 127     {
 128       *error= ptr->user_data ? MEMCACHED_SUCCESS : MEMCACHED_FAILURE;
 129       return (void *)ptr->user_data;
 130     }
 131   case MEMCACHED_CALLBACK_CLEANUP_FUNCTION:
 132     {
 133       *error= ptr->on_cleanup ? MEMCACHED_SUCCESS : MEMCACHED_FAILURE;
 134       return *(void **)&ptr->on_cleanup;
 135     }
 136   case MEMCACHED_CALLBACK_CLONE_FUNCTION:
 137     {
 138       *error= ptr->on_clone ? MEMCACHED_SUCCESS : MEMCACHED_FAILURE;
 139       return *(void **)&ptr->on_clone;
 140     }
 141   case MEMCACHED_CALLBACK_MALLOC_FUNCTION:
 142     {
 143       *error= ptr->call_malloc ? MEMCACHED_SUCCESS : MEMCACHED_FAILURE;
 144       return *(void **)&ptr->call_malloc;
 145     }
 146   case MEMCACHED_CALLBACK_REALLOC_FUNCTION:
 147     {
 148       *error= ptr->call_realloc ? MEMCACHED_SUCCESS : MEMCACHED_FAILURE;
 149       return *(void **)&ptr->call_realloc;
 150     }
 151   case MEMCACHED_CALLBACK_FREE_FUNCTION:
 152     {
 153       *error= ptr->call_free ? MEMCACHED_SUCCESS : MEMCACHED_FAILURE;
 154       return *(void **)&ptr->call_free;
 155     }
 156   case MEMCACHED_CALLBACK_GET_FAILURE:
 157     {
 158       *error= ptr->get_key_failure ? MEMCACHED_SUCCESS : MEMCACHED_FAILURE;
 159       return *(void **)&ptr->get_key_failure;
 160     }
 161   case MEMCACHED_CALLBACK_DELETE_TRIGGER:
 162     {
 163       *error= ptr->delete_trigger ? MEMCACHED_SUCCESS : MEMCACHED_FAILURE;
 164       return *(void **)&ptr->delete_trigger;
 165     }
 166   default:
 167       WATCHPOINT_ASSERT(0);
 168       *error= MEMCACHED_FAILURE;
 169       return NULL;
 170   }
 171 }