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