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