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_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
++) {};
94 result
->item_flags
= (uint32_t) strtoul(next_ptr
, &string_ptr
, 10);
96 if (errno
!= 0 or end_ptr
== string_ptr
)
101 /* Length fetch move past space*/
103 if (end_ptr
== string_ptr
)
108 for (next_ptr
= string_ptr
; isdigit(*string_ptr
); string_ptr
++) {};
110 value_length
= (size_t)strtoull(next_ptr
, &string_ptr
, 10);
112 if (errno
!= 0 or end_ptr
== string_ptr
)
118 if (*string_ptr
== '\r')
120 /* Skip past the \r\n */
126 for (next_ptr
= string_ptr
; isdigit(*string_ptr
); string_ptr
++) {};
128 result
->item_cas
= strtoull(next_ptr
, &string_ptr
, 10);
131 if (errno
!= 0 or end_ptr
< string_ptr
)
136 /* We add two bytes so that we can walk the \r\n */
137 if (memcached_failed(memcached_string_check(&result
->value
, value_length
+2)))
139 return memcached_set_error(*instance
, MEMCACHED_MEMORY_ALLOCATION_FAILURE
, MEMCACHED_AT
);
143 char *value_ptr
= memcached_string_value_mutable(&result
->value
);
145 We read the \r\n into the string since not doing so is more
146 cycles then the waster of memory to do so.
148 We are null terminating through, which will most likely make
149 some people lazy about using the return length.
151 size_t to_read
= (value_length
) + 2;
152 memcached_return_t rrc
= memcached_io_read(instance
, value_ptr
, to_read
, read_length
);
153 if (memcached_failed(rrc
) and rrc
== MEMCACHED_IN_PROGRESS
)
155 memcached_quit_server(instance
, true);
156 return memcached_set_error(*instance
, MEMCACHED_IN_PROGRESS
, MEMCACHED_AT
);
158 else if (memcached_failed(rrc
))
164 if (read_length
!= (ssize_t
)(value_length
+ 2))
169 /* This next bit blows the API, but this is internal....*/
172 char_ptr
= memcached_string_value_mutable(&result
->value
);;
173 char_ptr
[value_length
]= 0;
174 char_ptr
[value_length
+1]= 0;
175 memcached_string_set_length(&result
->value
, value_length
);
178 if (memcached_is_encrypted(instance
->root
) and memcached_result_length(result
))
180 hashkit_string_st
*destination
;
182 if ((destination
= hashkit_decrypt(&instance
->root
->hashkit
,
183 memcached_result_value(result
), memcached_result_length(result
))) == NULL
)
185 rc
= memcached_set_error(*instance
->root
, MEMCACHED_FAILURE
,
186 MEMCACHED_AT
, memcached_literal_param("hashkit_decrypt() failed"));
190 memcached_result_reset_value(result
);
191 if (memcached_failed(memcached_result_set_value(result
, hashkit_string_c_str(destination
), hashkit_string_length(destination
))))
193 rc
= memcached_set_error(*instance
->root
, MEMCACHED_FAILURE
,
194 MEMCACHED_AT
, memcached_literal_param("hashkit_decrypt() failed"));
198 if (memcached_failed(rc
))
200 memcached_result_reset(result
);
202 hashkit_string_free(destination
);
208 memcached_io_reset(instance
);
210 return MEMCACHED_PARTIAL_READ
;
213 static memcached_return_t
textual_read_one_response(memcached_instance_st
* instance
,
214 char *buffer
, const size_t buffer_length
,
215 memcached_result_st
*result
)
218 memcached_return_t rc
= memcached_io_readline(instance
, buffer
, buffer_length
, total_read
);
220 if (memcached_failed(rc
))
231 if (buffer
[1] == 'A' and buffer
[2] == 'L' and buffer
[3] == 'U' and buffer
[4] == 'E') /* VALUE */
233 /* We add back in one because we will need to search for END */
234 memcached_server_response_increment(instance
);
235 return textual_value_fetch(instance
, buffer
, result
);
238 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 */
240 /* Find the space, and then move one past it to copy version */
241 char *response_ptr
= index(buffer
, ' ');
245 long int version
= strtol(response_ptr
, &endptr
, 10);
246 if (errno
!= 0 or version
== LONG_MIN
or version
== LONG_MAX
or version
> UINT8_MAX
or version
== 0)
248 instance
->major_version
= instance
->minor_version
= instance
->micro_version
= UINT8_MAX
;
249 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
, memcached_literal_param("strtol() failed to parse major version"));
251 instance
->major_version
= uint8_t(version
);
255 version
= strtol(endptr
, &endptr
, 10);
256 if (errno
!= 0 or version
== LONG_MIN
or version
== LONG_MAX
or version
> UINT8_MAX
)
258 instance
->major_version
= instance
->minor_version
= instance
->micro_version
= UINT8_MAX
;
259 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
, memcached_literal_param("strtol() failed to parse minor version"));
261 instance
->minor_version
= uint8_t(version
);
265 version
= strtol(endptr
, &endptr
, 10);
266 if (errno
!= 0 or version
== LONG_MIN
or version
== LONG_MAX
or version
> UINT8_MAX
)
268 instance
->major_version
= instance
->minor_version
= instance
->micro_version
= UINT8_MAX
;
269 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
, memcached_literal_param("strtol() failed to parse micro version"));
271 instance
->micro_version
= uint8_t(version
);
273 return MEMCACHED_SUCCESS
;
281 if (buffer
[1] == 'K')
283 return MEMCACHED_SUCCESS
;
291 if (buffer
[1] == 'T' and buffer
[2] == 'A' and buffer
[3] == 'T') /* STORED STATS */
293 memcached_server_response_increment(instance
);
294 return MEMCACHED_STAT
;
297 else if (buffer
[1] == 'E' and buffer
[2] == 'R' and buffer
[3] == 'V' and buffer
[4] == 'E' and buffer
[5] == 'R'
299 and buffer
[7] == 'E' and buffer
[8] == 'R' and buffer
[9] == 'R' and buffer
[10] == 'O' and buffer
[11] == 'R' )
301 if (total_read
== memcached_literal_param_size("SERVER_ERROR"))
303 return MEMCACHED_SERVER_ERROR
;
306 if (total_read
>= memcached_literal_param_size("SERVER_ERROR object too large for cache") and
307 (memcmp(buffer
, memcached_literal_param("SERVER_ERROR object too large for cache")) == 0))
309 return MEMCACHED_E2BIG
;
312 if (total_read
>= memcached_literal_param_size("SERVER_ERROR out of memory storing object") and
313 (memcmp(buffer
, memcached_literal_param("SERVER_ERROR out of memory storing object")) == 0))
315 return MEMCACHED_SERVER_MEMORY_ALLOCATION_FAILURE
;
318 // Move past the basic error message and whitespace
319 char *startptr
= buffer
+ memcached_literal_param_size("SERVER_ERROR");
320 if (startptr
[0] == ' ')
325 char *endptr
= startptr
;
326 while (*endptr
!= '\r' && *endptr
!= '\n') endptr
++;
328 return memcached_set_error(*instance
, MEMCACHED_SERVER_ERROR
, MEMCACHED_AT
, startptr
, size_t(endptr
- startptr
));
331 else if (buffer
[1] == 'T' and buffer
[2] == 'O' and buffer
[3] == 'R') // and buffer[4] == 'E' and buffer[5] == 'D')
333 return MEMCACHED_STORED
;
341 if (buffer
[1] == 'E' and buffer
[2] == 'L' and buffer
[3] == 'E' and buffer
[4] == 'T' and buffer
[5] == 'E' and buffer
[6] == 'D')
343 return MEMCACHED_DELETED
;
351 if (buffer
[1] == 'O' and buffer
[2] == 'T'
353 and buffer
[4] == 'F' and buffer
[5] == 'O' and buffer
[6] == 'U' and buffer
[7] == 'N' and buffer
[8] == 'D')
355 return MEMCACHED_NOTFOUND
;
358 else if (buffer
[1] == 'O' and buffer
[2] == 'T'
360 and buffer
[4] == 'S' and buffer
[5] == 'T' and buffer
[6] == 'O' and buffer
[7] == 'R' and buffer
[8] == 'E' and buffer
[9] == 'D')
362 return MEMCACHED_NOTSTORED
;
367 case 'E': /* PROTOCOL ERROR or END */
370 if (buffer
[1] == 'N' and buffer
[2] == 'D')
372 return MEMCACHED_END
;
376 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'
378 and buffer
[9] == 'E' and buffer
[10] == 'R' and buffer
[11] == 'R' and buffer
[12] == 'O' and buffer
[13] == 'R')
380 return MEMCACHED_PROTOCOL_ERROR
;
384 else if (buffer
[1] == 'R' and buffer
[2] == 'R' and buffer
[3] == 'O' and buffer
[4] == 'R')
386 return MEMCACHED_ERROR
;
389 else if (buffer
[1] == 'X' and buffer
[2] == 'I' and buffer
[3] == 'S' and buffer
[4] == 'T' and buffer
[5] == 'S')
391 return MEMCACHED_DATA_EXISTS
;
396 case 'T': /* TOUCHED */
399 if (buffer
[1] == 'O' and buffer
[2] == 'U' and buffer
[3] == 'C' and buffer
[4] == 'H' and buffer
[5] == 'E' and buffer
[6] == 'D')
401 return MEMCACHED_SUCCESS
;
409 if (buffer
[1] == 'T' and buffer
[2] == 'E' and buffer
[3] == 'M')
411 /* We add back in one because we will need to search for END */
412 memcached_server_response_increment(instance
);
413 return MEMCACHED_ITEM
;
418 case 'C': /* CLIENT ERROR */
421 if (buffer
[1] == 'L' and buffer
[2] == 'I' and buffer
[3] == 'E' and buffer
[4] == 'N' and buffer
[5] == 'T'
423 and buffer
[7] == 'E' and buffer
[8] == 'R' and buffer
[9] == 'R' and buffer
[10] == 'O' and buffer
[11] == 'R')
425 // Move past the basic error message and whitespace
426 char *startptr
= buffer
+ memcached_literal_param_size("CLIENT_ERROR");
427 if (startptr
[0] == ' ')
432 char *endptr
= startptr
;
433 while (*endptr
!= '\r' && *endptr
!= '\n') endptr
++;
435 return memcached_set_error(*instance
, MEMCACHED_CLIENT_ERROR
, MEMCACHED_AT
, startptr
, size_t(endptr
- startptr
));
440 case '0': /* INCR/DECR response */
441 case '1': /* INCR/DECR response */
442 case '2': /* INCR/DECR response */
443 case '3': /* INCR/DECR response */
444 case '4': /* INCR/DECR response */
445 case '5': /* INCR/DECR response */
446 case '6': /* INCR/DECR response */
447 case '7': /* INCR/DECR response */
448 case '8': /* INCR/DECR response */
449 case '9': /* INCR/DECR response */
452 unsigned long long int auto_return_value
= strtoull(buffer
, (char **)NULL
, 10);
454 if (auto_return_value
== ULLONG_MAX
and errno
== ERANGE
)
456 result
->numeric_value
= UINT64_MAX
;
457 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
,
458 memcached_literal_param("Numeric response was out of range"));
460 else if (errno
== EINVAL
)
462 result
->numeric_value
= UINT64_MAX
;
463 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
,
464 memcached_literal_param("Numeric response was out of range"));
468 result
->numeric_value
= UINT64_MAX
;
469 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
,
470 memcached_literal_param("Numeric response was out of range"));
473 result
->numeric_value
= uint64_t(auto_return_value
);
475 WATCHPOINT_STRING(buffer
);
476 return MEMCACHED_SUCCESS
;
483 buffer
[total_read
]= 0;
485 if (total_read
>= sizeof("STORSTORED") -1)
487 fprintf(stderr
, "%s:%d '%s', %.*s\n", __FILE__
, __LINE__
,
488 buffer
, MEMCACHED_MAX_BUFFER
, instance
->read_buffer
);
489 assert(memcmp(buffer
,"STORSTORED", sizeof("STORSTORED") -1));
492 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
,
496 static memcached_return_t
binary_read_one_response(memcached_instance_st
* instance
,
497 char *buffer
, const size_t buffer_length
,
498 memcached_result_st
*result
)
500 memcached_return_t rc
;
501 protocol_binary_response_header header
;
503 assert(memcached_is_binary(instance
->root
));
505 if ((rc
= memcached_safe_read(instance
, &header
.bytes
, sizeof(header
.bytes
))) != MEMCACHED_SUCCESS
)
507 WATCHPOINT_ERROR(rc
);
511 if (header
.response
.magic
!= PROTOCOL_BINARY_RES
)
513 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
);
517 ** Convert the header to host local endian!
519 header
.response
.keylen
= ntohs(header
.response
.keylen
);
520 header
.response
.status
= ntohs(header
.response
.status
);
521 header
.response
.bodylen
= ntohl(header
.response
.bodylen
);
522 header
.response
.cas
= memcached_ntohll(header
.response
.cas
);
523 uint32_t bodylen
= header
.response
.bodylen
;
525 if (header
.response
.status
== PROTOCOL_BINARY_RESPONSE_SUCCESS
or
526 header
.response
.status
== PROTOCOL_BINARY_RESPONSE_AUTH_CONTINUE
)
528 switch (header
.response
.opcode
)
530 case PROTOCOL_BINARY_CMD_GETKQ
:
532 * We didn't increment the response counter for the GETKQ packet
533 * (only the final NOOP), so we need to increment the counter again.
535 memcached_server_response_increment(instance
);
537 case PROTOCOL_BINARY_CMD_GETK
:
539 uint16_t keylen
= header
.response
.keylen
;
540 memcached_result_reset(result
);
541 result
->item_cas
= header
.response
.cas
;
543 if ((rc
= memcached_safe_read(instance
, &result
->item_flags
, sizeof (result
->item_flags
))) != MEMCACHED_SUCCESS
)
545 WATCHPOINT_ERROR(rc
);
546 return MEMCACHED_UNKNOWN_READ_FAILURE
;
549 result
->item_flags
= ntohl(result
->item_flags
);
550 bodylen
-= header
.response
.extlen
;
552 result
->key_length
= keylen
;
553 if (memcached_failed(rc
= memcached_safe_read(instance
, result
->item_key
, keylen
)))
555 WATCHPOINT_ERROR(rc
);
556 return MEMCACHED_UNKNOWN_READ_FAILURE
;
559 // Only bother with doing this if key_length > 0
560 if (result
->key_length
)
562 if (memcached_array_size(instance
->root
->_namespace
) and memcached_array_size(instance
->root
->_namespace
) >= result
->key_length
)
564 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
);
567 if (memcached_array_size(instance
->root
->_namespace
))
569 result
->key_length
-= memcached_array_size(instance
->root
->_namespace
);
570 memmove(result
->item_key
, result
->item_key
+memcached_array_size(instance
->root
->_namespace
), result
->key_length
);
575 if (memcached_failed(memcached_string_check(&result
->value
, bodylen
)))
577 return MEMCACHED_MEMORY_ALLOCATION_FAILURE
;
580 char *vptr
= memcached_string_value_mutable(&result
->value
);
581 if (memcached_failed(rc
= memcached_safe_read(instance
, vptr
, bodylen
)))
583 WATCHPOINT_ERROR(rc
);
584 return MEMCACHED_UNKNOWN_READ_FAILURE
;
587 memcached_string_set_length(&result
->value
, bodylen
);
591 case PROTOCOL_BINARY_CMD_INCREMENT
:
592 case PROTOCOL_BINARY_CMD_DECREMENT
:
594 if (bodylen
!= sizeof(uint64_t))
596 result
->numeric_value
= UINT64_MAX
;
597 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
);
601 if ((rc
= memcached_safe_read(instance
, &val
, sizeof(val
))) != MEMCACHED_SUCCESS
)
603 result
->numeric_value
= UINT64_MAX
;
604 return MEMCACHED_UNKNOWN_READ_FAILURE
;
607 result
->numeric_value
= memcached_ntohll(val
);
611 case PROTOCOL_BINARY_CMD_SASL_LIST_MECHS
:
613 if (header
.response
.keylen
!= 0 || bodylen
+ 1 > buffer_length
)
615 return MEMCACHED_UNKNOWN_READ_FAILURE
;
619 if ((rc
= memcached_safe_read(instance
, buffer
, bodylen
)) != MEMCACHED_SUCCESS
)
621 return MEMCACHED_UNKNOWN_READ_FAILURE
;
627 case PROTOCOL_BINARY_CMD_VERSION
:
629 char version_buffer
[32]; // @todo document this number
630 memset(version_buffer
, 0, sizeof(version_buffer
));
632 if (memcached_safe_read(instance
, version_buffer
, bodylen
) != MEMCACHED_SUCCESS
)
634 return MEMCACHED_UNKNOWN_READ_FAILURE
;
639 long int version
= strtol(version_buffer
, &endptr
, 10);
640 if (errno
!= 0 or version
== LONG_MIN
or version
== LONG_MAX
or version
> UINT8_MAX
or version
== 0)
642 instance
->major_version
= instance
->minor_version
= instance
->micro_version
= UINT8_MAX
;
643 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
, memcached_literal_param("strtol() failed to parse major version"));
645 instance
->major_version
= uint8_t(version
);
649 version
= strtol(endptr
, &endptr
, 10);
650 if (errno
!= 0 or version
== LONG_MIN
or version
== LONG_MAX
or version
> UINT8_MAX
)
652 instance
->major_version
= instance
->minor_version
= instance
->micro_version
= UINT8_MAX
;
653 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
, memcached_literal_param("strtol() failed to parse minor version"));
655 instance
->minor_version
= uint8_t(version
);
659 version
= strtol(endptr
, &endptr
, 10);
660 if (errno
!= 0 or version
== LONG_MIN
or version
== LONG_MAX
or version
> UINT8_MAX
)
662 instance
->major_version
= instance
->minor_version
= instance
->micro_version
= UINT8_MAX
;
663 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
, memcached_literal_param("strtol() failed to parse micro version"));
665 instance
->micro_version
= uint8_t(version
);
669 case PROTOCOL_BINARY_CMD_TOUCH
:
671 rc
= MEMCACHED_SUCCESS
;
672 if (bodylen
== 4) // The four byte read is a bug?
674 char touch_buffer
[4]; // @todo document this number
675 rc
= memcached_safe_read(instance
, touch_buffer
, sizeof(touch_buffer
));
677 fprintf(stderr
, "%s:%d %d %d %d %d %.*s(%d)\n", __FILE__
, __LINE__
,
678 int(touch_buffer
[0]),
679 int(touch_buffer
[1]),
680 int(touch_buffer
[2]),
681 int(touch_buffer
[3]),
682 int(bodylen
), touch_buffer
, int(bodylen
));
685 return memcached_set_error(*instance
, rc
, MEMCACHED_AT
);
688 case PROTOCOL_BINARY_CMD_FLUSH
:
689 case PROTOCOL_BINARY_CMD_QUIT
:
690 case PROTOCOL_BINARY_CMD_SET
:
691 case PROTOCOL_BINARY_CMD_ADD
:
692 case PROTOCOL_BINARY_CMD_REPLACE
:
693 case PROTOCOL_BINARY_CMD_APPEND
:
694 case PROTOCOL_BINARY_CMD_PREPEND
:
695 case PROTOCOL_BINARY_CMD_DELETE
:
697 WATCHPOINT_ASSERT(bodylen
== 0);
698 return MEMCACHED_SUCCESS
;
701 case PROTOCOL_BINARY_CMD_NOOP
:
703 WATCHPOINT_ASSERT(bodylen
== 0);
704 return MEMCACHED_END
;
707 case PROTOCOL_BINARY_CMD_STAT
:
711 return MEMCACHED_END
;
713 else if (bodylen
+ 1 > buffer_length
)
715 /* not enough space in buffer.. should not happen... */
716 return MEMCACHED_UNKNOWN_READ_FAILURE
;
720 size_t keylen
= header
.response
.keylen
;
721 memset(buffer
, 0, buffer_length
);
722 if ((rc
= memcached_safe_read(instance
, buffer
, keylen
)) != MEMCACHED_SUCCESS
||
723 (rc
= memcached_safe_read(instance
, buffer
+ keylen
+ 1, bodylen
- keylen
)) != MEMCACHED_SUCCESS
)
725 WATCHPOINT_ERROR(rc
);
726 return MEMCACHED_UNKNOWN_READ_FAILURE
;
732 case PROTOCOL_BINARY_CMD_SASL_AUTH
:
733 case PROTOCOL_BINARY_CMD_SASL_STEP
:
735 memcached_result_reset(result
);
736 result
->item_cas
= header
.response
.cas
;
738 if (memcached_string_check(&result
->value
,
739 bodylen
) != MEMCACHED_SUCCESS
)
740 return MEMCACHED_MEMORY_ALLOCATION_FAILURE
;
742 char *vptr
= memcached_string_value_mutable(&result
->value
);
743 if ((rc
= memcached_safe_read(instance
, vptr
, bodylen
)) != MEMCACHED_SUCCESS
)
745 WATCHPOINT_ERROR(rc
);
746 return MEMCACHED_UNKNOWN_READ_FAILURE
;
749 memcached_string_set_length(&result
->value
, bodylen
);
754 /* Command not implemented yet! */
755 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
);
759 else if (header
.response
.bodylen
)
761 /* What should I do with the error message??? just discard it for now */
762 char hole
[SMALL_STRING_LEN
];
765 size_t nr
= (bodylen
> SMALL_STRING_LEN
) ? SMALL_STRING_LEN
: bodylen
;
766 if ((rc
= memcached_safe_read(instance
, hole
, nr
)) != MEMCACHED_SUCCESS
)
768 WATCHPOINT_ERROR(rc
);
769 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
);
771 bodylen
-= (uint32_t) nr
;
774 /* This might be an error from one of the quiet commands.. if
775 * so, just throw it away and get the next one. What about creating
776 * a callback to the user with the error information?
778 switch (header
.response
.opcode
)
780 case PROTOCOL_BINARY_CMD_SETQ
:
781 case PROTOCOL_BINARY_CMD_ADDQ
:
782 case PROTOCOL_BINARY_CMD_REPLACEQ
:
783 case PROTOCOL_BINARY_CMD_APPENDQ
:
784 case PROTOCOL_BINARY_CMD_PREPENDQ
:
785 return binary_read_one_response(instance
, buffer
, buffer_length
, result
);
792 rc
= MEMCACHED_SUCCESS
;
793 if (header
.response
.status
!= 0)
795 switch (header
.response
.status
)
797 case PROTOCOL_BINARY_RESPONSE_KEY_ENOENT
:
798 rc
= MEMCACHED_NOTFOUND
;
801 case PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS
:
802 rc
= MEMCACHED_DATA_EXISTS
;
805 case PROTOCOL_BINARY_RESPONSE_NOT_STORED
:
806 rc
= MEMCACHED_NOTSTORED
;
809 case PROTOCOL_BINARY_RESPONSE_E2BIG
:
813 case PROTOCOL_BINARY_RESPONSE_ENOMEM
:
814 rc
= MEMCACHED_MEMORY_ALLOCATION_FAILURE
;
817 case PROTOCOL_BINARY_RESPONSE_AUTH_CONTINUE
:
818 rc
= MEMCACHED_AUTH_CONTINUE
;
821 case PROTOCOL_BINARY_RESPONSE_AUTH_ERROR
:
822 rc
= MEMCACHED_AUTH_FAILURE
;
825 case PROTOCOL_BINARY_RESPONSE_EINVAL
:
826 case PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND
:
828 return memcached_set_error(*instance
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
);
836 static memcached_return_t
_read_one_response(memcached_instance_st
* instance
,
837 char *buffer
, const size_t buffer_length
,
838 memcached_result_st
*result
)
840 memcached_server_response_decrement(instance
);
844 Memcached
*root
= (Memcached
*)instance
->root
;
845 result
= &root
->result
;
848 memcached_return_t rc
;
849 if (memcached_is_binary(instance
->root
))
851 rc
= binary_read_one_response(instance
, buffer
, buffer_length
, result
);
855 rc
= textual_read_one_response(instance
, buffer
, buffer_length
, result
);
858 if (memcached_fatal(rc
))
860 memcached_io_reset(instance
);
866 memcached_return_t
memcached_read_one_response(memcached_instance_st
* instance
,
867 memcached_result_st
*result
)
869 char buffer
[SMALL_STRING_LEN
];
871 if (memcached_is_udp(instance
->root
))
873 return memcached_set_error(*instance
, MEMCACHED_NOT_SUPPORTED
, MEMCACHED_AT
);
877 return _read_one_response(instance
, buffer
, sizeof(buffer
), result
);
880 memcached_return_t
memcached_response(memcached_instance_st
* instance
,
881 memcached_result_st
*result
)
885 return memcached_response(instance
, buffer
, sizeof(buffer
), result
);
888 memcached_return_t
memcached_response(memcached_instance_st
* instance
,
889 char *buffer
, size_t buffer_length
,
890 memcached_result_st
*result
)
892 if (memcached_is_udp(instance
->root
))
894 return memcached_set_error(*instance
, MEMCACHED_NOT_SUPPORTED
, MEMCACHED_AT
);
897 /* We may have old commands in the buffer not sent, first purge */
898 if ((instance
->root
->flags
.no_block
) and (memcached_is_processing_input(instance
->root
) == false))
900 (void)memcached_io_write(instance
);
903 /* Before going into loop wait to see if we have any IO waiting for us */
906 memcached_return_t read_rc
= memcached_io_wait_for_read(instance
);
907 fprintf(stderr
, "%s:%d: %s\n", __FILE__
, __LINE__
, memcached_strerror(NULL
, read_rc
));
911 * The previous implementation purged all pending requests and just
912 * returned the last one. Purge all pending messages to ensure backwards
915 if (memcached_is_binary(instance
->root
) == false and memcached_server_response_count(instance
) > 1)
917 memcached_result_st junked_result
;
918 memcached_result_st
*junked_result_ptr
= memcached_result_create(instance
->root
, &junked_result
);
920 assert(junked_result_ptr
);
922 while (memcached_server_response_count(instance
) > 1)
924 memcached_return_t rc
= _read_one_response(instance
, buffer
, buffer_length
, junked_result_ptr
);
926 // @TODO should we return an error on another but a bad read case?
927 if (memcached_fatal(rc
))
929 memcached_result_free(junked_result_ptr
);
933 memcached_result_free(junked_result_ptr
);
936 return _read_one_response(instance
, buffer
, buffer_length
, result
);