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