git.m6w6.name Git - m6w6/libmemcached/blob - libmemcached/memcached_response.c

   1 /*
   2   Memcached library
   3
   4   memcached_response() is used to determine the return result
   5   from an issued command.
   6 */
   7
   8 #include "common.h"
   9 #include "memcached_io.h"
  10
  11 static memcached_return textual_read_one_response(memcached_server_st *ptr,
  12                                                   char *buffer, size_t buffer_length,
  13                                                   memcached_result_st *result);
  14 static memcached_return binary_read_one_response(memcached_server_st *ptr,
  15                                                  char *buffer, size_t buffer_length,
  16                                                  memcached_result_st *result);
  17
  18 memcached_return memcached_read_one_response(memcached_server_st *ptr,
  19                                              char *buffer, size_t buffer_length,
  20                                              memcached_result_st *result)
  21 {
  22   memcached_server_response_decrement(ptr);
  23
  24   if (result == NULL)
  25     result = &ptr->root->result;
  26
  27   memcached_return rc;
  28   if (ptr->root->flags & MEM_BINARY_PROTOCOL)
  29     rc= binary_read_one_response(ptr, buffer, buffer_length, result);
  30   else
  31     rc= textual_read_one_response(ptr, buffer, buffer_length, result);
  32
  33   unlikely(rc == MEMCACHED_UNKNOWN_READ_FAILURE ||
  34            rc == MEMCACHED_PROTOCOL_ERROR ||
  35            rc == MEMCACHED_CLIENT_ERROR ||
  36            rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE)
  37      memcached_io_reset(ptr);
  38
  39   return rc;
  40 }
  41
  42 memcached_return memcached_response(memcached_server_st *ptr,
  43                                     char *buffer, size_t buffer_length,
  44                                     memcached_result_st *result)
  45 {
  46   /* We may have old commands in the buffer not set, first purge */
  47   if (ptr->root->flags & MEM_NO_BLOCK)
  48     (void)memcached_io_write(ptr, NULL, 0, 1);
  49
  50   /*
  51    * The previous implementation purged all pending requests and just
  52    * returned the last one. Purge all pending messages to ensure backwards
  53    * compatibility.
  54    */
  55   if ((ptr->root->flags & MEM_BINARY_PROTOCOL) == 0)
  56     while (memcached_server_response_count(ptr) > 1)
  57     {
  58       memcached_return rc= memcached_read_one_response(ptr, buffer, buffer_length, result);
  59
  60       unlikely (rc != MEMCACHED_END &&
  61                 rc != MEMCACHED_STORED &&
  62                 rc != MEMCACHED_SUCCESS &&
  63                 rc != MEMCACHED_STAT &&
  64                 rc != MEMCACHED_DELETED &&
  65                 rc != MEMCACHED_NOTFOUND &&
  66                 rc != MEMCACHED_NOTSTORED &&
  67                 rc != MEMCACHED_DATA_EXISTS)
  68         return rc;
  69     }
  70
  71   return memcached_read_one_response(ptr, buffer, buffer_length, result);
  72 }
  73
  74 static memcached_return textual_value_fetch(memcached_server_st *ptr,
  75                                             char *buffer,
  76                                             memcached_result_st *result)
  77 {
  78   memcached_return rc= MEMCACHED_SUCCESS;
  79   char *string_ptr;
  80   char *end_ptr;
  81   char *next_ptr;
  82   size_t value_length;
  83   size_t to_read;
  84   char *value_ptr;
  85
  86   if (ptr->root->flags & MEM_USE_UDP)
  87     return MEMCACHED_NOT_SUPPORTED;
  88
  89   WATCHPOINT_ASSERT(ptr->root);
  90   end_ptr= buffer + MEMCACHED_DEFAULT_COMMAND_SIZE;
  91
  92   memcached_result_reset(result);
  93
  94   string_ptr= buffer;
  95   string_ptr+= 6; /* "VALUE " */
  96
  97
  98   /* We load the key */
  99   {
 100     char *key;
 101     size_t prefix_length;
 102
 103     key= result->key;
 104     result->key_length= 0;
 105
 106     for (prefix_length= ptr->root->prefix_key_length; !(iscntrl(*string_ptr) || isspace(*string_ptr)) ; string_ptr++)
 107     {
 108       if (prefix_length == 0)
 109       {
 110         *key= *string_ptr;
 111         key++;
 112         result->key_length++;
 113       }
 114       else
 115         prefix_length--;
 116     }
 117     result->key[result->key_length]= 0;
 118   }
 119
 120   if (end_ptr == string_ptr)
 121     goto read_error;
 122
 123   /* Flags fetch move past space */
 124   string_ptr++;
 125   if (end_ptr == string_ptr)
 126     goto read_error;
 127   for (next_ptr= string_ptr; isdigit(*string_ptr); string_ptr++);
 128   result->flags= strtoul(next_ptr, &string_ptr, 10);
 129
 130   if (end_ptr == string_ptr)
 131     goto read_error;
 132
 133   /* Length fetch move past space*/
 134   string_ptr++;
 135   if (end_ptr == string_ptr)
 136     goto read_error;
 137
 138   for (next_ptr= string_ptr; isdigit(*string_ptr); string_ptr++);
 139   value_length= (size_t)strtoull(next_ptr, &string_ptr, 10);
 140
 141   if (end_ptr == string_ptr)
 142     goto read_error;
 143
 144   /* Skip spaces */
 145   if (*string_ptr == '\r')
 146   {
 147     /* Skip past the \r\n */
 148     string_ptr+= 2;
 149   }
 150   else
 151   {
 152     string_ptr++;
 153     for (next_ptr= string_ptr; isdigit(*string_ptr); string_ptr++);
 154     result->cas= strtoull(next_ptr, &string_ptr, 10);
 155   }
 156
 157   if (end_ptr < string_ptr)
 158     goto read_error;
 159
 160   /* We add two bytes so that we can walk the \r\n */
 161   rc= memcached_string_check(&result->value, value_length+2);
 162   if (rc != MEMCACHED_SUCCESS)
 163   {
 164     value_length= 0;
 165     return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
 166   }
 167
 168   value_ptr= memcached_string_value(&result->value);
 169   /*
 170     We read the \r\n into the string since not doing so is more
 171     cycles then the waster of memory to do so.
 172
 173     We are null terminating through, which will most likely make
 174     some people lazy about using the return length.
 175   */
 176   to_read= (value_length) + 2;
 177   ssize_t read_length= 0;
 178   memcached_return rrc= memcached_io_read(ptr, value_ptr, to_read, &read_length);
 179   if (rrc != MEMCACHED_SUCCESS)
 180     return rrc;
 181
 182   if (read_length != (ssize_t)(value_length + 2))
 183   {
 184     goto read_error;
 185   }
 186
 187 /* This next bit blows the API, but this is internal....*/
 188   {
 189     char *char_ptr;
 190     char_ptr= memcached_string_value(&result->value);;
 191     char_ptr[value_length]= 0;
 192     char_ptr[value_length + 1]= 0;
 193     memcached_string_set_length(&result->value, value_length);
 194   }
 195
 196   return MEMCACHED_SUCCESS;
 197
 198 read_error:
 199   memcached_io_reset(ptr);
 200
 201   return MEMCACHED_PARTIAL_READ;
 202 }
 203
 204 static memcached_return textual_read_one_response(memcached_server_st *ptr,
 205                                                   char *buffer, size_t buffer_length,
 206                                                   memcached_result_st *result)
 207 {
 208   memcached_return rc= memcached_io_readline(ptr, buffer, buffer_length);
 209   if (rc != MEMCACHED_SUCCESS)
 210     return rc;
 211
 212   switch(buffer[0])
 213   {
 214   case 'V': /* VALUE || VERSION */
 215     if (buffer[1] == 'A') /* VALUE */
 216     {
 217       /* We add back in one because we will need to search for END */
 218       memcached_server_response_increment(ptr);
 219       return textual_value_fetch(ptr, buffer, result);
 220     }
 221     else if (buffer[1] == 'E') /* VERSION */
 222     {
 223       return MEMCACHED_SUCCESS;
 224     }
 225     else
 226     {
 227       WATCHPOINT_STRING(buffer);
 228       WATCHPOINT_ASSERT(0);
 229       return MEMCACHED_UNKNOWN_READ_FAILURE;
 230     }
 231   case 'O': /* OK */
 232     return MEMCACHED_SUCCESS;
 233   case 'S': /* STORED STATS SERVER_ERROR */
 234     {
 235       if (buffer[2] == 'A') /* STORED STATS */
 236       {
 237         memcached_server_response_increment(ptr);
 238         return MEMCACHED_STAT;
 239       }
 240       else if (buffer[1] == 'E')
 241         return MEMCACHED_SERVER_ERROR;
 242       else if (buffer[1] == 'T')
 243         return MEMCACHED_STORED;
 244       else
 245       {
 246         WATCHPOINT_STRING(buffer);
 247         WATCHPOINT_ASSERT(0);
 248         return MEMCACHED_UNKNOWN_READ_FAILURE;
 249       }
 250     }
 251   case 'D': /* DELETED */
 252     return MEMCACHED_DELETED;
 253   case 'N': /* NOT_FOUND */
 254     {
 255       if (buffer[4] == 'F')
 256         return MEMCACHED_NOTFOUND;
 257       else if (buffer[4] == 'S')
 258         return MEMCACHED_NOTSTORED;
 259       else
 260         return MEMCACHED_UNKNOWN_READ_FAILURE;
 261     }
 262   case 'E': /* PROTOCOL ERROR or END */
 263     {
 264       if (buffer[1] == 'N')
 265         return MEMCACHED_END;
 266       else if (buffer[1] == 'R')
 267         return MEMCACHED_PROTOCOL_ERROR;
 268       else if (buffer[1] == 'X')
 269         return MEMCACHED_DATA_EXISTS;
 270       else
 271         return MEMCACHED_UNKNOWN_READ_FAILURE;
 272     }
 273   case 'I': /* CLIENT ERROR */
 274       /* We add back in one because we will need to search for END */
 275       memcached_server_response_increment(ptr);
 276     return MEMCACHED_ITEM;
 277   case 'C': /* CLIENT ERROR */
 278     return MEMCACHED_CLIENT_ERROR;
 279   default:
 280     {
 281       unsigned long long auto_return_value;
 282
 283       if (sscanf(buffer, "%llu", &auto_return_value) == 1)
 284         return MEMCACHED_SUCCESS;
 285
 286       return MEMCACHED_UNKNOWN_READ_FAILURE;
 287     }
 288   }
 289
 290   /* NOTREACHED */
 291 }
 292
 293 char *memcached_result_value(memcached_result_st *ptr)
 294 {
 295   memcached_string_st *sptr= &ptr->value;
 296   return memcached_string_value(sptr);
 297 }
 298
 299 size_t memcached_result_length(memcached_result_st *ptr)
 300 {
 301   memcached_string_st *sptr= &ptr->value;
 302   return memcached_string_length(sptr);
 303 }
 304
 305 static memcached_return binary_read_one_response(memcached_server_st *ptr,
 306                                                  char *buffer, size_t buffer_length,
 307                                                  memcached_result_st *result)
 308 {
 309   protocol_binary_response_header header;
 310
 311   unlikely (memcached_safe_read(ptr, &header.bytes,
 312                                 sizeof(header.bytes)) != MEMCACHED_SUCCESS)
 313     return MEMCACHED_UNKNOWN_READ_FAILURE;
 314
 315   unlikely (header.response.magic != PROTOCOL_BINARY_RES)
 316     return MEMCACHED_PROTOCOL_ERROR;
 317
 318   /*
 319   ** Convert the header to host local endian!
 320   */
 321   header.response.keylen= ntohs(header.response.keylen);
 322   header.response.status= ntohs(header.response.status);
 323   header.response.bodylen= ntohl(header.response.bodylen);
 324   header.response.cas= ntohll(header.response.cas);
 325   uint32_t bodylen= header.response.bodylen;
 326
 327   if (header.response.status == 0)
 328   {
 329     switch (header.response.opcode)
 330     {
 331     case PROTOCOL_BINARY_CMD_GETK:
 332     case PROTOCOL_BINARY_CMD_GETKQ:
 333       {
 334         uint16_t keylen= header.response.keylen;
 335         memcached_result_reset(result);
 336         result->cas= header.response.cas;
 337
 338         if (memcached_safe_read(ptr, &result->flags,
 339                                 sizeof (result->flags)) != MEMCACHED_SUCCESS)
 340           return MEMCACHED_UNKNOWN_READ_FAILURE;
 341
 342         result->flags= ntohl(result->flags);
 343         bodylen -= header.response.extlen;
 344
 345         result->key_length= keylen;
 346         if (memcached_safe_read(ptr, result->key, keylen) != MEMCACHED_SUCCESS)
 347           return MEMCACHED_UNKNOWN_READ_FAILURE;
 348
 349         bodylen -= keylen;
 350         if (memcached_string_check(&result->value,
 351                                    bodylen) != MEMCACHED_SUCCESS)
 352           return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
 353
 354         char *vptr= memcached_string_value(&result->value);
 355         if (memcached_safe_read(ptr, vptr, bodylen) != MEMCACHED_SUCCESS)
 356           return MEMCACHED_UNKNOWN_READ_FAILURE;
 357
 358         memcached_string_set_length(&result->value, bodylen);
 359       }
 360       break;
 361     case PROTOCOL_BINARY_CMD_INCREMENT:
 362     case PROTOCOL_BINARY_CMD_DECREMENT:
 363       {
 364         if (bodylen != sizeof(uint64_t) || buffer_length != sizeof(uint64_t))
 365           return MEMCACHED_PROTOCOL_ERROR;
 366
 367         WATCHPOINT_ASSERT(bodylen == buffer_length);
 368         uint64_t val;
 369         if (memcached_safe_read(ptr, &val, sizeof(val)) != MEMCACHED_SUCCESS)
 370           return MEMCACHED_UNKNOWN_READ_FAILURE;
 371
 372         val= ntohll(val);
 373         memcpy(buffer, &val, sizeof(val));
 374       }
 375       break;
 376     case PROTOCOL_BINARY_CMD_VERSION:
 377       {
 378         memset(buffer, 0, buffer_length);
 379         if (bodylen >= buffer_length)
 380           /* not enough space in buffer.. should not happen... */
 381           return MEMCACHED_UNKNOWN_READ_FAILURE;
 382         else if (memcached_safe_read(ptr, buffer, bodylen) != MEMCACHED_SUCCESS)
 383           return MEMCACHED_UNKNOWN_READ_FAILURE;
 384       }
 385       break;
 386     case PROTOCOL_BINARY_CMD_FLUSH:
 387     case PROTOCOL_BINARY_CMD_QUIT:
 388     case PROTOCOL_BINARY_CMD_SET:
 389     case PROTOCOL_BINARY_CMD_ADD:
 390     case PROTOCOL_BINARY_CMD_REPLACE:
 391     case PROTOCOL_BINARY_CMD_APPEND:
 392     case PROTOCOL_BINARY_CMD_PREPEND:
 393     case PROTOCOL_BINARY_CMD_DELETE:
 394       {
 395         WATCHPOINT_ASSERT(bodylen == 0);
 396         return MEMCACHED_SUCCESS;
 397       }
 398     case PROTOCOL_BINARY_CMD_NOOP:
 399       {
 400         WATCHPOINT_ASSERT(bodylen == 0);
 401         return MEMCACHED_END;
 402       }
 403     case PROTOCOL_BINARY_CMD_STAT:
 404       {
 405         if (bodylen == 0)
 406           return MEMCACHED_END;
 407         else if (bodylen + 1 > buffer_length)
 408           /* not enough space in buffer.. should not happen... */
 409           return MEMCACHED_UNKNOWN_READ_FAILURE;
 410         else
 411         {
 412           size_t keylen= header.response.keylen;
 413           memset(buffer, 0, buffer_length);
 414           if (memcached_safe_read(ptr, buffer, keylen) != MEMCACHED_SUCCESS ||
 415               memcached_safe_read(ptr, buffer + keylen + 1,
 416                                   bodylen - keylen) != MEMCACHED_SUCCESS)
 417             return MEMCACHED_UNKNOWN_READ_FAILURE;
 418         }
 419       }
 420       break;
 421     default:
 422       {
 423         /* Command not implemented yet! */
 424         WATCHPOINT_ASSERT(0);
 425         return MEMCACHED_PROTOCOL_ERROR;
 426       }
 427     }
 428   }
 429   else if (header.response.bodylen)
 430   {
 431      /* What should I do with the error message??? just discard it for now */
 432     char hole[SMALL_STRING_LEN];
 433     while (bodylen > 0)
 434     {
 435       size_t nr= (bodylen > SMALL_STRING_LEN) ? SMALL_STRING_LEN : bodylen;
 436       if (memcached_safe_read(ptr, hole, nr) != MEMCACHED_SUCCESS)
 437         return MEMCACHED_UNKNOWN_READ_FAILURE;
 438       bodylen -= nr;
 439     }
 440
 441     /* This might be an error from one of the quiet commands.. if
 442      * so, just throw it away and get the next one. What about creating
 443      * a callback to the user with the error information?
 444      */
 445     switch (header.response.opcode)
 446     {
 447     case PROTOCOL_BINARY_CMD_SETQ:
 448     case PROTOCOL_BINARY_CMD_ADDQ:
 449     case PROTOCOL_BINARY_CMD_REPLACEQ:
 450     case PROTOCOL_BINARY_CMD_APPENDQ:
 451     case PROTOCOL_BINARY_CMD_PREPENDQ:
 452       return binary_read_one_response(ptr, buffer, buffer_length, result);
 453     default:
 454       break;
 455     }
 456   }
 457
 458   memcached_return rc= MEMCACHED_SUCCESS;
 459   unlikely(header.response.status != 0)
 460     switch (header.response.status)
 461     {
 462     case PROTOCOL_BINARY_RESPONSE_KEY_ENOENT:
 463       rc= MEMCACHED_NOTFOUND;
 464       break;
 465     case PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS:
 466       rc= MEMCACHED_DATA_EXISTS;
 467       break;
 468     case PROTOCOL_BINARY_RESPONSE_E2BIG:
 469     case PROTOCOL_BINARY_RESPONSE_EINVAL:
 470     case PROTOCOL_BINARY_RESPONSE_NOT_STORED:
 471     case PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND:
 472     case PROTOCOL_BINARY_RESPONSE_ENOMEM:
 473     default:
 474       /* @todo fix the error mappings */
 475       rc= MEMCACHED_PROTOCOL_ERROR;
 476       break;
 477     }
 478
 479   return rc;
 480 }