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 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(memcached_server_write_instance_st 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
, (char **)NULL
, 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
);
249 response_ptr
= index(response_ptr
, '.');
252 version
= strtol(response_ptr
, (char **)NULL
, 10);
253 if (version
== LONG_MIN
or version
== LONG_MAX
or errno
== EINVAL
or version
> UINT8_MAX
)
255 instance
->major_version
= instance
->minor_version
= instance
->micro_version
= UINT8_MAX
;
256 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
, memcached_literal_param("strtol() failed to parse minor version"));
258 instance
->minor_version
= uint8_t(version
);
260 response_ptr
= index(response_ptr
, '.');
263 version
= strtol(response_ptr
, (char **)NULL
, 10);
264 if (version
== LONG_MIN
or version
== LONG_MAX
or errno
== EINVAL
or version
> UINT8_MAX
)
266 instance
->major_version
= instance
->minor_version
= instance
->micro_version
= UINT8_MAX
;
267 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
, memcached_literal_param("strtol() failed to parse micro version"));
269 instance
->micro_version
= uint8_t(version
);
271 return MEMCACHED_SUCCESS
;
279 if (buffer
[1] == 'K')
281 return MEMCACHED_SUCCESS
;
289 if (buffer
[1] == 'T' and buffer
[2] == 'A' and buffer
[3] == 'T') /* STORED STATS */
291 memcached_server_response_increment(instance
);
292 return MEMCACHED_STAT
;
295 else if (buffer
[1] == 'E' and buffer
[2] == 'R' and buffer
[3] == 'V' and buffer
[4] == 'E' and buffer
[5] == 'R'
297 and buffer
[7] == 'E' and buffer
[8] == 'R' and buffer
[9] == 'R' and buffer
[10] == 'O' and buffer
[11] == 'R' )
299 if (total_read
== memcached_literal_param_size("SERVER_ERROR"))
301 return MEMCACHED_SERVER_ERROR
;
304 if (total_read
>= memcached_literal_param_size("SERVER_ERROR object too large for cache") and
305 (memcmp(buffer
, memcached_literal_param("SERVER_ERROR object too large for cache")) == 0))
307 return MEMCACHED_E2BIG
;
310 if (total_read
>= memcached_literal_param_size("SERVER_ERROR out of memory storing object") and
311 (memcmp(buffer
, memcached_literal_param("SERVER_ERROR out of memory storing object")) == 0))
313 return MEMCACHED_SERVER_MEMORY_ALLOCATION_FAILURE
;
316 // Move past the basic error message and whitespace
317 char *startptr
= buffer
+ memcached_literal_param_size("SERVER_ERROR");
318 if (startptr
[0] == ' ')
323 char *endptr
= startptr
;
324 while (*endptr
!= '\r' && *endptr
!= '\n') endptr
++;
326 return memcached_set_error(*instance
, MEMCACHED_SERVER_ERROR
, MEMCACHED_AT
, startptr
, size_t(endptr
- startptr
));
329 else if (buffer
[1] == 'T' and buffer
[2] == 'O' and buffer
[3] == 'R') // and buffer[4] == 'E' and buffer[5] == 'D')
331 return MEMCACHED_STORED
;
339 if (buffer
[1] == 'E' and buffer
[2] == 'L' and buffer
[3] == 'E' and buffer
[4] == 'T' and buffer
[5] == 'E' and buffer
[6] == 'D')
341 return MEMCACHED_DELETED
;
349 if (buffer
[1] == 'O' and buffer
[2] == 'T'
351 and buffer
[4] == 'F' and buffer
[5] == 'O' and buffer
[6] == 'U' and buffer
[7] == 'N' and buffer
[8] == 'D')
353 return MEMCACHED_NOTFOUND
;
356 else if (buffer
[1] == 'O' and buffer
[2] == 'T'
358 and buffer
[4] == 'S' and buffer
[5] == 'T' and buffer
[6] == 'O' and buffer
[7] == 'R' and buffer
[8] == 'E' and buffer
[9] == 'D')
360 return MEMCACHED_NOTSTORED
;
365 case 'E': /* PROTOCOL ERROR or END */
368 if (buffer
[1] == 'N' and buffer
[2] == 'D')
370 return MEMCACHED_END
;
374 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'
376 and buffer
[9] == 'E' and buffer
[10] == 'R' and buffer
[11] == 'R' and buffer
[12] == 'O' and buffer
[13] == 'R')
378 return MEMCACHED_PROTOCOL_ERROR
;
382 else if (buffer
[1] == 'R' and buffer
[2] == 'R' and buffer
[3] == 'O' and buffer
[4] == 'R')
384 return MEMCACHED_ERROR
;
387 else if (buffer
[1] == 'X' and buffer
[2] == 'I' and buffer
[3] == 'S' and buffer
[4] == 'T' and buffer
[5] == 'S')
389 return MEMCACHED_DATA_EXISTS
;
394 case 'T': /* TOUCHED */
397 if (buffer
[1] == 'O' and buffer
[2] == 'U' and buffer
[3] == 'C' and buffer
[4] == 'H' and buffer
[5] == 'E' and buffer
[6] == 'D')
399 return MEMCACHED_SUCCESS
;
407 if (buffer
[1] == 'T' and buffer
[2] == 'E' and buffer
[3] == 'M')
409 /* We add back in one because we will need to search for END */
410 memcached_server_response_increment(instance
);
411 return MEMCACHED_ITEM
;
416 case 'C': /* CLIENT ERROR */
419 if (buffer
[1] == 'L' and buffer
[2] == 'I' and buffer
[3] == 'E' and buffer
[4] == 'N' and buffer
[5] == 'T'
421 and buffer
[7] == 'E' and buffer
[8] == 'R' and buffer
[9] == 'R' and buffer
[10] == 'O' and buffer
[11] == 'R')
423 return MEMCACHED_CLIENT_ERROR
;
428 case '0': /* INCR/DECR response */
429 case '1': /* INCR/DECR response */
430 case '2': /* INCR/DECR response */
431 case '3': /* INCR/DECR response */
432 case '4': /* INCR/DECR response */
433 case '5': /* INCR/DECR response */
434 case '6': /* INCR/DECR response */
435 case '7': /* INCR/DECR response */
436 case '8': /* INCR/DECR response */
437 case '9': /* INCR/DECR response */
439 unsigned long long int auto_return_value
= strtoull(buffer
, (char **)NULL
, 10);
441 if (auto_return_value
== ULLONG_MAX
and errno
== ERANGE
)
443 result
->numeric_value
= UINT64_MAX
;
444 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
,
445 memcached_literal_param("Numeric response was out of range"));
447 else if (errno
== EINVAL
)
449 result
->numeric_value
= UINT64_MAX
;
450 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
,
451 memcached_literal_param("Numeric response was out of range"));
454 result
->numeric_value
= uint64_t(auto_return_value
);
456 WATCHPOINT_STRING(buffer
);
457 return MEMCACHED_SUCCESS
;
464 buffer
[total_read
]= 0;
466 if (total_read
>= sizeof("STORSTORED") -1)
468 fprintf(stderr
, "%s:%d '%s', %.*s\n", __FILE__
, __LINE__
,
469 buffer
, MEMCACHED_MAX_BUFFER
, instance
->read_buffer
);
470 assert(memcmp(buffer
,"STORSTORED", sizeof("STORSTORED") -1));
473 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
,
477 static memcached_return_t
binary_read_one_response(memcached_server_write_instance_st instance
,
478 char *buffer
, const size_t buffer_length
,
479 memcached_result_st
*result
)
481 memcached_return_t rc
;
482 protocol_binary_response_header header
;
484 if ((rc
= memcached_safe_read(instance
, &header
.bytes
, sizeof(header
.bytes
))) != MEMCACHED_SUCCESS
)
486 WATCHPOINT_ERROR(rc
);
490 if (header
.response
.magic
!= PROTOCOL_BINARY_RES
)
492 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
);
496 ** Convert the header to host local endian!
498 header
.response
.keylen
= ntohs(header
.response
.keylen
);
499 header
.response
.status
= ntohs(header
.response
.status
);
500 header
.response
.bodylen
= ntohl(header
.response
.bodylen
);
501 header
.response
.cas
= memcached_ntohll(header
.response
.cas
);
502 uint32_t bodylen
= header
.response
.bodylen
;
504 if (header
.response
.status
== PROTOCOL_BINARY_RESPONSE_SUCCESS
or
505 header
.response
.status
== PROTOCOL_BINARY_RESPONSE_AUTH_CONTINUE
)
507 switch (header
.response
.opcode
)
509 case PROTOCOL_BINARY_CMD_GETKQ
:
511 * We didn't increment the response counter for the GETKQ packet
512 * (only the final NOOP), so we need to increment the counter again.
514 memcached_server_response_increment(instance
);
516 case PROTOCOL_BINARY_CMD_GETK
:
518 uint16_t keylen
= header
.response
.keylen
;
519 memcached_result_reset(result
);
520 result
->item_cas
= header
.response
.cas
;
522 if ((rc
= memcached_safe_read(instance
, &result
->item_flags
, sizeof (result
->item_flags
))) != MEMCACHED_SUCCESS
)
524 WATCHPOINT_ERROR(rc
);
525 return MEMCACHED_UNKNOWN_READ_FAILURE
;
528 result
->item_flags
= ntohl(result
->item_flags
);
529 bodylen
-= header
.response
.extlen
;
531 result
->key_length
= keylen
;
532 if (memcached_failed(rc
= memcached_safe_read(instance
, result
->item_key
, keylen
)))
534 WATCHPOINT_ERROR(rc
);
535 return MEMCACHED_UNKNOWN_READ_FAILURE
;
538 // Only bother with doing this if key_length > 0
539 if (result
->key_length
)
541 if (memcached_array_size(instance
->root
->_namespace
) and memcached_array_size(instance
->root
->_namespace
) >= result
->key_length
)
543 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
);
546 if (memcached_array_size(instance
->root
->_namespace
))
548 result
->key_length
-= memcached_array_size(instance
->root
->_namespace
);
549 memmove(result
->item_key
, result
->item_key
+memcached_array_size(instance
->root
->_namespace
), result
->key_length
);
554 if (memcached_failed(memcached_string_check(&result
->value
, bodylen
)))
556 return MEMCACHED_MEMORY_ALLOCATION_FAILURE
;
559 char *vptr
= memcached_string_value_mutable(&result
->value
);
560 if (memcached_failed(rc
= memcached_safe_read(instance
, vptr
, bodylen
)))
562 WATCHPOINT_ERROR(rc
);
563 return MEMCACHED_UNKNOWN_READ_FAILURE
;
566 memcached_string_set_length(&result
->value
, bodylen
);
570 case PROTOCOL_BINARY_CMD_INCREMENT
:
571 case PROTOCOL_BINARY_CMD_DECREMENT
:
573 if (bodylen
!= sizeof(uint64_t))
575 result
->numeric_value
= UINT64_MAX
;
576 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
);
580 if ((rc
= memcached_safe_read(instance
, &val
, sizeof(val
))) != MEMCACHED_SUCCESS
)
582 result
->numeric_value
= UINT64_MAX
;
583 return MEMCACHED_UNKNOWN_READ_FAILURE
;
586 result
->numeric_value
= memcached_ntohll(val
);
590 case PROTOCOL_BINARY_CMD_SASL_LIST_MECHS
:
591 case PROTOCOL_BINARY_CMD_VERSION
:
593 char version_buffer
[32]; // @todo document this number
594 memset(version_buffer
, 0, sizeof(version_buffer
));
596 if (memcached_safe_read(instance
, version_buffer
, bodylen
) != MEMCACHED_SUCCESS
)
598 return MEMCACHED_UNKNOWN_READ_FAILURE
;
602 long int version
= strtol(version_buffer
, &p
, 10);
603 if (version
== LONG_MIN
or version
== LONG_MAX
or errno
== EINVAL
or version
> UINT8_MAX
or version
== 0)
605 instance
->major_version
= instance
->minor_version
= instance
->micro_version
= UINT8_MAX
;
606 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
, memcached_literal_param("strtol() failed to parse major version"));
608 instance
->major_version
= uint8_t(version
);
610 version
= strtol(p
+1, &p
, 10);
611 if (version
== LONG_MIN
or version
== LONG_MAX
or errno
== EINVAL
or version
> UINT8_MAX
)
613 instance
->major_version
= instance
->minor_version
= instance
->micro_version
= UINT8_MAX
;
614 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
, memcached_literal_param("strtol() failed to parse micro version"));
616 instance
->minor_version
= uint8_t(version
);
618 version
= strtol(p
+ 1, NULL
, 10);
621 instance
->major_version
= instance
->minor_version
= instance
->micro_version
= UINT8_MAX
;
622 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
, memcached_literal_param("strtol() failed to parse micro version"));
624 instance
->micro_version
= uint8_t(version
);
628 case PROTOCOL_BINARY_CMD_FLUSH
:
629 case PROTOCOL_BINARY_CMD_QUIT
:
630 case PROTOCOL_BINARY_CMD_SET
:
631 case PROTOCOL_BINARY_CMD_ADD
:
632 case PROTOCOL_BINARY_CMD_REPLACE
:
633 case PROTOCOL_BINARY_CMD_APPEND
:
634 case PROTOCOL_BINARY_CMD_PREPEND
:
635 case PROTOCOL_BINARY_CMD_DELETE
:
636 case PROTOCOL_BINARY_CMD_TOUCH
:
638 WATCHPOINT_ASSERT(bodylen
== 0);
639 return MEMCACHED_SUCCESS
;
642 case PROTOCOL_BINARY_CMD_NOOP
:
644 WATCHPOINT_ASSERT(bodylen
== 0);
645 return MEMCACHED_END
;
648 case PROTOCOL_BINARY_CMD_STAT
:
652 return MEMCACHED_END
;
654 else if (bodylen
+ 1 > buffer_length
)
656 /* not enough space in buffer.. should not happen... */
657 return MEMCACHED_UNKNOWN_READ_FAILURE
;
661 size_t keylen
= header
.response
.keylen
;
662 memset(buffer
, 0, buffer_length
);
663 if ((rc
= memcached_safe_read(instance
, buffer
, keylen
)) != MEMCACHED_SUCCESS
||
664 (rc
= memcached_safe_read(instance
, buffer
+ keylen
+ 1, bodylen
- keylen
)) != MEMCACHED_SUCCESS
)
666 WATCHPOINT_ERROR(rc
);
667 return MEMCACHED_UNKNOWN_READ_FAILURE
;
673 case PROTOCOL_BINARY_CMD_SASL_AUTH
:
674 case PROTOCOL_BINARY_CMD_SASL_STEP
:
676 memcached_result_reset(result
);
677 result
->item_cas
= header
.response
.cas
;
679 if (memcached_string_check(&result
->value
,
680 bodylen
) != MEMCACHED_SUCCESS
)
681 return MEMCACHED_MEMORY_ALLOCATION_FAILURE
;
683 char *vptr
= memcached_string_value_mutable(&result
->value
);
684 if ((rc
= memcached_safe_read(instance
, vptr
, bodylen
)) != MEMCACHED_SUCCESS
)
686 WATCHPOINT_ERROR(rc
);
687 return MEMCACHED_UNKNOWN_READ_FAILURE
;
690 memcached_string_set_length(&result
->value
, bodylen
);
695 /* Command not implemented yet! */
696 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
);
700 else if (header
.response
.bodylen
)
702 /* What should I do with the error message??? just discard it for now */
703 char hole
[SMALL_STRING_LEN
];
706 size_t nr
= (bodylen
> SMALL_STRING_LEN
) ? SMALL_STRING_LEN
: bodylen
;
707 if ((rc
= memcached_safe_read(instance
, hole
, nr
)) != MEMCACHED_SUCCESS
)
709 WATCHPOINT_ERROR(rc
);
710 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
);
712 bodylen
-= (uint32_t) nr
;
715 /* This might be an error from one of the quiet commands.. if
716 * so, just throw it away and get the next one. What about creating
717 * a callback to the user with the error information?
719 switch (header
.response
.opcode
)
721 case PROTOCOL_BINARY_CMD_SETQ
:
722 case PROTOCOL_BINARY_CMD_ADDQ
:
723 case PROTOCOL_BINARY_CMD_REPLACEQ
:
724 case PROTOCOL_BINARY_CMD_APPENDQ
:
725 case PROTOCOL_BINARY_CMD_PREPENDQ
:
726 return binary_read_one_response(instance
, buffer
, buffer_length
, result
);
733 rc
= MEMCACHED_SUCCESS
;
734 if (header
.response
.status
!= 0)
736 switch (header
.response
.status
)
738 case PROTOCOL_BINARY_RESPONSE_KEY_ENOENT
:
739 rc
= MEMCACHED_NOTFOUND
;
742 case PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS
:
743 rc
= MEMCACHED_DATA_EXISTS
;
746 case PROTOCOL_BINARY_RESPONSE_NOT_STORED
:
747 rc
= MEMCACHED_NOTSTORED
;
750 case PROTOCOL_BINARY_RESPONSE_E2BIG
:
754 case PROTOCOL_BINARY_RESPONSE_ENOMEM
:
755 rc
= MEMCACHED_MEMORY_ALLOCATION_FAILURE
;
758 case PROTOCOL_BINARY_RESPONSE_AUTH_CONTINUE
:
759 rc
= MEMCACHED_AUTH_CONTINUE
;
762 case PROTOCOL_BINARY_RESPONSE_AUTH_ERROR
:
763 rc
= MEMCACHED_AUTH_FAILURE
;
766 case PROTOCOL_BINARY_RESPONSE_EINVAL
:
767 case PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND
:
769 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
);
777 static memcached_return_t
_read_one_response(memcached_server_write_instance_st instance
,
778 char *buffer
, const size_t buffer_length
,
779 memcached_result_st
*result
)
781 memcached_server_response_decrement(instance
);
785 memcached_st
*root
= (memcached_st
*)instance
->root
;
786 result
= &root
->result
;
789 memcached_return_t rc
;
790 if (memcached_is_binary(instance
->root
))
792 rc
= binary_read_one_response(instance
, buffer
, buffer_length
, result
);
796 rc
= textual_read_one_response(instance
, buffer
, buffer_length
, result
);
799 if (memcached_fatal(rc
))
801 memcached_io_reset(instance
);
807 memcached_return_t
memcached_read_one_response(memcached_server_write_instance_st instance
,
808 memcached_result_st
*result
)
810 char buffer
[SMALL_STRING_LEN
];
812 if (memcached_is_udp(instance
->root
))
814 return memcached_set_error(*instance
, MEMCACHED_NOT_SUPPORTED
, MEMCACHED_AT
);
818 return _read_one_response(instance
, buffer
, sizeof(buffer
), result
);
821 memcached_return_t
memcached_response(memcached_server_write_instance_st instance
,
822 memcached_result_st
*result
)
826 return memcached_response(instance
, buffer
, sizeof(buffer
), result
);
829 memcached_return_t
memcached_response(memcached_server_write_instance_st instance
,
830 char *buffer
, size_t buffer_length
,
831 memcached_result_st
*result
)
833 if (memcached_is_udp(instance
->root
))
835 return memcached_set_error(*instance
, MEMCACHED_NOT_SUPPORTED
, MEMCACHED_AT
);
838 /* We may have old commands in the buffer not set, first purge */
839 if ((instance
->root
->flags
.no_block
) and (memcached_is_processing_input(instance
->root
) == false))
841 (void)memcached_io_write(instance
);
845 * The previous implementation purged all pending requests and just
846 * returned the last one. Purge all pending messages to ensure backwards
849 if (memcached_is_binary(instance
->root
) == false and memcached_server_response_count(instance
) > 1)
851 memcached_result_st junked_result
;
852 memcached_result_st
*junked_result_ptr
= memcached_result_create(instance
->root
, &junked_result
);
854 assert(junked_result_ptr
);
856 while (memcached_server_response_count(instance
) > 1)
858 memcached_return_t rc
= _read_one_response(instance
, buffer
, buffer_length
, junked_result_ptr
);
860 // @TODO should we return an error on another but a bad read case?
861 if (memcached_fatal(rc
))
863 memcached_result_free(junked_result_ptr
);
867 memcached_result_free(junked_result_ptr
);
870 return _read_one_response(instance
, buffer
, buffer_length
, result
);