#include <libmemcached/common.h>
#include <libmemcached/string.hpp>
-static memcached_return_t textual_value_fetch(memcached_server_write_instance_st instance,
+static memcached_return_t textual_value_fetch(memcached_instance_st* instance,
char *buffer,
memcached_result_st *result)
{
string_ptr+= 6; /* "VALUE " */
+ // Just used for cases of AES decrypt currently
+ memcached_return_t rc= MEMCACHED_SUCCESS;
+
/* We load the key */
{
char *key= result->item_key;
}
for (next_ptr= string_ptr; isdigit(*string_ptr); string_ptr++) {};
+ errno= 0;
result->item_flags= (uint32_t) strtoul(next_ptr, &string_ptr, 10);
- if (end_ptr == string_ptr)
+ if (errno != 0 or end_ptr == string_ptr)
{
goto read_error;
}
}
for (next_ptr= string_ptr; isdigit(*string_ptr); string_ptr++) {};
+ errno= 0;
value_length= (size_t)strtoull(next_ptr, &string_ptr, 10);
- if (end_ptr == string_ptr)
+ if (errno != 0 or end_ptr == string_ptr)
{
goto read_error;
}
{
string_ptr++;
for (next_ptr= string_ptr; isdigit(*string_ptr); string_ptr++) {};
+ errno= 0;
result->item_cas= strtoull(next_ptr, &string_ptr, 10);
}
- if (end_ptr < string_ptr)
+ if (errno != 0 or end_ptr < string_ptr)
{
goto read_error;
}
memcached_string_set_length(&result->value, value_length);
}
- return MEMCACHED_SUCCESS;
+ if (memcached_is_encrypted(instance->root) and memcached_result_length(result))
+ {
+ hashkit_string_st *destination;
+
+ if ((destination= hashkit_decrypt(&instance->root->hashkit,
+ memcached_result_value(result), memcached_result_length(result))) == NULL)
+ {
+ rc= memcached_set_error(*instance->root, MEMCACHED_FAILURE,
+ MEMCACHED_AT, memcached_literal_param("hashkit_decrypt() failed"));
+ }
+ else
+ {
+ memcached_result_reset_value(result);
+ if (memcached_failed(memcached_result_set_value(result, hashkit_string_c_str(destination), hashkit_string_length(destination))))
+ {
+ rc= memcached_set_error(*instance->root, MEMCACHED_FAILURE,
+ MEMCACHED_AT, memcached_literal_param("hashkit_decrypt() failed"));
+ }
+ }
+
+ if (memcached_failed(rc))
+ {
+ memcached_result_reset(result);
+ }
+ hashkit_string_free(destination);
+ }
+
+ return rc;
read_error:
memcached_io_reset(instance);
return MEMCACHED_PARTIAL_READ;
}
-static memcached_return_t textual_read_one_response(memcached_server_write_instance_st instance,
+static memcached_return_t textual_read_one_response(memcached_instance_st* instance,
char *buffer, const size_t buffer_length,
memcached_result_st *result)
{
{
/* Find the space, and then move one past it to copy version */
char *response_ptr= index(buffer, ' ');
- response_ptr++;
- long int version= strtol(response_ptr, (char **)NULL, 10);
- if (version == LONG_MIN or version == LONG_MAX or errno == EINVAL or version > UINT8_MAX or version == 0)
+ char *endptr;
+ errno= 0;
+ long int version= strtol(response_ptr, &endptr, 10);
+ if (errno != 0 or version == LONG_MIN or version == LONG_MAX or version > UINT8_MAX or version == 0)
{
instance->major_version= instance->minor_version= instance->micro_version= UINT8_MAX;
return memcached_set_error(*instance, MEMCACHED_UNKNOWN_READ_FAILURE, MEMCACHED_AT, memcached_literal_param("strtol() failed to parse major version"));
}
instance->major_version= uint8_t(version);
- response_ptr= index(response_ptr, '.');
- response_ptr++;
-
- version= strtol(response_ptr, (char **)NULL, 10);
- if (version == LONG_MIN or version == LONG_MAX or errno == EINVAL or version > UINT8_MAX)
+ endptr++;
+ errno= 0;
+ version= strtol(endptr, &endptr, 10);
+ if (errno != 0 or version == LONG_MIN or version == LONG_MAX or version > UINT8_MAX)
{
instance->major_version= instance->minor_version= instance->micro_version= UINT8_MAX;
return memcached_set_error(*instance, MEMCACHED_UNKNOWN_READ_FAILURE, MEMCACHED_AT, memcached_literal_param("strtol() failed to parse minor version"));
}
instance->minor_version= uint8_t(version);
- response_ptr= index(response_ptr, '.');
- response_ptr++;
-
- version= strtol(response_ptr, (char **)NULL, 10);
- if (version == LONG_MIN or version == LONG_MAX or errno == EINVAL or version > UINT8_MAX)
+ endptr++;
+ errno= 0;
+ version= strtol(endptr, &endptr, 10);
+ if (errno != 0 or version == LONG_MIN or version == LONG_MAX or version > UINT8_MAX)
{
instance->major_version= instance->minor_version= instance->micro_version= UINT8_MAX;
return memcached_set_error(*instance, MEMCACHED_UNKNOWN_READ_FAILURE, MEMCACHED_AT, memcached_literal_param("strtol() failed to parse micro version"));
and buffer[6] == '_'
and buffer[7] == 'E' and buffer[8] == 'R' and buffer[9] == 'R' and buffer[10] == 'O' and buffer[11] == 'R')
{
- return MEMCACHED_CLIENT_ERROR;
+ // Move past the basic error message and whitespace
+ char *startptr= buffer + memcached_literal_param_size("CLIENT_ERROR");
+ if (startptr[0] == ' ')
+ {
+ startptr++;
+ }
+
+ char *endptr= startptr;
+ while (*endptr != '\r' && *endptr != '\n') endptr++;
+
+ return memcached_set_error(*instance, MEMCACHED_CLIENT_ERROR, MEMCACHED_AT, startptr, size_t(endptr - startptr));
}
}
break;
case '8': /* INCR/DECR response */
case '9': /* INCR/DECR response */
{
+ errno= 0;
unsigned long long int auto_return_value= strtoull(buffer, (char **)NULL, 10);
if (auto_return_value == ULLONG_MAX and errno == ERANGE)
return memcached_set_error(*instance, MEMCACHED_UNKNOWN_READ_FAILURE, MEMCACHED_AT,
memcached_literal_param("Numeric response was out of range"));
}
+ else if (errno != 0)
+ {
+ result->numeric_value= UINT64_MAX;
+ return memcached_set_error(*instance, MEMCACHED_UNKNOWN_READ_FAILURE, MEMCACHED_AT,
+ memcached_literal_param("Numeric response was out of range"));
+ }
result->numeric_value= uint64_t(auto_return_value);
buffer, total_read);
}
-static memcached_return_t binary_read_one_response(memcached_server_write_instance_st instance,
+static memcached_return_t binary_read_one_response(memcached_instance_st* instance,
char *buffer, const size_t buffer_length,
memcached_result_st *result)
{
memcached_return_t rc;
protocol_binary_response_header header;
+ assert(memcached_is_binary(instance->root));
+
if ((rc= memcached_safe_read(instance, &header.bytes, sizeof(header.bytes))) != MEMCACHED_SUCCESS)
{
WATCHPOINT_ERROR(rc);
break;
case PROTOCOL_BINARY_CMD_SASL_LIST_MECHS:
+ {
+ if (header.response.keylen != 0 || bodylen + 1 > buffer_length)
+ {
+ return MEMCACHED_UNKNOWN_READ_FAILURE;
+ }
+ else
+ {
+ if ((rc= memcached_safe_read(instance, buffer, bodylen)) != MEMCACHED_SUCCESS)
+ {
+ return MEMCACHED_UNKNOWN_READ_FAILURE;
+ }
+ }
+ }
+ break;
+
case PROTOCOL_BINARY_CMD_VERSION:
{
char version_buffer[32]; // @todo document this number
return MEMCACHED_UNKNOWN_READ_FAILURE;
}
- char *p;
- long int version= strtol(version_buffer, &p, 10);
- if (version == LONG_MIN or version == LONG_MAX or errno == EINVAL or version > UINT8_MAX or version == 0)
+ char *endptr;
+ errno= 0;
+ long int version= strtol(version_buffer, &endptr, 10);
+ if (errno != 0 or version == LONG_MIN or version == LONG_MAX or version > UINT8_MAX or version == 0)
{
instance->major_version= instance->minor_version= instance->micro_version= UINT8_MAX;
return memcached_set_error(*instance, MEMCACHED_UNKNOWN_READ_FAILURE, MEMCACHED_AT, memcached_literal_param("strtol() failed to parse major version"));
}
instance->major_version= uint8_t(version);
- version= strtol(p +1, &p, 10);
- if (version == LONG_MIN or version == LONG_MAX or errno == EINVAL or version > UINT8_MAX)
+ endptr++;
+ errno= 0;
+ version= strtol(endptr, &endptr, 10);
+ if (errno != 0 or version == LONG_MIN or version == LONG_MAX or version > UINT8_MAX)
{
instance->major_version= instance->minor_version= instance->micro_version= UINT8_MAX;
- return memcached_set_error(*instance, MEMCACHED_UNKNOWN_READ_FAILURE, MEMCACHED_AT, memcached_literal_param("strtol() failed to parse micro version"));
+ return memcached_set_error(*instance, MEMCACHED_UNKNOWN_READ_FAILURE, MEMCACHED_AT, memcached_literal_param("strtol() failed to parse minor version"));
}
instance->minor_version= uint8_t(version);
- version= strtol(p + 1, NULL, 10);
- if (errno == ERANGE)
+ endptr++;
+ errno= 0;
+ version= strtol(endptr, &endptr, 10);
+ if (errno != 0 or version == LONG_MIN or version == LONG_MAX or version > UINT8_MAX)
{
instance->major_version= instance->minor_version= instance->micro_version= UINT8_MAX;
return memcached_set_error(*instance, MEMCACHED_UNKNOWN_READ_FAILURE, MEMCACHED_AT, memcached_literal_param("strtol() failed to parse micro version"));
}
break;
+ case PROTOCOL_BINARY_CMD_TOUCH:
+ {
+ rc= MEMCACHED_SUCCESS;
+ if (bodylen == 4) // The four byte read is a bug?
+ {
+ char touch_buffer[4]; // @todo document this number
+ rc= memcached_safe_read(instance, touch_buffer, sizeof(touch_buffer));
+#if 0
+ fprintf(stderr, "%s:%d %d %d %d %d %.*s(%d)\n", __FILE__, __LINE__,
+ int(touch_buffer[0]),
+ int(touch_buffer[1]),
+ int(touch_buffer[2]),
+ int(touch_buffer[3]),
+ int(bodylen), touch_buffer, int(bodylen));
+#endif
+ }
+ return memcached_set_error(*instance, rc, MEMCACHED_AT);
+ }
+
case PROTOCOL_BINARY_CMD_FLUSH:
case PROTOCOL_BINARY_CMD_QUIT:
case PROTOCOL_BINARY_CMD_SET:
case PROTOCOL_BINARY_CMD_APPEND:
case PROTOCOL_BINARY_CMD_PREPEND:
case PROTOCOL_BINARY_CMD_DELETE:
- case PROTOCOL_BINARY_CMD_TOUCH:
{
WATCHPOINT_ASSERT(bodylen == 0);
return MEMCACHED_SUCCESS;
return rc;
}
-static memcached_return_t _read_one_response(memcached_server_write_instance_st instance,
+static memcached_return_t _read_one_response(memcached_instance_st* instance,
char *buffer, const size_t buffer_length,
memcached_result_st *result)
{
if (result == NULL)
{
- memcached_st *root= (memcached_st *)instance->root;
+ Memcached *root= (Memcached *)instance->root;
result = &root->result;
}
return rc;
}
-memcached_return_t memcached_read_one_response(memcached_server_write_instance_st instance,
+memcached_return_t memcached_read_one_response(memcached_instance_st* instance,
memcached_result_st *result)
{
char buffer[SMALL_STRING_LEN];
return _read_one_response(instance, buffer, sizeof(buffer), result);
}
-memcached_return_t memcached_response(memcached_server_write_instance_st instance,
+memcached_return_t memcached_response(memcached_instance_st* instance,
memcached_result_st *result)
{
char buffer[1024];
return memcached_response(instance, buffer, sizeof(buffer), result);
}
-memcached_return_t memcached_response(memcached_server_write_instance_st instance,
+memcached_return_t memcached_response(memcached_instance_st* instance,
char *buffer, size_t buffer_length,
memcached_result_st *result)
{
return memcached_set_error(*instance, MEMCACHED_NOT_SUPPORTED, MEMCACHED_AT);
}
- /* We may have old commands in the buffer not set, first purge */
+ /* We may have old commands in the buffer not sent, first purge */
if ((instance->root->flags.no_block) and (memcached_is_processing_input(instance->root) == false))
{
(void)memcached_io_write(instance);
}
+ /* Before going into loop wait to see if we have any IO waiting for us */
+ if (0)
+ {
+ memcached_return_t read_rc= memcached_io_wait_for_read(instance);
+ fprintf(stderr, "%s:%d: %s\n", __FILE__, __LINE__, memcached_strerror(NULL, read_rc));
+ }
+
/*
* The previous implementation purged all pending requests and just
* returned the last one. Purge all pending messages to ensure backwards