X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fmemcached_response.c;h=cb29742810428648a539c4461f7f74d07d4bbf7d;hb=b4de8d3fd063b9017797dd9809ab3acb8a537606;hp=5c44e5f2b78e494ac53d659d66827875faa196b3;hpb=d7de77de3f79dd9a478ee40dd034af45b6a3f8ef;p=m6w6%2Flibmemcached

diff --git a/libmemcached/memcached_response.c b/libmemcached/memcached_response.c
index 5c44e5f2..cb297428 100644
--- a/libmemcached/memcached_response.c
+++ b/libmemcached/memcached_response.c
@@ -8,21 +8,24 @@
 #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)
 {
   memcached_server_response_decrement(ptr);
 
-  memcached_return rc;
-  if (ptr->root->flags & MEM_BINARY_PROTOCOL)
+  if (result == NULL)
+    result = &ptr->root->result;
+
+  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);
@@ -36,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);
 
   /*
@@ -49,9 +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)
-    while (memcached_server_response_count(ptr) > 1) {
-      memcached_return rc= memcached_read_one_response(ptr, buffer, buffer_length, result);
+  if (ptr->root->flags.binary_protocol == false)
+    while (memcached_server_response_count(ptr) > 1)
+    {
+      memcached_return_t rc= memcached_read_one_response(ptr, buffer, buffer_length, result);
       
       unlikely (rc != MEMCACHED_END &&
                 rc != MEMCACHED_STORED &&
@@ -67,40 +71,141 @@ memcached_return memcached_response(memcached_server_st *ptr,
   return memcached_read_one_response(ptr, buffer, buffer_length, result);
 }
 
-static memcached_return memcached_readline(memcached_server_st *ptr,
-                                           char *buffer,
-                                           size_t size)
+static memcached_return_t textual_value_fetch(memcached_server_st *ptr,
+                                            char *buffer,
+                                            memcached_result_st *result)
 {
-  bool line_complete= false;
-  char *buffer_ptr= buffer;
-  int total_nr=0;
+  memcached_return_t rc= MEMCACHED_SUCCESS;
+  char *string_ptr;
+  char *end_ptr;
+  char *next_ptr;
+  size_t value_length;
+  size_t to_read;
+  char *value_ptr;
+
+  if (ptr->root->flags.use_udp)
+    return MEMCACHED_NOT_SUPPORTED;
+
+  WATCHPOINT_ASSERT(ptr->root);
+  end_ptr= buffer + MEMCACHED_DEFAULT_COMMAND_SIZE;
 
-  while (!line_complete)
+  memcached_result_reset(result);
+
+  string_ptr= buffer;
+  string_ptr+= 6; /* "VALUE " */
+
+
+  /* We load the key */
   {
-    if (memcached_io_read(ptr, buffer_ptr, 1) != 1)
-      return MEMCACHED_UNKNOWN_READ_FAILURE;
+    char *key;
+    size_t prefix_length;
 
-    WATCHPOINT_ASSERT(*buffer_ptr != '\0');
-    if (*buffer_ptr == '\n')
-      line_complete=true;
-    else
+    key= result->key;
+    result->key_length= 0;
+
+    for (prefix_length= ptr->root->prefix_key_length; !(iscntrl(*string_ptr) || isspace(*string_ptr)) ; string_ptr++)
     {
-      ++buffer_ptr;
-      ++total_nr;
+      if (prefix_length == 0)
+      {
+        *key= *string_ptr;
+        key++;
+        result->key_length++;
+      }
+      else
+        prefix_length--;
     }
+    result->key[result->key_length]= 0;
+  }
+
+  if (end_ptr == string_ptr)
+    goto read_error;
+
+  /* Flags fetch move past space */
+  string_ptr++;
+  if (end_ptr == string_ptr)
+    goto read_error;
+  for (next_ptr= string_ptr; isdigit(*string_ptr); string_ptr++);
+  result->flags= (uint32_t) strtoul(next_ptr, &string_ptr, 10);
 
-    if (total_nr == size)
-      return MEMCACHED_PROTOCOL_ERROR;
+  if (end_ptr == string_ptr)
+    goto read_error;
+
+  /* Length fetch move past space*/
+  string_ptr++;
+  if (end_ptr == string_ptr)
+    goto read_error;
+
+  for (next_ptr= string_ptr; isdigit(*string_ptr); string_ptr++);
+  value_length= (size_t)strtoull(next_ptr, &string_ptr, 10);
+
+  if (end_ptr == string_ptr)
+    goto read_error;
+
+  /* Skip spaces */
+  if (*string_ptr == '\r')
+  {
+    /* Skip past the \r\n */
+    string_ptr+= 2;
+  }
+  else
+  {
+    string_ptr++;
+    for (next_ptr= string_ptr; isdigit(*string_ptr); string_ptr++);
+    result->cas= strtoull(next_ptr, &string_ptr, 10);
+  }
+
+  if (end_ptr < string_ptr)
+    goto read_error;
+
+  /* We add two bytes so that we can walk the \r\n */
+  rc= memcached_string_check(&result->value, value_length+2);
+  if (rc != MEMCACHED_SUCCESS)
+  {
+    value_length= 0;
+    return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
+  }
+
+  value_ptr= memcached_string_value(&result->value);
+  /* 
+    We read the \r\n into the string since not doing so is more 
+    cycles then the waster of memory to do so.
+
+    We are null terminating through, which will most likely make
+    some people lazy about using the return length.
+  */
+  to_read= (value_length) + 2;
+  ssize_t read_length= 0;
+  memcached_return_t rrc= memcached_io_read(ptr, value_ptr, to_read, &read_length);
+  if (rrc != MEMCACHED_SUCCESS)
+    return rrc;
+
+  if (read_length != (ssize_t)(value_length + 2))
+  {
+    goto read_error;
+  }
+
+/* This next bit blows the API, but this is internal....*/
+  {
+    char *char_ptr;
+    char_ptr= memcached_string_value(&result->value);;
+    char_ptr[value_length]= 0;
+    char_ptr[value_length + 1]= 0;
+    memcached_string_set_length(&result->value, value_length);
   }
 
   return MEMCACHED_SUCCESS;
