Added behavior method around testing of keys.

[m6w6/libmemcached] / lib / memcached_response.c

diff --git a/lib/memcached_response.c b/lib/memcached_response.c
index 6ec120c8662208e2ed7a8eb1f7ba2f1c7dc0eab1..33dc0b1e5bfd41d9c28bb41d061028ab313fa619 100644 (file)
--- a/lib/memcached_response.c
+++ b/lib/memcached_response.c
@@ -8,10 +8,9 @@
 #include "common.h"
 #include "memcached_io.h"
 
-memcached_return memcached_response(memcached_st *ptr, 
+memcached_return memcached_response(memcached_server_st *ptr, 
                                     char *buffer, size_t buffer_length,
-                                    memcached_result_st *result,
-                                    unsigned int server_key)
+                                    memcached_result_st *result)
 {
   unsigned int x;
   size_t send_length;
@@ -20,26 +19,40 @@ memcached_return memcached_response(memcached_st *ptr,
 
 
   send_length= 0;
+  /* UDP at the moment is odd...*/
+  if (ptr->type == MEMCACHED_CONNECTION_UDP)
+  {
+    char buffer[8];
+    ssize_t read_length;
+
+    return MEMCACHED_SUCCESS;
+
+    read_length= memcached_io_read(ptr, buffer, 8);
+  }
 
   /* We may have old commands in the buffer not set, first purge */
-  if (ptr->flags & MEM_NO_BLOCK)
-    (void)memcached_io_write(ptr, server_key, NULL, 0, 1);
+  if (ptr->root->flags & MEM_NO_BLOCK)
+    (void)memcached_io_write(ptr, NULL, 0, 1);
 
-  max_messages= memcached_server_response_count(ptr, server_key);
+  max_messages= memcached_server_response_count(ptr);
   for (x= 0; x <  max_messages; x++)
   {
     size_t total_length= 0;
     buffer_ptr= buffer;
 
+
     while (1)
     {
-      unsigned int read_length;
+      ssize_t read_length;
 
-      read_length= memcached_io_read(ptr, server_key,
-                                     buffer_ptr, 1);
+      read_length= memcached_io_read(ptr, buffer_ptr, 1);
+      WATCHPOINT_ASSERT(isgraph(*buffer_ptr) || isspace(*buffer_ptr));
 
       if (read_length != 1)
+      {
+        memcached_io_reset(ptr);
         return  MEMCACHED_UNKNOWN_READ_FAILURE;
+      }
 
       if (*buffer_ptr == '\n')
         break;
@@ -50,12 +63,15 @@ memcached_return memcached_response(memcached_st *ptr,
       WATCHPOINT_ASSERT(total_length <= buffer_length);
 
       if (total_length >= buffer_length)
+      {
+        memcached_io_reset(ptr);
         return MEMCACHED_PROTOCOL_ERROR;
+      }
     }
     buffer_ptr++;
     *buffer_ptr= 0;
 
-    memcached_server_response_decrement(ptr, server_key);
+    memcached_server_response_decrement(ptr);
   }
 
   switch(buffer[0])
@@ -66,11 +82,11 @@ memcached_return memcached_response(memcached_st *ptr,
       memcached_return rc;
 
       /* We add back in one because we will need to search for END */
-      memcached_server_response_increment(ptr, server_key);
+      memcached_server_response_increment(ptr);
       if (result)
-        rc= value_fetch(ptr, buffer, result, server_key);
+        rc= value_fetch(ptr, buffer, result);
       else
-        rc= value_fetch(ptr, buffer, &ptr->result, server_key);
+        rc= value_fetch(ptr, buffer, &ptr->root->result);
 
       return rc;
     }
@@ -82,6 +98,7 @@ memcached_return memcached_response(memcached_st *ptr,
     {
       WATCHPOINT_STRING(buffer);
       WATCHPOINT_ASSERT(0);
+      memcached_io_reset(ptr);
       return MEMCACHED_UNKNOWN_READ_FAILURE;
     }
   case 'O': /* OK */
@@ -90,7 +107,7 @@ memcached_return memcached_response(memcached_st *ptr,
     {
       if (buffer[2] == 'A') /* STORED STATS */
       {
-        memcached_server_response_increment(ptr, server_key);
+        memcached_server_response_increment(ptr);
         return MEMCACHED_STAT;
       }
       else if (buffer[1] == 'E')
@@ -101,6 +118,7 @@ memcached_return memcached_response(memcached_st *ptr,
       {
         WATCHPOINT_STRING(buffer);
         WATCHPOINT_ASSERT(0);
+        memcached_io_reset(ptr);
         return MEMCACHED_UNKNOWN_READ_FAILURE;
       }
     }
@@ -113,20 +131,31 @@ memcached_return memcached_response(memcached_st *ptr,
       else if (buffer[4] == 'S')
         return MEMCACHED_NOTSTORED;
       else
+      {
+        memcached_io_reset(ptr);
         return MEMCACHED_UNKNOWN_READ_FAILURE;
+      }
     }
   case 'E': /* PROTOCOL ERROR or END */
     {
       if (buffer[1] == 'N')
         return MEMCACHED_END;
       else if (buffer[1] == 'R')
+      {
+        memcached_io_reset(ptr);
         return MEMCACHED_PROTOCOL_ERROR;
+      }
       else
+      {
+        memcached_io_reset(ptr);
         return MEMCACHED_UNKNOWN_READ_FAILURE;
+      }
     }
   case 'C': /* CLIENT ERROR */
+    memcached_io_reset(ptr);
     return MEMCACHED_CLIENT_ERROR;
   default:
+    memcached_io_reset(ptr);
     return MEMCACHED_UNKNOWN_READ_FAILURE;
 
   }