vinted-memcached 1.8.0

data/ext/libmemcached-0.32/libmemcached/memcached_allocators.c

@@ -0,0 +1,72 @@
+#include "common.h"
+
+void libmemcached_free(memcached_st *ptr, void *mem)
+{
+  (void) ptr;
+  free(mem);
+}
+
+void *libmemcached_malloc(memcached_st *ptr, size_t size)
+{
+  (void) ptr;
+  return malloc(size);
+}
+
+void *libmemcached_realloc(memcached_st *ptr, void *mem, size_t size)
+{
+  (void) ptr;
+  return realloc(mem, size);
+}
+
+void *libmemcached_calloc(memcached_st *ptr, size_t nelem, size_t size)
+{
+  if (ptr->call_malloc != libmemcached_malloc)
+  {
+     void *ret = libmemcached_malloc(ptr, nelem * size);
+     if (ret != NULL) 
+       memset(ret, 0, nelem * size);
+
+     return ret;
+  }
+
+  return calloc(nelem, size);
+}
+
+memcached_return memcached_set_memory_allocators(memcached_st *ptr,
+                                                 memcached_malloc_function mem_malloc,
+                                                 memcached_free_function mem_free,
+                                                 memcached_realloc_function mem_realloc,
+                                                 memcached_calloc_function mem_calloc)
+{
+  /* All should be set, or none should be set */
+  if (mem_malloc == NULL && mem_free == NULL && mem_realloc == NULL && mem_calloc == NULL) 
+  {
+    ptr->call_malloc= libmemcached_malloc;
+    ptr->call_free= libmemcached_free;
+    ptr->call_realloc= libmemcached_realloc;
+    ptr->call_calloc= libmemcached_calloc;
+  }
+  else if (mem_malloc == NULL || mem_free == NULL || mem_realloc == NULL || mem_calloc == NULL)
+    return MEMCACHED_FAILURE;
+  else
+  {
+    ptr->call_malloc= mem_malloc;
+    ptr->call_free= mem_free;
+    ptr->call_realloc= mem_realloc;
+    ptr->call_calloc= mem_calloc;
+  }
+
+  return MEMCACHED_SUCCESS;
+}
+
+void memcached_get_memory_allocators(memcached_st *ptr,
+                                     memcached_malloc_function *mem_malloc,
+                                     memcached_free_function *mem_free,
+                                     memcached_realloc_function *mem_realloc,
+                                     memcached_calloc_function *mem_calloc)
+{
+   *mem_malloc= ptr->call_malloc;
+   *mem_free= ptr->call_free;
+   *mem_realloc= ptr->call_realloc;
+   *mem_calloc= ptr->call_calloc;
+}

data/ext/libmemcached-0.32/libmemcached/memcached_analyze.c

