Style cleanup

[m6w6/libmemcached] / libmemcached / memcached_response.c

diff --git a/libmemcached/memcached_response.c b/libmemcached/memcached_response.c
index ba0691b504a39590c67184d830e2c1753222cec4..cb29742810428648a539c4461f7f74d07d4bbf7d 100644 (file)
--- a/libmemcached/memcached_response.c
+++ b/libmemcached/memcached_response.c
@@ -8,14 +8,14 @@
 #include "common.h"
 #include "memcached_io.h"
 
-static memcached_return textual_read_one_response(memcached_server_st *ptr,
+static memcached_return_t textual_read_one_response(memcached_server_st *ptr,
                                                   char *buffer, size_t buffer_length,
                                                   memcached_result_st *result);
-static memcached_return binary_read_one_response(memcached_server_st *ptr,
+static memcached_return_t binary_read_one_response(memcached_server_st *ptr,
                                                  char *buffer, size_t buffer_length,
                                                  memcached_result_st *result);
 
-memcached_return memcached_read_one_response(memcached_server_st *ptr,
+memcached_return_t memcached_read_one_response(memcached_server_st *ptr,
                                              char *buffer, size_t buffer_length,
                                              memcached_result_st *result)
 {
@@ -24,8 +24,8 @@ memcached_return memcached_read_one_response(memcached_server_st *ptr,
   if (result == NULL)
     result = &ptr->root->result;
 
-  memcached_return rc;
-  if (ptr->root->flags & MEM_BINARY_PROTOCOL)
+  memcached_return_t rc;
+  if (ptr->root->flags.binary_protocol)
     rc= binary_read_one_response(ptr, buffer, buffer_length, result);
   else
     rc= textual_read_one_response(ptr, buffer, buffer_length, result);
@@ -39,12 +39,12 @@ memcached_return memcached_read_one_response(memcached_server_st *ptr,
   return rc;
 }
 
-memcached_return memcached_response(memcached_server_st *ptr, 
+memcached_return_t memcached_response(memcached_server_st *ptr, 
                                     char *buffer, size_t buffer_length,
                                     memcached_result_st *result)
 {
   /* We may have old commands in the buffer not set, first purge */
-  if (ptr->root->flags & MEM_NO_BLOCK)
+  if (ptr->root->flags.no_block)
     (void)memcached_io_write(ptr, NULL, 0, 1);
 
   /*
@@ -52,10 +52,10 @@ memcached_return memcached_response(memcached_server_st *ptr,
    * returned the last one. Purge all pending messages to ensure backwards
    * compatibility. 
    */
-  if ((ptr->root->flags & MEM_BINARY_PROTOCOL) == 0)
+  if (ptr->root->flags.binary_protocol == false)
     while (memcached_server_response_count(ptr) > 1)
     {
-      memcached_return rc= memcached_read_one_response(ptr, buffer, buffer_length, result);
+      memcached_return_t rc= memcached_read_one_response(ptr, buffer, buffer_length, result);
       
       unlikely (rc != MEMCACHED_END &&
                 rc != MEMCACHED_STORED &&
@@ -71,11 +71,11 @@ memcached_return memcached_response(memcached_server_st *ptr,
   return memcached_read_one_response(ptr, buffer, buffer_length, result);
 }
 
-static memcached_return textual_value_fetch(memcached_server_st *ptr,
+static memcached_return_t textual_value_fetch(memcached_server_st *ptr,
                                             char *buffer,
                                             memcached_result_st *result)
 {
-  memcached_return rc= MEMCACHED_SUCCESS;
+  memcached_return_t rc= MEMCACHED_SUCCESS;
   char *string_ptr;
   char *end_ptr;
   char *next_ptr;
@@ -83,7 +83,7 @@ static memcached_return textual_value_fetch(memcached_server_st *ptr,
   size_t to_read;
   char *value_ptr;
 
-  if (ptr->root->flags & MEM_USE_UDP)
+  if (ptr->root->flags.use_udp)
     return MEMCACHED_NOT_SUPPORTED;
 
   WATCHPOINT_ASSERT(ptr->root);
@@ -125,7 +125,7 @@ static memcached_return textual_value_fetch(memcached_server_st *ptr,
   if (end_ptr == string_ptr)
     goto read_error;
   for (next_ptr= string_ptr; isdigit(*string_ptr); string_ptr++);
-  result->flags= strtoul(next_ptr, &string_ptr, 10);
+  result->flags= (uint32_t) strtoul(next_ptr, &string_ptr, 10);
 
   if (end_ptr == string_ptr)
     goto read_error;
@@ -175,7 +175,7 @@ static memcached_return textual_value_fetch(memcached_server_st *ptr,
   */
   to_read= (value_length) + 2;
   ssize_t read_length= 0;
-  memcached_return rrc= memcached_io_read(ptr, value_ptr, to_read, &read_length);
+  memcached_return_t rrc= memcached_io_read(ptr, value_ptr, to_read, &read_length);
   if (rrc != MEMCACHED_SUCCESS)
     return rrc;
 
@@ -201,11 +201,11 @@ read_error:
   return MEMCACHED_PARTIAL_READ;
 }
 
-static memcached_return textual_read_one_response(memcached_server_st *ptr,
+static memcached_return_t textual_read_one_response(memcached_server_st *ptr,
                                                   char *buffer, size_t buffer_length,
                                                   memcached_result_st *result)
 {
-  memcached_return rc= memcached_io_readline(ptr, buffer, buffer_length);
+  memcached_return_t rc= memcached_io_readline(ptr, buffer, buffer_length);
   if (rc != MEMCACHED_SUCCESS)
     return rc;
 
@@ -250,7 +250,9 @@ static memcached_return textual_read_one_response(memcached_server_st *ptr,
             memory in the struct, which is important, for something that
             rarely should happen?
           */
-         rel_ptr= (char *)ptr->root->call_realloc(ptr->root, ptr->cached_server_error, endptr - startptr + 1);
+         rel_ptr= (char *)ptr->root->call_realloc(ptr->root, 
+                                                   ptr->cached_server_error, 
+                                                   (size_t) (endptr - startptr + 1));
 
           if (rel_ptr == NULL)
           {
@@ -261,7 +263,7 @@ static memcached_return textual_read_one_response(memcached_server_st *ptr,
           }
          ptr->cached_server_error= rel_ptr;
 
-         memcpy(ptr->cached_server_error, startptr, endptr - startptr);
+         memcpy(ptr->cached_server_error, startptr, (size_t) (endptr - startptr));
          ptr->cached_server_error[endptr - startptr]= 0;
          return MEMCACHED_SERVER_ERROR;
        }
@@ -328,7 +330,7 @@ size_t memcached_result_length(memcached_result_st *ptr)
   return memcached_string_length(sptr);
 }
 
-static memcached_return binary_read_one_response(memcached_server_st *ptr,
+static memcached_return_t binary_read_one_response(memcached_server_st *ptr,
                                                  char *buffer, size_t buffer_length,
                                                  memcached_result_st *result)
 {
@@ -354,8 +356,14 @@ static memcached_return binary_read_one_response(memcached_server_st *ptr,
   {
     switch (header.response.opcode)
     {
-    case PROTOCOL_BINARY_CMD_GETK:
     case PROTOCOL_BINARY_CMD_GETKQ:
+      /*
+       * We didn't increment the response counter for the GETKQ packet
+       * (only the final NOOP), so we need to increment the counter again.
+       */ 
+      memcached_server_response_increment(ptr); 
+      /* FALLTHROUGH */
+    case PROTOCOL_BINARY_CMD_GETK:
       {
         uint16_t keylen= header.response.keylen;
         memcached_result_reset(result);
@@ -461,7 +469,7 @@ static memcached_return binary_read_one_response(memcached_server_st *ptr,
       size_t nr= (bodylen > SMALL_STRING_LEN) ? SMALL_STRING_LEN : bodylen;
       if (memcached_safe_read(ptr, hole, nr) != MEMCACHED_SUCCESS)
         return MEMCACHED_UNKNOWN_READ_FAILURE;
-      bodylen -= nr;
+      bodylen-= (uint32_t) nr;
     }
 
     /* This might be an error from one of the quiet commands.. if
@@ -481,7 +489,7 @@ static memcached_return binary_read_one_response(memcached_server_st *ptr,
     }
   }
 
-  memcached_return rc= MEMCACHED_SUCCESS;
+  memcached_return_t rc= MEMCACHED_SUCCESS;
   unlikely(header.response.status != 0) 
     switch (header.response.status) 
     {
@@ -491,11 +499,17 @@ static memcached_return binary_read_one_response(memcached_server_st *ptr,
     case PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS:
       rc= MEMCACHED_DATA_EXISTS;
       break;
+    case PROTOCOL_BINARY_RESPONSE_NOT_STORED:
+      rc= MEMCACHED_NOTSTORED;
+      break;
     case PROTOCOL_BINARY_RESPONSE_E2BIG:
+      rc= MEMCACHED_E2BIG;
+      break;
+    case PROTOCOL_BINARY_RESPONSE_ENOMEM:
+      rc= MEMCACHED_MEMORY_ALLOCATION_FAILURE;
+      break;
     case PROTOCOL_BINARY_RESPONSE_EINVAL:
-    case PROTOCOL_BINARY_RESPONSE_NOT_STORED:
     case PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND:
-    case PROTOCOL_BINARY_RESPONSE_ENOMEM:
     default:
       /* @todo fix the error mappings */
       rc= MEMCACHED_PROTOCOL_ERROR;