git.m6w6.name Git - m6w6/libmemcached/blob - libmemcached/protocol/ascii_handler.c

   1 /*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
   2  *
   3  *  Libmemcached library
   4  *
   5  *  Copyright (C) 2011 Data Differential, http://datadifferential.com/
   6  *
   7  *  Redistribution and use in source and binary forms, with or without
   8  *  modification, are permitted provided that the following conditions are
   9  *  met:
  10  *
  11  *      * Redistributions of source code must retain the above copyright
  12  *  notice, this list of conditions and the following disclaimer.
  13  *
  14  *      * Redistributions in binary form must reproduce the above
  15  *  copyright notice, this list of conditions and the following disclaimer
  16  *  in the documentation and/or other materials provided with the
  17  *  distribution.
  18  *
  19  *      * The names of its contributors may not be used to endorse or
  20  *  promote products derived from this software without specific prior
  21  *  written permission.
  22  *
  23  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  24  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  25  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  26  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  27  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  28  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  29  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  30  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  31  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  32  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  33  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  34  *
  35  */
  36
  37 #include <libmemcached/protocol/common.h>
  38 #include <libmemcached/byteorder.h>
  39
  40 #include <ctype.h>
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43 #include <string.h>
  44
  45 /**
  46  * Try to parse a key from the string.
  47  * @pointer start pointer to a pointer to the string (IN and OUT)
  48  * @return length of the string of -1 if this was an illegal key (invalid
  49  *         characters or invalid length)
  50  * @todo add length!
  51  */
  52 static uint16_t parse_ascii_key(char **start)
  53 {
  54   uint16_t len= 0;
  55   char *c= *start;
  56   /* Strip leading whitespaces */
  57   while (isspace(*c))
  58   {
  59     ++c;
  60   }
  61
  62   *start= c;
  63
  64   while (*c != '\0' && !isspace(*c) && !iscntrl(*c))
  65   {
  66     ++c;
  67     ++len;
  68   }
  69
  70
  71   if (len == 0 || len > 240 || (*c != '\0' && *c != '\r' && iscntrl(*c)))
  72   {
  73     return 0;
  74   }
  75
  76   return len;
  77 }
  78
  79 /**
  80  * Spool a zero-terminated string
  81  * @param client destination
  82  * @param text the text to spool
  83  * @return status of the spool operation
  84  */
  85 static protocol_binary_response_status
  86 spool_string(memcached_protocol_client_st *client, const char *text)
  87 {
  88   return client->root->spool(client, text, strlen(text));
  89 }
  90
  91 /**
  92  * Send a "CLIENT_ERROR" message back to the client with the correct
  93  * format of the command being sent
  94  * @param client the client to send the message to
  95  */
  96 static void send_command_usage(memcached_protocol_client_st *client)
  97 {
  98   const char *errmsg[]= {
  99     [GET_CMD]= "CLIENT_ERROR: Syntax error: get <key>*\r\n",
 100     [GETS_CMD]= "CLIENT_ERROR: Syntax error: gets <key>*\r\n",
 101     [SET_CMD]= "CLIENT_ERROR: Syntax error: set <key> <flags> <exptime> <bytes> [noreply]\r\n",
 102     [ADD_CMD]= "CLIENT_ERROR: Syntax error: add <key> <flags> <exptime> <bytes> [noreply]\r\n",
 103     [REPLACE_CMD]= "CLIENT_ERROR: Syntax error: replace <key> <flags> <exptime> <bytes> [noreply]\r\n",
 104     [CAS_CMD]= "CLIENT_ERROR: Syntax error: cas <key> <flags> <exptime> <bytes> <casid> [noreply]\r\n",
 105     [APPEND_CMD]= "CLIENT_ERROR: Syntax error: append <key> <flags> <exptime> <bytes> [noreply]\r\n",
 106     [PREPEND_CMD]= "CLIENT_ERROR: Syntax error: prepend <key> <flags> <exptime> <bytes> [noreply]\r\n",
 107     [DELETE_CMD]= "CLIENT_ERROR: Syntax error: delete <key> [noreply]\r\n",
 108     [INCR_CMD]= "CLIENT_ERROR: Syntax error: incr <key> <value> [noreply]\r\n",
 109     [DECR_CMD]= "CLIENT_ERROR: Syntax error: decr <key> <value> [noreply]\r\n",
 110     [STATS_CMD]= "CLIENT_ERROR: Syntax error: stats [key]\r\n",
 111     [FLUSH_ALL_CMD]= "CLIENT_ERROR: Syntax error: flush_all [timeout] [noreply]\r\n",
 112     [VERSION_CMD]= "CLIENT_ERROR: Syntax error: version\r\n",
 113     [QUIT_CMD]="CLIENT_ERROR: Syntax error: quit\r\n",
 114
 115     [VERBOSITY_CMD]= "CLIENT_ERROR: Syntax error: verbosity <num>\r\n",
 116     [UNKNOWN_CMD]= "CLIENT_ERROR: Unknown command\r\n",
 117   };
 118
 119   client->mute = false;
 120   spool_string(client, errmsg[client->ascii_command]);
 121 }
 122
 123 /**
 124  * Callback for the VERSION responses
 125  * @param cookie client identifier
 126  * @param text the length of the body
 127  * @param textlen the length of the body
 128  */
 129 static protocol_binary_response_status
 130 ascii_version_response_handler(const void *cookie,
 131                                const void *text,
 132                                uint32_t textlen)
 133 {
 134   memcached_protocol_client_st *client= (memcached_protocol_client_st*)cookie;
 135   spool_string(client, "VERSION ");
 136   client->root->spool(client, text, textlen);
 137   spool_string(client, "\r\n");
 138   return PROTOCOL_BINARY_RESPONSE_SUCCESS;
 139 }
 140
 141 /**
 142  * Callback for the GET/GETQ/GETK and GETKQ responses
 143  * @param cookie client identifier
 144  * @param key the key for the item
 145  * @param keylen the length of the key
 146  * @param body the length of the body
 147  * @param bodylen the length of the body
 148  * @param flags the flags for the item
 149  * @param cas the CAS id for the item
 150  */
 151 static protocol_binary_response_status
 152 ascii_get_response_handler(const void *cookie,
 153                            const void *key,
 154                            uint16_t keylen,
 155                            const void *body,
 156                            uint32_t bodylen,
 157                            uint32_t flags,
 158                            uint64_t cas)
 159 {
 160   memcached_protocol_client_st *client= (void*)cookie;
 161   char buffer[300];
 162   strcpy(buffer, "VALUE ");
 163   const char *source= key;
 164   char *dest= buffer + 6;
 165
 166   for (int x= 0; x < keylen; ++x)
 167   {
 168     if (*source != '\0' && !isspace(*source) && !iscntrl(*source))
 169     {
 170       *dest= *source;
 171     }
 172     else
 173     {
 174       return PROTOCOL_BINARY_RESPONSE_EINVAL; /* key constraints in ascii */
 175     }
 176
 177     ++dest;
 178     ++source;
 179   }
 180
 181   size_t used= (size_t)(dest - buffer);
 182
 183   if (client->ascii_command == GETS_CMD)
 184   {
 185     snprintf(dest, sizeof(buffer) - used, " %u %u %" PRIu64 "\r\n", flags,
 186              bodylen, cas);
 187   }
 188   else
 189   {
 190     snprintf(dest, sizeof(buffer) - used, " %u %u\r\n", flags, bodylen);
 191   }
 192
 193   client->root->spool(client, buffer, strlen(buffer));
 194   client->root->spool(client, body, bodylen);
 195   client->root->spool(client, "\r\n", 2);
 196
 197   return PROTOCOL_BINARY_RESPONSE_SUCCESS;
 198 }
 199
 200 /**
 201  * Callback for the STAT responses
 202  * @param cookie client identifier
 203  * @param key the key for the item
 204  * @param keylen the length of the key
 205  * @param body the length of the body
 206  * @param bodylen the length of the body
 207  */
 208 static protocol_binary_response_status
 209 ascii_stat_response_handler(const void *cookie,
 210                      const void *key,
 211                      uint16_t keylen,
 212                      const void *body,
 213                      uint32_t bodylen)
 214 {
 215
 216   memcached_protocol_client_st *client= (void*)cookie;
 217
 218   if (key != NULL)
 219   {
 220     spool_string(client, "STAT ");
 221     client->root->spool(client, key, keylen);
 222     spool_string(client, " ");
 223     client->root->spool(client, body, bodylen);
 224     spool_string(client, "\r\n");
 225   }
 226   else
 227   {
 228     spool_string(client, "END\r\n");
 229   }
 230
 231   return PROTOCOL_BINARY_RESPONSE_SUCCESS;
 232 }
 233
 234 /**
 235  * Process a get or a gets request.
 236  * @param client the client handle
 237  * @param buffer the complete get(s) command
 238  * @param end the last character in the command
 239  */
 240 static void ascii_process_gets(memcached_protocol_client_st *client,
 241                                char *buffer, char *end)
 242 {
 243   char *key= buffer;
 244
 245   /* Skip command */
 246   key += (client->ascii_command == GETS_CMD) ? 5 : 4;
 247
 248   int num_keys= 0;
 249   while (key < end)
 250   {
 251     uint16_t nkey= parse_ascii_key(&key);
 252     if (nkey == 0) /* Invalid key... stop processing this line */
 253     {
 254       break;
 255     }
 256
 257     (void)client->root->callback->interface.v1.get(client, key, nkey,
 258                                                    ascii_get_response_handler);
 259     key += nkey;
 260     ++num_keys;
 261   }
 262
 263   if (num_keys == 0)
 264   {
 265     send_command_usage(client);
 266   }
 267   else
 268     client->root->spool(client, "END\r\n", 5);
 269 }
 270
 271 /**
 272  * Try to split up the command line "asdf asdf asdf asdf\n" into an
 273  * argument vector for easier parsing.
 274  * @param start the first character in the command line
 275  * @param end the last character in the command line ("\n")
 276  * @param vec the vector to insert the pointers into
 277  * @size the number of elements in the vector
 278  * @return the number of tokens in the vector
 279  */
 280 static int ascii_tokenize_command(char *str, char *end, char **vec, int size)
 281 {
 282   int elem= 0;
 283
 284   while (str < end)
 285   {
 286     /* Skip leading blanks */
 287     while (str < end && isspace(*str))
 288     {
 289       ++str;
 290     }
 291
 292     if (str == end)
 293     {
 294       return elem;
 295     }
 296
 297     vec[elem++]= str;
 298     /* find the next non-blank field */
 299     while (str < end && !isspace(*str))
 300     {
 301       ++str;
 302     }
 303
 304     /* zero-terminate it for easier parsing later on */
 305     *str= '\0';
 306     ++str;
 307
 308     /* Is the vector full? */
 309     if (elem == size)
 310     {
 311       break;
 312     }
 313   }
 314
 315   return elem;
 316 }
 317
 318 /**
 319  * If we for some reasons needs to push the line back to read more
 320  * data we have to reverse the tokenization. Just do the brain-dead replace
 321  * of all '\0' to ' ' and set the last character to '\n'. We could have used
 322  * the vector we created, but then we would have to search for all of the
 323  * spaces we ignored...
 324  * @param start pointer to the first character in the buffer to recover
 325  * @param end pointer to the last character in the buffer to recover
 326  */
 327 static void recover_tokenize_command(char *start, char *end)
 328 {
 329   while (start < end)
 330   {
 331     if (*start == '\0')
 332       *start= ' ';
 333     ++start;
 334   }
 335
 336   *end= '\n';
 337 }
 338
 339 /**
 340  * Convert the textual command into a comcode
 341  */
 342 static enum ascii_cmd ascii_to_cmd(char *start, size_t length)
 343 {
 344   struct {
 345     const char *cmd;
 346     size_t len;
 347     enum ascii_cmd cc;
 348   } commands[]= {
 349     { .cmd= "get", .len= 3, .cc= GET_CMD },
 350     { .cmd= "gets", .len= 4, .cc= GETS_CMD },
 351     { .cmd= "set", .len= 3, .cc= SET_CMD },
 352     { .cmd= "add", .len= 3, .cc= ADD_CMD },
 353     { .cmd= "replace", .len= 7, .cc= REPLACE_CMD },
 354     { .cmd= "cas", .len= 3, .cc= CAS_CMD },
 355     { .cmd= "append", .len= 6, .cc= APPEND_CMD },
 356     { .cmd= "prepend", .len= 7, .cc= PREPEND_CMD },
 357     { .cmd= "delete", .len= 6, .cc= DELETE_CMD },
 358     { .cmd= "incr", .len= 4, .cc= INCR_CMD },
 359     { .cmd= "decr", .len= 4, .cc= DECR_CMD },
 360     { .cmd= "stats", .len= 5, .cc= STATS_CMD },
 361     { .cmd= "flush_all", .len= 9, .cc= FLUSH_ALL_CMD },
 362     { .cmd= "version", .len= 7, .cc= VERSION_CMD },
 363     { .cmd= "quit", .len= 4, .cc= QUIT_CMD },
 364     { .cmd= "verbosity", .len= 9, .cc= VERBOSITY_CMD },
 365     { .cmd= NULL, .len= 0, .cc= UNKNOWN_CMD }};
 366
 367   int x= 0;
 368   while (commands[x].len > 0) {
 369     if (length >= commands[x].len)
 370     {
 371       if (strncmp(start, commands[x].cmd, commands[x].len) == 0)
 372       {
 373         /* Potential hit */
 374         if (length == commands[x].len || isspace(*(start + commands[x].len)))
 375         {
 376           return commands[x].cc;
 377         }
 378       }
 379     }
 380     ++x;
 381   }
 382
 383   return UNKNOWN_CMD;
 384 }
 385
 386 /**
 387  * Perform a delete operation.
 388  *
 389  * @param client client requesting the deletion
 390  * @param tokens the command as a vector
 391  * @param ntokens the number of items in the vector
 392  */
 393 static void process_delete(memcached_protocol_client_st *client,
 394                            char **tokens, int ntokens)
 395 {
 396   char *key= tokens[1];
 397   uint16_t nkey;
 398
 399   if (ntokens != 2 || (nkey= parse_ascii_key(&key)) == 0)
 400   {
 401     send_command_usage(client);
 402     return;
 403   }
 404
 405   if (client->root->callback->interface.v1.delete == NULL)
 406   {
 407     spool_string(client, "SERVER_ERROR: callback not implemented\r\n");
 408     return;
 409   }
 410
 411   protocol_binary_response_status rval;
 412   rval= client->root->callback->interface.v1.delete(client, key, nkey, 0);
 413
 414   if (rval == PROTOCOL_BINARY_RESPONSE_SUCCESS)
 415   {
 416     spool_string(client, "DELETED\r\n");
 417   }
 418   else if (rval == PROTOCOL_BINARY_RESPONSE_KEY_ENOENT)
 419   {
 420     spool_string(client, "NOT_FOUND\r\n");
 421   }
 422   else
 423   {
 424     char msg[80];
 425     snprintf(msg, sizeof(msg), "SERVER_ERROR: delete failed %u\r\n",(uint32_t)rval);
 426     spool_string(client, msg);
 427   }
 428 }
 429
 430 static void process_arithmetic(memcached_protocol_client_st *client,
 431                                char **tokens, int ntokens)
 432 {
 433   char *key= tokens[1];
 434   uint16_t nkey;
 435
 436   if (ntokens != 3 || (nkey= parse_ascii_key(&key)) == 0)
 437   {
 438     send_command_usage(client);
 439     return;
 440   }
 441
 442   uint64_t cas;
 443   uint64_t result;
 444   uint64_t delta= strtoull(tokens[2], NULL, 10);
 445
 446   protocol_binary_response_status rval;
 447   if (client->ascii_command == INCR_CMD)
 448   {
 449     if (client->root->callback->interface.v1.increment == NULL)
 450     {
 451       spool_string(client, "SERVER_ERROR: callback not implemented\r\n");
 452       return;
 453     }
 454     rval= client->root->callback->interface.v1.increment(client,
 455                                                          key, nkey,
 456                                                          delta, 0,
 457                                                          0,
 458                                                          &result,
 459                                                          &cas);
 460   }
 461   else
 462   {
 463     if (client->root->callback->interface.v1.decrement == NULL)
 464     {
 465       spool_string(client, "SERVER_ERROR: callback not implemented\r\n");
 466       return;
 467     }
 468     rval= client->root->callback->interface.v1.decrement(client,
 469                                                          key, nkey,
 470                                                          delta, 0,
 471                                                          0,
 472                                                          &result,
 473                                                          &cas);
 474   }
 475
 476   if (rval == PROTOCOL_BINARY_RESPONSE_SUCCESS)
 477   {
 478     char buffer[80];
 479     snprintf(buffer, sizeof(buffer), "%"PRIu64"\r\n", result);
 480     spool_string(client, buffer);
 481   }
 482   else
 483   {
 484     spool_string(client, "NOT_FOUND\r\n");
 485   }
 486 }
 487
 488 /**
 489  * Process the stats command (with or without a key specified)
 490  * @param key pointer to the first character after "stats"
 491  * @param end pointer to the "\n"
 492  */
 493 static void process_stats(memcached_protocol_client_st *client,
 494                           char *key, char *end)
 495 {
 496   if (client->root->callback->interface.v1.stat == NULL)
 497   {
 498     spool_string(client, "SERVER_ERROR: callback not implemented\r\n");
 499     return;
 500   }
 501
 502   while (isspace(*key))
 503     key++;
 504
 505   uint16_t nkey= (uint16_t)(end - key);
 506   (void)client->root->callback->interface.v1.stat(client, key, nkey,
 507                                                   ascii_stat_response_handler);
 508 }
 509
 510 static void process_version(memcached_protocol_client_st *client,
 511                             char **tokens, int ntokens)
 512 {
 513   (void)tokens;
 514   if (ntokens != 1)
 515   {
 516     send_command_usage(client);
 517     return;
 518   }
 519
 520   if (client->root->callback->interface.v1.version == NULL)
 521   {
 522     spool_string(client, "SERVER_ERROR: callback not implemented\r\n");
 523     return;
 524   }
 525
 526  client->root->callback->interface.v1.version(client,
 527                                               ascii_version_response_handler);
 528 }
 529
 530 static void process_flush(memcached_protocol_client_st *client,
 531                           char **tokens, int ntokens)
 532 {
 533   if (ntokens > 2)
 534   {
 535     send_command_usage(client);
 536     return;
 537   }
 538
 539   if (client->root->callback->interface.v1.flush == NULL)
 540   {
 541     spool_string(client, "SERVER_ERROR: callback not implemented\r\n");
 542     return;
 543   }
 544
 545   uint32_t timeout= 0;
 546   if (ntokens == 2)
 547   {
 548     timeout= (uint32_t)strtoul(tokens[1], NULL, 10);
 549   }
 550
 551   protocol_binary_response_status rval;
 552   rval= client->root->callback->interface.v1.flush(client, timeout);
 553   if (rval == PROTOCOL_BINARY_RESPONSE_SUCCESS)
 554     spool_string(client, "OK\r\n");
 555   else
 556     spool_string(client, "SERVER_ERROR: internal error\r\n");
 557 }
 558
 559 /**
 560  * Process one of the storage commands
 561  * @param client the client performing the operation
 562  * @param tokens the command tokens
 563  * @param ntokens the number of tokens
 564  * @param start pointer to the first character in the line
 565  * @param end pointer to the pointer where the last character of this
 566  *            command is (IN and OUT)
 567  * @param length the number of bytes available
 568  * @return -1 if an error occurs (and we should just terminate the connection
 569  *            because we are out of sync)
 570  *         0 storage command completed, continue processing
 571  *         1 We need more data, so just go ahead and wait for more!
 572  */
 573 static inline int process_storage_command(memcached_protocol_client_st *client,
 574                                      char **tokens, int ntokens, char *start,
 575                                      char **end, ssize_t length)
 576 {
 577   (void)ntokens; /* already checked */
 578   char *key= tokens[1];
 579   uint16_t nkey= parse_ascii_key(&key);
 580   if (nkey == 0)
 581   {
 582     /* return error */
 583     spool_string(client, "CLIENT_ERROR: bad key\r\n");
 584     return -1;
 585   }
 586
 587   uint32_t flags= (uint32_t)strtoul(tokens[2], NULL, 10);
 588   uint32_t timeout= (uint32_t)strtoul(tokens[3], NULL, 10);
 589   unsigned long nbytes= strtoul(tokens[4], NULL, 10);
 590
 591   /* Do we have all data? */
 592   unsigned long need= nbytes + (unsigned long)((*end - start) + 1) + 2; /* \n\r\n */
 593   if ((ssize_t)need > length)
 594   {
 595     /* Keep on reading */
 596     recover_tokenize_command(start, *end);
 597     return 1;
 598   }
 599
 600   void *data= (*end) + 1;
 601   uint64_t cas= 0;
 602   uint64_t result_cas;
 603   protocol_binary_response_status rval;
 604   switch (client->ascii_command)
 605   {
 606   case SET_CMD:
 607     rval= client->root->callback->interface.v1.set(client, key,
 608                                                    (uint16_t)nkey,
 609                                                    data,
 610                                                    (uint32_t)nbytes,
 611                                                    flags,
 612                                                    timeout, cas,
 613                                                    &result_cas);
 614     break;
 615   case ADD_CMD:
 616     rval= client->root->callback->interface.v1.add(client, key,
 617                                                    (uint16_t)nkey,
 618                                                    data,
 619                                                    (uint32_t)nbytes,
 620                                                    flags,
 621                                                    timeout, &result_cas);
 622     break;
 623   case CAS_CMD:
 624     cas= strtoull(tokens[5], NULL, 10);
 625     /* FALLTHROUGH */
 626   case REPLACE_CMD:
 627     rval= client->root->callback->interface.v1.replace(client, key,
 628                                                        (uint16_t)nkey,
 629                                                        data,
 630                                                        (uint32_t)nbytes,
 631                                                        flags,
 632                                                        timeout, cas,
 633                                                        &result_cas);
 634     break;
 635   case APPEND_CMD:
 636     rval= client->root->callback->interface.v1.append(client, key,
 637                                                       (uint16_t)nkey,
 638                                                       data,
 639                                                       (uint32_t)nbytes,
 640                                                       cas,
 641                                                       &result_cas);
 642     break;
 643   case PREPEND_CMD:
 644     rval= client->root->callback->interface.v1.prepend(client, key,
 645                                                        (uint16_t)nkey,
 646                                                        data,
 647                                                        (uint32_t)nbytes,
 648                                                        cas,
 649                                                        &result_cas);
 650     break;
 651
 652     /* gcc complains if I don't put all of the enums in here.. */
 653   case GET_CMD:
 654   case GETS_CMD:
 655   case DELETE_CMD:
 656   case DECR_CMD:
 657   case INCR_CMD:
 658   case STATS_CMD:
 659   case FLUSH_ALL_CMD:
 660   case VERSION_CMD:
 661   case QUIT_CMD:
 662   case VERBOSITY_CMD:
 663   case UNKNOWN_CMD:
 664   default:
 665     abort(); /* impossible */
 666   }
 667
 668   if (rval == PROTOCOL_BINARY_RESPONSE_SUCCESS)
 669   {
 670     spool_string(client, "STORED\r\n");
 671   }
 672   else
 673   {
 674     if (client->ascii_command == CAS_CMD)
 675     {
 676       if (rval == PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS)
 677       {
 678         spool_string(client, "EXISTS\r\n");
 679       }
 680       else if (rval == PROTOCOL_BINARY_RESPONSE_KEY_ENOENT)
 681       {
 682         spool_string(client, "NOT_FOUND\r\n");
 683       }
 684       else
 685       {
 686         spool_string(client, "NOT_STORED\r\n");
 687       }
 688     }
 689     else
 690     {
 691       spool_string(client, "NOT_STORED\r\n");
 692     }
 693   }
 694
 695   *end += nbytes + 2;
 696
 697   return 0;
 698 }
 699
 700 static int process_cas_command(memcached_protocol_client_st *client,
 701                                 char **tokens, int ntokens, char *start,
 702                                 char **end, ssize_t length)
 703 {
 704   if (ntokens != 6)
 705   {
 706     send_command_usage(client);
 707     return false;
 708   }
 709
 710   if (client->root->callback->interface.v1.replace == NULL)
 711   {
 712     spool_string(client, "SERVER_ERROR: callback not implemented\r\n");
 713     return false;
 714   }
 715
 716   return process_storage_command(client, tokens, ntokens, start, end, length);
 717 }
 718
 719 static int process_set_command(memcached_protocol_client_st *client,
 720                                 char **tokens, int ntokens, char *start,
 721                                 char **end, ssize_t length)
 722 {
 723   if (ntokens != 5)
 724   {
 725     send_command_usage(client);
 726     return false;
 727   }
 728
 729   if (client->root->callback->interface.v1.set == NULL)
 730   {
 731     spool_string(client, "SERVER_ERROR: callback not implemented\r\n");
 732     return false;
 733   }
 734
 735   return process_storage_command(client, tokens, ntokens, start, end, length);
 736 }
 737
 738 static int process_add_command(memcached_protocol_client_st *client,
 739                                 char **tokens, int ntokens, char *start,
 740                                 char **end, ssize_t length)
 741 {
 742   if (ntokens != 5)
 743   {
 744     send_command_usage(client);
 745     return false;
 746   }
 747
 748   if (client->root->callback->interface.v1.add == NULL)
 749   {
 750     spool_string(client, "SERVER_ERROR: callback not implemented\r\n");
 751     return false;
 752   }
 753
 754   return process_storage_command(client, tokens, ntokens, start, end, length);
 755 }
 756
 757 static int process_replace_command(memcached_protocol_client_st *client,
 758                                     char **tokens, int ntokens, char *start,
 759                                     char **end, ssize_t length)
 760 {
 761   if (ntokens != 5)
 762   {
 763     send_command_usage(client);
 764     return false;
 765   }
 766
 767   if (client->root->callback->interface.v1.replace == NULL)
 768   {
 769     spool_string(client, "SERVER_ERROR: callback not implemented\r\n");
 770     return false;
 771   }
 772
 773   return process_storage_command(client, tokens, ntokens, start, end, length);
 774 }
 775
 776 static int process_append_command(memcached_protocol_client_st *client,
 777                                    char **tokens, int ntokens, char *start,
 778                                    char **end, ssize_t length)
 779 {
 780   if (ntokens != 5)
 781   {
 782     send_command_usage(client);
 783     return false;
 784   }
 785
 786   if (client->root->callback->interface.v1.append == NULL)
 787   {
 788     spool_string(client, "SERVER_ERROR: callback not implemented\r\n");
 789     return false;
 790   }
 791
 792   return process_storage_command(client, tokens, ntokens, start, end, length);
 793 }
 794
 795 static int process_prepend_command(memcached_protocol_client_st *client,
 796                                     char **tokens, int ntokens, char *start,
 797                                     char **end, ssize_t length)
 798 {
 799   if (ntokens != 5)
 800   {
 801     send_command_usage(client);
 802     return false;
 803   }
 804
 805   if (client->root->callback->interface.v1.prepend == NULL)
 806   {
 807     spool_string(client, "SERVER_ERROR: callback not implemented\r\n");
 808     return false;
 809   }
 810
 811   return process_storage_command(client, tokens, ntokens, start, end, length);
 812 }
 813
 814 /**
 815  * The ASCII protocol support is just one giant big hack. Instead of adding
 816  * a optimal ascii support, I just convert the ASCII commands to the binary
 817  * protocol and calls back into the command handlers for the binary protocol ;)
 818  */
 819 memcached_protocol_event_t memcached_ascii_protocol_process_data(memcached_protocol_client_st *client, ssize_t *length, void **endptr)
 820 {
 821   char *ptr= (char*)client->root->input_buffer;
 822   *endptr= ptr;
 823
 824   do {
 825     /* Do we have \n (indicating the command preamble)*/
 826     char *end= memchr(ptr, '\n', (size_t)*length);
 827     if (end == NULL)
 828     {
 829       *endptr= ptr;
 830       return MEMCACHED_PROTOCOL_READ_EVENT;
 831     }
 832
 833     client->ascii_command= ascii_to_cmd(ptr, (size_t)(*length));
 834
 835     /* A multiget lists all of the keys, and I don't want to have an
 836      * avector of let's say 512 pointers to tokenize all of them, so let's
 837      * just handle them immediately
 838      */
 839     if (client->ascii_command == GET_CMD ||
 840         client->ascii_command == GETS_CMD) {
 841       if (client->root->callback->interface.v1.get != NULL)
 842         ascii_process_gets(client, ptr, end);
 843       else
 844         spool_string(client, "SERVER_ERROR: Command not implemented\n");
 845     } else {
 846       /* None of the defined commands takes 10 parameters, so lets just use
 847        * that as a maximum limit.
 848        */
 849       char *tokens[10];
 850       int ntokens= ascii_tokenize_command(ptr, end, tokens, 10);
 851
 852       if (ntokens < 10)
 853       {
 854         client->mute= strcmp(tokens[ntokens - 1], "noreply") == 0;
 855         if (client->mute)
 856           --ntokens; /* processed noreply token*/
 857       }
 858
 859       int error= 0;
 860
 861       switch (client->ascii_command) {
 862       case SET_CMD:
 863         error= process_set_command(client, tokens, ntokens, ptr, &end, *length);
 864         break;
 865       case ADD_CMD:
 866         error= process_add_command(client, tokens, ntokens, ptr, &end, *length);
 867         break;
 868       case REPLACE_CMD:
 869         error= process_replace_command(client, tokens, ntokens,
 870                                        ptr, &end, *length);
 871         break;
 872       case CAS_CMD:
 873         error= process_cas_command(client, tokens, ntokens, ptr, &end, *length);
 874         break;
 875       case APPEND_CMD:
 876         error= process_append_command(client, tokens, ntokens,
 877                                       ptr, &end, *length);
 878         break;
 879       case PREPEND_CMD:
 880         error= process_prepend_command(client, tokens, ntokens,
 881                                        ptr, &end, *length);
 882        break;
 883       case DELETE_CMD:
 884         process_delete(client, tokens, ntokens);
 885         break;
 886
 887       case INCR_CMD: /* FALLTHROUGH */
 888       case DECR_CMD:
 889         process_arithmetic(client, tokens, ntokens);
 890         break;
 891       case STATS_CMD:
 892         if (client->mute)
 893         {
 894           send_command_usage(client);
 895         }
 896         else
 897         {
 898           recover_tokenize_command(ptr, end);
 899           process_stats(client, ptr + 6, end);
 900         }
 901         break;
 902       case FLUSH_ALL_CMD:
 903         process_flush(client, tokens, ntokens);
 904         break;
 905       case VERSION_CMD:
 906         if (client->mute)
 907         {
 908           send_command_usage(client);
 909         }
 910         else
 911         {
 912           process_version(client, tokens, ntokens);
 913         }
 914         break;
 915       case QUIT_CMD:
 916         if (ntokens != 1 || client->mute)
 917         {
 918           send_command_usage(client);
 919         }
 920         else
 921         {
 922           if (client->root->callback->interface.v1.quit != NULL)
 923             client->root->callback->interface.v1.quit(client);
 924
 925           return MEMCACHED_PROTOCOL_ERROR_EVENT;
 926         }
 927         break;
 928
 929       case VERBOSITY_CMD:
 930         if (ntokens != 2)
 931           send_command_usage(client);
 932         else
 933           spool_string(client, "OK\r\n");
 934         break;
 935
 936       case UNKNOWN_CMD:
 937         send_command_usage(client);
 938         break;
 939
 940       case GET_CMD:
 941       case GETS_CMD:
 942       default:
 943         /* Should already be handled */
 944         abort();
 945       }
 946
 947       if (error == -1)
 948         return MEMCACHED_PROTOCOL_ERROR_EVENT;
 949       else if (error == 1)
 950         return MEMCACHED_PROTOCOL_READ_EVENT;
 951     }
 952
 953     /* Move past \n */
 954     ++end;
 955     *length -= end - ptr;
 956     ptr= end;
 957   } while (*length > 0);
 958
 959   *endptr= ptr;
 960   return MEMCACHED_PROTOCOL_READ_EVENT;
 961 }