git.m6w6.name Git - awesomized/libmemcached/blob - clients/memcapable.c

   1 /* -*- Mode: C; tab-width: 2; c-basic-offset: 2; indent-tabs-mode: nil -*- */
   2 #undef NDEBUG
   3 #include "config.h"
   4 #include <pthread.h>
   5 #include <sys/types.h>
   6 #include <sys/socket.h>
   7 #include <netdb.h>
   8 #include <arpa/inet.h>
   9 #include <netinet/in.h>
  10 #include <netinet/tcp.h>
  11 #include <fcntl.h>
  12 #include <signal.h>
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <errno.h>
  16 #include <assert.h>
  17 #include <string.h>
  18 #include <inttypes.h>
  19 #include <stdbool.h>
  20 #include <unistd.h>
  21 #include <poll.h>
  22 #include <ctype.h>
  23
  24 #include <libmemcached/memcached/protocol_binary.h>
  25 #include <libmemcached/byteorder.h>
  26
  27 #ifdef linux
  28 /* /usr/include/netinet/in.h defines macros from ntohs() to _bswap_nn to
  29  * optimize the conversion functions, but the prototypes generate warnings
  30  * from gcc. The conversion methods isn't the bottleneck for my app, so
  31  * just remove the warnings by undef'ing the optimization ..
  32  */
  33 #undef ntohs
  34 #undef ntohl
  35 #endif
  36
  37 /* Should we generate coredumps when we enounter an error (-c) */
  38 static bool do_core= false;
  39 /* connection to the server */
  40 static int sock;
  41 /* Should the output from test failures be verbose or quiet? */
  42 static bool verbose= false;
  43
  44 /* The number of seconds to wait for an IO-operation */
  45 static int timeout= 2;
  46
  47 /*
  48  * Instead of having to cast between the different datatypes we create
  49  * a union of all of the different types of pacages we want to send.
  50  * A lot of the different commands use the same packet layout, so I'll
  51  * just define the different types I need. The typedefs only contain
  52  * the header of the message, so we need some space for keys and body
  53  * To avoid to have to do multiple writes, lets add a chunk of memory
  54  * to use. 1k should be more than enough for header, key and body.
  55  */
  56 typedef union
  57 {
  58   protocol_binary_request_no_extras plain;
  59   protocol_binary_request_flush flush;
  60   protocol_binary_request_incr incr;
  61   protocol_binary_request_set set;
  62   char bytes[1024];
  63 } command;
  64
  65 typedef union
  66 {
  67   protocol_binary_response_no_extras plain;
  68   protocol_binary_response_incr incr;
  69   protocol_binary_response_decr decr;
  70   char bytes[1024];
  71 } response;
  72
  73 enum test_return
  74 {
  75   TEST_SKIP, TEST_PASS, TEST_PASS_RECONNECT, TEST_FAIL
  76 };
  77
  78 /**
  79  * Try to get an addrinfo struct for a given port on a given host
  80  */
  81 static struct addrinfo *lookuphost(const char *hostname, const char *port)
  82 {
  83   struct addrinfo *ai= 0;
  84   struct addrinfo hints= {.ai_family=AF_UNSPEC,
  85     .ai_protocol=IPPROTO_TCP,
  86     .ai_socktype=SOCK_STREAM};
  87   int error= getaddrinfo(hostname, port, &hints, &ai);
  88
  89   if (error != 0)
  90   {
  91     if (error != EAI_SYSTEM)
  92       fprintf(stderr, "getaddrinfo(): %s\n", gai_strerror(error));
  93     else
  94       perror("getaddrinfo()");
  95   }
  96
  97   return ai;
  98 }
  99
 100 /**
 101  * Set the socket in nonblocking mode
 102  * @return -1 if failure, the socket otherwise
 103  */
 104 static int set_noblock(void)
 105 {
 106   int flags= fcntl(sock, F_GETFL, 0);
 107   if (flags == -1)
 108   {
 109     perror("Failed to get socket flags");
 110     close(sock);
 111     return -1;
 112   }
 113
 114   if ((flags & O_NONBLOCK) != O_NONBLOCK)
 115   {
 116     if (fcntl(sock, F_SETFL, flags | O_NONBLOCK) == -1)
 117     {
 118       perror("Failed to set socket to nonblocking mode");
 119       close(sock);
 120       return -1;
 121     }
 122   }
 123
 124   return sock;
 125 }
 126
 127 /**
 128  * Try to open a connection to the server
 129  * @param hostname the name of the server to connect to
 130  * @param port the port number (or service) to connect to
 131  * @return positive integer if success, -1 otherwise
 132  */
 133 static int connect_server(const char *hostname, const char *port)
 134 {
 135   struct addrinfo *ai= lookuphost(hostname, port);
 136   sock= -1;
 137   if (ai != NULL)
 138   {
 139     if ((sock=socket(ai->ai_family, ai->ai_socktype,
 140                      ai->ai_protocol)) != -1)
 141     {
 142       if (connect(sock, ai->ai_addr, ai->ai_addrlen) == -1)
 143       {
 144         fprintf(stderr, "Failed to connect socket: %s\n",
 145                 strerror(errno));
 146         close(sock);
 147         sock= -1;
 148       }
 149       else
 150       {
 151         sock= set_noblock();
 152       }
 153     } else
 154       fprintf(stderr, "Failed to create socket: %s\n", strerror(errno));
 155
 156     freeaddrinfo(ai);
 157   }
 158
 159   return sock;
 160 }
 161
 162 static ssize_t timeout_io_op(int fd, short direction, void *buf, size_t len)
 163 {
 164   ssize_t ret;
 165
 166   if (direction == POLLOUT)
 167     ret= write(fd, buf, len);
 168   else
 169     ret= read(fd, buf, len);
 170
 171   if (ret == -1 && errno == EWOULDBLOCK) {
 172     struct pollfd fds= {
 173       .events= direction,
 174       .fd= fd
 175     };
 176     int err= poll(&fds, 1, timeout * 1000);
 177
 178     if (err == 1)
 179     {
 180       if (direction == POLLOUT)
 181         ret= write(fd, buf, len);
 182       else
 183         ret= read(fd, buf, len);
 184     }
 185     else if (err == 0)
 186     {
 187       errno= ETIMEDOUT;
 188     }
 189     else
 190     {
 191       perror("Failed to poll");
 192       return -1;
 193     }
 194   }
 195
 196   return ret;
 197 }
 198
 199 /**
 200  * Ensure that an expression is true. If it isn't print out a message similar
 201  * to assert() and create a coredump if the user wants that. If not an error
 202  * message is returned.
 203  *
 204  */
 205 static enum test_return ensure(bool val, const char *expression, const char *file, int line)
 206 {
 207   if (!val)
 208   {
 209     if (verbose)
 210       fprintf(stderr, "\n%s:%u: %s", file, line, expression);
 211
 212     if (do_core)
 213       abort();
 214
 215     return TEST_FAIL;
 216   }
 217
 218   return TEST_PASS;
 219 }
 220
 221 #define verify(expression) do { if (ensure(expression, #expression, __FILE__, __LINE__) == TEST_FAIL) return TEST_FAIL; } while (0)
 222 #define execute(expression) do { if (ensure(expression == TEST_PASS, #expression, __FILE__, __LINE__) == TEST_FAIL) return TEST_FAIL; } while (0)
 223
 224 /**
 225  * Send a chunk of memory over the socket (retry if the call is iterrupted
 226  */
 227 static enum test_return retry_write(const void* buf, size_t len)
 228 {
 229   size_t offset= 0;
 230   const char* ptr= buf;
 231
 232   do
 233   {
 234     size_t num_bytes= len - offset;
 235     ssize_t nw= timeout_io_op(sock, POLLOUT, (void*)(ptr + offset), num_bytes);
 236     if (nw == -1)
 237       verify(errno == EINTR || errno == EAGAIN);
 238     else
 239       offset+= (size_t)nw;
 240   } while (offset < len);
 241
 242   return TEST_PASS;
 243 }
 244
 245 /**
 246  * Resend a packet to the server (All fields in the command header should
 247  * be in network byte order)
 248  */
 249 static enum test_return resend_packet(command *cmd)
 250 {
 251   size_t length= sizeof (protocol_binary_request_no_extras) +
 252           ntohl(cmd->plain.message.header.request.bodylen);
 253
 254   execute(retry_write(cmd, length));
 255   return TEST_PASS;
 256 }
 257
 258 /**
 259  * Send a command to the server. The command header needs to be updated
 260  * to network byte order
 261  */
 262 static enum test_return send_packet(command *cmd)
 263 {
 264   /* Fix the byteorder of the header */
 265   cmd->plain.message.header.request.keylen=
 266           ntohs(cmd->plain.message.header.request.keylen);
 267   cmd->plain.message.header.request.bodylen=
 268           ntohl(cmd->plain.message.header.request.bodylen);
 269   cmd->plain.message.header.request.cas=
 270           ntohll(cmd->plain.message.header.request.cas);
 271
 272   execute(resend_packet(cmd));
 273   return TEST_PASS;
 274 }
 275
 276 /**
 277  * Read a fixed length chunk of data from the server
 278  */
 279 static enum test_return retry_read(void *buf, size_t len)
 280 {
 281   size_t offset= 0;
 282   do
 283   {
 284     ssize_t nr= timeout_io_op(sock, POLLIN, ((char*) buf) + offset, len - offset);
 285     switch (nr) {
 286     case -1 :
 287       verify(errno == EINTR || errno == EAGAIN);
 288       break;
 289     case 0:
 290       return TEST_FAIL;
 291     default:
 292       offset+= (size_t)nr;
 293     }
 294   } while (offset < len);
 295
 296   return TEST_PASS;
 297 }
 298
 299 /**
 300  * Receive a response from the server and conver the fields in the header
 301  * to local byte order
 302  */
 303 static enum test_return recv_packet(response *rsp)
 304 {
 305   execute(retry_read(rsp, sizeof (protocol_binary_response_no_extras)));
 306
 307   /* Fix the byte order in the packet header */
 308   rsp->plain.message.header.response.keylen=
 309           ntohs(rsp->plain.message.header.response.keylen);
 310   rsp->plain.message.header.response.status=
 311           ntohs(rsp->plain.message.header.response.status);
 312   rsp->plain.message.header.response.bodylen=
 313           ntohl(rsp->plain.message.header.response.bodylen);
 314   rsp->plain.message.header.response.cas=
 315           ntohll(rsp->plain.message.header.response.cas);
 316
 317   size_t bodysz= rsp->plain.message.header.response.bodylen;
 318   if (bodysz > 0)
 319     execute(retry_read(rsp->bytes + sizeof (protocol_binary_response_no_extras), bodysz));
 320
 321   return TEST_PASS;
 322 }
 323
 324 /**
 325  * Create a storage command (add, set, replace etc)
 326  *
 327  * @param cmd destination buffer
 328  * @param cc the storage command to create
 329  * @param key the key to store
 330  * @param keylen the length of the key
 331  * @param dta the data to store with the key
 332  * @param dtalen the length of the data to store with the key
 333  * @param flags the flags to store along with the key
 334  * @param exp the expiry time for the key
 335  */
 336 static void storage_command(command *cmd,
 337                             uint8_t cc,
 338                             const void* key,
 339                             size_t keylen,
 340                             const void* dta,
 341                             size_t dtalen,
 342                             uint32_t flags,
 343                             uint32_t exp)
 344 {
 345   /* all of the storage commands use the same command layout */
 346   protocol_binary_request_set *request= &cmd->set;
 347
 348   memset(request, 0, sizeof (*request));
 349   request->message.header.request.magic= PROTOCOL_BINARY_REQ;
 350   request->message.header.request.opcode= cc;
 351   request->message.header.request.keylen= (uint16_t)keylen;
 352   request->message.header.request.extlen= 8;
 353   request->message.header.request.bodylen= (uint32_t)(keylen + 8 + dtalen);
 354   request->message.header.request.opaque= 0xdeadbeef;
 355   request->message.body.flags= flags;
 356   request->message.body.expiration= exp;
 357
 358   off_t key_offset= sizeof (protocol_binary_request_no_extras) + 8;
 359   memcpy(cmd->bytes + key_offset, key, keylen);
 360   if (dta != NULL)
 361     memcpy(cmd->bytes + key_offset + keylen, dta, dtalen);
 362 }
 363
 364 /**
 365  * Create a basic command to send to the server
 366  * @param cmd destination buffer
 367  * @param cc the command to create
 368  * @param key the key to store
 369  * @param keylen the length of the key
 370  * @param dta the data to store with the key
 371  * @param dtalen the length of the data to store with the key
 372  */
 373 static void raw_command(command *cmd,
 374                         uint8_t cc,
 375                         const void* key,
 376                         size_t keylen,
 377                         const void* dta,
 378                         size_t dtalen)
 379 {
 380   /* all of the storage commands use the same command layout */
 381   memset(cmd, 0, sizeof (*cmd));
 382   cmd->plain.message.header.request.magic= PROTOCOL_BINARY_REQ;
 383   cmd->plain.message.header.request.opcode= cc;
 384   cmd->plain.message.header.request.keylen= (uint16_t)keylen;
 385   cmd->plain.message.header.request.bodylen= (uint32_t)(keylen + dtalen);
 386   cmd->plain.message.header.request.opaque= 0xdeadbeef;
 387
 388   off_t key_offset= sizeof (protocol_binary_request_no_extras);
 389
 390   if (key != NULL)
 391     memcpy(cmd->bytes + key_offset, key, keylen);
 392
 393   if (dta != NULL)
 394     memcpy(cmd->bytes + key_offset + keylen, dta, dtalen);
 395 }
 396
 397 /**
 398  * Create the flush command
 399  * @param cmd destination buffer
 400  * @param cc the command to create (FLUSH/FLUSHQ)
 401  * @param exptime when to flush
 402  * @param use_extra to force using of the extra field?
 403  */
 404 static void flush_command(command *cmd,
 405                           uint8_t cc, uint32_t exptime, bool use_extra)
 406 {
 407   memset(cmd, 0, sizeof (cmd->flush));
 408   cmd->flush.message.header.request.magic= PROTOCOL_BINARY_REQ;
 409   cmd->flush.message.header.request.opcode= cc;
 410   cmd->flush.message.header.request.opaque= 0xdeadbeef;
 411
 412   if (exptime != 0 || use_extra)
 413   {
 414     cmd->flush.message.header.request.extlen= 4;
 415     cmd->flush.message.body.expiration= htonl(exptime);
 416     cmd->flush.message.header.request.bodylen= 4;
 417   }
 418 }
 419
 420 /**
 421  * Create a incr/decr command
 422  * @param cc the cmd to create (FLUSH/FLUSHQ)
 423  * @param key the key to operate on
 424  * @param keylen the number of bytes in the key
 425  * @param delta the number to add/subtract
 426  * @param initial the initial value if the key doesn't exist
 427  * @param exp when the key should expire if it isn't set
 428  */
 429 static void arithmetic_command(command *cmd,
 430                                uint8_t cc,
 431                                const void* key,
 432                                size_t keylen,
 433                                uint64_t delta,
 434                                uint64_t initial,
 435                                uint32_t exp)
 436 {
 437   memset(cmd, 0, sizeof (cmd->incr));
 438   cmd->incr.message.header.request.magic= PROTOCOL_BINARY_REQ;
 439   cmd->incr.message.header.request.opcode= cc;
 440   cmd->incr.message.header.request.keylen= (uint16_t)keylen;
 441   cmd->incr.message.header.request.extlen= 20;
 442   cmd->incr.message.header.request.bodylen= (uint32_t)(keylen + 20);
 443   cmd->incr.message.header.request.opaque= 0xdeadbeef;
 444   cmd->incr.message.body.delta= htonll(delta);
 445   cmd->incr.message.body.initial= htonll(initial);
 446   cmd->incr.message.body.expiration= htonl(exp);
 447
 448   off_t key_offset= sizeof (protocol_binary_request_no_extras) + 20;
 449   memcpy(cmd->bytes + key_offset, key, keylen);
 450 }
 451
 452 /**
 453  * Validate the response header from the server
 454  * @param rsp the response to check
 455  * @param cc the expected command
 456  * @param status the expected status
 457  */
 458 static enum test_return do_validate_response_header(response *rsp,
 459                                                     uint8_t cc, uint16_t status)
 460 {
 461   verify(rsp->plain.message.header.response.magic == PROTOCOL_BINARY_RES);
 462   verify(rsp->plain.message.header.response.opcode == cc);
 463   verify(rsp->plain.message.header.response.datatype == PROTOCOL_BINARY_RAW_BYTES);
 464   verify(rsp->plain.message.header.response.status == status);
 465   verify(rsp->plain.message.header.response.opaque == 0xdeadbeef);
 466
 467   if (status == PROTOCOL_BINARY_RESPONSE_SUCCESS)
 468   {
 469     switch (cc) {
 470     case PROTOCOL_BINARY_CMD_ADDQ:
 471     case PROTOCOL_BINARY_CMD_APPENDQ:
 472     case PROTOCOL_BINARY_CMD_DECREMENTQ:
 473     case PROTOCOL_BINARY_CMD_DELETEQ:
 474     case PROTOCOL_BINARY_CMD_FLUSHQ:
 475     case PROTOCOL_BINARY_CMD_INCREMENTQ:
 476     case PROTOCOL_BINARY_CMD_PREPENDQ:
 477     case PROTOCOL_BINARY_CMD_QUITQ:
 478     case PROTOCOL_BINARY_CMD_REPLACEQ:
 479     case PROTOCOL_BINARY_CMD_SETQ:
 480       verify("Quiet command shouldn't return on success" == NULL);
 481     default:
 482       break;
 483     }
 484
 485     switch (cc) {
 486     case PROTOCOL_BINARY_CMD_ADD:
 487     case PROTOCOL_BINARY_CMD_REPLACE:
 488     case PROTOCOL_BINARY_CMD_SET:
 489     case PROTOCOL_BINARY_CMD_APPEND:
 490     case PROTOCOL_BINARY_CMD_PREPEND:
 491       verify(rsp->plain.message.header.response.keylen == 0);
 492       verify(rsp->plain.message.header.response.extlen == 0);
 493       verify(rsp->plain.message.header.response.bodylen == 0);
 494       verify(rsp->plain.message.header.response.cas != 0);
 495       break;
 496     case PROTOCOL_BINARY_CMD_FLUSH:
 497     case PROTOCOL_BINARY_CMD_NOOP:
 498     case PROTOCOL_BINARY_CMD_QUIT:
 499     case PROTOCOL_BINARY_CMD_DELETE:
 500       verify(rsp->plain.message.header.response.keylen == 0);
 501       verify(rsp->plain.message.header.response.extlen == 0);
 502       verify(rsp->plain.message.header.response.bodylen == 0);
 503       verify(rsp->plain.message.header.response.cas == 0);
 504       break;
 505
 506     case PROTOCOL_BINARY_CMD_DECREMENT:
 507     case PROTOCOL_BINARY_CMD_INCREMENT:
 508       verify(rsp->plain.message.header.response.keylen == 0);
 509       verify(rsp->plain.message.header.response.extlen == 0);
 510       verify(rsp->plain.message.header.response.bodylen == 8);
 511       verify(rsp->plain.message.header.response.cas != 0);
 512       break;
 513
 514     case PROTOCOL_BINARY_CMD_STAT:
 515       verify(rsp->plain.message.header.response.extlen == 0);
 516       /* key and value exists in all packets except in the terminating */
 517       verify(rsp->plain.message.header.response.cas == 0);
 518       break;
 519
 520     case PROTOCOL_BINARY_CMD_VERSION:
 521       verify(rsp->plain.message.header.response.keylen == 0);
 522       verify(rsp->plain.message.header.response.extlen == 0);
 523       verify(rsp->plain.message.header.response.bodylen != 0);
 524       verify(rsp->plain.message.header.response.cas == 0);
 525       break;
 526
 527     case PROTOCOL_BINARY_CMD_GET:
 528     case PROTOCOL_BINARY_CMD_GETQ:
 529       verify(rsp->plain.message.header.response.keylen == 0);
 530       verify(rsp->plain.message.header.response.extlen == 4);
 531       verify(rsp->plain.message.header.response.cas != 0);
 532       break;
 533
 534     case PROTOCOL_BINARY_CMD_GETK:
 535     case PROTOCOL_BINARY_CMD_GETKQ:
 536       verify(rsp->plain.message.header.response.keylen != 0);
 537       verify(rsp->plain.message.header.response.extlen == 4);
 538       verify(rsp->plain.message.header.response.cas != 0);
 539       break;
 540
 541     default:
 542       /* Undefined command code */
 543       break;
 544     }
 545   }
 546   else
 547   {
 548     verify(rsp->plain.message.header.response.cas == 0);
 549     verify(rsp->plain.message.header.response.extlen == 0);
 550     if (cc != PROTOCOL_BINARY_CMD_GETK)
 551     {
 552       verify(rsp->plain.message.header.response.keylen == 0);
 553     }
 554   }
 555
 556   return TEST_PASS;
 557 }
 558
 559 /* We call verify(validate_response_header), but that macro
 560  * expects a boolean expression, and the function returns
 561  * an enum.... Let's just create a macro to avoid cluttering
 562  * the code with all of the == TEST_PASS ;-)
 563  */
 564 #define validate_response_header(a,b,c) \
 565         do_validate_response_header(a,b,c) == TEST_PASS
 566
 567 static enum test_return test_binary_noop(void)
 568 {
 569   command cmd;
 570   response rsp;
 571   raw_command(&cmd, PROTOCOL_BINARY_CMD_NOOP, NULL, 0, NULL, 0);
 572   execute(send_packet(&cmd));
 573   execute(recv_packet(&rsp));
 574   verify(validate_response_header(&rsp, PROTOCOL_BINARY_CMD_NOOP,
 575                                   PROTOCOL_BINARY_RESPONSE_SUCCESS));
 576   return TEST_PASS;
 577 }
 578
 579 static enum test_return test_binary_quit_impl(uint8_t cc)
 580 {
 581   command cmd;
 582   response rsp;
 583   raw_command(&cmd, cc, NULL, 0, NULL, 0);
 584
 585   execute(send_packet(&cmd));
 586   if (cc == PROTOCOL_BINARY_CMD_QUIT)
 587   {
 588     execute(recv_packet(&rsp));
 589     verify(validate_response_header(&rsp, PROTOCOL_BINARY_CMD_QUIT,
 590                                     PROTOCOL_BINARY_RESPONSE_SUCCESS));
 591   }
 592
 593   /* Socket should be closed now, read should return 0 */
 594   verify(timeout_io_op(sock, POLLIN, rsp.bytes, sizeof(rsp.bytes)) == 0);
 595
 596   return TEST_PASS_RECONNECT;
 597 }
 598
 599 static enum test_return test_binary_quit(void)
 600 {
 601   return test_binary_quit_impl(PROTOCOL_BINARY_CMD_QUIT);
 602 }
 603
 604 static enum test_return test_binary_quitq(void)
 605 {
 606   return test_binary_quit_impl(PROTOCOL_BINARY_CMD_QUITQ);
 607 }
 608
 609 static enum test_return test_binary_set_impl(const char* key, uint8_t cc)
 610 {
 611   command cmd;
 612   response rsp;
 613
 614   uint64_t value= 0xdeadbeefdeadcafe;
 615   storage_command(&cmd, cc, key, strlen(key), &value, sizeof (value), 0, 0);
 616
 617   /* set should always work */
 618   for (int ii= 0; ii < 10; ii++)
 619   {
 620     if (ii == 0)
 621       execute(send_packet(&cmd));
 622     else
 623       execute(resend_packet(&cmd));
 624
 625     if (cc == PROTOCOL_BINARY_CMD_SET)
 626     {
 627       execute(recv_packet(&rsp));
 628       verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_SUCCESS));
 629     }
 630     else
 631       execute(test_binary_noop());
 632   }
 633
 634   /*
 635    * We need to get the current CAS id, and at this time we haven't
 636    * verified that we have a working get
 637    */
 638   if (cc == PROTOCOL_BINARY_CMD_SETQ)
 639   {
 640     cmd.set.message.header.request.opcode= PROTOCOL_BINARY_CMD_SET;
 641     execute(resend_packet(&cmd));
 642     execute(recv_packet(&rsp));
 643     verify(validate_response_header(&rsp, PROTOCOL_BINARY_CMD_SET,
 644                                     PROTOCOL_BINARY_RESPONSE_SUCCESS));
 645     cmd.set.message.header.request.opcode= PROTOCOL_BINARY_CMD_SETQ;
 646   }
 647
 648   /* try to set with the correct CAS value */
 649   cmd.plain.message.header.request.cas=
 650           htonll(rsp.plain.message.header.response.cas);
 651   execute(resend_packet(&cmd));
 652   if (cc == PROTOCOL_BINARY_CMD_SET)
 653   {
 654     execute(recv_packet(&rsp));
 655     verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_SUCCESS));
 656   }
 657   else
 658     execute(test_binary_noop());
 659
 660   /* try to set with an incorrect CAS value */
 661   cmd.plain.message.header.request.cas=
 662           htonll(rsp.plain.message.header.response.cas - 1);
 663   execute(resend_packet(&cmd));
 664   execute(recv_packet(&rsp));
 665   verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS));
 666
 667   return test_binary_noop();
 668 }
 669
 670 static enum test_return test_binary_set(void)
 671 {
 672   return test_binary_set_impl("test_binary_set", PROTOCOL_BINARY_CMD_SET);
 673 }
 674
 675 static enum test_return test_binary_setq(void)
 676 {
 677   return test_binary_set_impl("test_binary_setq", PROTOCOL_BINARY_CMD_SETQ);
 678 }
 679
 680 static enum test_return test_binary_add_impl(const char* key, uint8_t cc)
 681 {
 682   command cmd;
 683   response rsp;
 684   uint64_t value= 0xdeadbeefdeadcafe;
 685   storage_command(&cmd, cc, key, strlen(key), &value, sizeof (value), 0, 0);
 686
 687   /* first add should work, rest of them should fail (even with cas
 688      as wildcard */
 689   for (int ii=0; ii < 10; ii++)
 690   {
 691     if (ii == 0)
 692       execute(send_packet(&cmd));
 693     else
 694       execute(resend_packet(&cmd));
 695
 696     if (cc == PROTOCOL_BINARY_CMD_ADD || ii > 0)
 697     {
 698       uint16_t expected_result;
 699       if (ii == 0)
 700         expected_result= PROTOCOL_BINARY_RESPONSE_SUCCESS;
 701       else
 702         expected_result= PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS;
 703
 704       execute(recv_packet(&rsp));
 705       verify(validate_response_header(&rsp, cc, expected_result));
 706     }
 707     else
 708       execute(test_binary_noop());
 709   }
 710
 711   return TEST_PASS;
 712 }
 713
 714 static enum test_return test_binary_add(void)
 715 {
 716   return test_binary_add_impl("test_binary_add", PROTOCOL_BINARY_CMD_ADD);
 717 }
 718
 719 static enum test_return test_binary_addq(void)
 720 {
 721   return test_binary_add_impl("test_binary_addq", PROTOCOL_BINARY_CMD_ADDQ);
 722 }
 723
 724 static enum test_return binary_set_item(const char *key, const char *value)
 725 {
 726   command cmd;
 727   response rsp;
 728   storage_command(&cmd, PROTOCOL_BINARY_CMD_SET, key, strlen(key),
 729                   value, strlen(value), 0, 0);
 730   execute(send_packet(&cmd));
 731   execute(recv_packet(&rsp));
 732   verify(validate_response_header(&rsp, PROTOCOL_BINARY_CMD_SET,
 733                                   PROTOCOL_BINARY_RESPONSE_SUCCESS));
 734   return TEST_PASS;
 735 }
 736
 737 static enum test_return test_binary_replace_impl(const char* key, uint8_t cc)
 738 {
 739   command cmd;
 740   response rsp;
 741   uint64_t value= 0xdeadbeefdeadcafe;
 742   storage_command(&cmd, cc, key, strlen(key), &value, sizeof (value), 0, 0);
 743
 744   /* first replace should fail, successive should succeed (when the
 745      item is added! */
 746   for (int ii= 0; ii < 10; ii++)
 747   {
 748     if (ii == 0)
 749       execute(send_packet(&cmd));
 750     else
 751       execute(resend_packet(&cmd));
 752
 753     if (cc == PROTOCOL_BINARY_CMD_REPLACE || ii == 0)
 754     {
 755       uint16_t expected_result;
 756       if (ii == 0)
 757         expected_result=PROTOCOL_BINARY_RESPONSE_KEY_ENOENT;
 758       else
 759         expected_result=PROTOCOL_BINARY_RESPONSE_SUCCESS;
 760
 761       execute(recv_packet(&rsp));
 762       verify(validate_response_header(&rsp, cc, expected_result));
 763
 764       if (ii == 0)
 765         execute(binary_set_item(key, key));
 766     }
 767     else
 768       execute(test_binary_noop());
 769   }
 770
 771   /* verify that replace with CAS value works! */
 772   cmd.plain.message.header.request.cas=
 773           htonll(rsp.plain.message.header.response.cas);
 774   execute(resend_packet(&cmd));
 775
 776   if (cc == PROTOCOL_BINARY_CMD_REPLACE)
 777   {
 778     execute(recv_packet(&rsp));
 779     verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_SUCCESS));
 780   }
 781   else
 782     execute(test_binary_noop());
 783
 784   /* try to set with an incorrect CAS value */
 785   cmd.plain.message.header.request.cas=
 786           htonll(rsp.plain.message.header.response.cas - 1);
 787   execute(resend_packet(&cmd));
 788   execute(recv_packet(&rsp));
 789   verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS));
 790
 791   return TEST_PASS;
 792 }
 793
 794 static enum test_return test_binary_replace(void)
 795 {
 796   return test_binary_replace_impl("test_binary_replace", PROTOCOL_BINARY_CMD_REPLACE);
 797 }
 798
 799 static enum test_return test_binary_replaceq(void)
 800 {
 801   return test_binary_replace_impl("test_binary_replaceq", PROTOCOL_BINARY_CMD_REPLACEQ);
 802 }
 803
 804 static enum test_return test_binary_delete_impl(const char *key, uint8_t cc)
 805 {
 806   command cmd;
 807   response rsp;
 808   raw_command(&cmd, cc, key, strlen(key), NULL, 0);
 809
 810   /* The delete shouldn't work the first time, because the item isn't there */
 811   execute(send_packet(&cmd));
 812   execute(recv_packet(&rsp));
 813   verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_KEY_ENOENT));
 814   execute(binary_set_item(key, key));
 815
 816   /* The item should be present now, resend*/
 817   execute(resend_packet(&cmd));
 818   if (cc == PROTOCOL_BINARY_CMD_DELETE)
 819   {
 820     execute(recv_packet(&rsp));
 821     verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_SUCCESS));
 822   }
 823
 824   execute(test_binary_noop());
 825
 826   return TEST_PASS;
 827 }
 828
 829 static enum test_return test_binary_delete(void)
 830 {
 831   return test_binary_delete_impl("test_binary_delete", PROTOCOL_BINARY_CMD_DELETE);
 832 }
 833
 834 static enum test_return test_binary_deleteq(void)
 835 {
 836   return test_binary_delete_impl("test_binary_deleteq", PROTOCOL_BINARY_CMD_DELETEQ);
 837 }
 838
 839 static enum test_return test_binary_get_impl(const char *key, uint8_t cc)
 840 {
 841   command cmd;
 842   response rsp;
 843
 844   raw_command(&cmd, cc, key, strlen(key), NULL, 0);
 845   execute(send_packet(&cmd));
 846
 847   if (cc == PROTOCOL_BINARY_CMD_GET || cc == PROTOCOL_BINARY_CMD_GETK)
 848   {
 849     execute(recv_packet(&rsp));
 850     verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_KEY_ENOENT));
 851   }
 852   else
 853     execute(test_binary_noop());
 854
 855   execute(binary_set_item(key, key));
 856   execute(resend_packet(&cmd));
 857   execute(recv_packet(&rsp));
 858   verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_SUCCESS));
 859
 860   return TEST_PASS;
 861 }
 862
 863 static enum test_return test_binary_get(void)
 864 {
 865   return test_binary_get_impl("test_binary_get", PROTOCOL_BINARY_CMD_GET);
 866 }
 867
 868 static enum test_return test_binary_getk(void)
 869 {
 870   return test_binary_get_impl("test_binary_getk", PROTOCOL_BINARY_CMD_GETK);
 871 }
 872
 873 static enum test_return test_binary_getq(void)
 874 {
 875   return test_binary_get_impl("test_binary_getq", PROTOCOL_BINARY_CMD_GETQ);
 876 }
 877
 878 static enum test_return test_binary_getkq(void)
 879 {
 880   return test_binary_get_impl("test_binary_getkq", PROTOCOL_BINARY_CMD_GETKQ);
 881 }
 882
 883 static enum test_return test_binary_incr_impl(const char* key, uint8_t cc)
 884 {
 885   command cmd;
 886   response rsp;
 887   arithmetic_command(&cmd, cc, key, strlen(key), 1, 0, 0);
 888
 889   uint64_t ii;
 890   for (ii= 0; ii < 10; ++ii)
 891   {
 892     if (ii == 0)
 893       execute(send_packet(&cmd));
 894     else
 895       execute(resend_packet(&cmd));
 896
 897     if (cc == PROTOCOL_BINARY_CMD_INCREMENT)
 898     {
 899       execute(recv_packet(&rsp));
 900       verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_SUCCESS));
 901       verify(ntohll(rsp.incr.message.body.value) == ii);
 902     }
 903     else
 904       execute(test_binary_noop());
 905   }
 906
 907   /* @todo add incorrect CAS */
 908   return TEST_PASS;
 909 }
 910
 911 static enum test_return test_binary_incr(void)
 912 {
 913   return test_binary_incr_impl("test_binary_incr", PROTOCOL_BINARY_CMD_INCREMENT);
 914 }
 915
 916 static enum test_return test_binary_incrq(void)
 917 {
 918   return test_binary_incr_impl("test_binary_incrq", PROTOCOL_BINARY_CMD_INCREMENTQ);
 919 }
 920
 921 static enum test_return test_binary_decr_impl(const char* key, uint8_t cc)
 922 {
 923   command cmd;
 924   response rsp;
 925   arithmetic_command(&cmd, cc, key, strlen(key), 1, 9, 0);
 926
 927   int ii;
 928   for (ii= 9; ii > -1; --ii)
 929   {
 930     if (ii == 9)
 931       execute(send_packet(&cmd));
 932     else
 933       execute(resend_packet(&cmd));
 934
 935     if (cc == PROTOCOL_BINARY_CMD_DECREMENT)
 936     {
 937       execute(recv_packet(&rsp));
 938       verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_SUCCESS));
 939       verify(ntohll(rsp.decr.message.body.value) == (uint64_t)ii);
 940     }
 941     else
 942       execute(test_binary_noop());
 943   }
 944
 945   /* decr 0 should not wrap */
 946   execute(resend_packet(&cmd));
 947   if (cc == PROTOCOL_BINARY_CMD_DECREMENT)
 948   {
 949     execute(recv_packet(&rsp));
 950     verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_SUCCESS));
 951     verify(ntohll(rsp.decr.message.body.value) == 0);
 952   }
 953   else
 954   {
 955     /* @todo get the value and verify! */
 956
 957   }
 958
 959   /* @todo add incorrect cas */
 960   execute(test_binary_noop());
 961   return TEST_PASS;
 962 }
 963
 964 static enum test_return test_binary_decr(void)
 965 {
 966   return test_binary_decr_impl("test_binary_decr",
 967                                PROTOCOL_BINARY_CMD_DECREMENT);
 968 }
 969
 970 static enum test_return test_binary_decrq(void)
 971 {
 972   return test_binary_decr_impl("test_binary_decrq",
 973                                PROTOCOL_BINARY_CMD_DECREMENTQ);
 974 }
 975
 976 static enum test_return test_binary_version(void)
 977 {
 978   command cmd;
 979   response rsp;
 980   raw_command(&cmd, PROTOCOL_BINARY_CMD_VERSION, NULL, 0, NULL, 0);
 981
 982   execute(send_packet(&cmd));
 983   execute(recv_packet(&rsp));
 984   verify(validate_response_header(&rsp, PROTOCOL_BINARY_CMD_VERSION,
 985                                   PROTOCOL_BINARY_RESPONSE_SUCCESS));
 986
 987   return TEST_PASS;
 988 }
 989
 990 static enum test_return test_binary_flush_impl(const char *key, uint8_t cc)
 991 {
 992   command cmd;
 993   response rsp;
 994
 995   for (int ii= 0; ii < 2; ++ii)
 996   {
 997     execute(binary_set_item(key, key));
 998     flush_command(&cmd, cc, 0, ii == 0);
 999     execute(send_packet(&cmd));
1000
1001     if (cc == PROTOCOL_BINARY_CMD_FLUSH)
1002     {
1003       execute(recv_packet(&rsp));
1004       verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_SUCCESS));
1005     }
1006     else
1007       execute(test_binary_noop());
1008
1009     raw_command(&cmd, PROTOCOL_BINARY_CMD_GET, key, strlen(key), NULL, 0);
1010     execute(send_packet(&cmd));
1011     execute(recv_packet(&rsp));
1012     verify(validate_response_header(&rsp, PROTOCOL_BINARY_CMD_GET,
1013                                     PROTOCOL_BINARY_RESPONSE_KEY_ENOENT));
1014   }
1015
1016   return TEST_PASS;
1017 }
1018
1019 static enum test_return test_binary_flush(void)
1020 {
1021   return test_binary_flush_impl("test_binary_flush", PROTOCOL_BINARY_CMD_FLUSH);
1022 }
1023
1024 static enum test_return test_binary_flushq(void)
1025 {
1026   return test_binary_flush_impl("test_binary_flushq", PROTOCOL_BINARY_CMD_FLUSHQ);
1027 }
1028
1029 static enum test_return test_binary_concat_impl(const char *key, uint8_t cc)
1030 {
1031   command cmd;
1032   response rsp;
1033   const char *value;
1034
1035   if (cc == PROTOCOL_BINARY_CMD_APPEND || cc == PROTOCOL_BINARY_CMD_APPENDQ)
1036     value="hello";
1037   else
1038     value=" world";
1039
1040   execute(binary_set_item(key, value));
1041
1042   if (cc == PROTOCOL_BINARY_CMD_APPEND || cc == PROTOCOL_BINARY_CMD_APPENDQ)
1043     value=" world";
1044   else
1045     value="hello";
1046
1047   raw_command(&cmd, cc, key, strlen(key), value, strlen(value));
1048   execute(send_packet(&cmd));
1049   if (cc == PROTOCOL_BINARY_CMD_APPEND || cc == PROTOCOL_BINARY_CMD_PREPEND)
1050   {
1051     execute(recv_packet(&rsp));
1052     verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_SUCCESS));
1053   }
1054   else
1055     execute(test_binary_noop());
1056
1057   raw_command(&cmd, PROTOCOL_BINARY_CMD_GET, key, strlen(key), NULL, 0);
1058   execute(send_packet(&cmd));
1059   execute(recv_packet(&rsp));
1060   verify(validate_response_header(&rsp, PROTOCOL_BINARY_CMD_GET,
1061                                   PROTOCOL_BINARY_RESPONSE_SUCCESS));
1062   verify(rsp.plain.message.header.response.bodylen - 4 == 11);
1063   verify(memcmp(rsp.bytes + 28, "hello world", 11) == 0);
1064
1065   return TEST_PASS;
1066 }
1067
1068 static enum test_return test_binary_append(void)
1069 {
1070   return test_binary_concat_impl("test_binary_append", PROTOCOL_BINARY_CMD_APPEND);
1071 }
1072
1073 static enum test_return test_binary_prepend(void)
1074 {
1075   return test_binary_concat_impl("test_binary_prepend", PROTOCOL_BINARY_CMD_PREPEND);
1076 }
1077
1078 static enum test_return test_binary_appendq(void)
1079 {
1080   return test_binary_concat_impl("test_binary_appendq", PROTOCOL_BINARY_CMD_APPENDQ);
1081 }
1082
1083 static enum test_return test_binary_prependq(void)
1084 {
1085   return test_binary_concat_impl("test_binary_prependq", PROTOCOL_BINARY_CMD_PREPENDQ);
1086 }
1087
1088 static enum test_return test_binary_stat(void)
1089 {
1090   command cmd;
1091   response rsp;
1092
1093   raw_command(&cmd, PROTOCOL_BINARY_CMD_STAT, NULL, 0, NULL, 0);
1094   execute(send_packet(&cmd));
1095
1096   do
1097   {
1098     execute(recv_packet(&rsp));
1099     verify(validate_response_header(&rsp, PROTOCOL_BINARY_CMD_STAT,
1100                                     PROTOCOL_BINARY_RESPONSE_SUCCESS));
1101   } while (rsp.plain.message.header.response.keylen != 0);
1102
1103   return TEST_PASS;
1104 }
1105
1106 static enum test_return test_binary_illegal(void)
1107 {
1108   command cmd;
1109   response rsp;
1110   uint8_t cc= 0x1b;
1111
1112   while (cc != 0x00)
1113   {
1114     raw_command(&cmd, cc, NULL, 0, NULL, 0);
1115     execute(send_packet(&cmd));
1116     execute(recv_packet(&rsp));
1117     verify(validate_response_header(&rsp, cc, PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND));
1118     ++cc;
1119   }
1120
1121   return TEST_PASS_RECONNECT;
1122 }
1123
1124 static enum test_return send_string(const char *cmd)
1125 {
1126   execute(retry_write(cmd, strlen(cmd)));
1127   return TEST_PASS;
1128 }
1129
1130 static enum test_return receive_line(char *buffer, size_t size)
1131 {
1132   size_t offset= 0;
1133   while (offset < size)
1134   {
1135     execute(retry_read(buffer + offset, 1));
1136     if (buffer[offset] == '\n')
1137     {
1138       if (offset + 1 < size)
1139       {
1140         buffer[offset + 1]= '\0';
1141         return TEST_PASS;
1142       }
1143       else
1144         return TEST_FAIL;
1145     }
1146     ++offset;
1147   }
1148
1149   return TEST_FAIL;
1150 }
1151
1152 static enum test_return receive_response(const char *msg) {
1153   char buffer[80];
1154   execute(receive_line(buffer, sizeof(buffer)));
1155   verify(strcmp(msg, buffer) == 0);
1156   return TEST_PASS;
1157 }
1158
1159 static enum test_return test_ascii_quit(void)
1160 {
1161   /* Verify that quit handles unknown options */
1162   execute(send_string("quit foo bar\r\n"));
1163   execute(receive_response("ERROR\r\n"));
1164
1165   /* quit doesn't support noreply */
1166   execute(send_string("quit noreply\r\n"));
1167   execute(receive_response("ERROR\r\n"));
1168
1169   /* Verify that quit works */
1170   execute(send_string("quit\r\n"));
1171
1172   /* Socket should be closed now, read should return 0 */
1173   char buffer[80];
1174   verify(timeout_io_op(sock, POLLIN, buffer, sizeof(buffer)) == 0);
1175   return TEST_PASS_RECONNECT;
1176
1177 }
1178
1179 static enum test_return test_ascii_version(void)
1180 {
1181   /* Verify that version command handles unknown options */
1182   execute(send_string("version foo bar\r\n"));
1183   execute(receive_response("ERROR\r\n"));
1184
1185   /* version doesn't support noreply */
1186   execute(send_string("version noreply\r\n"));
1187   execute(receive_response("ERROR\r\n"));
1188
1189   /* Verify that verify works */
1190   execute(send_string("version\r\n"));
1191   char buffer[256];
1192   execute(receive_line(buffer, sizeof(buffer)));
1193   verify(strncmp(buffer, "VERSION ", 8) == 0);
1194
1195   return TEST_PASS;
1196 }
1197
1198 static enum test_return test_ascii_verbosity(void)
1199 {
1200   /* This command does not adhere to the spec! */
1201   execute(send_string("verbosity foo bar my\r\n"));
1202   execute(receive_response("ERROR\r\n"));
1203
1204   execute(send_string("verbosity noreply\r\n"));
1205   execute(test_ascii_version());
1206
1207   execute(send_string("verbosity 0 noreply\r\n"));
1208   execute(test_ascii_version());
1209
1210   execute(send_string("verbosity\r\n"));
1211   execute(receive_response("ERROR\r\n"));
1212
1213   execute(send_string("verbosity 1\r\n"));
1214   execute(receive_response("OK\r\n"));
1215
1216   execute(send_string("verbosity 0\r\n"));
1217   execute(receive_response("OK\r\n"));
1218
1219   return TEST_PASS;
1220 }
1221
1222
1223
1224 static enum test_return test_ascii_set_impl(const char* key, bool noreply)
1225 {
1226   /* @todo add tests for bogus format! */
1227   char buffer[1024];
1228   sprintf(buffer, "set %s 0 0 5%s\r\nvalue\r\n", key,
1229           noreply ? " noreply" : "");
1230   execute(send_string(buffer));
1231
1232   if (!noreply)
1233     execute(receive_response("STORED\r\n"));
1234
1235   return test_ascii_version();
1236 }
1237
1238 static enum test_return test_ascii_set(void)
1239 {
1240   return test_ascii_set_impl("test_ascii_set", false);
1241 }
1242
1243 static enum test_return test_ascii_set_noreply(void)
1244 {
1245   return test_ascii_set_impl("test_ascii_set_noreply", true);
1246 }
1247
1248 static enum test_return test_ascii_add_impl(const char* key, bool noreply)
1249 {
1250   /* @todo add tests for bogus format! */
1251   char buffer[1024];
1252   sprintf(buffer, "add %s 0 0 5%s\r\nvalue\r\n", key,
1253           noreply ? " noreply" : "");
1254   execute(send_string(buffer));
1255
1256   if (!noreply)
1257     execute(receive_response("STORED\r\n"));
1258
1259   execute(send_string(buffer));
1260
1261   if (!noreply)
1262     execute(receive_response("NOT_STORED\r\n"));
1263
1264   return test_ascii_version();
1265 }
1266
1267 static enum test_return test_ascii_add(void)
1268 {
1269   return test_ascii_add_impl("test_ascii_add", false);
1270 }
1271
1272 static enum test_return test_ascii_add_noreply(void)
1273 {
1274   return test_ascii_add_impl("test_ascii_add_noreply", true);
1275 }
1276
1277 static enum test_return ascii_get_value(const char *key, const char *value)
1278 {
1279
1280   char buffer[1024];
1281   size_t datasize= strlen(value);
1282
1283   verify(datasize < sizeof(buffer));
1284   execute(receive_line(buffer, sizeof(buffer)));
1285   verify(strncmp(buffer, "VALUE ", 6) == 0);
1286   verify(strncmp(buffer + 6, key, strlen(key)) == 0);
1287   char *ptr= buffer + 6 + strlen(key) + 1;
1288   char *end;
1289
1290   unsigned long val= strtoul(ptr, &end, 10); /* flags */
1291   verify(ptr != end);
1292   verify(val == 0);
1293   verify(end != NULL);
1294   val= strtoul(end, &end, 10); /* size */
1295   verify(ptr != end);
1296   verify(val == datasize);
1297   verify(end != NULL);
1298   while (*end != '\n' && isspace(*end))
1299     ++end;
1300   verify(*end == '\n');
1301
1302   execute(retry_read(buffer, datasize));
1303   verify(memcmp(buffer, value, datasize) == 0);
1304
1305   execute(retry_read(buffer, 2));
1306   verify(memcmp(buffer, "\r\n", 2) == 0);
1307
1308   return TEST_PASS;
1309 }
1310
1311 static enum test_return ascii_get_item(const char *key, const char *value,
1312                                        bool exist)
1313 {
1314   char buffer[1024];
1315   size_t datasize= 0;
1316   if (value != NULL)
1317     datasize= strlen(value);
1318
1319   verify(datasize < sizeof(buffer));
1320   sprintf(buffer, "get %s\r\n", key);
1321   execute(send_string(buffer));
1322
1323   if (exist)
1324     execute(ascii_get_value(key, value));
1325
1326   execute(retry_read(buffer, 5));
1327   verify(memcmp(buffer, "END\r\n", 5) == 0);
1328
1329   return TEST_PASS;
1330 }
1331
1332 static enum test_return ascii_gets_value(const char *key, const char *value,
1333                                          unsigned long *cas)
1334 {
1335
1336   char buffer[1024];
1337   size_t datasize= strlen(value);
1338
1339   verify(datasize < sizeof(buffer));
1340   execute(receive_line(buffer, sizeof(buffer)));
1341   verify(strncmp(buffer, "VALUE ", 6) == 0);
1342   verify(strncmp(buffer + 6, key, strlen(key)) == 0);
1343   char *ptr= buffer + 6 + strlen(key) + 1;
1344   char *end;
1345
1346   unsigned long val= strtoul(ptr, &end, 10); /* flags */
1347   verify(ptr != end);
1348   verify(val == 0);
1349   verify(end != NULL);
1350   val= strtoul(end, &end, 10); /* size */
1351   verify(ptr != end);
1352   verify(val == datasize);
1353   verify(end != NULL);
1354   *cas= strtoul(end, &end, 10); /* cas */
1355   verify(ptr != end);
1356   verify(val == datasize);
1357   verify(end != NULL);
1358
1359   while (*end != '\n' && isspace(*end))
1360     ++end;
1361   verify(*end == '\n');
1362
1363   execute(retry_read(buffer, datasize));
1364   verify(memcmp(buffer, value, datasize) == 0);
1365
1366   execute(retry_read(buffer, 2));
1367   verify(memcmp(buffer, "\r\n", 2) == 0);
1368
1369   return TEST_PASS;
1370 }
1371
1372 static enum test_return ascii_gets_item(const char *key, const char *value,
1373                                         bool exist, unsigned long *cas)
1374 {
1375   char buffer[1024];
1376   size_t datasize= 0;
1377   if (value != NULL)
1378     datasize= strlen(value);
1379
1380   verify(datasize < sizeof(buffer));
1381   sprintf(buffer, "gets %s\r\n", key);
1382   execute(send_string(buffer));
1383
1384   if (exist)
1385     execute(ascii_gets_value(key, value, cas));
1386
1387   execute(retry_read(buffer, 5));
1388   verify(memcmp(buffer, "END\r\n", 5) == 0);
1389
1390   return TEST_PASS;
1391 }
1392
1393 static enum test_return ascii_set_item(const char *key, const char *value)
1394 {
1395   char buffer[300];
1396   size_t len= strlen(value);
1397   sprintf(buffer, "set %s 0 0 %u\r\n", key, (unsigned int)len);
1398   execute(send_string(buffer));
1399   execute(retry_write(value, len));
1400   execute(send_string("\r\n"));
1401   execute(receive_response("STORED\r\n"));
1402   return TEST_PASS;
1403 }
1404
1405 static enum test_return test_ascii_replace_impl(const char* key, bool noreply)
1406 {
1407   char buffer[1024];
1408   sprintf(buffer, "replace %s 0 0 5%s\r\nvalue\r\n", key,
1409           noreply ? " noreply" : "");
1410   execute(send_string(buffer));
1411
1412   if (noreply)
1413     execute(test_ascii_version());
1414   else
1415     execute(receive_response("NOT_STORED\r\n"));
1416
1417   execute(ascii_set_item(key, "value"));
1418   execute(ascii_get_item(key, "value", true));
1419
1420
1421   execute(send_string(buffer));
1422
1423   if (noreply)
1424     execute(test_ascii_version());
1425   else
1426     execute(receive_response("STORED\r\n"));
1427
1428   return test_ascii_version();
1429 }
1430
1431 static enum test_return test_ascii_replace(void)
1432 {
1433   return test_ascii_replace_impl("test_ascii_replace", false);
1434 }
1435
1436 static enum test_return test_ascii_replace_noreply(void)
1437 {
1438   return test_ascii_replace_impl("test_ascii_replace_noreply", true);
1439 }
1440
1441 static enum test_return test_ascii_cas_impl(const char* key, bool noreply)
1442 {
1443   char buffer[1024];
1444   unsigned long cas;
1445
1446   execute(ascii_set_item(key, "value"));
1447   execute(ascii_gets_item(key, "value", true, &cas));
1448
1449   sprintf(buffer, "cas %s 0 0 6 %lu%s\r\nvalue2\r\n", key, cas,
1450           noreply ? " noreply" : "");
1451   execute(send_string(buffer));
1452
1453   if (noreply)
1454     execute(test_ascii_version());
1455   else
1456     execute(receive_response("STORED\r\n"));
1457
1458   /* reexecute the same command should fail due to illegal cas */
1459   execute(send_string(buffer));
1460
1461   if (noreply)
1462     execute(test_ascii_version());
1463   else
1464     execute(receive_response("EXISTS\r\n"));
1465
1466   return test_ascii_version();
1467 }
1468
1469 static enum test_return test_ascii_cas(void)
1470 {
1471   return test_ascii_cas_impl("test_ascii_cas", false);
1472 }
1473
1474 static enum test_return test_ascii_cas_noreply(void)
1475 {
1476   return test_ascii_cas_impl("test_ascii_cas_noreply", true);
1477 }
1478
1479 static enum test_return test_ascii_delete_impl(const char *key, bool noreply)
1480 {
1481   execute(ascii_set_item(key, "value"));
1482
1483   execute(send_string("delete\r\n"));
1484   execute(receive_response("ERROR\r\n"));
1485   /* BUG: the server accepts delete a b */
1486   execute(send_string("delete a b c d e\r\n"));
1487   execute(receive_response("ERROR\r\n"));
1488
1489   char buffer[1024];
1490   sprintf(buffer, "delete %s%s\r\n", key, noreply ? " noreply" : "");
1491   execute(send_string(buffer));
1492
1493   if (noreply)
1494     execute(test_ascii_version());
1495   else
1496     execute(receive_response("DELETED\r\n"));
1497
1498   execute(ascii_get_item(key, "value", false));
1499   execute(send_string(buffer));
1500   if (noreply)
1501     execute(test_ascii_version());
1502   else
1503     execute(receive_response("NOT_FOUND\r\n"));
1504
1505   return TEST_PASS;
1506 }
1507
1508 static enum test_return test_ascii_delete(void)
1509 {
1510   return test_ascii_delete_impl("test_ascii_delete", false);
1511 }
1512
1513 static enum test_return test_ascii_delete_noreply(void)
1514 {
1515   return test_ascii_delete_impl("test_ascii_delete_noreply", true);
1516 }
1517
1518 static enum test_return test_ascii_get(void)
1519 {
1520   execute(ascii_set_item("test_ascii_get", "value"));
1521
1522   execute(send_string("get\r\n"));
1523   execute(receive_response("ERROR\r\n"));
1524   execute(ascii_get_item("test_ascii_get", "value", true));
1525   execute(ascii_get_item("test_ascii_get_notfound", "value", false));
1526
1527   return TEST_PASS;
1528 }
1529
1530 static enum test_return test_ascii_gets(void)
1531 {
1532   execute(ascii_set_item("test_ascii_gets", "value"));
1533
1534   execute(send_string("gets\r\n"));
1535   execute(receive_response("ERROR\r\n"));
1536   unsigned long cas;
1537   execute(ascii_gets_item("test_ascii_gets", "value", true, &cas));
1538   execute(ascii_gets_item("test_ascii_gets_notfound", "value", false, &cas));
1539
1540   return TEST_PASS;
1541 }
1542
1543 static enum test_return test_ascii_mget(void)
1544 {
1545   execute(ascii_set_item("test_ascii_mget1", "value"));
1546   execute(ascii_set_item("test_ascii_mget2", "value"));
1547   execute(ascii_set_item("test_ascii_mget3", "value"));
1548   execute(ascii_set_item("test_ascii_mget4", "value"));
1549   execute(ascii_set_item("test_ascii_mget5", "value"));
1550
1551   execute(send_string("get test_ascii_mget1 test_ascii_mget2 test_ascii_mget3 "
1552                       "test_ascii_mget4 test_ascii_mget5 "
1553                       "test_ascii_mget6\r\n"));
1554   execute(ascii_get_value("test_ascii_mget1", "value"));
1555   execute(ascii_get_value("test_ascii_mget2", "value"));
1556   execute(ascii_get_value("test_ascii_mget3", "value"));
1557   execute(ascii_get_value("test_ascii_mget4", "value"));
1558   execute(ascii_get_value("test_ascii_mget5", "value"));
1559
1560   char buffer[5];
1561   execute(retry_read(buffer, 5));
1562   verify(memcmp(buffer, "END\r\n", 5) == 0);
1563  return TEST_PASS;
1564 }
1565
1566 static enum test_return test_ascii_incr_impl(const char* key, bool noreply)
1567 {
1568   char cmd[300];
1569   sprintf(cmd, "incr %s 1%s\r\n", key, noreply ? " noreply" : "");
1570
1571   execute(ascii_set_item(key, "0"));
1572   for (int x= 1; x < 11; ++x)
1573   {
1574     execute(send_string(cmd));
1575
1576     if (noreply)
1577       execute(test_ascii_version());
1578     else
1579     {
1580       char buffer[80];
1581       execute(receive_line(buffer, sizeof(buffer)));
1582       int val= atoi(buffer);
1583       verify(val == x);
1584     }
1585   }
1586
1587   execute(ascii_get_item(key, "10", true));
1588
1589   return TEST_PASS;
1590 }
1591
1592 static enum test_return test_ascii_incr(void)
1593 {
1594   return test_ascii_incr_impl("test_ascii_incr", false);
1595 }
1596
1597 static enum test_return test_ascii_incr_noreply(void)
1598 {
1599   return test_ascii_incr_impl("test_ascii_incr_noreply", true);
1600 }
1601
1602 static enum test_return test_ascii_decr_impl(const char* key, bool noreply)
1603 {
1604   char cmd[300];
1605   sprintf(cmd, "decr %s 1%s\r\n", key, noreply ? " noreply" : "");
1606
1607   execute(ascii_set_item(key, "9"));
1608   for (int x= 8; x > -1; --x)
1609   {
1610     execute(send_string(cmd));
1611
1612     if (noreply)
1613       execute(test_ascii_version());
1614     else
1615     {
1616       char buffer[80];
1617       execute(receive_line(buffer, sizeof(buffer)));
1618       int val= atoi(buffer);
1619       verify(val == x);
1620     }
1621   }
1622
1623   execute(ascii_get_item(key, "0", true));
1624
1625   /* verify that it doesn't wrap */
1626   execute(send_string(cmd));
1627   if (noreply)
1628     execute(test_ascii_version());
1629   else
1630   {
1631     char buffer[80];
1632     execute(receive_line(buffer, sizeof(buffer)));
1633   }
1634   execute(ascii_get_item(key, "0", true));
1635
1636   return TEST_PASS;
1637 }
1638
1639 static enum test_return test_ascii_decr(void)
1640 {
1641   return test_ascii_decr_impl("test_ascii_decr", false);
1642 }
1643
1644 static enum test_return test_ascii_decr_noreply(void)
1645 {
1646   return test_ascii_decr_impl("test_ascii_decr_noreply", true);
1647 }
1648
1649
1650 static enum test_return test_ascii_flush_impl(const char *key, bool noreply)
1651 {
1652 #if 0
1653   /* Verify that the flush_all command handles unknown options */
1654   /* Bug in the current memcached server! */
1655   execute(send_string("flush_all foo bar\r\n"));
1656   execute(receive_response("ERROR\r\n"));
1657 #endif
1658
1659   execute(ascii_set_item(key, key));
1660   execute(ascii_get_item(key, key, true));
1661
1662   if (noreply)
1663   {
1664     execute(send_string("flush_all noreply\r\n"));
1665     execute(test_ascii_version());
1666   }
1667   else
1668   {
1669     execute(send_string("flush_all\r\n"));
1670     execute(receive_response("OK\r\n"));
1671   }
1672
1673   execute(ascii_get_item(key, key, false));
1674
1675   return TEST_PASS;
1676 }
1677
1678 static enum test_return test_ascii_flush(void)
1679 {
1680   return test_ascii_flush_impl("test_ascii_flush", false);
1681 }
1682
1683 static enum test_return test_ascii_flush_noreply(void)
1684 {
1685   return test_ascii_flush_impl("test_ascii_flush_noreply", true);
1686 }
1687
1688 static enum test_return test_ascii_concat_impl(const char *key,
1689                                                bool append,
1690                                                bool noreply)
1691 {
1692   const char *value;
1693
1694   if (append)
1695     value="hello";
1696   else
1697     value=" world";
1698
1699   execute(ascii_set_item(key, value));
1700
1701   if (append)
1702     value=" world";
1703   else
1704     value="hello";
1705
1706   char cmd[400];
1707   sprintf(cmd, "%s %s 0 0 %u%s\r\n%s\r\n",
1708           append ? "append" : "prepend",
1709           key, (unsigned int)strlen(value), noreply ? " noreply" : "",
1710           value);
1711   execute(send_string(cmd));
1712
1713   if (noreply)
1714     execute(test_ascii_version());
1715   else
1716     execute(receive_response("STORED\r\n"));
1717
1718   execute(ascii_get_item(key, "hello world", true));
1719
1720   sprintf(cmd, "%s %s_notfound 0 0 %u%s\r\n%s\r\n",
1721           append ? "append" : "prepend",
1722           key, (unsigned int)strlen(value), noreply ? " noreply" : "",
1723           value);
1724   execute(send_string(cmd));
1725
1726   if (noreply)
1727     execute(test_ascii_version());
1728   else
1729     execute(receive_response("NOT_STORED\r\n"));
1730
1731   return TEST_PASS;
1732 }
1733
1734 static enum test_return test_ascii_append(void)
1735 {
1736   return test_ascii_concat_impl("test_ascii_append", true, false);
1737 }
1738
1739 static enum test_return test_ascii_prepend(void)
1740 {
1741   return test_ascii_concat_impl("test_ascii_prepend", false, false);
1742 }
1743
1744 static enum test_return test_ascii_append_noreply(void)
1745 {
1746   return test_ascii_concat_impl("test_ascii_append_noreply", true, true);
1747 }
1748
1749 static enum test_return test_ascii_prepend_noreply(void)
1750 {
1751   return test_ascii_concat_impl("test_ascii_prepend_noreply", false, true);
1752 }
1753
1754 static enum test_return test_ascii_stat(void)
1755 {
1756   execute(send_string("stats noreply\r\n"));
1757   execute(receive_response("ERROR\r\n"));
1758   execute(send_string("stats\r\n"));
1759   char buffer[1024];
1760   do {
1761     execute(receive_line(buffer, sizeof(buffer)));
1762   } while (strcmp(buffer, "END\r\n") != 0);
1763
1764   return TEST_PASS_RECONNECT;
1765 }
1766
1767 typedef enum test_return(*TEST_FUNC)(void);
1768
1769 struct testcase
1770 {
1771   const char *description;
1772   TEST_FUNC function;
1773 };
1774
1775 struct testcase testcases[]= {
1776   { "ascii quit", test_ascii_quit },
1777   { "ascii version", test_ascii_version },
1778   { "ascii verbosity", test_ascii_verbosity },
1779   { "ascii set", test_ascii_set },
1780   { "ascii set noreply", test_ascii_set_noreply },
1781   { "ascii get", test_ascii_get },
1782   { "ascii gets", test_ascii_gets },
1783   { "ascii mget", test_ascii_mget },
1784   { "ascii flush", test_ascii_flush },
1785   { "ascii flush noreply", test_ascii_flush_noreply },
1786   { "ascii add", test_ascii_add },
1787   { "ascii add noreply", test_ascii_add_noreply },
1788   { "ascii replace", test_ascii_replace },
1789   { "ascii replace noreply", test_ascii_replace_noreply },
1790   { "ascii cas", test_ascii_cas },
1791   { "ascii cas noreply", test_ascii_cas_noreply },
1792   { "ascii delete", test_ascii_delete },
1793   { "ascii delete noreply", test_ascii_delete_noreply },
1794   { "ascii incr", test_ascii_incr },
1795   { "ascii incr noreply", test_ascii_incr_noreply },
1796   { "ascii decr", test_ascii_decr },
1797   { "ascii decr noreply", test_ascii_decr_noreply },
1798   { "ascii append", test_ascii_append },
1799   { "ascii append noreply", test_ascii_append_noreply },
1800   { "ascii prepend", test_ascii_prepend },
1801   { "ascii prepend noreply", test_ascii_prepend_noreply },
1802   { "ascii stat", test_ascii_stat },
1803   { "binary noop", test_binary_noop },
1804   { "binary quit", test_binary_quit },
1805   { "binary quitq", test_binary_quitq },
1806   { "binary set", test_binary_set },
1807   { "binary setq", test_binary_setq },
1808   { "binary flush", test_binary_flush },
1809   { "binary flushq", test_binary_flushq },
1810   { "binary add", test_binary_add },
1811   { "binary addq", test_binary_addq },
1812   { "binary replace", test_binary_replace },
1813   { "binary replaceq", test_binary_replaceq },
1814   { "binary delete", test_binary_delete },
1815   { "binary deleteq", test_binary_deleteq },
1816   { "binary get", test_binary_get },
1817   { "binary getq", test_binary_getq },
1818   { "binary getk", test_binary_getk },
1819   { "binary getkq", test_binary_getkq },
1820   { "binary incr", test_binary_incr },
1821   { "binary incrq", test_binary_incrq },
1822   { "binary decr", test_binary_decr },
1823   { "binary decrq", test_binary_decrq },
1824   { "binary version", test_binary_version },
1825   { "binary append", test_binary_append },
1826   { "binary appendq", test_binary_appendq },
1827   { "binary prepend", test_binary_prepend },
1828   { "binary prependq", test_binary_prependq },
1829   { "binary stat", test_binary_stat },
1830   { "binary illegal", test_binary_illegal },
1831   { NULL, NULL}
1832 };
1833
1834 int main(int argc, char **argv)
1835 {
1836   static const char * const status_msg[]= {"[skip]", "[pass]", "[pass]", "[FAIL]"};
1837   int total= 0;
1838   int failed= 0;
1839   const char *hostname= "localhost";
1840   const char *port= "11211";
1841   int cmd;
1842
1843   while ((cmd= getopt(argc, argv, "t:vch:p:?")) != EOF)
1844   {
1845     switch (cmd) {
1846     case 't':
1847       timeout= atoi(optarg);
1848       if (timeout == 0)
1849       {
1850         fprintf(stderr, "Invalid timeout. Please specify a number for -t\n");
1851         return 1;
1852       }
1853       break;
1854     case 'v': verbose= true;
1855       break;
1856     case 'c': do_core= true;
1857       break;
1858     case 'h': hostname= optarg;
1859       break;
1860     case 'p': port= optarg;
1861       break;
1862     default:
1863       fprintf(stderr, "Usage: %s [-h hostname] [-p port] [-c] [-v] [-t n]\n"
1864               "\t-c\tGenerate coredump if a test fails\n"
1865               "\t-v\tVerbose test output (print out the assertion)\n"
1866               "\t-t n\tSet the timeout for io-operations to n seconds\n",
1867               argv[0]);
1868       return 1;
1869     }
1870   }
1871
1872   sock= connect_server(hostname, port);
1873   if (sock == -1)
1874   {
1875     fprintf(stderr, "Failed to connect to <%s:%s>: %s\n",
1876             hostname, port, strerror(errno));
1877     return 1;
1878   }
1879
1880   for (int ii= 0; testcases[ii].description != NULL; ++ii)
1881   {
1882     ++total;
1883     fprintf(stdout, "%-40s", testcases[ii].description);
1884     fflush(stdout);
1885
1886     bool reconnect= false;
1887     enum test_return ret= testcases[ii].function();
1888     if (ret == TEST_FAIL)
1889     {
1890       reconnect= true;
1891       ++failed;
1892       if (verbose)
1893         fprintf(stderr, "\n");
1894     }
1895     else if (ret == TEST_PASS_RECONNECT)
1896       reconnect= true;
1897
1898     fprintf(stderr, "%s\n", status_msg[ret]);
1899     if (reconnect)
1900     {
1901       (void) close(sock);
1902       if ((sock=connect_server(hostname, port)) == -1)
1903       {
1904         fprintf(stderr, "Failed to connect to <%s:%s>: %s\n",
1905                 hostname, port, strerror(errno));
1906         fprintf(stderr, "%d of %d tests failed\n", failed, total);
1907         return 1;
1908       }
1909     }
1910   }
1911
1912   (void) close(sock);
1913   if (failed == 0)
1914     fprintf(stdout, "All tests passed\n");
1915   else
1916     fprintf(stderr, "%d of %d tests failed\n", failed, total);
1917
1918   return (failed == 0) ? 0 : 1;
1919 }