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

   1 #include "common.h"
   2 #include <sys/types.h>
   3 #include <sys/socket.h>
   4 #include <netinet/tcp.h>
   5
   6 /*
   7   This function is used to modify the behabior of running client.
   8
   9   We quit all connections so we can reset the sockets.
  10 */
  11
  12 static void set_behavior_flag(memcached_st *ptr, memcached_flags temp_flag, uint64_t data)
  13 {
  14   if (data)
  15     ptr->flags|= temp_flag;
  16   else
  17     ptr->flags&= ~temp_flag;
  18 }
  19
  20 memcached_return memcached_behavior_set(memcached_st *ptr,
  21                                         memcached_behavior flag,
  22                                         uint64_t data)
  23 {
  24   switch (flag)
  25   {
  26   case MEMCACHED_BEHAVIOR_SND_TIMEOUT:
  27     ptr->snd_timeout= (int32_t)data;
  28     break;
  29   case MEMCACHED_BEHAVIOR_RCV_TIMEOUT:
  30     ptr->rcv_timeout= (int32_t)data;
  31     break;
  32   case MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT:
  33     ptr->server_failure_limit= (uint32_t)data;
  34     break;
  35   case MEMCACHED_BEHAVIOR_BINARY_PROTOCOL:
  36     set_behavior_flag(ptr, MEM_BINARY_PROTOCOL, data);
  37     break;
  38   case MEMCACHED_BEHAVIOR_SUPPORT_CAS:
  39     set_behavior_flag(ptr, MEM_SUPPORT_CAS, data);
  40     break;
  41   case MEMCACHED_BEHAVIOR_NO_BLOCK:
  42     set_behavior_flag(ptr, MEM_NO_BLOCK, data);
  43     memcached_quit(ptr);
  44   case MEMCACHED_BEHAVIOR_BUFFER_REQUESTS:
  45     set_behavior_flag(ptr, MEM_BUFFER_REQUESTS, data);
  46     memcached_quit(ptr);
  47     break;
  48   case MEMCACHED_BEHAVIOR_TCP_NODELAY:
  49     set_behavior_flag(ptr, MEM_TCP_NODELAY, data);
  50     memcached_quit(ptr);
  51     break;
  52   case MEMCACHED_BEHAVIOR_DISTRIBUTION:
  53     {
  54       ptr->distribution= (memcached_server_distribution)(data);
  55       run_distribution(ptr);
  56       break;
  57     }
  58   case MEMCACHED_BEHAVIOR_KETAMA:
  59     {
  60       if (data)
  61       {
  62         ptr->hash= MEMCACHED_HASH_MD5;
  63         ptr->distribution= MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA;
  64       }
  65       else
  66       {
  67         ptr->hash= 0;
  68         ptr->distribution= 0;
  69       }
  70       run_distribution(ptr);
  71       break;
  72     }
  73   case MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED:
  74     {
  75       ptr->hash= MEMCACHED_HASH_MD5;
  76       ptr->distribution= MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA;
  77       set_behavior_flag(ptr, MEM_KETAMA_WEIGHTED, data);
  78       run_distribution(ptr);
  79       break;
  80     }
  81   case MEMCACHED_BEHAVIOR_HASH:
  82     ptr->hash= (memcached_hash)(data);
  83     break;
  84   case MEMCACHED_BEHAVIOR_KETAMA_HASH:
  85     ptr->hash_continuum= (memcached_hash)(data);
  86     run_distribution(ptr);
  87     break;
  88   case MEMCACHED_BEHAVIOR_CACHE_LOOKUPS:
  89     set_behavior_flag(ptr, MEM_USE_CACHE_LOOKUPS, data);
  90     memcached_quit(ptr);
  91     break;
  92   case MEMCACHED_BEHAVIOR_VERIFY_KEY:
  93     set_behavior_flag(ptr, MEM_VERIFY_KEY, data);
  94     break;
  95   case MEMCACHED_BEHAVIOR_SORT_HOSTS:
  96     {
  97       set_behavior_flag(ptr, MEM_USE_SORT_HOSTS, data);
  98       run_distribution(ptr);
  99
 100       break;
 101     }
 102   case MEMCACHED_BEHAVIOR_POLL_TIMEOUT:
 103     ptr->poll_timeout= (int32_t)data;
 104     break;
 105   case MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT:
 106     ptr->connect_timeout= (int32_t)data;
 107     break;
 108   case MEMCACHED_BEHAVIOR_RETRY_TIMEOUT:
 109     ptr->retry_timeout= (int32_t)data;
 110     break;
 111   case MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE:
 112     ptr->send_size= (int32_t)data;
 113     memcached_quit(ptr);
 114     break;
 115   case MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE:
 116     ptr->recv_size= (int32_t)data;
 117     memcached_quit(ptr);
 118     break;
 119   case MEMCACHED_BEHAVIOR_USER_DATA:
 120     return MEMCACHED_FAILURE;
 121   }
 122
 123   return MEMCACHED_SUCCESS;
 124 }
 125
 126 uint64_t memcached_behavior_get(memcached_st *ptr,
 127                                 memcached_behavior flag)
 128 {
 129   memcached_flags temp_flag= 0;
 130
 131   switch (flag)
 132   {
 133   case MEMCACHED_BEHAVIOR_BINARY_PROTOCOL:
 134     temp_flag= MEM_BINARY_PROTOCOL;
 135     break;
 136   case MEMCACHED_BEHAVIOR_SUPPORT_CAS:
 137     temp_flag= MEM_SUPPORT_CAS;
 138     break;
 139   case MEMCACHED_BEHAVIOR_CACHE_LOOKUPS:
 140     temp_flag= MEM_USE_CACHE_LOOKUPS;
 141     break;
 142   case MEMCACHED_BEHAVIOR_NO_BLOCK:
 143     temp_flag= MEM_NO_BLOCK;
 144     break;
 145   case MEMCACHED_BEHAVIOR_BUFFER_REQUESTS:
 146     temp_flag= MEM_BUFFER_REQUESTS;
 147     break;
 148   case MEMCACHED_BEHAVIOR_TCP_NODELAY:
 149     temp_flag= MEM_TCP_NODELAY;
 150     break;
 151   case MEMCACHED_BEHAVIOR_VERIFY_KEY:
 152     temp_flag= MEM_VERIFY_KEY;
 153     break;
 154   case MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED:
 155     temp_flag= MEM_KETAMA_WEIGHTED;
 156     break;
 157   case MEMCACHED_BEHAVIOR_DISTRIBUTION:
 158     return ptr->distribution;
 159   case MEMCACHED_BEHAVIOR_KETAMA:
 160     return (ptr->distribution == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA) ? 1 : 0;
 161   case MEMCACHED_BEHAVIOR_HASH:
 162     return ptr->hash;
 163   case MEMCACHED_BEHAVIOR_KETAMA_HASH:
 164     return ptr->hash_continuum;
 165   case MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT:
 166     return ptr->server_failure_limit;
 167   case MEMCACHED_BEHAVIOR_SORT_HOSTS:
 168     temp_flag= MEM_USE_SORT_HOSTS;
 169     break;
 170   case MEMCACHED_BEHAVIOR_POLL_TIMEOUT:
 171     {
 172       return (uint64_t)ptr->poll_timeout;
 173     }
 174   case MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT:
 175     {
 176       return (uint64_t)ptr->connect_timeout;
 177     }
 178   case MEMCACHED_BEHAVIOR_RETRY_TIMEOUT:
 179     {
 180       return (uint64_t)ptr->retry_timeout;
 181     }
 182   case MEMCACHED_BEHAVIOR_SND_TIMEOUT:
 183     return (uint64_t)ptr->snd_timeout;
 184   case MEMCACHED_BEHAVIOR_RCV_TIMEOUT:
 185     return (uint64_t)ptr->rcv_timeout;
 186   case MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE:
 187     {
 188       int sock_size;
 189       socklen_t sock_length= sizeof(int);
 190
 191       /* REFACTOR */
 192       /* We just try the first host, and if it is down we return zero */
 193       if ((memcached_connect(&ptr->hosts[0])) != MEMCACHED_SUCCESS)
 194         return 0;
 195
 196       if (getsockopt(ptr->hosts[0].fd, SOL_SOCKET,
 197                      SO_SNDBUF, &sock_size, &sock_length))
 198         return 0; /* Zero means error */
 199
 200       return sock_size;
 201     }
 202   case MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE:
 203     {
 204       int sock_size;
 205       socklen_t sock_length= sizeof(int);
 206
 207       /* REFACTOR */
 208       /* We just try the first host, and if it is down we return zero */
 209       if ((memcached_connect(&ptr->hosts[0])) != MEMCACHED_SUCCESS)
 210         return 0;
 211
 212       if (getsockopt(ptr->hosts[0].fd, SOL_SOCKET,
 213                      SO_RCVBUF, &sock_size, &sock_length))
 214         return 0; /* Zero means error */
 215
 216       return sock_size;
 217     }
 218   case MEMCACHED_BEHAVIOR_USER_DATA:
 219     return MEMCACHED_FAILURE;
 220   }
 221
 222   WATCHPOINT_ASSERT(temp_flag); /* Programming mistake if it gets this far */
 223   if (ptr->flags & temp_flag)
 224     return 1;
 225   else
 226     return 0;
 227
 228   return MEMCACHED_SUCCESS;
 229 }