memcached_return memcached_do(memcached_server_st *ptr, const void *command,
size_t command_length, uint8_t with_flush)
{
memcached_return rc;
ssize_t sent_length;
WATCHPOINT_ASSERT(command_length);
WATCHPOINT_ASSERT(command);
if ((rc= memcached_connect(ptr)) != MEMCACHED_SUCCESS)
{
WATCHPOINT_ERROR(rc);
return rc;
}
/*
** Since non buffering ops in UDP mode dont check to make sure they will fit
** before they start writing, if there is any data in buffer, clear it out,
** otherwise we might get a partial write.
**/
if (ptr->type == MEMCACHED_CONNECTION_UDP && with_flush && ptr->write_buffer_offset > UDP_DATAGRAM_HEADER_LENGTH)
memcached_io_write(ptr, NULL, 0, 1);
sent_length= memcached_io_write(ptr, command, command_length, (char) with_flush);
if (sent_length == -1 || (size_t)sent_length != command_length)
rc= MEMCACHED_WRITE_FAILURE;
else if ((ptr->root->flags & MEM_NOREPLY) == 0)
memcached_server_response_increment(ptr);
return rc;
}
memcached_return_t memcached_vdo(memcached_server_write_instance_st ptr,
const struct libmemcached_io_vector_st *vector, size_t count,
bool with_flush)
{
memcached_return_t rc;
ssize_t sent_length;
size_t command_length= 0;
uint32_t x;
WATCHPOINT_ASSERT(count);
WATCHPOINT_ASSERT(vector);
if ((rc= memcached_connect(ptr)) != MEMCACHED_SUCCESS)
{
WATCHPOINT_ERROR(rc);
return rc;
}
/*
** Since non buffering ops in UDP mode dont check to make sure they will fit
** before they start writing, if there is any data in buffer, clear it out,
** otherwise we might get a partial write.
**/
if (ptr->type == MEMCACHED_CONNECTION_UDP && with_flush && ptr->write_buffer_offset > UDP_DATAGRAM_HEADER_LENGTH)
{
memcached_io_write(ptr, NULL, 0, true);
}
sent_length= memcached_io_writev(ptr, vector, count, with_flush);
for (x= 0; x < count; ++x, vector++)
{
command_length+= vector->length;
}
if (sent_length == -1 || (size_t)sent_length != command_length)
{
rc= MEMCACHED_WRITE_FAILURE;
WATCHPOINT_ERROR(rc);
WATCHPOINT_ERRNO(errno);
}
else if ((ptr->root->flags.no_reply) == 0)
{
memcached_server_response_increment(ptr);
}
return rc;
}
memcached_return memcached_do(memcached_server_st *ptr, const void *command,
size_t command_length, uint8_t with_flush)
{
memcached_return rc;
ssize_t sent_length;
WATCHPOINT_ASSERT(command_length);
WATCHPOINT_ASSERT(command);
if ((rc= memcached_connect(ptr)) != MEMCACHED_SUCCESS)
return rc;
sent_length= memcached_io_write(ptr, command, command_length, with_flush);
if (sent_length == -1 || sent_length != command_length)
rc= MEMCACHED_WRITE_FAILURE;
else
memcached_server_response_increment(ptr);
return rc;
}
memcached_return memcached_vdo(memcached_server_st *ptr,
const struct libmemcached_io_vector_st *vector, size_t count,
uint8_t with_flush)
{
memcached_return rc;
ssize_t sent_length;
size_t command_length;
uint32_t x;
WATCHPOINT_ASSERT(count);
WATCHPOINT_ASSERT(vector);
if ((rc= memcached_connect(ptr)) != MEMCACHED_SUCCESS)
{
WATCHPOINT_ERROR(rc);
return rc;
}
if (ptr->type == MEMCACHED_CONNECTION_UDP && with_flush && ptr->write_buffer_offset > UDP_DATAGRAM_HEADER_LENGTH)
{
memcached_io_write(ptr, NULL, 0, true);
}
sent_length= memcached_io_writev(ptr, vector, count, (char) with_flush);
command_length = 0;
for (x= 0; x < count; ++x, vector++)
command_length+= vector->length;
if (sent_length == -1 || (size_t)sent_length != command_length) {
rc = MEMCACHED_WRITE_FAILURE;
WATCHPOINT_ERROR(rc);
} else if ((ptr->root->flags & MEM_NOREPLY) == 0)
memcached_server_response_increment(ptr);
return rc;
}
static memcached_return_t binary_read_one_response(memcached_server_write_instance_st ptr,
char *buffer, size_t buffer_length,
memcached_result_st *result)
{
memcached_return_t rc;
protocol_binary_response_header header;
if (ptr->root->flags.use_udp) {
// This is how we detect we are expecting a new UDP response
ptr->num_datagrams = 0;
}
for (;;)
{
if ((rc= memcached_safe_read(ptr, &header.bytes, sizeof(header.bytes))) != MEMCACHED_SUCCESS)
{
WATCHPOINT_ERROR(rc);
return rc;
}
if (memcached_server_response_decrement(ptr, header.response.opaque))
{
break;
} else {
memcached_safe_read(ptr, NULL, ntohl(header.response.bodylen));
}
}
if (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 == PROTOCOL_BINARY_RESPONSE_SUCCESS ||
header.response.status == PROTOCOL_BINARY_RESPONSE_AUTH_CONTINUE)
{
switch (header.response.opcode)
{
case PROTOCOL_BINARY_CMD_GETKQ:
/*
* We didn't increment the response counter for the GETKQ packet
* (only the final NOOP), so we need to increment the counter again.
*/
if (!ptr->root->flags.check_opaque)
{
memcached_server_response_increment(ptr, 0);
}
/* FALLTHROUGH */
case PROTOCOL_BINARY_CMD_GETK:
{
uint16_t keylen= header.response.keylen;
memcached_result_reset(result);
result->item_cas= header.response.cas;
if ((rc= memcached_safe_read(ptr, &result->item_flags,
sizeof (result->item_flags))) != MEMCACHED_SUCCESS)
{
WATCHPOINT_ERROR(rc);
return MEMCACHED_UNKNOWN_READ_FAILURE;
}
result->item_flags= ntohl(result->item_flags);
bodylen -= header.response.extlen;
result->key_length= keylen;
if ((rc= memcached_safe_read(ptr, result->item_key, keylen)) != MEMCACHED_SUCCESS)
{
WATCHPOINT_ERROR(rc);
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_mutable(&result->value);
if ((rc= memcached_safe_read(ptr, vptr, bodylen)) != MEMCACHED_SUCCESS)
{
WATCHPOINT_ERROR(rc);
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 ((rc= memcached_safe_read(ptr, &val, sizeof(val))) != MEMCACHED_SUCCESS)
{
WATCHPOINT_ERROR(rc);
return MEMCACHED_UNKNOWN_READ_FAILURE;
}
val= ntohll(val);
memcpy(buffer, &val, sizeof(val));
}
break;
case PROTOCOL_BINARY_CMD_SASL_LIST_MECHS:
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 ((rc= memcached_safe_read(ptr, buffer, bodylen)) != MEMCACHED_SUCCESS)
{
WATCHPOINT_ERROR(rc);
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;
}
case PROTOCOL_BINARY_CMD_NOOP:
{
WATCHPOINT_ASSERT(bodylen == 0);
return MEMCACHED_END;
}
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 ((rc= memcached_safe_read(ptr, buffer, keylen)) != MEMCACHED_SUCCESS ||
(rc= memcached_safe_read(ptr, buffer + keylen + 1, bodylen - keylen)) != MEMCACHED_SUCCESS)
{
WATCHPOINT_ERROR(rc);
return MEMCACHED_UNKNOWN_READ_FAILURE;
}
if (header.response.keylen > 0)
{
memcached_server_response_increment(ptr, header.response.opaque);
}
}
}
break;
case PROTOCOL_BINARY_CMD_SASL_AUTH:
case PROTOCOL_BINARY_CMD_SASL_STEP:
{
memcached_result_reset(result);
result->item_cas= header.response.cas;
if (memcached_string_check(&result->value,
bodylen) != MEMCACHED_SUCCESS)
return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
char *vptr= memcached_string_value_mutable(&result->value);
if ((rc= memcached_safe_read(ptr, vptr, bodylen)) != MEMCACHED_SUCCESS)
{
WATCHPOINT_ERROR(rc);
return MEMCACHED_UNKNOWN_READ_FAILURE;
}
memcached_string_set_length(&result->value, bodylen);
}
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 hole[SMALL_STRING_LEN];
while (bodylen > 0)
{
size_t nr= (bodylen > SMALL_STRING_LEN) ? SMALL_STRING_LEN : bodylen;
if ((rc= memcached_safe_read(ptr, hole, nr)) != MEMCACHED_SUCCESS)
{
WATCHPOINT_ERROR(rc);
return MEMCACHED_UNKNOWN_READ_FAILURE;
}
bodylen-= (uint32_t) nr;
}
/* This might be an error from one of the quiet commands.. if
* so, just throw it away and get the next one. What about creating
* a callback to the user with the error information?
*/
switch (header.response.opcode)
{
case PROTOCOL_BINARY_CMD_SETQ:
case PROTOCOL_BINARY_CMD_ADDQ:
case PROTOCOL_BINARY_CMD_REPLACEQ:
case PROTOCOL_BINARY_CMD_APPENDQ:
case PROTOCOL_BINARY_CMD_PREPENDQ:
if (!ptr->root->flags.check_opaque)
memcached_server_response_increment(ptr, 0);
return binary_read_one_response(ptr, buffer, buffer_length, result);
default:
break;
}
}
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_NOT_STORED:
rc= MEMCACHED_NOTSTORED;
break;
case PROTOCOL_BINARY_RESPONSE_E2BIG:
rc= MEMCACHED_E2BIG;
break;
case PROTOCOL_BINARY_RESPONSE_ENOMEM:
rc= MEMCACHED_MEMORY_ALLOCATION_FAILURE;
break;
case PROTOCOL_BINARY_RESPONSE_AUTH_CONTINUE:
rc= MEMCACHED_AUTH_CONTINUE;
break;
case PROTOCOL_BINARY_RESPONSE_AUTH_ERROR:
rc= MEMCACHED_AUTH_FAILURE;
break;
case PROTOCOL_BINARY_RESPONSE_EINVAL:
case PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND:
default:
/* @todo fix the error mappings */
rc= MEMCACHED_PROTOCOL_ERROR;
break;
}
return rc;
}
static memcached_return_t textual_read_one_response(memcached_server_write_instance_st ptr,
char *buffer, size_t buffer_length,
memcached_result_st *result)
{
memcached_return_t rc= memcached_io_readline(ptr, buffer, buffer_length);
if (rc != MEMCACHED_SUCCESS)
return rc;
if (!memcached_server_response_decrement(ptr, 0))
{
return MEMCACHED_PROTOCOL_ERROR;
}
switch(buffer[0])
{
case 'V': /* VALUE || VERSION */
if (buffer[1] == 'A') /* VALUE */
{
/* We add back in one because we will need to search for END */
memcached_server_response_increment(ptr, 0);
return textual_value_fetch(ptr, buffer, result);
}
else if (buffer[1] == 'E') /* VERSION */
{
return MEMCACHED_SUCCESS;
}
else
{
WATCHPOINT_STRING(buffer);
return MEMCACHED_UNKNOWN_READ_FAILURE;
}
case 'O': /* OK */
return MEMCACHED_SUCCESS;
case 'S': /* STORED STATS SERVER_ERROR */
{
if (buffer[2] == 'A') /* STORED STATS */
{
memcached_server_response_increment(ptr, 0);
return MEMCACHED_STAT;
}
else if (buffer[1] == 'E') /* SERVER_ERROR */
{
char *rel_ptr;
char *startptr= buffer + 13, *endptr= startptr;
while (*endptr != '\r' && *endptr != '\n') endptr++;
/*
Yes, we could make this "efficent" but to do that we would need
to maintain more state for the size of the buffer. Why waste
memory in the struct, which is important, for something that
rarely should happen?
*/
rel_ptr= (char *)libmemcached_realloc(ptr->root,
ptr->cached_server_error,
(size_t) (endptr - startptr + 1));
if (rel_ptr == NULL)
{
/* If we happened to have some memory, we just null it since we don't know the size */
if (ptr->cached_server_error)
ptr->cached_server_error[0]= 0;
return MEMCACHED_SERVER_ERROR;
}
ptr->cached_server_error= rel_ptr;
memcpy(ptr->cached_server_error, startptr, (size_t) (endptr - startptr));
ptr->cached_server_error[endptr - startptr]= 0;
return MEMCACHED_SERVER_ERROR;
}
else if (buffer[1] == 'T')
return MEMCACHED_STORED;
else
{
WATCHPOINT_STRING(buffer);
return MEMCACHED_UNKNOWN_READ_FAILURE;
}
}
case 'D': /* DELETED */
return MEMCACHED_DELETED;
case 'N': /* NOT_FOUND */
{
if (buffer[4] == 'F')
return MEMCACHED_NOTFOUND;
else if (buffer[4] == 'S')
return MEMCACHED_NOTSTORED;
else
{
WATCHPOINT_STRING(buffer);
return MEMCACHED_UNKNOWN_READ_FAILURE;
}
}
case 'E': /* PROTOCOL ERROR or END */
{
if (buffer[1] == 'N')
return MEMCACHED_END;
else if (buffer[1] == 'R')
return MEMCACHED_PROTOCOL_ERROR;
else if (buffer[1] == 'X')
return MEMCACHED_DATA_EXISTS;
else
{
WATCHPOINT_STRING(buffer);
return MEMCACHED_UNKNOWN_READ_FAILURE;
}
}
case 'I': /* CLIENT ERROR */
/* We add back in one because we will need to search for END */
memcached_server_response_increment(ptr, 0);
return MEMCACHED_ITEM;
case 'C': /* CLIENT ERROR */
return MEMCACHED_CLIENT_ERROR;
default:
{
unsigned long long auto_return_value;
if (sscanf(buffer, "%llu", &auto_return_value) == 1)
return MEMCACHED_SUCCESS;
WATCHPOINT_STRING(buffer);
return MEMCACHED_UNKNOWN_READ_FAILURE;
}
}
/* NOTREACHED */
}
