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 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_BINARY_PROTOCOL:
  27     set_behavior_flag(ptr, MEM_BINARY_PROTOCOL, data);
  28     break;
  29   case MEMCACHED_BEHAVIOR_SUPPORT_CAS:
  30     set_behavior_flag(ptr, MEM_SUPPORT_CAS, data);
  31     break;
  32   case MEMCACHED_BEHAVIOR_NO_BLOCK:
  33     set_behavior_flag(ptr, MEM_NO_BLOCK, data);
  34     memcached_quit(ptr);
  35   case MEMCACHED_BEHAVIOR_BUFFER_REQUESTS:
  36     set_behavior_flag(ptr, MEM_BUFFER_REQUESTS, data);
  37     memcached_quit(ptr);
  38     break;
  39   case MEMCACHED_BEHAVIOR_TCP_NODELAY:
  40     set_behavior_flag(ptr, MEM_TCP_NODELAY, data);
  41     memcached_quit(ptr);
  42     break;
  43   case MEMCACHED_BEHAVIOR_DISTRIBUTION:
  44     {
  45       ptr->distribution= (memcached_server_distribution)(data);
  46       run_distribution(ptr);
  47       break;
  48     }
  49   case MEMCACHED_BEHAVIOR_KETAMA:
  50     {
  51       if (data)
  52       {
  53         ptr->hash= MEMCACHED_HASH_MD5;
  54         ptr->distribution= MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA;
  55       }
  56       else
  57       {
  58         ptr->hash= 0;
  59         ptr->distribution= 0;
  60       }
  61       run_distribution(ptr);
  62       break;
  63     }
  64   case MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED:
  65     {
  66       ptr->hash= MEMCACHED_HASH_MD5;
  67       ptr->distribution= MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA;
  68       set_behavior_flag(ptr, MEM_KETAMA_WEIGHTED, data);
  69       run_distribution(ptr);
  70       break;
  71     }
  72   case MEMCACHED_BEHAVIOR_HASH:
  73     ptr->hash= (memcached_hash)(data);
  74     break;
  75   case MEMCACHED_BEHAVIOR_KETAMA_HASH:
  76     ptr->hash_continuum= (memcached_hash)(data);
  77     run_distribution(ptr);
  78     break;
  79   case MEMCACHED_BEHAVIOR_CACHE_LOOKUPS:
  80     set_behavior_flag(ptr, MEM_USE_CACHE_LOOKUPS, data);
  81     memcached_quit(ptr);
  82     break;
  83   case MEMCACHED_BEHAVIOR_VERIFY_KEY:
  84     set_behavior_flag(ptr, MEM_VERIFY_KEY, data);
  85     break;
  86   case MEMCACHED_BEHAVIOR_SORT_HOSTS:
  87     {
  88       set_behavior_flag(ptr, MEM_USE_SORT_HOSTS, data);
  89       run_distribution(ptr);
  90
  91       break;
  92     }
  93   case MEMCACHED_BEHAVIOR_POLL_TIMEOUT:
  94     ptr->poll_timeout= (int32_t)data;
  95     break;
  96   case MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT:
  97     ptr->connect_timeout= (int32_t)data;
  98     break;
  99   case MEMCACHED_BEHAVIOR_RETRY_TIMEOUT:
 100     ptr->retry_timeout= (int32_t)data;
 101     break;
 102   case MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE:
 103     ptr->send_size= (int32_t)data;
 104     memcached_quit(ptr);
 105     break;
 106   case MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE:
 107     ptr->recv_size= (int32_t)data;
 108     memcached_quit(ptr);
 109     break;
 110   case MEMCACHED_BEHAVIOR_USER_DATA:
 111     return MEMCACHED_FAILURE;
 112   }
 113
 114   return MEMCACHED_SUCCESS;
 115 }
 116
 117 uint64_t memcached_behavior_get(memcached_st *ptr,
 118                                 memcached_behavior flag)
 119 {
 120   memcached_flags temp_flag= 0;
 121
 122   switch (flag)
 123   {
 124   case MEMCACHED_BEHAVIOR_BINARY_PROTOCOL:
 125     temp_flag= MEM_BINARY_PROTOCOL;
 126     break;
 127   case MEMCACHED_BEHAVIOR_SUPPORT_CAS:
 128     temp_flag= MEM_SUPPORT_CAS;
 129     break;
 130   case MEMCACHED_BEHAVIOR_CACHE_LOOKUPS:
 131     temp_flag= MEM_USE_CACHE_LOOKUPS;
 132     break;
 133   case MEMCACHED_BEHAVIOR_NO_BLOCK:
 134     temp_flag= MEM_NO_BLOCK;
 135     break;
 136   case MEMCACHED_BEHAVIOR_BUFFER_REQUESTS:
 137     temp_flag= MEM_BUFFER_REQUESTS;
 138     break;
 139   case MEMCACHED_BEHAVIOR_TCP_NODELAY:
 140     temp_flag= MEM_TCP_NODELAY;
 141     break;
 142   case MEMCACHED_BEHAVIOR_VERIFY_KEY:
 143     temp_flag= MEM_VERIFY_KEY;
 144     break;
 145   case MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED:
 146     temp_flag= MEM_KETAMA_WEIGHTED;
 147     break;
 148   case MEMCACHED_BEHAVIOR_DISTRIBUTION:
 149     return ptr->distribution;
 150   case MEMCACHED_BEHAVIOR_KETAMA:
 151     return (ptr->distribution == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA) ? 1 : 0;
 152   case MEMCACHED_BEHAVIOR_HASH:
 153     return ptr->hash;
 154   case MEMCACHED_BEHAVIOR_KETAMA_HASH:
 155     return ptr->hash_continuum;
 156   case MEMCACHED_BEHAVIOR_SORT_HOSTS:
 157     temp_flag= MEM_USE_SORT_HOSTS;
 158     break;
 159   case MEMCACHED_BEHAVIOR_POLL_TIMEOUT:
 160     {
 161       return (unsigned long long)ptr->poll_timeout;
 162     }
 163   case MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT:
 164     {
 165       return (unsigned long long)ptr->connect_timeout;
 166     }
 167   case MEMCACHED_BEHAVIOR_RETRY_TIMEOUT:
 168     {
 169       return (unsigned long long)ptr->retry_timeout;
 170     }
 171   case MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE:
 172     {
 173       int sock_size;
 174       socklen_t sock_length= sizeof(int);
 175
 176       /* REFACTOR */
 177       /* We just try the first host, and if it is down we return zero */
 178       if ((memcached_connect(&ptr->hosts[0])) != MEMCACHED_SUCCESS)
 179         return 0;
 180
 181       if (getsockopt(ptr->hosts[0].fd, SOL_SOCKET,
 182                      SO_SNDBUF, &sock_size, &sock_length))
 183         return 0; /* Zero means error */
 184
 185       return sock_size;
 186     }
 187   case MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE:
 188     {
 189       int sock_size;
 190       socklen_t sock_length= sizeof(int);
 191
 192       /* REFACTOR */
 193       /* We just try the first host, and if it is down we return zero */
 194       if ((memcached_connect(&ptr->hosts[0])) != MEMCACHED_SUCCESS)
 195         return 0;
 196
 197       if (getsockopt(ptr->hosts[0].fd, SOL_SOCKET,
 198                      SO_RCVBUF, &sock_size, &sock_length))
 199         return 0; /* Zero means error */
 200
 201       return sock_size;
 202     }
 203   case MEMCACHED_BEHAVIOR_USER_DATA:
 204     return MEMCACHED_FAILURE;
 205   }
 206
 207   WATCHPOINT_ASSERT(temp_flag); /* Programming mistake if it gets this far */
 208   if (ptr->flags & temp_flag)
 209     return 1;
 210   else
 211     return 0;
 212
 213   return MEMCACHED_SUCCESS;
 214 }