@@ -0,0 +1,100 @@
+#include "common.h"
+
+static void calc_largest_consumption(memcached_analysis_st *result,
+                                     const uint32_t server_num,
+                                     const uint64_t nbytes)
+{
+  if (result->most_used_bytes < nbytes)
+  {
+    result->most_used_bytes= nbytes;
+    result->most_consumed_server= server_num;
+  }
+}
+
+static void calc_oldest_node(memcached_analysis_st *result,
+                                     const uint32_t server_num,
+                                     const uint32_t uptime)
+{
+  if (result->longest_uptime < uptime)
+  {
+    result->longest_uptime= uptime;
+    result->oldest_server= server_num;
+  }
+}
+
+static void calc_least_free_node(memcached_analysis_st *result,
+                                 const uint32_t server_num,
+                                 const uint64_t max_allowed_bytes,
+                                 const uint64_t used_bytes)
+{
+  uint64_t remaining_bytes= max_allowed_bytes - used_bytes;
+
+  if (result->least_remaining_bytes == 0 ||
+      remaining_bytes < result->least_remaining_bytes)
+  {
+    result->least_remaining_bytes= remaining_bytes;
+    result->least_free_server= server_num;
+  }
+}
+
+static void calc_average_item_size(memcached_analysis_st *result,
+                                   const uint64_t total_items,
+                                   const uint64_t total_bytes)
+{
+  if (total_items > 0 && total_bytes > 0)
+    result->average_item_size= (uint32_t) (total_bytes / total_items);
+}
+
+static void calc_hit_ratio(memcached_analysis_st *result,
+                           const uint64_t total_get_hits,
+                           const uint64_t total_get_cmds)
+{
+  if (total_get_hits == 0 || total_get_cmds == 0)
+  {
+    result->pool_hit_ratio= 0;
+    return;
+  }
+
+  double temp= (double) (total_get_hits/total_get_cmds);
+  result->pool_hit_ratio= temp * 100;
+}
+
+memcached_analysis_st *memcached_analyze(memcached_st *memc,
+                                         memcached_stat_st *memc_stat,
+                                         memcached_return *error)
+{
+  uint64_t total_items= 0, total_bytes= 0;
+  uint64_t total_get_cmds= 0, total_get_hits= 0;
+  uint32_t server_count, x;
+  memcached_analysis_st *result;
+  
+  *error= MEMCACHED_SUCCESS;
+  server_count= memcached_server_count(memc);
+  result= (memcached_analysis_st*)calloc(memc->number_of_hosts,
+                                         sizeof(memcached_analysis_st));
+
+  if (!result)
+  {
+    *error= MEMCACHED_MEMORY_ALLOCATION_FAILURE;
+    return NULL;
+  }
+
+  for (x= 0; x < server_count; x++)
+  {
+    calc_largest_consumption(result, x, memc_stat[x].bytes);
+    calc_oldest_node(result, x, memc_stat[x].uptime);
+    calc_least_free_node(result, x,
+                         memc_stat[x].limit_maxbytes, 
+                         memc_stat[x].bytes);
+
+    total_get_hits+= memc_stat[x].get_hits;
+    total_get_cmds+= memc_stat[x].cmd_get;
+    total_items+= memc_stat[x].curr_items;
+    total_bytes+= memc_stat[x].bytes;
+  }
+
+  calc_average_item_size(result, total_items, total_bytes);
+  calc_hit_ratio(result, total_get_hits, total_get_cmds);
+
+  return result;
+}

data/ext/libmemcached-0.32/libmemcached/memcached_auto.c

