X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fget.cc;h=88f8b56a1ed4285814c3248cbb47304cb8459d88;hb=76bf27c007d5015d3dcf2981c942d8afb2e97302;hp=576a9b7e5feca61eed21a03fd23ed747b12537f7;hpb=1235c31867b421455a9758909144e74c954d9395;p=awesomized%2Flibmemcached

diff --git a/libmemcached/get.cc b/libmemcached/get.cc
index 576a9b7e..88f8b56a 100644
--- a/libmemcached/get.cc
+++ b/libmemcached/get.cc
@@ -2,7 +2,7 @@
  * 
  *  Libmemcached library
  *
- *  Copyright (C) 2011 Data Differential, http://datadifferential.com/
+ *  Copyright (C) 2011-2012 Data Differential, http://datadifferential.com/
  *  Copyright (C) 2006-2009 Brian Aker All rights reserved.
  *
  *  Redistribution and use in source and binary forms, with or without
@@ -35,8 +35,7 @@
  *
  */
 
-#include "libmemcached/common.h"
-#include <iostream>
+#include <libmemcached/common.h>
 
 /*
   What happens if no servers exist?
@@ -67,82 +66,114 @@ char *memcached_get_by_key(memcached_st *ptr,
                            uint32_t *flags,
                            memcached_return_t *error)
 {
-  unlikely (ptr->flags.use_udp)
+  memcached_return_t unused;
+  if (error == NULL)
   {
-    *error= MEMCACHED_NOT_SUPPORTED;
-    return NULL;
+    error= &unused;
+  }
+
+  uint64_t query_id= 0;
+  if (ptr)
+  {
+    query_id= ptr->query_id;
   }
 
   /* Request the key */
   *error= memcached_mget_by_key_real(ptr, group_key, group_key_length,
-                                     (const char * const *)&key,
-                                     &key_length, 1, false);
+                                     (const char * const *)&key, &key_length, 
+                                     1, false);
+  if (ptr)
+  {
+    assert_msg(ptr->query_id == query_id +1, "Programmer error, the query_id was not incremented.");
+  }
+
+  if (memcached_failed(*error))
+  {
+    if (ptr)
+    {
+      if (memcached_has_current_error(*ptr)) // Find the most accurate error
+      {
+        *error= memcached_last_error(ptr);
+      }
+    }
+
+    if (value_length) 
+    {
+      *value_length= 0;
+    }
+
+    return NULL;
+  }
 
   char *value= memcached_fetch(ptr, NULL, NULL,
                                value_length, flags, error);
+  assert_msg(ptr->query_id == query_id +1, "Programmer error, the query_id was not incremented.");
+
   /* This is for historical reasons */
   if (*error == MEMCACHED_END)
+  {
     *error= MEMCACHED_NOTFOUND;
+  }
 
   if (value == NULL)
   {
-    if (ptr->get_key_failure && *error == MEMCACHED_NOTFOUND)
+    if (ptr->get_key_failure and *error == MEMCACHED_NOTFOUND)
     {
-
-      memcached_result_reset(&ptr->result);
-      memcached_return_t rc= ptr->get_key_failure(ptr, key, key_length, &ptr->result);
+      memcached_result_st key_failure_result;
+      memcached_result_st* result_ptr= memcached_result_create(ptr, &key_failure_result);
+      memcached_return_t rc= ptr->get_key_failure(ptr, key, key_length, result_ptr);
 
       /* On all failure drop to returning NULL */
-      if (rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED)
+      if (rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED)
       {
         if (rc == MEMCACHED_BUFFERED)
         {
           uint64_t latch; /* We use latch to track the state of the original socket */
           latch= memcached_behavior_get(ptr, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS);
           if (latch == 0)
+          {
             memcached_behavior_set(ptr, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
+          }
 
           rc= memcached_set(ptr, key, key_length,
-                            (memcached_result_value(&ptr->result)),
-                            (memcached_result_length(&ptr->result)),
+                            (memcached_result_value(result_ptr)),
+                            (memcached_result_length(result_ptr)),
                             0,
-                            (memcached_result_flags(&ptr->result)));
+                            (memcached_result_flags(result_ptr)));
 
-          if (rc == MEMCACHED_BUFFERED && latch == 0)
+          if (rc == MEMCACHED_BUFFERED and latch == 0)
+          {
             memcached_behavior_set(ptr, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 0);
+          }
         }
         else
         {
           rc= memcached_set(ptr, key, key_length,
-                            (memcached_result_value(&ptr->result)),
-                            (memcached_result_length(&ptr->result)),
+                            (memcached_result_value(result_ptr)),
+                            (memcached_result_length(result_ptr)),
                             0,
-                            (memcached_result_flags(&ptr->result)));
+                            (memcached_result_flags(result_ptr)));
         }
 
-        if (rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED)
+        if (rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED)
         {
           *error= rc;
-          *value_length= memcached_result_length(&ptr->result);
-          *flags= memcached_result_flags(&ptr->result);
-          return memcached_string_c_copy(&ptr->result.value);
+          *value_length= memcached_result_length(result_ptr);
+          *flags= memcached_result_flags(result_ptr);
+          char *result_value=  memcached_string_take_value(&result_ptr->value);
+          memcached_result_free(result_ptr);
+
+          return result_value;
         }
       }
+
+      memcached_result_free(result_ptr);
     }
