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

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