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