+
+static memcached_return binary_read_one_response(memcached_server_st *ptr,
+ char *buffer, size_t buffer_length,
+ memcached_result_st *result)
+{
+ protocol_binary_response_header header;
+
+ unlikely (memcached_safe_read(ptr, &header.bytes,
+ sizeof(header.bytes)) != MEMCACHED_SUCCESS)
+ return MEMCACHED_UNKNOWN_READ_FAILURE;
+
+ unlikely (header.response.magic != PROTOCOL_BINARY_RES)
+ return MEMCACHED_PROTOCOL_ERROR;
+
+ /*
+ ** Convert the header to host local endian!
+ */
+ header.response.keylen= ntohs(header.response.keylen);
+ header.response.status= ntohs(header.response.status);
+ header.response.bodylen= ntohl(header.response.bodylen);
+ header.response.cas= ntohll(header.response.cas);
+ uint32_t bodylen= header.response.bodylen;
+
+ if (header.response.status == 0)
+ {
+ switch (header.response.opcode)
+ {
+ case PROTOCOL_BINARY_CMD_GETK:
+ case PROTOCOL_BINARY_CMD_GETKQ:
+ {
+ uint16_t keylen= header.response.keylen;
+ memcached_result_reset(result);
+ result->cas= header.response.cas;
+
+ if (memcached_safe_read(ptr, &result->flags,
+ sizeof (result->flags)) != MEMCACHED_SUCCESS)
+ return MEMCACHED_UNKNOWN_READ_FAILURE;
+
+ result->flags= ntohl(result->flags);
+ bodylen -= header.response.extlen;
+
+ result->key_length= keylen;
+ if (memcached_safe_read(ptr, result->key, keylen) != MEMCACHED_SUCCESS)
+ return MEMCACHED_UNKNOWN_READ_FAILURE;
+
+ bodylen -= keylen;
+ if (memcached_string_check(&result->value,
+ bodylen) != MEMCACHED_SUCCESS)
+ return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
+
+ char *vptr= memcached_string_value(&result->value);
+ if (memcached_safe_read(ptr, vptr, bodylen) != MEMCACHED_SUCCESS)
+ return MEMCACHED_UNKNOWN_READ_FAILURE;
+
+ memcached_string_set_length(&result->value, bodylen);
+ }
+ break;
+ case PROTOCOL_BINARY_CMD_INCREMENT:
+ case PROTOCOL_BINARY_CMD_DECREMENT:
+ {
+ if (bodylen != sizeof(uint64_t) || buffer_length != sizeof(uint64_t))
+ return MEMCACHED_PROTOCOL_ERROR;
+
+ WATCHPOINT_ASSERT(bodylen == buffer_length);
+ uint64_t val;
+ if (memcached_safe_read(ptr, &val, sizeof(val)) != MEMCACHED_SUCCESS)
+ return MEMCACHED_UNKNOWN_READ_FAILURE;
+
+ val= ntohll(val);
+ memcpy(buffer, &val, sizeof(val));
+ }
+ break;
+ case PROTOCOL_BINARY_CMD_VERSION:
+ {
+ memset(buffer, 0, buffer_length);
+ if (bodylen >= buffer_length)
+ /* not enough space in buffer.. should not happen... */
+ return MEMCACHED_UNKNOWN_READ_FAILURE;
+ else if (memcached_safe_read(ptr, buffer, bodylen) != MEMCACHED_SUCCESS)
+ return MEMCACHED_UNKNOWN_READ_FAILURE;
+ }
+ break;
+ case PROTOCOL_BINARY_CMD_FLUSH:
+ case PROTOCOL_BINARY_CMD_QUIT:
+ case PROTOCOL_BINARY_CMD_SET:
+ case PROTOCOL_BINARY_CMD_ADD:
+ case PROTOCOL_BINARY_CMD_REPLACE:
+ case PROTOCOL_BINARY_CMD_APPEND:
+ case PROTOCOL_BINARY_CMD_PREPEND:
+ case PROTOCOL_BINARY_CMD_DELETE:
+ {
+ WATCHPOINT_ASSERT(bodylen == 0);
+ return MEMCACHED_SUCCESS;
+ }
+ break;
+ case PROTOCOL_BINARY_CMD_NOOP:
+ {
+ WATCHPOINT_ASSERT(bodylen == 0);
+ return MEMCACHED_END;
+ }
+ break;
+ case PROTOCOL_BINARY_CMD_STAT:
+ {
+ if (bodylen == 0)
+ return MEMCACHED_END;
+ else if (bodylen + 1 > buffer_length)
+ /* not enough space in buffer.. should not happen... */
+ return MEMCACHED_UNKNOWN_READ_FAILURE;
+ else
+ {
+ size_t keylen= header.response.keylen;
+ memset(buffer, 0, buffer_length);
+ if (memcached_safe_read(ptr, buffer, keylen) != MEMCACHED_SUCCESS ||
+ memcached_safe_read(ptr, buffer + keylen + 1,
+ bodylen - keylen) != MEMCACHED_SUCCESS)
+ return MEMCACHED_UNKNOWN_READ_FAILURE;
+ }
+ }
+ break;
+ default:
+ {
+ /* Command not implemented yet! */
+ WATCHPOINT_ASSERT(0);
+ return MEMCACHED_PROTOCOL_ERROR;
+ }
+ }
+ }
+ else if (header.response.bodylen)
+ {
+ /* What should I do with the error message??? just discard it for now */
+ char buffer[SMALL_STRING_LEN];
+ while (bodylen > 0)
+ {
+ size_t nr= (bodylen > SMALL_STRING_LEN) ? SMALL_STRING_LEN : bodylen;
+ if (memcached_safe_read(ptr, buffer, nr) != MEMCACHED_SUCCESS)
+ return MEMCACHED_UNKNOWN_READ_FAILURE;
+ bodylen -= nr;
+ }
+ }
+
+ memcached_return rc= MEMCACHED_SUCCESS;
+ unlikely(header.response.status != 0)
+ switch (header.response.status)
+ {
+ case PROTOCOL_BINARY_RESPONSE_KEY_ENOENT:
+ rc= MEMCACHED_NOTFOUND;
+ break;
+ case PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS:
+ rc= MEMCACHED_DATA_EXISTS;
+ break;
+ case PROTOCOL_BINARY_RESPONSE_E2BIG:
+ case PROTOCOL_BINARY_RESPONSE_EINVAL:
+ case PROTOCOL_BINARY_RESPONSE_NOT_STORED:
+ case PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND:
+ case PROTOCOL_BINARY_RESPONSE_ENOMEM:
+ default:
+ /* @todo fix the error mappings */
+ rc= MEMCACHED_PROTOCOL_ERROR;
+ break;
+ }
+
+ return rc;
+}