+    assert_msg(ptr->query_id == query_id +1, "Programmer error, the query_id was not incremented.");
 
     return NULL;
   }
 
-  size_t dummy_length;
-  uint32_t dummy_flags;
-  memcached_return_t dummy_error;
-
-  char *dummy_value= memcached_fetch(ptr, NULL, NULL,
-                                     &dummy_length, &dummy_flags,
-                                     &dummy_error);
-  WATCHPOINT_ASSERT(dummy_length == 0);
-  WATCHPOINT_ASSERT(dummy_value == 0);
-
   return value;
 }
 
@@ -171,35 +202,36 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
                                                      bool mget_mode)
 {
   bool failures_occured_in_sending= false;
-  const char *get_command= "get ";
-  uint8_t get_command_length= 4;
+  const char *get_command= "get";
+  uint8_t get_command_length= 3;
   unsigned int master_server_key= (unsigned int)-1; /* 0 is a valid server id! */
-  bool is_group_key_set= false;
 
   memcached_return_t rc;
-  if (memcached_failed(rc= initialize_query(ptr)))
+  if (memcached_failed(rc= initialize_query(ptr, true)))
   {
     return rc;
   }
 
-  unlikely (ptr->flags.use_udp)
-    return MEMCACHED_NOT_SUPPORTED;
+  if (memcached_is_udp(ptr))
+  {
+    return memcached_set_error(*ptr, MEMCACHED_NOT_SUPPORTED, MEMCACHED_AT);
+  }
 
   LIBMEMCACHED_MEMCACHED_MGET_START();
 
   if (number_of_keys == 0)
-    return MEMCACHED_NOTFOUND;
-
-  if (ptr->flags.verify_key && (memcached_key_test(keys, key_length, number_of_keys) == MEMCACHED_BAD_KEY_PROVIDED))
   {
-    return MEMCACHED_BAD_KEY_PROVIDED;
+    return memcached_set_error(*ptr, MEMCACHED_NOTFOUND, MEMCACHED_AT, memcached_literal_param("number_of_keys was zero"));
   }
 
-  if (group_key && group_key_length)
+  if (memcached_failed(memcached_key_test(*ptr, keys, key_length, number_of_keys)))
   {
-    if (ptr->flags.verify_key and (memcached_key_test((const char * const *)&group_key, &group_key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED))
-      return MEMCACHED_BAD_KEY_PROVIDED;
+    return memcached_last_error(ptr);
+  }
 
+  bool is_group_key_set= false;
+  if (group_key and group_key_length)
+  {
     master_server_key= memcached_generate_hash_with_redistribution(ptr, group_key, group_key_length);
     is_group_key_set= true;
   }
@@ -212,22 +244,25 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
   */
   for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
   {
-    memcached_server_write_instance_st instance=
-      memcached_server_instance_fetch(ptr, x);
+    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, x);
 
-    if (memcached_server_response_count(instance))
+    if (instance->response_count())
     {
       char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
 
       if (ptr->flags.no_block)
-        (void)memcached_io_write(instance, NULL, 0, true);
+      {
+        memcached_io_write(instance);
+      }
 
-      while(memcached_server_response_count(instance))
+      while(instance->response_count())
+      {
         (void)memcached_response(instance, buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, &ptr->result);
+      }
     }
   }
 
-  if (ptr->flags.binary_protocol)
+  if (memcached_is_binary(ptr))
   {
     return binary_mget_by_key(ptr, master_server_key, is_group_key_set, keys,
                               key_length, number_of_keys, mget_mode);
@@ -235,8 +270,8 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
 
   if (ptr->flags.support_cas)
   {
-    get_command= "gets ";
-    get_command_length= 5;
+    get_command= "gets";
+    get_command_length= 4;
   }
 
   /*
@@ -247,7 +282,6 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
   size_t hosts_connected= 0;
   for (uint32_t x= 0; x < number_of_keys; x++)
   {
-    memcached_server_write_instance_st instance;
     uint32_t server_key;
 
     if (is_group_key_set)
@@ -259,41 +293,42 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
       server_key= memcached_generate_hash_with_redistribution(ptr, keys[x], key_length[x]);
     }
 
-    instance= memcached_server_instance_fetch(ptr, server_key);
+    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, server_key);
 
-    struct libmemcached_io_vector_st vector[]=
+    libmemcached_io_vector_st vector[]=
     {
-      { get_command_length, get_command },
-      { memcached_array_size(ptr->prefix_key), memcached_array_string(ptr->prefix_key) },
-      { key_length[x], keys[x] },
-      { 1, " " }
+      { get_command, get_command_length },
+      { memcached_literal_param(" ") },
+      { memcached_array_string(ptr->_namespace), memcached_array_size(ptr->_namespace) },
+      { keys[x], key_length[x] }
     };
 
 
-    if (memcached_server_response_count(instance) == 0)
+    if (instance->response_count() == 0)
     {
       rc= memcached_connect(instance);
 
-      if (rc != MEMCACHED_SUCCESS)
+      if (memcached_failed(rc))
       {
+        memcached_set_error(*instance, rc, MEMCACHED_AT);
         continue;
       }
       hosts_connected++;
 
-      if ((memcached_io_writev(instance, vector, 4, false)) == -1)
+      if ((memcached_io_writev(instance, vector, 4, false)) == false)
       {
         failures_occured_in_sending= true;
         continue;
       }
-      WATCHPOINT_ASSERT(instance->cursor_active == 0);
-      memcached_server_response_increment(instance);
-      WATCHPOINT_ASSERT(instance->cursor_active == 1);
+      WATCHPOINT_ASSERT(instance->cursor_active_ == 0);
+      memcached_instance_response_increment(instance);
+      WATCHPOINT_ASSERT(instance->cursor_active_ == 1);
     }
     else
     {
-      if ((memcached_io_writev(instance, (vector + 1), 3, false)) == -1)
+      if ((memcached_io_writev(instance, (vector + 1), 3, false)) == false)
       {
-        memcached_server_response_reset(instance);
+        memcached_instance_response_reset(instance);
         failures_occured_in_sending= true;
         continue;
       }
@@ -304,10 +339,12 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
   {
     LIBMEMCACHED_MEMCACHED_MGET_END();
 
-    if (rc != MEMCACHED_SUCCESS)
+    if (memcached_failed(rc))
+    {
       return rc;
+    }
 
-    return MEMCACHED_NO_SERVERS;
+    return memcached_set_error(*ptr, MEMCACHED_NO_SERVERS, MEMCACHED_AT);
   }
 
 
@@ -317,10 +354,9 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
   bool success_happened= false;
   for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
   {
-    memcached_server_write_instance_st instance=
-      memcached_server_instance_fetch(ptr, x);
+    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, x);
 
-    if (memcached_server_response_count(instance))
+    if (instance->response_count())
     {
       /* We need to do something about non-connnected hosts in the future */
       if ((memcached_io_write(instance, "\r\n", 2, true)) == -1)
@@ -336,13 +372,17 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
 
   LIBMEMCACHED_MEMCACHED_MGET_END();
 
-  if (failures_occured_in_sending && success_happened)
+  if (failures_occured_in_sending and success_happened)
+  {
     return MEMCACHED_SOME_ERRORS;
+  }
 
   if (success_happened)
+  {
     return MEMCACHED_SUCCESS;
+  }
 
-  return MEMCACHED_FAILURE;
+  return MEMCACHED_FAILURE; // Complete failure occurred
 }
 
 memcached_return_t memcached_mget_by_key(memcached_st *ptr,
@@ -379,10 +419,23 @@ memcached_return_t memcached_mget_execute_by_key(memcached_st *ptr,
                                                  void *context,
                                                  unsigned int number_of_callbacks)
 {
-  if ((ptr->flags.binary_protocol) == 0)
-    return MEMCACHED_NOT_SUPPORTED;
-
   memcached_return_t rc;
+  if (memcached_failed(rc= initialize_query(ptr, false)))
+  {
+    return rc;
+  }
+
+  if (memcached_is_udp(ptr))
+  {
+    return memcached_set_error(*ptr, MEMCACHED_NOT_SUPPORTED, MEMCACHED_AT);
+  }
+
+  if (memcached_is_binary(ptr) == false)
+  {
+    return memcached_set_error(*ptr, MEMCACHED_NOT_SUPPORTED, MEMCACHED_AT,
+                               memcached_literal_param("ASCII protocol is not supported for memcached_mget_execute_by_key()"));
+  }
+
   memcached_callback_st *original_callbacks= ptr->callbacks;
   memcached_callback_st cb= {
     callback,
@@ -415,7 +468,6 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr,
   for (uint32_t x= 0; x < number_of_keys; ++x)
   {
     uint32_t server_key;
-    memcached_server_write_instance_st instance;
 
     if (is_group_key_set)
     {
@@ -426,26 +478,32 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr,
       server_key= memcached_generate_hash_with_redistribution(ptr, keys[x], key_length[x]);
     }
 
-    instance= memcached_server_instance_fetch(ptr, server_key);
+    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, server_key);
 
-    if (memcached_server_response_count(instance) == 0)
+    if (instance->response_count() == 0)
     {
       rc= memcached_connect(instance);
-      if (rc != MEMCACHED_SUCCESS)
+      if (memcached_failed(rc))
+      {
         continue;
+      }
     }
 
     protocol_binary_request_getk request= { }; //= {.bytes= {0}};
-    request.message.header.request.magic= PROTOCOL_BINARY_REQ;
+    initialize_binary_request(instance, request.message.header);
     if (mget_mode)
+    {
       request.message.header.request.opcode= PROTOCOL_BINARY_CMD_GETKQ;
+    }
     else
+    {
       request.message.header.request.opcode= PROTOCOL_BINARY_CMD_GETK;
+    }
 
     memcached_return_t vk;
     vk= memcached_validate_key_length(key_length[x],
                                       ptr->flags.binary_protocol);
-    unlikely (vk != MEMCACHED_SUCCESS)
+    if (vk != MEMCACHED_SUCCESS)
     {
       if (x > 0)
       {
@@ -455,18 +513,18 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr,
       return vk;
     }
 
-    request.message.header.request.keylen= htons((uint16_t)(key_length[x] + memcached_array_size(ptr->prefix_key)));
+    request.message.header.request.keylen= htons((uint16_t)(key_length[x] + memcached_array_size(ptr->_namespace)));
     request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
-    request.message.header.request.bodylen= htonl((uint32_t)( key_length[x] + memcached_array_size(ptr->prefix_key)));
+    request.message.header.request.bodylen= htonl((uint32_t)( key_length[x] + memcached_array_size(ptr->_namespace)));
 
-    struct libmemcached_io_vector_st vector[]=
+    libmemcached_io_vector_st vector[]=
     {
-      { sizeof(request.bytes), request.bytes },
-      { memcached_array_size(ptr->prefix_key), memcached_array_string(ptr->prefix_key) },
-      { key_length[x], keys[x] }
+      { request.bytes, sizeof(request.bytes) },
+      { memcached_array_string(ptr->_namespace), memcached_array_size(ptr->_namespace) },
+      { keys[x], key_length[x] }
     };
 
-    if (memcached_io_writev(instance, vector, 3, flush) == -1)
+    if (memcached_io_writev(instance, vector, 3, flush) == false)
     {
       memcached_server_response_reset(instance);
       rc= MEMCACHED_SOME_ERRORS;
@@ -476,7 +534,7 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr,
     /* We just want one pending response per server */
     memcached_server_response_reset(instance);
     memcached_server_response_increment(instance);
-    if ((x > 0 && x == ptr->io_key_prefetch) && memcached_flush_buffers(ptr) != MEMCACHED_SUCCESS)
+    if ((x > 0 and x == ptr->io_key_prefetch) and memcached_flush_buffers(ptr) != MEMCACHED_SUCCESS)
     {
       rc= MEMCACHED_SOME_ERRORS;
     }
@@ -488,20 +546,19 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr,
       Send a noop command to flush the buffers
     */
     protocol_binary_request_noop request= {}; //= {.bytes= {0}};
-    request.message.header.request.magic= PROTOCOL_BINARY_REQ;
     request.message.header.request.opcode= PROTOCOL_BINARY_CMD_NOOP;
     request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
 
     for (uint32_t x= 0; x < memcached_server_count(ptr); ++x)
     {
-      memcached_server_write_instance_st instance=
-        memcached_server_instance_fetch(ptr, x);
+      org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, x);
+      initialize_binary_request(instance, request.message.header);
 
-      if (memcached_server_response_count(instance))
+      if (instance->response_count())
       {
-        if (memcached_io_write(instance, NULL, 0, true) == -1)
+        if (memcached_io_write(instance) == false)
         {
-          memcached_server_response_reset(instance);
+          memcached_instance_response_reset(instance);
           memcached_io_reset(instance);
           rc= MEMCACHED_SOME_ERRORS;
         }
@@ -509,7 +566,7 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr,
         if (memcached_io_write(instance, request.bytes,
                                sizeof(request.bytes), true) == -1)
         {
-          memcached_server_response_reset(instance);
+          memcached_instance_response_reset(instance);
           memcached_io_reset(instance);
           rc= MEMCACHED_SOME_ERRORS;
         }
@@ -533,7 +590,9 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr,
   uint64_t randomize_read= memcached_behavior_get(ptr, MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ);
 
   if (randomize_read)
+  {
     start= (uint32_t)random() % (uint32_t)(ptr->number_of_replicas + 1);
+  }
 
   /* Loop for each replica */
   for (uint32_t replica= 0; replica <= ptr->number_of_replicas; ++replica)
@@ -548,20 +607,27 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr,
       uint32_t server= hash[x] + replica;
 
       /* In case of randomized reads */
-      if (randomize_read && ((server + start) <= (hash[x] + ptr->number_of_replicas)))
-        server += start;
+      if (randomize_read and ((server + start) <= (hash[x] + ptr->number_of_replicas)))
+      {
+        server+= start;
+      }
 
       while (server >= memcached_server_count(ptr))
+      {
         server -= memcached_server_count(ptr);
+      }
 
       if (dead_servers[server])
+      {
         continue;
+      }
 
-      memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, server);
+      org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, server);
 
-      if (memcached_server_response_count(instance) == 0)
+      if (instance->response_count() == 0)
       {
         rc= memcached_connect(instance);
+
         if (memcached_failed(rc))
         {
           memcached_io_reset(instance);
@@ -572,11 +638,11 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr,
       }
 
       protocol_binary_request_getk request= {};
-      request.message.header.request.magic= PROTOCOL_BINARY_REQ;
+      initialize_binary_request(instance, request.message.header);
       request.message.header.request.opcode= PROTOCOL_BINARY_CMD_GETK;
-      request.message.header.request.keylen= htons((uint16_t)(key_length[x] + memcached_array_size(ptr->prefix_key)));
+      request.message.header.request.keylen= htons((uint16_t)(key_length[x] + memcached_array_size(ptr->_namespace)));
       request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
-      request.message.header.request.bodylen= htonl((uint32_t)(key_length[x] + memcached_array_size(ptr->prefix_key)));
+      request.message.header.request.bodylen= htonl((uint32_t)(key_length[x] + memcached_array_size(ptr->_namespace)));
 
       /*
        * We need to disable buffering to actually know that the request was
@@ -588,14 +654,14 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr,
        * that we might have processed some of the responses etc. For now,
        * just make sure we work _correctly_
      */
-      struct libmemcached_io_vector_st vector[]=
+      libmemcached_io_vector_st vector[]=
       {
-        { sizeof(request.bytes), request.bytes },
-        { memcached_array_size(ptr->prefix_key), memcached_array_string(ptr->prefix_key) },
-        { key_length[x], keys[x] }
+        { request.bytes, sizeof(request.bytes) },
+        { memcached_array_string(ptr->_namespace), memcached_array_size(ptr->_namespace) },
+        { keys[x], key_length[x] }
       };
 
-      if (memcached_io_writev(instance, vector, 3, true) == -1)
+      if (memcached_io_writev(instance, vector, 3, true) == false)
       {
         memcached_io_reset(instance);
         dead_servers[server]= true;
@@ -608,7 +674,9 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr,
     }
 
     if (success)
+    {
       break;
+    }
   }
 
   return rc;
@@ -628,10 +696,10 @@ static memcached_return_t binary_mget_by_key(memcached_st *ptr,
                               keys, key_length, number_of_keys, mget_mode);
   }
 
-  uint32_t* hash= static_cast<uint32_t*>(libmemcached_malloc(ptr, sizeof(uint32_t) * number_of_keys));
-  bool* dead_servers= static_cast<bool*>(libmemcached_calloc(ptr, memcached_server_count(ptr), sizeof(bool)));
+  uint32_t* hash= libmemcached_xvalloc(ptr, number_of_keys, uint32_t);
+  bool* dead_servers= libmemcached_xcalloc(ptr, memcached_server_count(ptr), bool);
 
-  if (hash == NULL || dead_servers == NULL)
+  if (hash == NULL or dead_servers == NULL)
   {
     libmemcached_free(ptr, hash);
     libmemcached_free(ptr, dead_servers);