@@ -0,0 +1,207 @@
+#include "common.h"
+
+static memcached_return memcached_auto(memcached_st *ptr, 
+                                       const char *verb,
+                                       const char *key, size_t key_length,
+                                       unsigned int offset,
+                                       uint64_t *value)
+{
+  size_t send_length;
+  memcached_return rc;
+  char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
+  unsigned int server_key;
+  bool no_reply= (ptr->flags & MEM_NOREPLY);
+
+  unlikely (ptr->hosts == NULL || ptr->number_of_hosts == 0)
+    return MEMCACHED_NO_SERVERS;
+
+  if ((ptr->flags & MEM_VERIFY_KEY) && (memcached_key_test((const char **)&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED))
+    return MEMCACHED_BAD_KEY_PROVIDED;
+
+  server_key= memcached_generate_hash(ptr, key, key_length);
+
+  send_length= (size_t)snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, 
+                                "%s %s%.*s %u%s\r\n", verb,
+                                ptr->prefix_key,
+                                (int)key_length, key,
+                                offset, no_reply ? " noreply" : "");
+  unlikely (send_length >= MEMCACHED_DEFAULT_COMMAND_SIZE)
+    return MEMCACHED_WRITE_FAILURE;
+
+  rc= memcached_do(&ptr->hosts[server_key], buffer, send_length, 1);
+  if (no_reply || rc != MEMCACHED_SUCCESS)
+    return rc;
+
+  rc= memcached_response(&ptr->hosts[server_key], buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, NULL);
+
+  /* 
+    So why recheck responce? Because the protocol is brain dead :)
+    The number returned might end up equaling one of the string 
+    values. Less chance of a mistake with strncmp() so we will 
+    use it. We still called memcached_response() though since it
+    worked its magic for non-blocking IO.
+  */
+  if (!strncmp(buffer, "ERROR\r\n", 7))
+  {
+    *value= 0;
+    rc= MEMCACHED_PROTOCOL_ERROR;
+  }
+  else if (!strncmp(buffer, "NOT_FOUND\r\n", 11))
+  {
+    *value= 0;
+    rc= MEMCACHED_NOTFOUND;
+  }
+  else
+  {
+    *value= strtoull(buffer, (char **)NULL, 10);
+    rc= MEMCACHED_SUCCESS;
+  }
+
+  return rc;
+}
+
+static memcached_return binary_incr_decr(memcached_st *ptr, uint8_t cmd,
+                                         const char *key, size_t key_length,
+                                         uint64_t offset, uint64_t initial,
+                                         uint32_t expiration,
+                                         uint64_t *value) 
+{
+  unsigned int server_key;
+  bool no_reply= (ptr->flags & MEM_NOREPLY);
+
+  unlikely (ptr->hosts == NULL || ptr->number_of_hosts == 0)
+    return MEMCACHED_NO_SERVERS;
+
+  server_key= memcached_generate_hash(ptr, key, key_length);
+
+  if (no_reply)
+  {
+    if(cmd == PROTOCOL_BINARY_CMD_DECREMENT)
+      cmd= PROTOCOL_BINARY_CMD_DECREMENTQ;
+    if(cmd == PROTOCOL_BINARY_CMD_INCREMENT)
+      cmd= PROTOCOL_BINARY_CMD_INCREMENTQ;
+  }
+  protocol_binary_request_incr request= {.bytes= {0}};
+  
+  uint16_t key_with_prefix_length = ptr->prefix_key_length + key_length;
+  char *key_with_prefix = alloca(key_with_prefix_length + 1);
+  strcpy(key_with_prefix, ptr->prefix_key);
+  strcat(key_with_prefix, key);
+  
+
+  request.message.header.request.magic= PROTOCOL_BINARY_REQ;
+  request.message.header.request.opcode= cmd;
+  request.message.header.request.keylen= htons((uint16_t) key_with_prefix_length);
+  request.message.header.request.extlen= 20;
+  request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
+  request.message.header.request.bodylen= htonl((uint32_t) (key_with_prefix_length + request.message.header.request.extlen));
+  request.message.body.delta= htonll(offset);
+  request.message.body.initial= htonll(initial);
+  request.message.body.expiration= htonl((uint32_t) expiration);
+
+  if ((memcached_do(&ptr->hosts[server_key], request.bytes,
+                    sizeof(request.bytes), 0)!=MEMCACHED_SUCCESS) ||
+      (memcached_io_write(&ptr->hosts[server_key], key_with_prefix, key_with_prefix_length, 1) == -1)) 
+  {
+    memcached_io_reset(&ptr->hosts[server_key]);
+    return MEMCACHED_WRITE_FAILURE;
+  }
+
+  if (no_reply)
+    return MEMCACHED_SUCCESS;
+  return memcached_response(&ptr->hosts[server_key], (char*)value, sizeof(*value), NULL);
+}
+
+memcached_return memcached_increment(memcached_st *ptr, 
+                                     const char *key, size_t key_length,
+                                     uint32_t offset,
+                                     uint64_t *value)
+{
+  memcached_return rc= memcached_validate_key_length(key_length, ptr->flags & MEM_BINARY_PROTOCOL);
+  unlikely (rc != MEMCACHED_SUCCESS)
+    return rc;
+
+  LIBMEMCACHED_MEMCACHED_INCREMENT_START();
+  if (ptr->flags & MEM_BINARY_PROTOCOL) 
+    rc= binary_incr_decr(ptr, PROTOCOL_BINARY_CMD_INCREMENT, key, key_length,
+                         (uint64_t)offset, 0, MEMCACHED_EXPIRATION_NOT_ADD,
+                         value);
+  else 
+     rc= memcached_auto(ptr, "incr", key, key_length, offset, value);
+  
+  LIBMEMCACHED_MEMCACHED_INCREMENT_END();
+
+  return rc;
+}
+
+memcached_return memcached_decrement(memcached_st *ptr, 
+                                     const char *key, size_t key_length,
+                                     uint32_t offset,
+                                     uint64_t *value)
+{
+  memcached_return rc= memcached_validate_key_length(key_length, ptr->flags & MEM_BINARY_PROTOCOL);
+  unlikely (rc != MEMCACHED_SUCCESS)
+    return rc;
+
+  LIBMEMCACHED_MEMCACHED_DECREMENT_START();
+  if (ptr->flags & MEM_BINARY_PROTOCOL) 
+    rc= binary_incr_decr(ptr, PROTOCOL_BINARY_CMD_DECREMENT, key, key_length,
+                         (uint64_t)offset, 0, MEMCACHED_EXPIRATION_NOT_ADD,
+                         value);
+  else 
+    rc= memcached_auto(ptr, "decr", key, key_length, offset, value);      
+  
+  LIBMEMCACHED_MEMCACHED_DECREMENT_END();
+
+  return rc;
+}
+
+memcached_return memcached_increment_with_initial(memcached_st *ptr,
+                                                  const char *key,
+                                                  size_t key_length,
+                                                  uint64_t offset,
+                                                  uint64_t initial,
+                                                  time_t expiration,
+                                                  uint64_t *value)
+{
+  memcached_return rc= memcached_validate_key_length(key_length, ptr->flags & MEM_BINARY_PROTOCOL);
+  unlikely (rc != MEMCACHED_SUCCESS)
+    return rc;
+
+  LIBMEMCACHED_MEMCACHED_INCREMENT_WITH_INITIAL_START();
+  if (ptr->flags & MEM_BINARY_PROTOCOL)
+    rc= binary_incr_decr(ptr, PROTOCOL_BINARY_CMD_INCREMENT, key,
+                         key_length, offset, initial, (uint32_t)expiration, 
+                         value);
+  else
+    rc= MEMCACHED_PROTOCOL_ERROR;
+
+  LIBMEMCACHED_MEMCACHED_INCREMENT_WITH_INITIAL_END();
+
+  return rc;
+}
+
+memcached_return memcached_decrement_with_initial(memcached_st *ptr,
+                                                  const char *key,
+                                                  size_t key_length,
+                                                  uint64_t offset,
+                                                  uint64_t initial,
+                                                  time_t expiration,
+                                                  uint64_t *value)
+{
+  memcached_return rc= memcached_validate_key_length(key_length, ptr->flags & MEM_BINARY_PROTOCOL);
+  unlikely (rc != MEMCACHED_SUCCESS)
+    return rc;
+
+  LIBMEMCACHED_MEMCACHED_DECREMENT_WITH_INITIAL_START();
+  if (ptr->flags & MEM_BINARY_PROTOCOL)
+    rc= binary_incr_decr(ptr, PROTOCOL_BINARY_CMD_DECREMENT, key,
+                         key_length, offset, initial, (uint32_t)expiration,
+                         value);
+  else
+    rc= MEMCACHED_PROTOCOL_ERROR;
+
+  LIBMEMCACHED_MEMCACHED_DECREMENT_WITH_INITIAL_END();
+
+  return rc;
+}