+
+read_error:
+  memcached_io_reset(ptr);
+
+  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_readline(ptr, buffer, buffer_length);
+  memcached_return_t rc= memcached_io_readline(ptr, buffer, buffer_length);
   if (rc != MEMCACHED_SUCCESS)
     return rc;
 
@@ -109,16 +214,9 @@ static memcached_return textual_read_one_response(memcached_server_st *ptr,
   case 'V': /* VALUE || VERSION */
     if (buffer[1] == 'A') /* VALUE */
     {
-      memcached_return rc;
-
       /* We add back in one because we will need to search for END */
       memcached_server_response_increment(ptr);
-      if (result)
-        rc= value_fetch(ptr, buffer, result);
-      else
-        rc= value_fetch(ptr, buffer, &ptr->root->result);
-
-      return rc;
+      return textual_value_fetch(ptr, buffer, result);
     }
     else if (buffer[1] == 'E') /* VERSION */
     {
@@ -139,8 +237,36 @@ static memcached_return textual_read_one_response(memcached_server_st *ptr,
         memcached_server_response_increment(ptr);
         return MEMCACHED_STAT;
       }
-      else if (buffer[1] == 'E')
-        return MEMCACHED_SERVER_ERROR;
+      else if (buffer[1] == 'E') /* SERVER_ERROR */ 
+	{
+          char *rel_ptr;
+	  char *startptr= buffer + 13, *endptr= startptr;
+
+	  while (*endptr != '\r' && *endptr != '\n') endptr++;
+
+          /* 
+            Yes, we could make this "efficent" but to do that we would need
+            to maintain more state for the size of the buffer. Why waste
+            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, 
+                                                   (size_t) (endptr - startptr + 1));
+
+          if (rel_ptr == NULL)
+          {
+            /* If we happened to have some memory, we just null it since we don't know the size */
+            if (ptr->cached_server_error)
+              ptr->cached_server_error[0]= 0;
+            return MEMCACHED_SERVER_ERROR;
+          }
+	  ptr->cached_server_error= rel_ptr;
+
+	  memcpy(ptr->cached_server_error, startptr, (size_t) (endptr - startptr));
+	  ptr->cached_server_error[endptr - startptr]= 0;
+	  return MEMCACHED_SERVER_ERROR;
+	}
       else if (buffer[1] == 'T')
         return MEMCACHED_STORED;
       else
@@ -172,6 +298,10 @@ static memcached_return textual_read_one_response(memcached_server_st *ptr,
       else
         return MEMCACHED_UNKNOWN_READ_FAILURE;
     }
+  case 'I': /* CLIENT ERROR */
+      /* We add back in one because we will need to search for END */
+      memcached_server_response_increment(ptr);
+    return MEMCACHED_ITEM;
   case 'C': /* CLIENT ERROR */
     return MEMCACHED_CLIENT_ERROR;
   default:
@@ -185,7 +315,7 @@ static memcached_return textual_read_one_response(memcached_server_st *ptr,
     }
   }
 
-  return MEMCACHED_SUCCESS;
+  /* NOTREACHED */
 }
 
 char *memcached_result_value(memcached_result_st *ptr)
@@ -200,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)
 {
@@ -226,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);
@@ -293,13 +429,11 @@ static memcached_return binary_read_one_response(memcached_server_st *ptr,
         WATCHPOINT_ASSERT(bodylen == 0);
         return MEMCACHED_SUCCESS;
       } 
-      break;
     case PROTOCOL_BINARY_CMD_NOOP:
       {
         WATCHPOINT_ASSERT(bodylen == 0);
         return MEMCACHED_END;
       }
-      break;
     case PROTOCOL_BINARY_CMD_STAT:
       {
         if (bodylen == 0)
@@ -329,17 +463,33 @@ static memcached_return binary_read_one_response(memcached_server_st *ptr,
   else if (header.response.bodylen) 
   {
      /* What should I do with the error message??? just discard it for now */
-    char buffer[SMALL_STRING_LEN];
+    char hole[SMALL_STRING_LEN];
     while (bodylen > 0) 
     {
       size_t nr= (bodylen > SMALL_STRING_LEN) ? SMALL_STRING_LEN : bodylen;
-      if (memcached_safe_read(ptr, buffer, nr) != MEMCACHED_SUCCESS)
+      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
+     * so, just throw it away and get the next one. What about creating
+     * a callback to the user with the error information?
+     */
+    switch (header.response.opcode)
+    {
+    case PROTOCOL_BINARY_CMD_SETQ:
+    case PROTOCOL_BINARY_CMD_ADDQ:
+    case PROTOCOL_BINARY_CMD_REPLACEQ:
+    case PROTOCOL_BINARY_CMD_APPENDQ:
+    case PROTOCOL_BINARY_CMD_PREPENDQ:
+      return binary_read_one_response(ptr, buffer, buffer_length, result);
+    default:
+      break;
     }
   }
 
-  memcached_return rc= MEMCACHED_SUCCESS;
+  memcached_return_t rc= MEMCACHED_SUCCESS;
   unlikely(header.response.status != 0) 
     switch (header.response.status) 
     {
@@ -349,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;