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         ptr->prefix_key_length= strlen(key);
  23         if ((ptr->prefix_key_length > MEMCACHED_PREFIX_KEY_MAX_SIZE -1)
  24             || (strcpy(ptr->prefix_key, key) == NULL))
  25         {
  26           ptr->prefix_key_length= 0;
  27           return MEMCACHED_BAD_KEY_PROVIDED;
  28         }
  29       }
  30       else
  31       {
  32         memset(ptr->prefix_key, 0, MEMCACHED_PREFIX_KEY_MAX_SIZE);
  33         ptr->prefix_key_length= 0;
  34       }
  35
  36       break;
  37     }
  38   case MEMCACHED_CALLBACK_USER_DATA:
  39     {
  40       ptr->user_data= data;
  41       break;
  42     }
  43   case MEMCACHED_CALLBACK_CLEANUP_FUNCTION:
  44     {
  45       memcached_cleanup_func func= (memcached_cleanup_func)data;
  46       ptr->on_cleanup= func;
  47       break;
  48     }
  49   case MEMCACHED_CALLBACK_CLONE_FUNCTION:
  50     {
  51       memcached_clone_func func= (memcached_clone_func)data;
  52       ptr->on_clone= func;
  53       break;
  54     }
  55   case MEMCACHED_CALLBACK_MALLOC_FUNCTION:
  56     {
  57       memcached_malloc_function func= (memcached_malloc_function)data;
  58       ptr->call_malloc= func;
  59       break;
  60     }
  61   case MEMCACHED_CALLBACK_REALLOC_FUNCTION:
  62     {
  63       memcached_realloc_function func= (memcached_realloc_function)data;
  64       ptr->call_realloc= func;
  65       break;
  66     }
  67   case MEMCACHED_CALLBACK_FREE_FUNCTION:
  68     {
  69       memcached_free_function func= (memcached_free_function)data;
  70       ptr->call_free= func;
  71       break;
  72     }
  73   case MEMCACHED_CALLBACK_GET_FAILURE:
  74     {
  75       memcached_trigger_key func= (memcached_trigger_key)data;
  76       ptr->get_key_failure= func;
  77       break;
  78     }
  79   case MEMCACHED_CALLBACK_DELETE_TRIGGER:
  80     {
  81       memcached_trigger_delete_key func= (memcached_trigger_delete_key)data;
  82       ptr->delete_trigger= func;
  83       break;
  84     }
  85   default:
  86     return MEMCACHED_FAILURE;
  87   }
  88
  89   return MEMCACHED_SUCCESS;
  90 }
  91
  92 void *memcached_callback_get(memcached_st *ptr,
  93                              memcached_callback flag,
  94                              memcached_return *error)
  95 {
  96   memcached_return local_error;
  97   if (!error)
  98     error = &local_error;
  99
 100   switch (flag)
 101   {
 102   case MEMCACHED_CALLBACK_PREFIX_KEY:
 103     {
 104       if (ptr->prefix_key[0] == 0)
 105       {
 106         *error= MEMCACHED_FAILURE;
 107         return NULL;
 108       }
 109       else
 110       {
 111         *error= MEMCACHED_SUCCESS;
 112         return (void *)ptr->prefix_key;
 113       }
 114     }
 115   case MEMCACHED_CALLBACK_USER_DATA:
 116     {
 117       *error= ptr->user_data ? MEMCACHED_SUCCESS : MEMCACHED_FAILURE;
 118       return (void *)ptr->user_data;
 119     }
 120   case MEMCACHED_CALLBACK_CLEANUP_FUNCTION:
 121     {
 122       *error= ptr->on_cleanup ? MEMCACHED_SUCCESS : MEMCACHED_FAILURE;
 123       return (void *)ptr->on_cleanup;
 124     }
 125   case MEMCACHED_CALLBACK_CLONE_FUNCTION:
 126     {
 127       *error= ptr->on_clone ? MEMCACHED_SUCCESS : MEMCACHED_FAILURE;
 128       return (void *)ptr->on_clone;
 129     }
 130   case MEMCACHED_CALLBACK_MALLOC_FUNCTION:
 131     {
 132       *error= ptr->call_malloc ? MEMCACHED_SUCCESS : MEMCACHED_FAILURE;
 133       return (void *)ptr->call_malloc;
 134     }
 135   case MEMCACHED_CALLBACK_REALLOC_FUNCTION:
 136     {
 137       *error= ptr->call_realloc ? MEMCACHED_SUCCESS : MEMCACHED_FAILURE;
 138       return (void *)ptr->call_realloc;
 139     }
 140   case MEMCACHED_CALLBACK_FREE_FUNCTION:
 141     {
 142       *error= ptr->call_free ? MEMCACHED_SUCCESS : MEMCACHED_FAILURE;
 143       return (void *)ptr->call_free;
 144     }
 145   case MEMCACHED_CALLBACK_GET_FAILURE:
 146     {
 147       *error= ptr->get_key_failure ? MEMCACHED_SUCCESS : MEMCACHED_FAILURE;
 148       return (void *)ptr->get_key_failure;
 149     }
 150   case MEMCACHED_CALLBACK_DELETE_TRIGGER:
 151     {
 152       *error= ptr->delete_trigger ? MEMCACHED_SUCCESS : MEMCACHED_FAILURE;
 153       return (void *)ptr->delete_trigger;
 154     }
 155   default:
 156       WATCHPOINT_ASSERT(0);
 157       *error= MEMCACHED_FAILURE;
 158       return NULL;
 159   }
 160 }