#include "common.h"
-static memcached_return_t textual_read_one_response(memcached_server_instance_st *ptr,
+static memcached_return_t textual_read_one_response(memcached_server_write_instance_st ptr,
char *buffer, size_t buffer_length,
memcached_result_st *result);
-static memcached_return_t binary_read_one_response(memcached_server_instance_st *ptr,
+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 memcached_read_one_response(memcached_server_instance_st *ptr,
+memcached_return_t memcached_read_one_response(memcached_server_write_instance_st ptr,
char *buffer, size_t buffer_length,
memcached_result_st *result)
{
return rc;
}
-memcached_return_t memcached_response(memcached_server_instance_st *ptr,
+memcached_return_t memcached_response(memcached_server_write_instance_st ptr,
char *buffer, size_t buffer_length,
memcached_result_st *result)
{
/* We may have old commands in the buffer not set, first purge */
if ((ptr->root->flags.no_block) && (memcached_is_processing_input(ptr->root) == false))
{
- (void)memcached_io_write(ptr, NULL, 0, 1);
+ (void)memcached_io_write(ptr, NULL, 0, true);
}
/*
* The previous implementation purged all pending requests and just
* returned the last one. Purge all pending messages to ensure backwards
- * compatibility.
+ * compatibility.
*/
if (ptr->root->flags.binary_protocol == false)
while (memcached_server_response_count(ptr) > 1)
unlikely (rc != MEMCACHED_END &&
rc != MEMCACHED_STORED &&
rc != MEMCACHED_SUCCESS &&
- rc != MEMCACHED_STAT &&
+ rc != MEMCACHED_STAT &&
rc != MEMCACHED_DELETED &&
rc != MEMCACHED_NOTFOUND &&
- rc != MEMCACHED_NOTSTORED &&
+ rc != MEMCACHED_NOTSTORED &&
rc != MEMCACHED_DATA_EXISTS)
return rc;
}
return memcached_read_one_response(ptr, buffer, buffer_length, result);
}
-static memcached_return_t textual_value_fetch(memcached_server_instance_st *ptr,
+static memcached_return_t textual_value_fetch(memcached_server_write_instance_st ptr,
char *buffer,
memcached_result_st *result)
{
char *key;
size_t prefix_length;
- key= result->key;
+ key= result->item_key;
result->key_length= 0;
for (prefix_length= ptr->root->prefix_key_length; !(iscntrl(*string_ptr) || isspace(*string_ptr)) ; string_ptr++)
else
prefix_length--;
}
- result->key[result->key_length]= 0;
+ result->item_key[result->key_length]= 0;
}
if (end_ptr == string_ptr)
if (end_ptr == string_ptr)
goto read_error;
for (next_ptr= string_ptr; isdigit(*string_ptr); string_ptr++);
- result->flags= (uint32_t) strtoul(next_ptr, &string_ptr, 10);
+ result->item_flags= (uint32_t) strtoul(next_ptr, &string_ptr, 10);
if (end_ptr == string_ptr)
goto read_error;
{
string_ptr++;
for (next_ptr= string_ptr; isdigit(*string_ptr); string_ptr++);
- result->cas= strtoull(next_ptr, &string_ptr, 10);
+ result->item_cas= strtoull(next_ptr, &string_ptr, 10);
}
if (end_ptr < string_ptr)
return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
}
- value_ptr= memcached_string_value(&result->value);
- /*
- We read the \r\n into the string since not doing so is more
+ value_ptr= memcached_string_value_mutable(&result->value);
+ /*
+ We read the \r\n into the string since not doing so is more
cycles then the waster of memory to do so.
We are null terminating through, which will most likely make
/* This next bit blows the API, but this is internal....*/
{
char *char_ptr;
- char_ptr= memcached_string_value(&result->value);;
+ char_ptr= memcached_string_value_mutable(&result->value);;
char_ptr[value_length]= 0;
char_ptr[value_length + 1]= 0;
memcached_string_set_length(&result->value, value_length);
return MEMCACHED_PARTIAL_READ;
}
-static memcached_return_t textual_read_one_response(memcached_server_instance_st *ptr,
+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_server_response_increment(ptr);
return MEMCACHED_STAT;
}
- else if (buffer[1] == 'E') /* SERVER_ERROR */
+ 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,
+ ptr->cached_server_error,
(size_t) (endptr - startptr + 1));
if (rel_ptr == NULL)
/* NOTREACHED */
}
-static memcached_return_t binary_read_one_response(memcached_server_instance_st *ptr,
+static memcached_return_t binary_read_one_response(memcached_server_write_instance_st ptr,
char *buffer, size_t buffer_length,
memcached_result_st *result)
{
protocol_binary_response_header header;
- unlikely (memcached_safe_read(ptr, &header.bytes,
+ unlikely (memcached_safe_read(ptr, &header.bytes,
sizeof(header.bytes)) != MEMCACHED_SUCCESS)
return MEMCACHED_UNKNOWN_READ_FAILURE;
- unlikely (header.response.magic != PROTOCOL_BINARY_RES)
+ unlikely (header.response.magic != PROTOCOL_BINARY_RES)
return MEMCACHED_PROTOCOL_ERROR;
/*
header.response.cas= ntohll(header.response.cas);
uint32_t bodylen= header.response.bodylen;
- if (header.response.status == 0)
+ if (header.response.status == PROTOCOL_BINARY_RESPONSE_SUCCESS ||
+ header.response.status == PROTOCOL_BINARY_RESPONSE_AUTH_CONTINUE)
{
switch (header.response.opcode)
{
/*
* We didn't increment the response counter for the GETKQ packet
* (only the final NOOP), so we need to increment the counter again.
- */
- memcached_server_response_increment(ptr);
+ */
+ memcached_server_response_increment(ptr);
/* FALLTHROUGH */
case PROTOCOL_BINARY_CMD_GETK:
{
uint16_t keylen= header.response.keylen;
memcached_result_reset(result);
- result->cas= header.response.cas;
+ result->item_cas= header.response.cas;
- if (memcached_safe_read(ptr, &result->flags,
- sizeof (result->flags)) != MEMCACHED_SUCCESS)
+ if (memcached_safe_read(ptr, &result->item_flags,
+ sizeof (result->item_flags)) != MEMCACHED_SUCCESS)
return MEMCACHED_UNKNOWN_READ_FAILURE;
- result->flags= ntohl(result->flags);
+ result->item_flags= ntohl(result->item_flags);
bodylen -= header.response.extlen;
result->key_length= keylen;
- if (memcached_safe_read(ptr, result->key, keylen) != MEMCACHED_SUCCESS)
+ if (memcached_safe_read(ptr, result->item_key, keylen) != MEMCACHED_SUCCESS)
return MEMCACHED_UNKNOWN_READ_FAILURE;
bodylen -= keylen;
if (memcached_string_check(&result->value,
- bodylen) != MEMCACHED_SUCCESS)
+ bodylen) != MEMCACHED_SUCCESS)
return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
- char *vptr= memcached_string_value(&result->value);
- if (memcached_safe_read(ptr, vptr, bodylen) != MEMCACHED_SUCCESS)
+ char *vptr= memcached_string_value_mutable(&result->value);
+ if (memcached_safe_read(ptr, vptr, bodylen) != MEMCACHED_SUCCESS)
return MEMCACHED_UNKNOWN_READ_FAILURE;
- memcached_string_set_length(&result->value, bodylen);
- }
+ 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))
+ 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)
+ 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_SASL_LIST_MECHS:
case PROTOCOL_BINARY_CMD_VERSION:
{
memset(buffer, 0, buffer_length);
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:
{
WATCHPOINT_ASSERT(bodylen == 0);
return MEMCACHED_SUCCESS;
- }
+ }
case PROTOCOL_BINARY_CMD_NOOP:
{
WATCHPOINT_ASSERT(bodylen == 0);
else if (bodylen + 1 > buffer_length)
/* not enough space in buffer.. should not happen... */
return MEMCACHED_UNKNOWN_READ_FAILURE;
- else
+ else
{
- size_t keylen= header.response.keylen;
+ 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,
+ memcached_safe_read(ptr, buffer + keylen + 1,
bodylen - keylen) != MEMCACHED_SUCCESS)
return MEMCACHED_UNKNOWN_READ_FAILURE;
}
- }
+ }
+ 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 (memcached_safe_read(ptr, vptr, bodylen) != MEMCACHED_SUCCESS)
+ 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)
+ }
+ 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)
+ while (bodylen > 0)
{
size_t nr= (bodylen > SMALL_STRING_LEN) ? SMALL_STRING_LEN : bodylen;
if (memcached_safe_read(ptr, hole, nr) != MEMCACHED_SUCCESS)
}
memcached_return_t rc= MEMCACHED_SUCCESS;
- unlikely(header.response.status != 0)
- switch (header.response.status)
+ unlikely(header.response.status != 0)
+ switch (header.response.status)
{
case PROTOCOL_BINARY_RESPONSE_KEY_ENOENT:
rc= MEMCACHED_NOTFOUND;
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:
projects / awesomized / libmemcached / blobdiff