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(org::libmemcached::Instance
* instance
,
43 memcached_result_st
*result
)
46 ssize_t read_length
= 0;
49 WATCHPOINT_ASSERT(instance
->root
);
50 char *end_ptr
= buffer
+ MEMCACHED_DEFAULT_COMMAND_SIZE
;
52 memcached_result_reset(result
);
54 char *string_ptr
= buffer
;
55 string_ptr
+= 6; /* "VALUE " */
58 // Just used for cases of AES decrypt currently
59 memcached_return_t rc
= MEMCACHED_SUCCESS
;
63 char *key
= result
->item_key
;
64 result
->key_length
= 0;
66 for (ptrdiff_t prefix_length
= memcached_array_size(instance
->root
->_namespace
); !(iscntrl(*string_ptr
) || isspace(*string_ptr
)) ; string_ptr
++)
68 if (prefix_length
== 0)
77 result
->item_key
[result
->key_length
]= 0;
80 if (end_ptr
== string_ptr
)
85 /* Flags fetch move past space */
87 if (end_ptr
== string_ptr
)
92 for (next_ptr
= string_ptr
; isdigit(*string_ptr
); string_ptr
++) {};
93 result
->item_flags
= (uint32_t) strtoul(next_ptr
, &string_ptr
, 10);
95 if (end_ptr
== string_ptr
)
100 /* Length fetch move past space*/
102 if (end_ptr
== string_ptr
)
107 for (next_ptr
= string_ptr
; isdigit(*string_ptr
); string_ptr
++) {};
108 value_length
= (size_t)strtoull(next_ptr
, &string_ptr
, 10);
110 if (end_ptr
== string_ptr
)
116 if (*string_ptr
== '\r')
118 /* Skip past the \r\n */
124 for (next_ptr
= string_ptr
; isdigit(*string_ptr
); string_ptr
++) {};
125 result
->item_cas
= strtoull(next_ptr
, &string_ptr
, 10);
128 if (end_ptr
< string_ptr
)
133 /* We add two bytes so that we can walk the \r\n */
134 if (memcached_failed(memcached_string_check(&result
->value
, value_length
+2)))
136 return memcached_set_error(*instance
, MEMCACHED_MEMORY_ALLOCATION_FAILURE
, MEMCACHED_AT
);
140 char *value_ptr
= memcached_string_value_mutable(&result
->value
);
142 We read the \r\n into the string since not doing so is more
143 cycles then the waster of memory to do so.
145 We are null terminating through, which will most likely make
146 some people lazy about using the return length.
148 size_t to_read
= (value_length
) + 2;
149 memcached_return_t rrc
= memcached_io_read(instance
, value_ptr
, to_read
, read_length
);
150 if (memcached_failed(rrc
) and rrc
== MEMCACHED_IN_PROGRESS
)
152 memcached_quit_server(instance
, true);
153 return memcached_set_error(*instance
, MEMCACHED_IN_PROGRESS
, MEMCACHED_AT
);
155 else if (memcached_failed(rrc
))
161 if (read_length
!= (ssize_t
)(value_length
+ 2))
166 /* This next bit blows the API, but this is internal....*/
169 char_ptr
= memcached_string_value_mutable(&result
->value
);;
170 char_ptr
[value_length
]= 0;
171 char_ptr
[value_length
+1]= 0;
172 memcached_string_set_length(&result
->value
, value_length
);
175 if (memcached_is_encrypted(instance
->root
) and memcached_result_length(result
))
177 hashkit_string_st
*destination
;
179 if ((destination
= hashkit_decrypt(&instance
->root
->hashkit
,
180 memcached_result_value(result
), memcached_result_length(result
))) == NULL
)
182 rc
= memcached_set_error(*instance
->root
, MEMCACHED_FAILURE
,
183 MEMCACHED_AT
, memcached_literal_param("hashkit_decrypt() failed"));
187 memcached_result_reset_value(result
);
188 if (memcached_failed(memcached_result_set_value(result
, hashkit_string_c_str(destination
), hashkit_string_length(destination
))))
190 rc
= memcached_set_error(*instance
->root
, MEMCACHED_FAILURE
,
191 MEMCACHED_AT
, memcached_literal_param("hashkit_decrypt() failed"));
195 if (memcached_failed(rc
))
197 memcached_result_reset(result
);
199 hashkit_string_free(destination
);
205 memcached_io_reset(instance
);
207 return MEMCACHED_PARTIAL_READ
;
210 static memcached_return_t
textual_read_one_response(org::libmemcached::Instance
* instance
,
211 char *buffer
, const size_t buffer_length
,
212 memcached_result_st
*result
)
215 memcached_return_t rc
= memcached_io_readline(instance
, buffer
, buffer_length
, total_read
);
217 if (memcached_failed(rc
))
228 if (buffer
[1] == 'A' and buffer
[2] == 'L' and buffer
[3] == 'U' and buffer
[4] == 'E') /* VALUE */
230 /* We add back in one because we will need to search for END */
231 memcached_server_response_increment(instance
);
232 return textual_value_fetch(instance
, buffer
, result
);
235 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 */
237 /* Find the space, and then move one past it to copy version */
238 char *response_ptr
= index(buffer
, ' ');
241 long int version
= strtol(response_ptr
, &endptr
, 10);
242 if (version
== LONG_MIN
or version
== LONG_MAX
or errno
== EINVAL
or version
> UINT8_MAX
or version
== 0)
244 instance
->major_version
= instance
->minor_version
= instance
->micro_version
= UINT8_MAX
;
245 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
, memcached_literal_param("strtol() failed to parse major version"));
247 instance
->major_version
= uint8_t(version
);
250 version
= strtol(endptr
, &endptr
, 10);
251 if (version
== LONG_MIN
or version
== LONG_MAX
or errno
== EINVAL
or version
> UINT8_MAX
)
253 instance
->major_version
= instance
->minor_version
= instance
->micro_version
= UINT8_MAX
;
254 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
, memcached_literal_param("strtol() failed to parse minor version"));
256 instance
->minor_version
= uint8_t(version
);
259 version
= strtol(endptr
, &endptr
, 10);
260 if (version
== LONG_MIN
or version
== LONG_MAX
or errno
== EINVAL
or version
> UINT8_MAX
)
262 instance
->major_version
= instance
->minor_version
= instance
->micro_version
= UINT8_MAX
;
263 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
, memcached_literal_param("strtol() failed to parse micro version"));
265 instance
->micro_version
= uint8_t(version
);
267 return MEMCACHED_SUCCESS
;
275 if (buffer
[1] == 'K')
277 return MEMCACHED_SUCCESS
;
285 if (buffer
[1] == 'T' and buffer
[2] == 'A' and buffer
[3] == 'T') /* STORED STATS */
287 memcached_server_response_increment(instance
);
288 return MEMCACHED_STAT
;
291 else if (buffer
[1] == 'E' and buffer
[2] == 'R' and buffer
[3] == 'V' and buffer
[4] == 'E' and buffer
[5] == 'R'
293 and buffer
[7] == 'E' and buffer
[8] == 'R' and buffer
[9] == 'R' and buffer
[10] == 'O' and buffer
[11] == 'R' )
295 if (total_read
== memcached_literal_param_size("SERVER_ERROR"))
297 return MEMCACHED_SERVER_ERROR
;
300 if (total_read
>= memcached_literal_param_size("SERVER_ERROR object too large for cache") and
301 (memcmp(buffer
, memcached_literal_param("SERVER_ERROR object too large for cache")) == 0))
303 return MEMCACHED_E2BIG
;
306 if (total_read
>= memcached_literal_param_size("SERVER_ERROR out of memory storing object") and
307 (memcmp(buffer
, memcached_literal_param("SERVER_ERROR out of memory storing object")) == 0))
309 return MEMCACHED_SERVER_MEMORY_ALLOCATION_FAILURE
;
312 // Move past the basic error message and whitespace
313 char *startptr
= buffer
+ memcached_literal_param_size("SERVER_ERROR");
314 if (startptr
[0] == ' ')
319 char *endptr
= startptr
;
320 while (*endptr
!= '\r' && *endptr
!= '\n') endptr
++;
322 return memcached_set_error(*instance
, MEMCACHED_SERVER_ERROR
, MEMCACHED_AT
, startptr
, size_t(endptr
- startptr
));
325 else if (buffer
[1] == 'T' and buffer
[2] == 'O' and buffer
[3] == 'R') // and buffer[4] == 'E' and buffer[5] == 'D')
327 return MEMCACHED_STORED
;
335 if (buffer
[1] == 'E' and buffer
[2] == 'L' and buffer
[3] == 'E' and buffer
[4] == 'T' and buffer
[5] == 'E' and buffer
[6] == 'D')
337 return MEMCACHED_DELETED
;
345 if (buffer
[1] == 'O' and buffer
[2] == 'T'
347 and buffer
[4] == 'F' and buffer
[5] == 'O' and buffer
[6] == 'U' and buffer
[7] == 'N' and buffer
[8] == 'D')
349 return MEMCACHED_NOTFOUND
;
352 else if (buffer
[1] == 'O' and buffer
[2] == 'T'
354 and buffer
[4] == 'S' and buffer
[5] == 'T' and buffer
[6] == 'O' and buffer
[7] == 'R' and buffer
[8] == 'E' and buffer
[9] == 'D')
356 return MEMCACHED_NOTSTORED
;
361 case 'E': /* PROTOCOL ERROR or END */
364 if (buffer
[1] == 'N' and buffer
[2] == 'D')
366 return MEMCACHED_END
;
370 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'
372 and buffer
[9] == 'E' and buffer
[10] == 'R' and buffer
[11] == 'R' and buffer
[12] == 'O' and buffer
[13] == 'R')
374 return MEMCACHED_PROTOCOL_ERROR
;
378 else if (buffer
[1] == 'R' and buffer
[2] == 'R' and buffer
[3] == 'O' and buffer
[4] == 'R')
380 return MEMCACHED_ERROR
;
383 else if (buffer
[1] == 'X' and buffer
[2] == 'I' and buffer
[3] == 'S' and buffer
[4] == 'T' and buffer
[5] == 'S')
385 return MEMCACHED_DATA_EXISTS
;
390 case 'T': /* TOUCHED */
393 if (buffer
[1] == 'O' and buffer
[2] == 'U' and buffer
[3] == 'C' and buffer
[4] == 'H' and buffer
[5] == 'E' and buffer
[6] == 'D')
395 return MEMCACHED_SUCCESS
;
403 if (buffer
[1] == 'T' and buffer
[2] == 'E' and buffer
[3] == 'M')
405 /* We add back in one because we will need to search for END */
406 memcached_server_response_increment(instance
);
407 return MEMCACHED_ITEM
;
412 case 'C': /* CLIENT ERROR */
415 if (buffer
[1] == 'L' and buffer
[2] == 'I' and buffer
[3] == 'E' and buffer
[4] == 'N' and buffer
[5] == 'T'
417 and buffer
[7] == 'E' and buffer
[8] == 'R' and buffer
[9] == 'R' and buffer
[10] == 'O' and buffer
[11] == 'R')
419 return MEMCACHED_CLIENT_ERROR
;
424 case '0': /* INCR/DECR response */
425 case '1': /* INCR/DECR response */
426 case '2': /* INCR/DECR response */
427 case '3': /* INCR/DECR response */
428 case '4': /* INCR/DECR response */
429 case '5': /* INCR/DECR response */
430 case '6': /* INCR/DECR response */
431 case '7': /* INCR/DECR response */
432 case '8': /* INCR/DECR response */
433 case '9': /* INCR/DECR response */
435 unsigned long long int auto_return_value
= strtoull(buffer
, (char **)NULL
, 10);
437 if (auto_return_value
== ULLONG_MAX
and errno
== ERANGE
)
439 result
->numeric_value
= UINT64_MAX
;
440 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
,
441 memcached_literal_param("Numeric response was out of range"));
443 else if (errno
== EINVAL
)
445 result
->numeric_value
= UINT64_MAX
;
446 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
,
447 memcached_literal_param("Numeric response was out of range"));
450 result
->numeric_value
= uint64_t(auto_return_value
);
452 WATCHPOINT_STRING(buffer
);
453 return MEMCACHED_SUCCESS
;
460 buffer
[total_read
]= 0;
462 if (total_read
>= sizeof("STORSTORED") -1)
464 fprintf(stderr
, "%s:%d '%s', %.*s\n", __FILE__
, __LINE__
,
465 buffer
, MEMCACHED_MAX_BUFFER
, instance
->read_buffer
);
466 assert(memcmp(buffer
,"STORSTORED", sizeof("STORSTORED") -1));
469 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
,
473 static memcached_return_t
binary_read_one_response(org::libmemcached::Instance
* instance
,
474 char *buffer
, const size_t buffer_length
,
475 memcached_result_st
*result
)
477 memcached_return_t rc
;
478 protocol_binary_response_header header
;
480 if ((rc
= memcached_safe_read(instance
, &header
.bytes
, sizeof(header
.bytes
))) != MEMCACHED_SUCCESS
)
482 WATCHPOINT_ERROR(rc
);
486 if (header
.response
.magic
!= PROTOCOL_BINARY_RES
)
488 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
);
492 ** Convert the header to host local endian!
494 header
.response
.keylen
= ntohs(header
.response
.keylen
);
495 header
.response
.status
= ntohs(header
.response
.status
);
496 header
.response
.bodylen
= ntohl(header
.response
.bodylen
);
497 header
.response
.cas
= memcached_ntohll(header
.response
.cas
);
498 uint32_t bodylen
= header
.response
.bodylen
;
500 if (header
.response
.status
== PROTOCOL_BINARY_RESPONSE_SUCCESS
or
501 header
.response
.status
== PROTOCOL_BINARY_RESPONSE_AUTH_CONTINUE
)
503 switch (header
.response
.opcode
)
505 case PROTOCOL_BINARY_CMD_GETKQ
:
507 * We didn't increment the response counter for the GETKQ packet
508 * (only the final NOOP), so we need to increment the counter again.
510 memcached_server_response_increment(instance
);
512 case PROTOCOL_BINARY_CMD_GETK
:
514 uint16_t keylen
= header
.response
.keylen
;
515 memcached_result_reset(result
);
516 result
->item_cas
= header
.response
.cas
;
518 if ((rc
= memcached_safe_read(instance
, &result
->item_flags
, sizeof (result
->item_flags
))) != MEMCACHED_SUCCESS
)
520 WATCHPOINT_ERROR(rc
);
521 return MEMCACHED_UNKNOWN_READ_FAILURE
;
524 result
->item_flags
= ntohl(result
->item_flags
);
525 bodylen
-= header
.response
.extlen
;
527 result
->key_length
= keylen
;
528 if (memcached_failed(rc
= memcached_safe_read(instance
, result
->item_key
, keylen
)))
530 WATCHPOINT_ERROR(rc
);
531 return MEMCACHED_UNKNOWN_READ_FAILURE
;
534 // Only bother with doing this if key_length > 0
535 if (result
->key_length
)
537 if (memcached_array_size(instance
->root
->_namespace
) and memcached_array_size(instance
->root
->_namespace
) >= result
->key_length
)
539 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
);
542 if (memcached_array_size(instance
->root
->_namespace
))
544 result
->key_length
-= memcached_array_size(instance
->root
->_namespace
);
545 memmove(result
->item_key
, result
->item_key
+memcached_array_size(instance
->root
->_namespace
), result
->key_length
);
550 if (memcached_failed(memcached_string_check(&result
->value
, bodylen
)))
552 return MEMCACHED_MEMORY_ALLOCATION_FAILURE
;
555 char *vptr
= memcached_string_value_mutable(&result
->value
);
556 if (memcached_failed(rc
= memcached_safe_read(instance
, vptr
, bodylen
)))
558 WATCHPOINT_ERROR(rc
);
559 return MEMCACHED_UNKNOWN_READ_FAILURE
;
562 memcached_string_set_length(&result
->value
, bodylen
);
566 case PROTOCOL_BINARY_CMD_INCREMENT
:
567 case PROTOCOL_BINARY_CMD_DECREMENT
:
569 if (bodylen
!= sizeof(uint64_t))
571 result
->numeric_value
= UINT64_MAX
;
572 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
);
576 if ((rc
= memcached_safe_read(instance
, &val
, sizeof(val
))) != MEMCACHED_SUCCESS
)
578 result
->numeric_value
= UINT64_MAX
;
579 return MEMCACHED_UNKNOWN_READ_FAILURE
;
582 result
->numeric_value
= memcached_ntohll(val
);
586 case PROTOCOL_BINARY_CMD_SASL_LIST_MECHS
:
588 if (header
.response
.keylen
!= 0 || bodylen
+ 1 > buffer_length
)
590 return MEMCACHED_UNKNOWN_READ_FAILURE
;
594 if ((rc
= memcached_safe_read(instance
, buffer
, bodylen
)) != MEMCACHED_SUCCESS
)
596 return MEMCACHED_UNKNOWN_READ_FAILURE
;
602 case PROTOCOL_BINARY_CMD_VERSION
:
604 char version_buffer
[32]; // @todo document this number
605 memset(version_buffer
, 0, sizeof(version_buffer
));
607 if (memcached_safe_read(instance
, version_buffer
, bodylen
) != MEMCACHED_SUCCESS
)
609 return MEMCACHED_UNKNOWN_READ_FAILURE
;
613 long int version
= strtol(version_buffer
, &endptr
, 10);
614 if (version
== LONG_MIN
or version
== LONG_MAX
or errno
== EINVAL
or version
> UINT8_MAX
or version
== 0)
616 instance
->major_version
= instance
->minor_version
= instance
->micro_version
= UINT8_MAX
;
617 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
, memcached_literal_param("strtol() failed to parse major version"));
619 instance
->major_version
= uint8_t(version
);
622 version
= strtol(endptr
, &endptr
, 10);
623 if (version
== LONG_MIN
or version
== LONG_MAX
or errno
== EINVAL
or version
> UINT8_MAX
)
625 instance
->major_version
= instance
->minor_version
= instance
->micro_version
= UINT8_MAX
;
626 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
, memcached_literal_param("strtol() failed to parse minor version"));
628 instance
->minor_version
= uint8_t(version
);
631 version
= strtol(endptr
, &endptr
, 10);
632 if (version
== LONG_MIN
or version
== LONG_MAX
or errno
== EINVAL
or version
> UINT8_MAX
)
634 instance
->major_version
= instance
->minor_version
= instance
->micro_version
= UINT8_MAX
;
635 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
, memcached_literal_param("strtol() failed to parse micro version"));
637 instance
->micro_version
= uint8_t(version
);
641 case PROTOCOL_BINARY_CMD_FLUSH
:
642 case PROTOCOL_BINARY_CMD_QUIT
:
643 case PROTOCOL_BINARY_CMD_SET
:
644 case PROTOCOL_BINARY_CMD_ADD
:
645 case PROTOCOL_BINARY_CMD_REPLACE
:
646 case PROTOCOL_BINARY_CMD_APPEND
:
647 case PROTOCOL_BINARY_CMD_PREPEND
:
648 case PROTOCOL_BINARY_CMD_DELETE
:
649 case PROTOCOL_BINARY_CMD_TOUCH
:
651 WATCHPOINT_ASSERT(bodylen
== 0);
652 return MEMCACHED_SUCCESS
;
655 case PROTOCOL_BINARY_CMD_NOOP
:
657 WATCHPOINT_ASSERT(bodylen
== 0);
658 return MEMCACHED_END
;
661 case PROTOCOL_BINARY_CMD_STAT
:
665 return MEMCACHED_END
;
667 else if (bodylen
+ 1 > buffer_length
)
669 /* not enough space in buffer.. should not happen... */
670 return MEMCACHED_UNKNOWN_READ_FAILURE
;
674 size_t keylen
= header
.response
.keylen
;
675 memset(buffer
, 0, buffer_length
);
676 if ((rc
= memcached_safe_read(instance
, buffer
, keylen
)) != MEMCACHED_SUCCESS
||
677 (rc
= memcached_safe_read(instance
, buffer
+ keylen
+ 1, bodylen
- keylen
)) != MEMCACHED_SUCCESS
)
679 WATCHPOINT_ERROR(rc
);
680 return MEMCACHED_UNKNOWN_READ_FAILURE
;
686 case PROTOCOL_BINARY_CMD_SASL_AUTH
:
687 case PROTOCOL_BINARY_CMD_SASL_STEP
:
689 memcached_result_reset(result
);
690 result
->item_cas
= header
.response
.cas
;
692 if (memcached_string_check(&result
->value
,
693 bodylen
) != MEMCACHED_SUCCESS
)
694 return MEMCACHED_MEMORY_ALLOCATION_FAILURE
;
696 char *vptr
= memcached_string_value_mutable(&result
->value
);
697 if ((rc
= memcached_safe_read(instance
, vptr
, bodylen
)) != MEMCACHED_SUCCESS
)
699 WATCHPOINT_ERROR(rc
);
700 return MEMCACHED_UNKNOWN_READ_FAILURE
;
703 memcached_string_set_length(&result
->value
, bodylen
);
708 /* Command not implemented yet! */
709 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
);
713 else if (header
.response
.bodylen
)
715 /* What should I do with the error message??? just discard it for now */
716 char hole
[SMALL_STRING_LEN
];
719 size_t nr
= (bodylen
> SMALL_STRING_LEN
) ? SMALL_STRING_LEN
: bodylen
;
720 if ((rc
= memcached_safe_read(instance
, hole
, nr
)) != MEMCACHED_SUCCESS
)
722 WATCHPOINT_ERROR(rc
);
723 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
);
725 bodylen
-= (uint32_t) nr
;
728 /* This might be an error from one of the quiet commands.. if
729 * so, just throw it away and get the next one. What about creating
730 * a callback to the user with the error information?
732 switch (header
.response
.opcode
)
734 case PROTOCOL_BINARY_CMD_SETQ
:
735 case PROTOCOL_BINARY_CMD_ADDQ
:
736 case PROTOCOL_BINARY_CMD_REPLACEQ
:
737 case PROTOCOL_BINARY_CMD_APPENDQ
:
738 case PROTOCOL_BINARY_CMD_PREPENDQ
:
739 return binary_read_one_response(instance
, buffer
, buffer_length
, result
);
746 rc
= MEMCACHED_SUCCESS
;
747 if (header
.response
.status
!= 0)
749 switch (header
.response
.status
)
751 case PROTOCOL_BINARY_RESPONSE_KEY_ENOENT
:
752 rc
= MEMCACHED_NOTFOUND
;
755 case PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS
:
756 rc
= MEMCACHED_DATA_EXISTS
;
759 case PROTOCOL_BINARY_RESPONSE_NOT_STORED
:
760 rc
= MEMCACHED_NOTSTORED
;
763 case PROTOCOL_BINARY_RESPONSE_E2BIG
:
767 case PROTOCOL_BINARY_RESPONSE_ENOMEM
:
768 rc
= MEMCACHED_MEMORY_ALLOCATION_FAILURE
;
771 case PROTOCOL_BINARY_RESPONSE_AUTH_CONTINUE
:
772 rc
= MEMCACHED_AUTH_CONTINUE
;
775 case PROTOCOL_BINARY_RESPONSE_AUTH_ERROR
:
776 rc
= MEMCACHED_AUTH_FAILURE
;
779 case PROTOCOL_BINARY_RESPONSE_EINVAL
:
780 case PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND
:
782 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
);
790 static memcached_return_t
_read_one_response(org::libmemcached::Instance
* instance
,
791 char *buffer
, const size_t buffer_length
,
792 memcached_result_st
*result
)
794 memcached_server_response_decrement(instance
);
798 memcached_st
*root
= (memcached_st
*)instance
->root
;
799 result
= &root
->result
;
802 memcached_return_t rc
;
803 if (memcached_is_binary(instance
->root
))
805 rc
= binary_read_one_response(instance
, buffer
, buffer_length
, result
);
809 rc
= textual_read_one_response(instance
, buffer
, buffer_length
, result
);
812 if (memcached_fatal(rc
))
814 memcached_io_reset(instance
);
820 memcached_return_t
memcached_read_one_response(org::libmemcached::Instance
* instance
,
821 memcached_result_st
*result
)
823 char buffer
[SMALL_STRING_LEN
];
825 if (memcached_is_udp(instance
->root
))
827 return memcached_set_error(*instance
, MEMCACHED_NOT_SUPPORTED
, MEMCACHED_AT
);
831 return _read_one_response(instance
, buffer
, sizeof(buffer
), result
);
834 memcached_return_t
memcached_response(org::libmemcached::Instance
* instance
,
835 memcached_result_st
*result
)
839 return memcached_response(instance
, buffer
, sizeof(buffer
), result
);
842 memcached_return_t
memcached_response(org::libmemcached::Instance
* instance
,
843 char *buffer
, size_t buffer_length
,
844 memcached_result_st
*result
)
846 if (memcached_is_udp(instance
->root
))
848 return memcached_set_error(*instance
, MEMCACHED_NOT_SUPPORTED
, MEMCACHED_AT
);
851 /* We may have old commands in the buffer not set, first purge */
852 if ((instance
->root
->flags
.no_block
) and (memcached_is_processing_input(instance
->root
) == false))
854 (void)memcached_io_write(instance
);
858 * The previous implementation purged all pending requests and just
859 * returned the last one. Purge all pending messages to ensure backwards
862 if (memcached_is_binary(instance
->root
) == false and memcached_server_response_count(instance
) > 1)
864 memcached_result_st junked_result
;
865 memcached_result_st
*junked_result_ptr
= memcached_result_create(instance
->root
, &junked_result
);
867 assert(junked_result_ptr
);
869 while (memcached_server_response_count(instance
) > 1)
871 memcached_return_t rc
= _read_one_response(instance
, buffer
, buffer_length
, junked_result_ptr
);
873 // @TODO should we return an error on another but a bad read case?
874 if (memcached_fatal(rc
))
876 memcached_result_free(junked_result_ptr
);
880 memcached_result_free(junked_result_ptr
);
883 return _read_one_response(instance
, buffer
, buffer_length
, result
);