1 /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
5 * Copyright (C) 2011 Data Differential, http://datadifferential.com/
6 * Copyright (C) 2006-2009 Brian Aker All rights reserved.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are
12 * * Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
15 * * Redistributions in binary form must reproduce the above
16 * copyright notice, this list of conditions and the following disclaimer
17 * in the documentation and/or other materials provided with the
20 * * The names of its contributors may not be used to endorse or
21 * promote products derived from this software without specific prior
24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
25 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
26 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
27 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
28 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
29 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
30 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
31 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
32 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
34 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38 #include <libmemcached/common.h>
39 #include <libmemcached/string.hpp>
41 static memcached_return_t
textual_value_fetch(memcached_server_write_instance_st ptr
,
43 memcached_result_st
*result
)
46 ssize_t read_length
= 0;
49 if (ptr
->root
->flags
.use_udp
)
51 return memcached_set_error(*ptr
, MEMCACHED_NOT_SUPPORTED
, MEMCACHED_AT
);
54 WATCHPOINT_ASSERT(ptr
->root
);
55 char *end_ptr
= buffer
+ MEMCACHED_DEFAULT_COMMAND_SIZE
;
57 memcached_result_reset(result
);
59 char *string_ptr
= buffer
;
60 string_ptr
+= 6; /* "VALUE " */
68 key
= result
->item_key
;
69 result
->key_length
= 0;
71 for (prefix_length
= memcached_array_size(ptr
->root
->_namespace
); !(iscntrl(*string_ptr
) || isspace(*string_ptr
)) ; string_ptr
++)
73 if (prefix_length
== 0)
82 result
->item_key
[result
->key_length
]= 0;
85 if (end_ptr
== string_ptr
)
90 /* Flags fetch move past space */
92 if (end_ptr
== string_ptr
)
97 for (next_ptr
= string_ptr
; isdigit(*string_ptr
); string_ptr
++) {};
98 result
->item_flags
= (uint32_t) strtoul(next_ptr
, &string_ptr
, 10);
100 if (end_ptr
== string_ptr
)
105 /* Length fetch move past space*/
107 if (end_ptr
== string_ptr
)
112 for (next_ptr
= string_ptr
; isdigit(*string_ptr
); string_ptr
++) {};
113 value_length
= (size_t)strtoull(next_ptr
, &string_ptr
, 10);
115 if (end_ptr
== string_ptr
)
121 if (*string_ptr
== '\r')
123 /* Skip past the \r\n */
129 for (next_ptr
= string_ptr
; isdigit(*string_ptr
); string_ptr
++) {};
130 result
->item_cas
= strtoull(next_ptr
, &string_ptr
, 10);
133 if (end_ptr
< string_ptr
)
138 /* We add two bytes so that we can walk the \r\n */
139 if (memcached_failed(memcached_string_check(&result
->value
, value_length
+2)))
141 return memcached_set_error(*ptr
, MEMCACHED_MEMORY_ALLOCATION_FAILURE
, MEMCACHED_AT
);
145 char *value_ptr
= memcached_string_value_mutable(&result
->value
);
147 We read the \r\n into the string since not doing so is more
148 cycles then the waster of memory to do so.
150 We are null terminating through, which will most likely make
151 some people lazy about using the return length.
153 size_t to_read
= (value_length
) + 2;
154 memcached_return_t rrc
= memcached_io_read(ptr
, value_ptr
, to_read
, &read_length
);
155 if (memcached_failed(rrc
) and rrc
== MEMCACHED_IN_PROGRESS
)
157 memcached_quit_server(ptr
, true);
158 return memcached_set_error(*ptr
, MEMCACHED_IN_PROGRESS
, MEMCACHED_AT
);
160 else if (memcached_failed(rrc
))
166 if (read_length
!= (ssize_t
)(value_length
+ 2))
171 /* This next bit blows the API, but this is internal....*/
174 char_ptr
= memcached_string_value_mutable(&result
->value
);;
175 char_ptr
[value_length
]= 0;
176 char_ptr
[value_length
+1]= 0;
177 memcached_string_set_length(&result
->value
, value_length
);
180 return MEMCACHED_SUCCESS
;
183 memcached_io_reset(ptr
);
185 return MEMCACHED_PARTIAL_READ
;
188 static memcached_return_t
textual_read_one_response(memcached_server_write_instance_st ptr
,
189 char *buffer
, size_t buffer_length
,
190 memcached_result_st
*result
,
191 uint64_t& numeric_value
)
193 numeric_value
= UINT64_MAX
;
195 memcached_return_t rc
= memcached_io_readline(ptr
, buffer
, buffer_length
, total_read
);
197 if (memcached_failed(rc
))
204 case 'V': /* VALUE || VERSION */
205 if (buffer
[1] == 'A' and buffer
[2] == 'L' and buffer
[3] == 'U' and buffer
[4] == 'E') /* VALUE */
207 /* We add back in one because we will need to search for END */
208 memcached_server_response_increment(ptr
);
209 return textual_value_fetch(ptr
, buffer
, result
);
211 else if (buffer
[1] == 'E' and buffer
[2] == 'R' and buffer
[3] == 'S' and buffer
[4] == 'I' and buffer
[5] == 'O' and buffer
[6] == 'N') /* VERSION */
213 return MEMCACHED_SUCCESS
;
218 if (buffer
[1] == 'K')
220 return MEMCACHED_SUCCESS
;
224 case 'S': /* STORED STATS SERVER_ERROR */
226 if (buffer
[1] == 'T' and buffer
[2] == 'A' and buffer
[3] == 'T') /* STORED STATS */
228 memcached_server_response_increment(ptr
);
229 return MEMCACHED_STAT
;
231 else if (buffer
[1] == 'E' and buffer
[2] == 'R' and buffer
[3] == 'V' and buffer
[4] == 'E' and buffer
[5] == 'R'
233 and buffer
[7] == 'E' and buffer
[8] == 'R' and buffer
[9] == 'R' and buffer
[10] == 'O' and buffer
[11] == 'R' ) /* SERVER_ERROR */
235 if (total_read
== memcached_literal_param_size("SERVER_ERROR"))
237 return MEMCACHED_SERVER_ERROR
;
240 if (total_read
> memcached_literal_param_size("SERVER_ERROR object too large for cache") and
241 (memcmp(buffer
, memcached_literal_param("SERVER_ERROR object too large for cache")) == 0))
243 return MEMCACHED_E2BIG
;
246 // Move past the basic error message and whitespace
247 char *startptr
= buffer
+ memcached_literal_param_size("SERVER_ERROR");
248 if (startptr
[0] == ' ')
253 char *endptr
= startptr
;
254 while (*endptr
!= '\r' && *endptr
!= '\n') endptr
++;
256 return memcached_set_error(*ptr
, MEMCACHED_SERVER_ERROR
, MEMCACHED_AT
, startptr
, size_t(endptr
- startptr
));
258 else if (buffer
[1] == 'T' and buffer
[2] == 'O' and buffer
[3] == 'R' and buffer
[4] == 'E' and buffer
[5] == 'D')
260 return MEMCACHED_STORED
;
265 case 'D': /* DELETED */
266 if (buffer
[1] == 'E' and buffer
[2] == 'L' and buffer
[3] == 'E' and buffer
[4] == 'T' and buffer
[5] == 'E' and buffer
[6] == 'D')
268 return MEMCACHED_DELETED
;
272 case 'N': /* NOT_FOUND */
274 if (buffer
[1] == 'O' and buffer
[2] == 'T'
276 and buffer
[4] == 'F' and buffer
[5] == 'O' and buffer
[6] == 'U' and buffer
[7] == 'N' and buffer
[8] == 'D')
278 return MEMCACHED_NOTFOUND
;
280 else if (buffer
[1] == 'O' and buffer
[2] == 'T'
282 and buffer
[4] == 'S' and buffer
[5] == 'T' and buffer
[6] == 'O' and buffer
[7] == 'R' and buffer
[8] == 'E' and buffer
[9] == 'D')
284 return MEMCACHED_NOTSTORED
;
289 case 'E': /* PROTOCOL ERROR or END */
291 if (buffer
[1] == 'N' and buffer
[2] == 'D')
293 return MEMCACHED_END
;
295 else if (buffer
[1] == 'R' and buffer
[2] == 'O' and buffer
[3] == 'T' and buffer
[4] == 'O' and buffer
[5] == 'C' and buffer
[6] == 'O' and buffer
[7] == 'L'
297 and buffer
[9] == 'E' and buffer
[10] == 'R' and buffer
[11] == 'R' and buffer
[12] == 'O' and buffer
[13] == 'R')
299 return MEMCACHED_PROTOCOL_ERROR
;
301 else if (buffer
[1] == 'X' and buffer
[2] == 'I' and buffer
[3] == 'S' and buffer
[4] == 'T' and buffer
[5] == 'S')
303 return MEMCACHED_DATA_EXISTS
;
308 case 'T': /* TOUCHED */
310 if (buffer
[1] == 'O' and buffer
[2] == 'U' and buffer
[3] == 'C' and buffer
[4] == 'H' and buffer
[5] == 'E' and buffer
[6] == 'D')
312 return MEMCACHED_SUCCESS
;
318 if (buffer
[1] == 'T' and buffer
[2] == 'E' and buffer
[3] == 'M')
320 /* We add back in one because we will need to search for END */
321 memcached_server_response_increment(ptr
);
322 return MEMCACHED_ITEM
;
326 case 'C': /* CLIENT ERROR */
327 if (buffer
[1] == 'L' and buffer
[2] == 'I' and buffer
[3] == 'E' and buffer
[4] == 'N' and buffer
[5] == 'T')
329 return MEMCACHED_CLIENT_ERROR
;
333 case '0': /* INCR/DECR response */
334 case '1': /* INCR/DECR response */
335 case '2': /* INCR/DECR response */
336 case '3': /* INCR/DECR response */
337 case '4': /* INCR/DECR response */
338 case '5': /* INCR/DECR response */
339 case '6': /* INCR/DECR response */
340 case '7': /* INCR/DECR response */
341 case '8': /* INCR/DECR response */
342 case '9': /* INCR/DECR response */
344 unsigned long long int auto_return_value
= strtoull(buffer
, (char **)NULL
, 10);
346 if (auto_return_value
== ULLONG_MAX
and errno
== ERANGE
)
348 return MEMCACHED_UNKNOWN_READ_FAILURE
;
350 else if (errno
== EINVAL
)
352 return MEMCACHED_UNKNOWN_READ_FAILURE
;
355 numeric_value
= uint64_t(auto_return_value
);
357 WATCHPOINT_STRING(buffer
);
358 return MEMCACHED_SUCCESS
;
365 return MEMCACHED_UNKNOWN_READ_FAILURE
;
368 static memcached_return_t
binary_read_one_response(memcached_server_write_instance_st ptr
,
369 char *buffer
, size_t buffer_length
,
370 memcached_result_st
*result
)
372 memcached_return_t rc
;
373 protocol_binary_response_header header
;
375 if ((rc
= memcached_safe_read(ptr
, &header
.bytes
, sizeof(header
.bytes
))) != MEMCACHED_SUCCESS
)
377 WATCHPOINT_ERROR(rc
);
381 if (header
.response
.magic
!= PROTOCOL_BINARY_RES
)
383 return MEMCACHED_PROTOCOL_ERROR
;
387 ** Convert the header to host local endian!
389 header
.response
.keylen
= ntohs(header
.response
.keylen
);
390 header
.response
.status
= ntohs(header
.response
.status
);
391 header
.response
.bodylen
= ntohl(header
.response
.bodylen
);
392 header
.response
.cas
= memcached_ntohll(header
.response
.cas
);
393 uint32_t bodylen
= header
.response
.bodylen
;
395 if (header
.response
.status
== PROTOCOL_BINARY_RESPONSE_SUCCESS
or
396 header
.response
.status
== PROTOCOL_BINARY_RESPONSE_AUTH_CONTINUE
)
398 switch (header
.response
.opcode
)
400 case PROTOCOL_BINARY_CMD_GETKQ
:
402 * We didn't increment the response counter for the GETKQ packet
403 * (only the final NOOP), so we need to increment the counter again.
405 memcached_server_response_increment(ptr
);
407 case PROTOCOL_BINARY_CMD_GETK
:
409 uint16_t keylen
= header
.response
.keylen
;
410 memcached_result_reset(result
);
411 result
->item_cas
= header
.response
.cas
;
413 if ((rc
= memcached_safe_read(ptr
, &result
->item_flags
, sizeof (result
->item_flags
))) != MEMCACHED_SUCCESS
)
415 WATCHPOINT_ERROR(rc
);
416 return MEMCACHED_UNKNOWN_READ_FAILURE
;
419 result
->item_flags
= ntohl(result
->item_flags
);
420 bodylen
-= header
.response
.extlen
;
422 result
->key_length
= keylen
;
423 if (memcached_failed(rc
= memcached_safe_read(ptr
, result
->item_key
, keylen
)))
425 WATCHPOINT_ERROR(rc
);
426 return MEMCACHED_UNKNOWN_READ_FAILURE
;
429 // Only bother with doing this if key_length > 0
430 if (result
->key_length
)
432 if (memcached_array_size(ptr
->root
->_namespace
) and memcached_array_size(ptr
->root
->_namespace
) >= result
->key_length
)
434 return memcached_set_error(*ptr
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
);
437 if (memcached_array_size(ptr
->root
->_namespace
))
439 result
->key_length
-= memcached_array_size(ptr
->root
->_namespace
);
440 memmove(result
->item_key
, result
->item_key
+memcached_array_size(ptr
->root
->_namespace
), result
->key_length
);
445 if (memcached_failed(memcached_string_check(&result
->value
, bodylen
)))
447 return MEMCACHED_MEMORY_ALLOCATION_FAILURE
;
450 char *vptr
= memcached_string_value_mutable(&result
->value
);
451 if (memcached_failed(rc
= memcached_safe_read(ptr
, vptr
, bodylen
)))
453 WATCHPOINT_ERROR(rc
);
454 return MEMCACHED_UNKNOWN_READ_FAILURE
;
457 memcached_string_set_length(&result
->value
, bodylen
);
461 case PROTOCOL_BINARY_CMD_INCREMENT
:
462 case PROTOCOL_BINARY_CMD_DECREMENT
:
464 if (bodylen
!= sizeof(uint64_t) or buffer_length
!= sizeof(uint64_t))
466 return MEMCACHED_PROTOCOL_ERROR
;
469 WATCHPOINT_ASSERT(bodylen
== buffer_length
);
471 if ((rc
= memcached_safe_read(ptr
, &val
, sizeof(val
))) != MEMCACHED_SUCCESS
)
473 WATCHPOINT_ERROR(rc
);
474 return MEMCACHED_UNKNOWN_READ_FAILURE
;
477 val
= memcached_ntohll(val
);
478 memcpy(buffer
, &val
, sizeof(val
));
482 case PROTOCOL_BINARY_CMD_SASL_LIST_MECHS
:
483 case PROTOCOL_BINARY_CMD_VERSION
:
485 memset(buffer
, 0, buffer_length
);
486 if (bodylen
>= buffer_length
)
488 /* not enough space in buffer.. should not happen... */
489 return MEMCACHED_UNKNOWN_READ_FAILURE
;
491 else if ((rc
= memcached_safe_read(ptr
, buffer
, bodylen
)) != MEMCACHED_SUCCESS
)
493 WATCHPOINT_ERROR(rc
);
494 return MEMCACHED_UNKNOWN_READ_FAILURE
;
498 case PROTOCOL_BINARY_CMD_FLUSH
:
499 case PROTOCOL_BINARY_CMD_QUIT
:
500 case PROTOCOL_BINARY_CMD_SET
:
501 case PROTOCOL_BINARY_CMD_ADD
:
502 case PROTOCOL_BINARY_CMD_REPLACE
:
503 case PROTOCOL_BINARY_CMD_APPEND
:
504 case PROTOCOL_BINARY_CMD_PREPEND
:
505 case PROTOCOL_BINARY_CMD_DELETE
:
506 case PROTOCOL_BINARY_CMD_TOUCH
:
508 WATCHPOINT_ASSERT(bodylen
== 0);
509 return MEMCACHED_SUCCESS
;
512 case PROTOCOL_BINARY_CMD_NOOP
:
514 WATCHPOINT_ASSERT(bodylen
== 0);
515 return MEMCACHED_END
;
518 case PROTOCOL_BINARY_CMD_STAT
:
522 return MEMCACHED_END
;
524 else if (bodylen
+ 1 > buffer_length
)
526 /* not enough space in buffer.. should not happen... */
527 return MEMCACHED_UNKNOWN_READ_FAILURE
;
531 size_t keylen
= header
.response
.keylen
;
532 memset(buffer
, 0, buffer_length
);
533 if ((rc
= memcached_safe_read(ptr
, buffer
, keylen
)) != MEMCACHED_SUCCESS
||
534 (rc
= memcached_safe_read(ptr
, buffer
+ keylen
+ 1, bodylen
- keylen
)) != MEMCACHED_SUCCESS
)
536 WATCHPOINT_ERROR(rc
);
537 return MEMCACHED_UNKNOWN_READ_FAILURE
;
543 case PROTOCOL_BINARY_CMD_SASL_AUTH
:
544 case PROTOCOL_BINARY_CMD_SASL_STEP
:
546 memcached_result_reset(result
);
547 result
->item_cas
= header
.response
.cas
;
549 if (memcached_string_check(&result
->value
,
550 bodylen
) != MEMCACHED_SUCCESS
)
551 return MEMCACHED_MEMORY_ALLOCATION_FAILURE
;
553 char *vptr
= memcached_string_value_mutable(&result
->value
);
554 if ((rc
= memcached_safe_read(ptr
, vptr
, bodylen
)) != MEMCACHED_SUCCESS
)
556 WATCHPOINT_ERROR(rc
);
557 return MEMCACHED_UNKNOWN_READ_FAILURE
;
560 memcached_string_set_length(&result
->value
, bodylen
);
565 /* Command not implemented yet! */
566 WATCHPOINT_ASSERT(0);
567 return MEMCACHED_PROTOCOL_ERROR
;
571 else if (header
.response
.bodylen
)
573 /* What should I do with the error message??? just discard it for now */
574 char hole
[SMALL_STRING_LEN
];
577 size_t nr
= (bodylen
> SMALL_STRING_LEN
) ? SMALL_STRING_LEN
: bodylen
;
578 if ((rc
= memcached_safe_read(ptr
, hole
, nr
)) != MEMCACHED_SUCCESS
)
580 WATCHPOINT_ERROR(rc
);
581 return memcached_set_error(*ptr
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
);
583 bodylen
-= (uint32_t) nr
;
586 /* This might be an error from one of the quiet commands.. if
587 * so, just throw it away and get the next one. What about creating
588 * a callback to the user with the error information?
590 switch (header
.response
.opcode
)
592 case PROTOCOL_BINARY_CMD_SETQ
:
593 case PROTOCOL_BINARY_CMD_ADDQ
:
594 case PROTOCOL_BINARY_CMD_REPLACEQ
:
595 case PROTOCOL_BINARY_CMD_APPENDQ
:
596 case PROTOCOL_BINARY_CMD_PREPENDQ
:
597 return binary_read_one_response(ptr
, buffer
, buffer_length
, result
);
604 rc
= MEMCACHED_SUCCESS
;
605 if (header
.response
.status
!= 0)
607 switch (header
.response
.status
)
609 case PROTOCOL_BINARY_RESPONSE_KEY_ENOENT
:
610 rc
= MEMCACHED_NOTFOUND
;
613 case PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS
:
614 rc
= MEMCACHED_DATA_EXISTS
;
617 case PROTOCOL_BINARY_RESPONSE_NOT_STORED
:
618 rc
= MEMCACHED_NOTSTORED
;
621 case PROTOCOL_BINARY_RESPONSE_E2BIG
:
625 case PROTOCOL_BINARY_RESPONSE_ENOMEM
:
626 rc
= MEMCACHED_MEMORY_ALLOCATION_FAILURE
;
629 case PROTOCOL_BINARY_RESPONSE_AUTH_CONTINUE
:
630 rc
= MEMCACHED_AUTH_CONTINUE
;
633 case PROTOCOL_BINARY_RESPONSE_AUTH_ERROR
:
634 rc
= MEMCACHED_AUTH_FAILURE
;
637 case PROTOCOL_BINARY_RESPONSE_EINVAL
:
638 case PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND
:
640 /* @todo fix the error mappings */
641 rc
= MEMCACHED_PROTOCOL_ERROR
;
649 memcached_return_t
memcached_read_one_response(memcached_server_write_instance_st ptr
,
650 char *buffer
, size_t buffer_length
,
651 memcached_result_st
*result
)
653 uint64_t numeric_value
;
655 return memcached_read_one_response(ptr
, buffer
, buffer_length
, result
, numeric_value
);
658 memcached_return_t
memcached_read_one_response(memcached_server_write_instance_st ptr
,
659 char *buffer
, size_t buffer_length
,
660 memcached_result_st
*result
,
661 uint64_t& numeric_value
)
663 memcached_server_response_decrement(ptr
);
667 memcached_st
*root
= (memcached_st
*)ptr
->root
;
668 result
= &root
->result
;
671 memcached_return_t rc
;
672 if (ptr
->root
->flags
.binary_protocol
)
674 rc
= binary_read_one_response(ptr
, buffer
, buffer_length
, result
);
678 rc
= textual_read_one_response(ptr
, buffer
, buffer_length
, result
, numeric_value
);
681 if (rc
== MEMCACHED_UNKNOWN_READ_FAILURE
or
682 rc
== MEMCACHED_READ_FAILURE
or
683 rc
== MEMCACHED_PROTOCOL_ERROR
or
684 rc
== MEMCACHED_CLIENT_ERROR
or
685 rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
)
687 memcached_io_reset(ptr
);
693 memcached_return_t
memcached_response(memcached_server_write_instance_st ptr
,
694 char *buffer
, size_t buffer_length
,
695 memcached_result_st
*result
)
697 uint64_t numeric_value
;
699 return memcached_response(ptr
, buffer
, buffer_length
, result
, numeric_value
);
702 memcached_return_t
memcached_response(memcached_server_write_instance_st ptr
,
703 char *buffer
, size_t buffer_length
,
704 memcached_result_st
*result
,
705 uint64_t& numeric_value
)
707 /* We may have old commands in the buffer not set, first purge */
708 if ((ptr
->root
->flags
.no_block
) && (memcached_is_processing_input(ptr
->root
) == false))
710 (void)memcached_io_write(ptr
);
714 * The previous implementation purged all pending requests and just
715 * returned the last one. Purge all pending messages to ensure backwards
718 if (ptr
->root
->flags
.binary_protocol
== false)
720 while (memcached_server_response_count(ptr
) > 1)
722 memcached_return_t rc
= memcached_read_one_response(ptr
, buffer
, buffer_length
, result
, numeric_value
);
724 if (rc
!= MEMCACHED_END
&&
725 rc
!= MEMCACHED_STORED
&&
726 rc
!= MEMCACHED_SUCCESS
&&
727 rc
!= MEMCACHED_STAT
&&
728 rc
!= MEMCACHED_DELETED
&&
729 rc
!= MEMCACHED_NOTFOUND
&&
730 rc
!= MEMCACHED_NOTSTORED
&&
731 rc
!= MEMCACHED_DATA_EXISTS
)
738 return memcached_read_one_response(ptr
, buffer
, buffer_length
, result
, numeric_value
);