data/ext/libmemcached-0.32/libmemcached/memcached_behavior.c

@@ -0,0 +1,290 @@
+#include "common.h"
+#include <time.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/tcp.h>
+
+/*
+  This function is used to modify the behavior of running client.
+
+  We quit all connections so we can reset the sockets.
+*/
+
+static void set_behavior_flag(memcached_st *ptr, memcached_flags temp_flag, uint64_t data)
+{
+  if (data)
+    ptr->flags|= temp_flag;
+  else
+    ptr->flags&= ~temp_flag;
+}
+
+memcached_return memcached_behavior_set(memcached_st *ptr,
+                                        memcached_behavior flag,
+                                        uint64_t data)
+{
+  switch (flag)
+  {
+  case MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK:
+    ptr->io_msg_watermark= (uint32_t) data;
+    break;
+  case MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK:
+    ptr->io_bytes_watermark= (uint32_t)data;
+    break;
+  case MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH:
+    ptr->io_key_prefetch = (uint32_t)data;
+    break;
+  case MEMCACHED_BEHAVIOR_SND_TIMEOUT:
+    ptr->snd_timeout= (int32_t)data;
+    break;
+  case MEMCACHED_BEHAVIOR_RCV_TIMEOUT:
+    ptr->rcv_timeout= (int32_t)data;
+    break;
+  case MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT:
+    ptr->server_failure_limit= (uint32_t)data;
+    break;
+  case MEMCACHED_BEHAVIOR_BINARY_PROTOCOL:
+    if (data)
+        set_behavior_flag(ptr, MEM_VERIFY_KEY, 0);
+    set_behavior_flag(ptr, MEM_BINARY_PROTOCOL, data);
+    break;
+  case MEMCACHED_BEHAVIOR_SUPPORT_CAS:
+    set_behavior_flag(ptr, MEM_SUPPORT_CAS, data);
+    break;
+  case MEMCACHED_BEHAVIOR_NO_BLOCK:
+    set_behavior_flag(ptr, MEM_NO_BLOCK, data);
+    memcached_quit(ptr);
+    break;
+  case MEMCACHED_BEHAVIOR_BUFFER_REQUESTS:
+    set_behavior_flag(ptr, MEM_BUFFER_REQUESTS, data);
+    memcached_quit(ptr);
+    break;
+  case MEMCACHED_BEHAVIOR_USE_UDP:
+    if (ptr->number_of_hosts)
+      return MEMCACHED_FAILURE;
+    set_behavior_flag(ptr, MEM_USE_UDP, data);
+    if (data)
+      set_behavior_flag(ptr,MEM_NOREPLY,data);
+    break;
+  case MEMCACHED_BEHAVIOR_TCP_NODELAY:
+    set_behavior_flag(ptr, MEM_TCP_NODELAY, data);
+    memcached_quit(ptr);
+    break;
+  case MEMCACHED_BEHAVIOR_DISTRIBUTION:
+    {
+      ptr->distribution= (memcached_server_distribution)(data);
+      if (ptr->distribution == MEMCACHED_DISTRIBUTION_RANDOM)
+      {
+        srandom((uint32_t) time(NULL));
+      }
+      run_distribution(ptr);
+      break;
+    }
+  case MEMCACHED_BEHAVIOR_KETAMA:
+    {
+      if (data)
+      {
+        ptr->hash= MEMCACHED_HASH_MD5;
+        ptr->distribution= MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA;
+      }
+      else
+      {
+        ptr->hash= 0;
+        ptr->distribution= 0;
+      }
+      run_distribution(ptr);
+      break;
+    }
+  case MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED:
+    {
+      ptr->hash= MEMCACHED_HASH_MD5;
+      ptr->distribution= MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA;
+      set_behavior_flag(ptr, MEM_KETAMA_WEIGHTED, data);
+      run_distribution(ptr);
+      break;
+    }
+  case MEMCACHED_BEHAVIOR_HASH:
+#ifndef HAVE_HSIEH_HASH
+    if ((memcached_hash)(data) == MEMCACHED_HASH_HSIEH)
+      return MEMCACHED_FAILURE;
+#endif
+    ptr->hash= (memcached_hash)(data);
+    break;
+  case MEMCACHED_BEHAVIOR_KETAMA_HASH:
+    ptr->hash_continuum= (memcached_hash)(data);
+    run_distribution(ptr);
+    break;
+  case MEMCACHED_BEHAVIOR_CACHE_LOOKUPS:
+    set_behavior_flag(ptr, MEM_USE_CACHE_LOOKUPS, data);
+    memcached_quit(ptr);
+    break;
+  case MEMCACHED_BEHAVIOR_VERIFY_KEY:
+    if (ptr->flags & MEM_BINARY_PROTOCOL)
+        break;
+    set_behavior_flag(ptr, MEM_VERIFY_KEY, data);
+    break;
+  case MEMCACHED_BEHAVIOR_SORT_HOSTS:
+    {
+      set_behavior_flag(ptr, MEM_USE_SORT_HOSTS, data);
+      run_distribution(ptr);
+
+      break;
+    }
+  case MEMCACHED_BEHAVIOR_POLL_TIMEOUT:
+    ptr->poll_timeout= (int32_t)data;
+    break;
+  case MEMCACHED_BEHAVIOR_POLL_MAX_RETRIES:
+    ptr->poll_max_retries= (uint32_t) data;
+    break;
+  case MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT:
+    ptr->connect_timeout= (int32_t)data;
+    break;
+  case MEMCACHED_BEHAVIOR_RETRY_TIMEOUT:
+    ptr->retry_timeout= (int32_t)data;
+    break;
+  case MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE:
+    ptr->send_size= (int32_t)data;
+    memcached_quit(ptr);
+    break;
+  case MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE:
+    ptr->recv_size= (int32_t)data;
+    memcached_quit(ptr);
+    break;
+  case MEMCACHED_BEHAVIOR_USER_DATA:
+    return MEMCACHED_FAILURE;
+  case MEMCACHED_BEHAVIOR_HASH_WITH_PREFIX_KEY:
+    set_behavior_flag(ptr, MEM_HASH_WITH_PREFIX_KEY, data);
+    break;
+  case MEMCACHED_BEHAVIOR_NOREPLY:
+    set_behavior_flag(ptr, MEM_NOREPLY, data);
+    break;
+  case MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS:
+    set_behavior_flag(ptr, MEM_AUTO_EJECT_HOSTS, data);
+    break;
+  default:
+    /* Shouldn't get here */
+    WATCHPOINT_ASSERT(flag);
+    break;
+  }
+
+  return MEMCACHED_SUCCESS;
+}
+
+uint64_t memcached_behavior_get(memcached_st *ptr,
+                                memcached_behavior flag)
+{
+  memcached_flags temp_flag= MEM_NO_BLOCK;
+
+  switch (flag)
+  {
+  case MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK:
+    return ptr->io_msg_watermark;
+  case MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK:
+    return ptr->io_bytes_watermark;
+  case MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH:
+    return ptr->io_key_prefetch;
+  case MEMCACHED_BEHAVIOR_BINARY_PROTOCOL:
+    temp_flag= MEM_BINARY_PROTOCOL;
+    break;
+  case MEMCACHED_BEHAVIOR_SUPPORT_CAS:
+    temp_flag= MEM_SUPPORT_CAS;
+    break;
+  case MEMCACHED_BEHAVIOR_CACHE_LOOKUPS:
+    temp_flag= MEM_USE_CACHE_LOOKUPS;
+    break;
+  case MEMCACHED_BEHAVIOR_NO_BLOCK:
+    temp_flag= MEM_NO_BLOCK;
+    break;
+  case MEMCACHED_BEHAVIOR_BUFFER_REQUESTS:
+    temp_flag= MEM_BUFFER_REQUESTS;
+    break;
+  case MEMCACHED_BEHAVIOR_USE_UDP:
+    temp_flag= MEM_USE_UDP;
+    break;
+  case MEMCACHED_BEHAVIOR_TCP_NODELAY:
+    temp_flag= MEM_TCP_NODELAY;
+    break;
+  case MEMCACHED_BEHAVIOR_VERIFY_KEY:
+    temp_flag= MEM_VERIFY_KEY;
+    break;
+  case MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED:
+    temp_flag= MEM_KETAMA_WEIGHTED;
+    break;
+  case MEMCACHED_BEHAVIOR_DISTRIBUTION:
+    return ptr->distribution;
+  case MEMCACHED_BEHAVIOR_KETAMA:
+    return (ptr->distribution == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA) ? (uint64_t) 1 : 0;
+  case MEMCACHED_BEHAVIOR_HASH:
+    return ptr->hash;
+  case MEMCACHED_BEHAVIOR_KETAMA_HASH:
+    return ptr->hash_continuum;
+  case MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT:
+    return ptr->server_failure_limit;
+  case MEMCACHED_BEHAVIOR_SORT_HOSTS:
+    temp_flag= MEM_USE_SORT_HOSTS;
+    break;
+  case MEMCACHED_BEHAVIOR_POLL_TIMEOUT:
+    return (uint64_t)ptr->poll_timeout;
+  case MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT:
+    return (uint64_t)ptr->connect_timeout;
+  case MEMCACHED_BEHAVIOR_RETRY_TIMEOUT:
+    return (uint64_t)ptr->retry_timeout;
+  case MEMCACHED_BEHAVIOR_SND_TIMEOUT:
+    return (uint64_t)ptr->snd_timeout;
+  case MEMCACHED_BEHAVIOR_RCV_TIMEOUT:
+    return (uint64_t)ptr->rcv_timeout;
+  case MEMCACHED_BEHAVIOR_POLL_MAX_RETRIES:
+    return (uint64_t)ptr->poll_max_retries;
+  case MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE:
+    {
+      int sock_size;
+      socklen_t sock_length= sizeof(int);
+
+      /* REFACTOR */
+      /* We just try the first host, and if it is down we return zero */
+      if ((memcached_connect(&ptr->hosts[0])) != MEMCACHED_SUCCESS)
+        return 0;
+
+      if (getsockopt(ptr->hosts[0].fd, SOL_SOCKET,
+                     SO_SNDBUF, &sock_size, &sock_length))
+        return 0; /* Zero means error */
+
+      return (uint64_t) sock_size;
+    }
+  case MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE:
+    {
+      int sock_size;
+      socklen_t sock_length= sizeof(int);
+
+      /* REFACTOR */
+      /* We just try the first host, and if it is down we return zero */
+      if ((memcached_connect(&ptr->hosts[0])) != MEMCACHED_SUCCESS)
+        return 0;
+
+      if (getsockopt(ptr->hosts[0].fd, SOL_SOCKET,
+                     SO_RCVBUF, &sock_size, &sock_length))
+        return 0; /* Zero means error */
+
+      return (uint64_t) sock_size;
+    }
+  case MEMCACHED_BEHAVIOR_USER_DATA:
+    return MEMCACHED_FAILURE;
+  case MEMCACHED_BEHAVIOR_HASH_WITH_PREFIX_KEY:
+    temp_flag= MEM_HASH_WITH_PREFIX_KEY;
+    break;
+  case MEMCACHED_BEHAVIOR_NOREPLY:
+    temp_flag= MEM_NOREPLY;
+    break;
+  case MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS:
+    temp_flag= MEM_AUTO_EJECT_HOSTS;
+    break;
+  default:
+    WATCHPOINT_ASSERT(flag);
+    break;
+  }
+
+  WATCHPOINT_ASSERT(temp_flag); /* Programming mistake if it gets this far */
+  if (ptr->flags & temp_flag)
+    return 1;
+  else
+    return 0;
+}