X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fget.cc;h=1deb39765ea7d2a0162acfb9a6d67e789ab1f3b0;hb=3dcd41c50068eec906a1a11a178e9b3f08ef2326;hp=6dfb7a79a271409902f88947e9d0cb870da5bc01;hpb=5cb5e0d2dacc49ea143b8e059b0f90251d0e2c23;p=m6w6%2Flibmemcached

diff --git a/libmemcached/get.cc b/libmemcached/get.cc
index 6dfb7a79..1deb3976 100644
--- a/libmemcached/get.cc
+++ b/libmemcached/get.cc
@@ -68,36 +68,39 @@ char *memcached_get_by_key(memcached_st *ptr,
 {
   memcached_return_t unused;
   if (error == NULL)
+  {
     error= &unused;
+  }
 
-  unlikely (ptr->flags.use_udp)
+  uint64_t query_id= 0;
+  if (ptr)
   {
-    if (value_length) 
-      *value_length= 0;
-
-    *error= memcached_set_error(*ptr, MEMCACHED_NOT_SUPPORTED, MEMCACHED_AT);
-    return NULL;
+    query_id= ptr->query_id;
   }
 
-  uint64_t query_id= ptr->query_id;
-  (void)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);
-  assert_msg(ptr->query_id == query_id +1, "Programmer error, the query_id was not incremented.");
-
+  if (ptr)
+  {
+    assert_msg(ptr->query_id == query_id +1, "Programmer error, the query_id was not incremented.");
+  }
 
   if (memcached_failed(*error))
   {
-    if (memcached_has_current_error(*ptr)) // Find the most accurate error
+    if (ptr)
     {
-      *error= memcached_last_error(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;
   }
@@ -108,7 +111,9 @@ char *memcached_get_by_key(memcached_st *ptr,
 
   /* This is for historical reasons */
   if (*error == MEMCACHED_END)
+  {
     *error= MEMCACHED_NOTFOUND;
+  }
 
   if (value == NULL)
   {
@@ -118,14 +123,16 @@ char *memcached_get_by_key(memcached_st *ptr,
       memcached_return_t rc= ptr->get_key_failure(ptr, key, key_length, &ptr->result);
 
       /* 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)),
@@ -161,17 +168,6 @@ char *memcached_get_by_key(memcached_st *ptr,
     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);
-  assert_msg(dummy_value == 0, "memcached_fetch() returned additional values beyond the single get it expected");
-  assert_msg(dummy_length == 0, "memcached_fetch() returned additional values beyond the single get it expected");
-  assert_msg(ptr->query_id == query_id +1, "Programmer error, the query_id was not incremented.");
-
   return value;
 }
 
@@ -205,12 +201,12 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
   unsigned int master_server_key= (unsigned int)-1; /* 0 is a valid server id! */
 
   memcached_return_t rc;
-  if (memcached_failed(rc= initialize_query(ptr)))
+  if (memcached_failed(rc= initialize_query(ptr, true)))
   {
     return rc;
   }
 
-  if (ptr->flags.use_udp)
+  if (memcached_is_udp(ptr))
   {
     return memcached_set_error(*ptr, MEMCACHED_NOT_SUPPORTED, MEMCACHED_AT);
   }
@@ -224,17 +220,12 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
 
   if (memcached_failed(memcached_key_test(*ptr, keys, key_length, number_of_keys)))
   {
-    return memcached_set_error(*ptr, MEMCACHED_BAD_KEY_PROVIDED, MEMCACHED_AT, memcached_literal_param("A bad key value was provided"));
+    return memcached_last_error(ptr);
   }
 
   bool is_group_key_set= false;
   if (group_key and group_key_length)
   {
-    if (memcached_failed(memcached_key_test(*ptr, (const char * const *)&group_key, &group_key_length, 1)))
-    {
-      return memcached_set_error(*ptr, MEMCACHED_BAD_KEY_PROVIDED, MEMCACHED_AT, memcached_literal_param("A bad group key was provided."));
-    }
-
     master_server_key= memcached_generate_hash_with_redistribution(ptr, group_key, group_key_length);
     is_group_key_set= true;
   }
@@ -247,22 +238,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);
+    memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, x);
 
     if (memcached_server_response_count(instance))
     {
       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))
+      {
         (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);
@@ -296,7 +290,7 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
 
     instance= memcached_server_instance_fetch(ptr, server_key);
 
-    struct libmemcached_io_vector_st vector[]=
+    libmemcached_io_vector_st vector[]=
     {
       { get_command, get_command_length },
       { memcached_array_string(ptr->_namespace), memcached_array_size(ptr->_namespace) },
@@ -341,7 +335,9 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
     LIBMEMCACHED_MEMCACHED_MGET_END();
 
     if (memcached_failed(rc))
+    {
       return rc;
+    }
 
     return memcached_set_error(*ptr, MEMCACHED_NO_SERVERS, MEMCACHED_AT);
   }
@@ -417,12 +413,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)
+  memcached_return_t rc;
+  if (memcached_failed(rc= initialize_query(ptr, false)))
+  {
+    return rc;
+  }
+
+  if (memcached_is_udp(ptr))
   {
-    return MEMCACHED_NOT_SUPPORTED;
+    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_return_t rc;
   memcached_callback_st *original_callbacks= ptr->callbacks;
   memcached_callback_st cb= {
     callback,
@@ -479,14 +486,18 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr,
     protocol_binary_request_getk request= { }; //= {.bytes= {0}};
     request.message.header.request.magic= PROTOCOL_BINARY_REQ;
     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)
       {
@@ -500,7 +511,7 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr,
     request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
     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[]=
     {
       { request.bytes, sizeof(request.bytes) },
       { memcached_array_string(ptr->_namespace), memcached_array_size(ptr->_namespace) },
@@ -535,12 +546,11 @@ static memcached_return_t simple_binary_mget(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);
+      memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, x);
 
       if (memcached_server_response_count(instance))
       {
-        if (memcached_io_write(instance, NULL, 0, true) == -1)
+        if (memcached_io_write(instance) == false)
         {
           memcached_server_response_reset(instance);
           memcached_io_reset(instance);
@@ -634,7 +644,7 @@ 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[]=
       {
         { request.bytes, sizeof(request.bytes) },
         { memcached_array_string(ptr->_namespace), memcached_array_size(ptr->_namespace) },
@@ -676,8 +686,8 @@ 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)
   {