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>
40 static memcached_return_t
textual_read_one_response(memcached_server_write_instance_st ptr
,
41 char *buffer
, size_t buffer_length
,
42 memcached_result_st
*result
);
43 static memcached_return_t
binary_read_one_response(memcached_server_write_instance_st ptr
,
44 char *buffer
, size_t buffer_length
,
45 memcached_result_st
*result
);
47 memcached_return_t
memcached_read_one_response(memcached_server_write_instance_st ptr
,
48 char *buffer
, size_t buffer_length
,
49 memcached_result_st
*result
)
51 memcached_server_response_decrement(ptr
);
55 memcached_st
*root
= (memcached_st
*)ptr
->root
;
56 result
= &root
->result
;
59 memcached_return_t rc
;
60 if (ptr
->root
->flags
.binary_protocol
)
62 rc
= binary_read_one_response(ptr
, buffer
, buffer_length
, result
);
66 rc
= textual_read_one_response(ptr
, buffer
, buffer_length
, result
);
69 unlikely(rc
== MEMCACHED_UNKNOWN_READ_FAILURE
or
70 rc
== MEMCACHED_PROTOCOL_ERROR
or
71 rc
== MEMCACHED_CLIENT_ERROR
or
72 rc
== MEMCACHED_MEMORY_ALLOCATION_FAILURE
)
73 memcached_io_reset(ptr
);
78 memcached_return_t
memcached_response(memcached_server_write_instance_st ptr
,
79 char *buffer
, size_t buffer_length
,
80 memcached_result_st
*result
)
82 /* We may have old commands in the buffer not set, first purge */
83 if ((ptr
->root
->flags
.no_block
) && (memcached_is_processing_input(ptr
->root
) == false))
85 (void)memcached_io_write(ptr
, NULL
, 0, true);
89 * The previous implementation purged all pending requests and just
90 * returned the last one. Purge all pending messages to ensure backwards
93 if (ptr
->root
->flags
.binary_protocol
== false)
95 while (memcached_server_response_count(ptr
) > 1)
97 memcached_return_t rc
= memcached_read_one_response(ptr
, buffer
, buffer_length
, result
);
99 unlikely (rc
!= MEMCACHED_END
&&
100 rc
!= MEMCACHED_STORED
&&
101 rc
!= MEMCACHED_SUCCESS
&&
102 rc
!= MEMCACHED_STAT
&&
103 rc
!= MEMCACHED_DELETED
&&
104 rc
!= MEMCACHED_NOTFOUND
&&
105 rc
!= MEMCACHED_NOTSTORED
&&
106 rc
!= MEMCACHED_DATA_EXISTS
)
111 return memcached_read_one_response(ptr
, buffer
, buffer_length
, result
);
114 static memcached_return_t
textual_value_fetch(memcached_server_write_instance_st ptr
,
116 memcached_result_st
*result
)
123 ssize_t read_length
= 0;
125 if (ptr
->root
->flags
.use_udp
)
126 return memcached_set_error(*ptr
, MEMCACHED_NOT_SUPPORTED
, MEMCACHED_AT
);
128 WATCHPOINT_ASSERT(ptr
->root
);
129 end_ptr
= buffer
+ MEMCACHED_DEFAULT_COMMAND_SIZE
;
131 memcached_result_reset(result
);
134 string_ptr
+= 6; /* "VALUE " */
137 /* We load the key */
140 size_t prefix_length
;
142 key
= result
->item_key
;
143 result
->key_length
= 0;
145 for (prefix_length
= memcached_array_size(ptr
->root
->prefix_key
); !(iscntrl(*string_ptr
) || isspace(*string_ptr
)) ; string_ptr
++)
147 if (prefix_length
== 0)
151 result
->key_length
++;
156 result
->item_key
[result
->key_length
]= 0;
159 if (end_ptr
== string_ptr
)
162 /* Flags fetch move past space */
164 if (end_ptr
== string_ptr
)
167 for (next_ptr
= string_ptr
; isdigit(*string_ptr
); string_ptr
++) {};
168 result
->item_flags
= (uint32_t) strtoul(next_ptr
, &string_ptr
, 10);
170 if (end_ptr
== string_ptr
)
173 /* Length fetch move past space*/
175 if (end_ptr
== string_ptr
)
178 for (next_ptr
= string_ptr
; isdigit(*string_ptr
); string_ptr
++) {};
179 value_length
= (size_t)strtoull(next_ptr
, &string_ptr
, 10);
181 if (end_ptr
== string_ptr
)
185 if (*string_ptr
== '\r')
187 /* Skip past the \r\n */
193 for (next_ptr
= string_ptr
; isdigit(*string_ptr
); string_ptr
++) {};
194 result
->item_cas
= strtoull(next_ptr
, &string_ptr
, 10);
197 if (end_ptr
< string_ptr
)
200 /* We add two bytes so that we can walk the \r\n */
201 if (memcached_failed(memcached_string_check(&result
->value
, value_length
+2)))
204 return memcached_set_error(*ptr
, MEMCACHED_MEMORY_ALLOCATION_FAILURE
, MEMCACHED_AT
);
208 char *value_ptr
= memcached_string_value_mutable(&result
->value
);
210 We read the \r\n into the string since not doing so is more
211 cycles then the waster of memory to do so.
213 We are null terminating through, which will most likely make
214 some people lazy about using the return length.
216 to_read
= (value_length
) + 2;
217 memcached_return_t rrc
= memcached_io_read(ptr
, value_ptr
, to_read
, &read_length
);
218 if (memcached_failed(rrc
) and rrc
== MEMCACHED_IN_PROGRESS
)
220 memcached_quit_server(ptr
, true);
221 return memcached_set_error(*ptr
, rrc
, MEMCACHED_AT
);
223 else if (memcached_failed(rrc
))
229 if (read_length
!= (ssize_t
)(value_length
+ 2))
234 /* This next bit blows the API, but this is internal....*/
237 char_ptr
= memcached_string_value_mutable(&result
->value
);;
238 char_ptr
[value_length
]= 0;
239 char_ptr
[value_length
+1]= 0;
240 memcached_string_set_length(&result
->value
, value_length
);
243 return MEMCACHED_SUCCESS
;
246 memcached_io_reset(ptr
);
248 return MEMCACHED_PARTIAL_READ
;
251 static memcached_return_t
textual_read_one_response(memcached_server_write_instance_st ptr
,
252 char *buffer
, size_t buffer_length
,
253 memcached_result_st
*result
)
255 memcached_return_t rc
= memcached_io_readline(ptr
, buffer
, buffer_length
);
256 if (memcached_failed(rc
))
263 case 'V': /* VALUE || VERSION */
264 if (buffer
[1] == 'A') /* VALUE */
266 /* We add back in one because we will need to search for END */
267 memcached_server_response_increment(ptr
);
268 return textual_value_fetch(ptr
, buffer
, result
);
270 else if (buffer
[1] == 'E') /* VERSION */
272 return MEMCACHED_SUCCESS
;
276 WATCHPOINT_STRING(buffer
);
277 return MEMCACHED_UNKNOWN_READ_FAILURE
;
280 return MEMCACHED_SUCCESS
;
281 case 'S': /* STORED STATS SERVER_ERROR */
283 if (buffer
[2] == 'A') /* STORED STATS */
285 memcached_server_response_increment(ptr
);
286 return MEMCACHED_STAT
;
288 else if (buffer
[1] == 'E') /* SERVER_ERROR */
290 char *startptr
= buffer
+ 13, *endptr
= startptr
;
292 while (*endptr
!= '\r' && *endptr
!= '\n') endptr
++;
295 Yes, we could make this "efficent" but to do that we would need
296 to maintain more state for the size of the buffer. Why waste
297 memory in the struct, which is important, for something that
298 rarely should happen?
300 char *rel_ptr
= (char *)libmemcached_realloc(ptr
->root
,
301 ptr
->cached_server_error
,
302 (size_t) (endptr
- startptr
+ 1));
306 /* If we happened to have some memory, we just null it since we don't know the size */
307 if (ptr
->cached_server_error
)
308 ptr
->cached_server_error
[0]= 0;
309 return MEMCACHED_SERVER_ERROR
;
311 ptr
->cached_server_error
= rel_ptr
;
313 memcpy(ptr
->cached_server_error
, startptr
, (size_t) (endptr
- startptr
));
314 ptr
->cached_server_error
[endptr
- startptr
]= 0;
315 return MEMCACHED_SERVER_ERROR
;
317 else if (buffer
[1] == 'T')
319 return MEMCACHED_STORED
;
323 WATCHPOINT_STRING(buffer
);
324 return MEMCACHED_UNKNOWN_READ_FAILURE
;
327 case 'D': /* DELETED */
328 return MEMCACHED_DELETED
;
330 case 'N': /* NOT_FOUND */
332 if (buffer
[4] == 'F')
333 return MEMCACHED_NOTFOUND
;
334 else if (buffer
[4] == 'S')
335 return MEMCACHED_NOTSTORED
;
338 WATCHPOINT_STRING(buffer
);
339 return MEMCACHED_UNKNOWN_READ_FAILURE
;
342 case 'E': /* PROTOCOL ERROR or END */
344 if (buffer
[1] == 'N')
345 return MEMCACHED_END
;
346 else if (buffer
[1] == 'R')
347 return MEMCACHED_PROTOCOL_ERROR
;
348 else if (buffer
[1] == 'X')
349 return MEMCACHED_DATA_EXISTS
;
352 WATCHPOINT_STRING(buffer
);
353 return MEMCACHED_UNKNOWN_READ_FAILURE
;
357 case 'I': /* CLIENT ERROR */
358 /* We add back in one because we will need to search for END */
359 memcached_server_response_increment(ptr
);
360 return MEMCACHED_ITEM
;
361 case 'C': /* CLIENT ERROR */
362 return MEMCACHED_CLIENT_ERROR
;
365 unsigned long long auto_return_value
;
367 if (sscanf(buffer
, "%llu", &auto_return_value
) == 1)
368 return MEMCACHED_SUCCESS
;
370 WATCHPOINT_STRING(buffer
);
371 return MEMCACHED_UNKNOWN_READ_FAILURE
;
378 static memcached_return_t
binary_read_one_response(memcached_server_write_instance_st ptr
,
379 char *buffer
, size_t buffer_length
,
380 memcached_result_st
*result
)
382 memcached_return_t rc
;
383 protocol_binary_response_header header
;
385 if ((rc
= memcached_safe_read(ptr
, &header
.bytes
, sizeof(header
.bytes
))) != MEMCACHED_SUCCESS
)
387 WATCHPOINT_ERROR(rc
);
391 if (header
.response
.magic
!= PROTOCOL_BINARY_RES
)
393 return MEMCACHED_PROTOCOL_ERROR
;
397 ** Convert the header to host local endian!
399 header
.response
.keylen
= ntohs(header
.response
.keylen
);
400 header
.response
.status
= ntohs(header
.response
.status
);
401 header
.response
.bodylen
= ntohl(header
.response
.bodylen
);
402 header
.response
.cas
= memcached_ntohll(header
.response
.cas
);
403 uint32_t bodylen
= header
.response
.bodylen
;
405 if (header
.response
.status
== PROTOCOL_BINARY_RESPONSE_SUCCESS
||
406 header
.response
.status
== PROTOCOL_BINARY_RESPONSE_AUTH_CONTINUE
)
408 switch (header
.response
.opcode
)
410 case PROTOCOL_BINARY_CMD_GETKQ
:
412 * We didn't increment the response counter for the GETKQ packet
413 * (only the final NOOP), so we need to increment the counter again.
415 memcached_server_response_increment(ptr
);
417 case PROTOCOL_BINARY_CMD_GETK
:
419 uint16_t keylen
= header
.response
.keylen
;
420 memcached_result_reset(result
);
421 result
->item_cas
= header
.response
.cas
;
423 if ((rc
= memcached_safe_read(ptr
, &result
->item_flags
, sizeof (result
->item_flags
))) != MEMCACHED_SUCCESS
)
425 WATCHPOINT_ERROR(rc
);
426 return MEMCACHED_UNKNOWN_READ_FAILURE
;
429 result
->item_flags
= ntohl(result
->item_flags
);
430 bodylen
-= header
.response
.extlen
;
432 result
->key_length
= keylen
;
433 if (memcached_failed(rc
= memcached_safe_read(ptr
, result
->item_key
, keylen
)))
435 WATCHPOINT_ERROR(rc
);
436 return MEMCACHED_UNKNOWN_READ_FAILURE
;
439 // Only bother with doing this if key_length > 0
440 if (result
->key_length
)
442 if (memcached_array_size(ptr
->root
->prefix_key
) and memcached_array_size(ptr
->root
->prefix_key
) >= result
->key_length
)
444 return memcached_set_error(*ptr
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
);
447 if (memcached_array_size(ptr
->root
->prefix_key
))
449 result
->key_length
-= memcached_array_size(ptr
->root
->prefix_key
);
450 memmove(result
->item_key
, result
->item_key
+memcached_array_size(ptr
->root
->prefix_key
), result
->key_length
);
455 if (memcached_failed(memcached_string_check(&result
->value
, bodylen
)))
457 return MEMCACHED_MEMORY_ALLOCATION_FAILURE
;
460 char *vptr
= memcached_string_value_mutable(&result
->value
);
461 if (memcached_failed(rc
= memcached_safe_read(ptr
, vptr
, bodylen
)))
463 WATCHPOINT_ERROR(rc
);
464 return MEMCACHED_UNKNOWN_READ_FAILURE
;
467 memcached_string_set_length(&result
->value
, bodylen
);
471 case PROTOCOL_BINARY_CMD_INCREMENT
:
472 case PROTOCOL_BINARY_CMD_DECREMENT
:
474 if (bodylen
!= sizeof(uint64_t) || buffer_length
!= sizeof(uint64_t))
476 return MEMCACHED_PROTOCOL_ERROR
;
479 WATCHPOINT_ASSERT(bodylen
== buffer_length
);
481 if ((rc
= memcached_safe_read(ptr
, &val
, sizeof(val
))) != MEMCACHED_SUCCESS
)
483 WATCHPOINT_ERROR(rc
);
484 return MEMCACHED_UNKNOWN_READ_FAILURE
;
487 val
= memcached_ntohll(val
);
488 memcpy(buffer
, &val
, sizeof(val
));
492 case PROTOCOL_BINARY_CMD_SASL_LIST_MECHS
:
493 case PROTOCOL_BINARY_CMD_VERSION
:
495 memset(buffer
, 0, buffer_length
);
496 if (bodylen
>= buffer_length
)
498 /* not enough space in buffer.. should not happen... */
499 return MEMCACHED_UNKNOWN_READ_FAILURE
;
501 else if ((rc
= memcached_safe_read(ptr
, buffer
, bodylen
)) != MEMCACHED_SUCCESS
)
503 WATCHPOINT_ERROR(rc
);
504 return MEMCACHED_UNKNOWN_READ_FAILURE
;
508 case PROTOCOL_BINARY_CMD_FLUSH
:
509 case PROTOCOL_BINARY_CMD_QUIT
:
510 case PROTOCOL_BINARY_CMD_SET
:
511 case PROTOCOL_BINARY_CMD_ADD
:
512 case PROTOCOL_BINARY_CMD_REPLACE
:
513 case PROTOCOL_BINARY_CMD_APPEND
:
514 case PROTOCOL_BINARY_CMD_PREPEND
:
515 case PROTOCOL_BINARY_CMD_DELETE
:
517 WATCHPOINT_ASSERT(bodylen
== 0);
518 return MEMCACHED_SUCCESS
;
520 case PROTOCOL_BINARY_CMD_NOOP
:
522 WATCHPOINT_ASSERT(bodylen
== 0);
523 return MEMCACHED_END
;
525 case PROTOCOL_BINARY_CMD_STAT
:
529 return MEMCACHED_END
;
531 else if (bodylen
+ 1 > buffer_length
)
533 /* not enough space in buffer.. should not happen... */
534 return MEMCACHED_UNKNOWN_READ_FAILURE
;
538 size_t keylen
= header
.response
.keylen
;
539 memset(buffer
, 0, buffer_length
);
540 if ((rc
= memcached_safe_read(ptr
, buffer
, keylen
)) != MEMCACHED_SUCCESS
||
541 (rc
= memcached_safe_read(ptr
, buffer
+ keylen
+ 1, bodylen
- keylen
)) != MEMCACHED_SUCCESS
)
543 WATCHPOINT_ERROR(rc
);
544 return MEMCACHED_UNKNOWN_READ_FAILURE
;
550 case PROTOCOL_BINARY_CMD_SASL_AUTH
:
551 case PROTOCOL_BINARY_CMD_SASL_STEP
:
553 memcached_result_reset(result
);
554 result
->item_cas
= header
.response
.cas
;
556 if (memcached_string_check(&result
->value
,
557 bodylen
) != MEMCACHED_SUCCESS
)
558 return MEMCACHED_MEMORY_ALLOCATION_FAILURE
;
560 char *vptr
= memcached_string_value_mutable(&result
->value
);
561 if ((rc
= memcached_safe_read(ptr
, vptr
, bodylen
)) != MEMCACHED_SUCCESS
)
563 WATCHPOINT_ERROR(rc
);
564 return MEMCACHED_UNKNOWN_READ_FAILURE
;
567 memcached_string_set_length(&result
->value
, bodylen
);
572 /* Command not implemented yet! */
573 WATCHPOINT_ASSERT(0);
574 return MEMCACHED_PROTOCOL_ERROR
;
578 else if (header
.response
.bodylen
)
580 /* What should I do with the error message??? just discard it for now */
581 char hole
[SMALL_STRING_LEN
];
584 size_t nr
= (bodylen
> SMALL_STRING_LEN
) ? SMALL_STRING_LEN
: bodylen
;
585 if ((rc
= memcached_safe_read(ptr
, hole
, nr
)) != MEMCACHED_SUCCESS
)
587 WATCHPOINT_ERROR(rc
);
588 return memcached_set_error(*ptr
, MEMCACHED_UNKNOWN_READ_FAILURE
, MEMCACHED_AT
);
590 bodylen
-= (uint32_t) nr
;
593 /* This might be an error from one of the quiet commands.. if
594 * so, just throw it away and get the next one. What about creating
595 * a callback to the user with the error information?
597 switch (header
.response
.opcode
)
599 case PROTOCOL_BINARY_CMD_SETQ
:
600 case PROTOCOL_BINARY_CMD_ADDQ
:
601 case PROTOCOL_BINARY_CMD_REPLACEQ
:
602 case PROTOCOL_BINARY_CMD_APPENDQ
:
603 case PROTOCOL_BINARY_CMD_PREPENDQ
:
604 return binary_read_one_response(ptr
, buffer
, buffer_length
, result
);
610 rc
= MEMCACHED_SUCCESS
;
611 unlikely(header
.response
.status
!= 0)
612 switch (header
.response
.status
)
614 case PROTOCOL_BINARY_RESPONSE_KEY_ENOENT
:
615 rc
= MEMCACHED_NOTFOUND
;
617 case PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS
:
618 rc
= MEMCACHED_DATA_EXISTS
;
620 case PROTOCOL_BINARY_RESPONSE_NOT_STORED
:
621 rc
= MEMCACHED_NOTSTORED
;
623 case PROTOCOL_BINARY_RESPONSE_E2BIG
:
626 case PROTOCOL_BINARY_RESPONSE_ENOMEM
:
627 rc
= MEMCACHED_MEMORY_ALLOCATION_FAILURE
;
629 case PROTOCOL_BINARY_RESPONSE_AUTH_CONTINUE
:
630 rc
= MEMCACHED_AUTH_CONTINUE
;
632 case PROTOCOL_BINARY_RESPONSE_AUTH_ERROR
:
633 rc
= MEMCACHED_AUTH_FAILURE
;
635 case PROTOCOL_BINARY_RESPONSE_EINVAL
:
636 case PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND
:
638 /* @todo fix the error mappings */
639 rc
= MEMCACHED_PROTOCOL_ERROR
;