* compatibility.
*/
if (ptr->root->flags.binary_protocol == false)
+ {
while (memcached_server_response_count(ptr) > 1)
{
memcached_return_t rc= memcached_read_one_response(ptr, buffer, buffer_length, result);
rc != MEMCACHED_DATA_EXISTS)
return rc;
}
+ }
return memcached_read_one_response(ptr, buffer, buffer_length, result);
}
key= result->item_key;
result->key_length= 0;
- for (prefix_length= ptr->root->prefix_key_length; !(iscntrl(*string_ptr) || isspace(*string_ptr)) ; string_ptr++)
+ for (prefix_length= memcached_array_size(ptr->root->prefix_key); !(iscntrl(*string_ptr) || isspace(*string_ptr)) ; string_ptr++)
{
if (prefix_length == 0)
{
else
{
WATCHPOINT_STRING(buffer);
- WATCHPOINT_ASSERT(0);
return MEMCACHED_UNKNOWN_READ_FAILURE;
}
case 'O': /* OK */
else
{
WATCHPOINT_STRING(buffer);
- WATCHPOINT_ASSERT(0);
return MEMCACHED_UNKNOWN_READ_FAILURE;
}
}
else if (buffer[4] == 'S')
return MEMCACHED_NOTSTORED;
else
+ {
+ WATCHPOINT_STRING(buffer);
return MEMCACHED_UNKNOWN_READ_FAILURE;
+ }
}
case 'E': /* PROTOCOL ERROR or END */
{
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 */
if (sscanf(buffer, "%llu", &auto_return_value) == 1)
return MEMCACHED_SUCCESS;
+ WATCHPOINT_STRING(buffer);
return MEMCACHED_UNKNOWN_READ_FAILURE;
}
}
char *buffer, size_t buffer_length,
memcached_result_st *result)
{
+ memcached_return_t rc;
protocol_binary_response_header header;
- unlikely (memcached_safe_read(ptr, &header.bytes,
- sizeof(header.bytes)) != MEMCACHED_SUCCESS)
- return MEMCACHED_UNKNOWN_READ_FAILURE;
+ if ((rc= memcached_safe_read(ptr, &header.bytes, sizeof(header.bytes))) != MEMCACHED_SUCCESS)
+ {
+ WATCHPOINT_ERROR(rc);
+ return rc;
+ }
- unlikely (header.response.magic != PROTOCOL_BINARY_RES)
+ if (header.response.magic != PROTOCOL_BINARY_RES)
+ {
return MEMCACHED_PROTOCOL_ERROR;
+ }
/*
** Convert the header to host local endian!
memcached_result_reset(result);
result->item_cas= header.response.cas;
- if (memcached_safe_read(ptr, &result->item_flags,
- sizeof (result->item_flags)) != MEMCACHED_SUCCESS)
+ 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 (memcached_safe_read(ptr, result->item_key, keylen) != MEMCACHED_SUCCESS)
+ 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,
return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
char *vptr= memcached_string_value_mutable(&result->value);
- if (memcached_safe_read(ptr, vptr, bodylen) != MEMCACHED_SUCCESS)
+ 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);
}
WATCHPOINT_ASSERT(bodylen == buffer_length);
uint64_t val;
- if (memcached_safe_read(ptr, &val, sizeof(val)) != MEMCACHED_SUCCESS)
+ 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));
{
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)
+ }
+ 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_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)
+ 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;
+ }
}
}
break;
return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
char *vptr= memcached_string_value_mutable(&result->value);
- if (memcached_safe_read(ptr, vptr, bodylen) != MEMCACHED_SUCCESS)
+ 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);
}
while (bodylen > 0)
{
size_t nr= (bodylen > SMALL_STRING_LEN) ? SMALL_STRING_LEN : bodylen;
- if (memcached_safe_read(ptr, hole, nr) != MEMCACHED_SUCCESS)
+ if ((rc= memcached_safe_read(ptr, hole, nr)) != MEMCACHED_SUCCESS)
+ {
+ WATCHPOINT_ERROR(rc);
return MEMCACHED_UNKNOWN_READ_FAILURE;
+ }
bodylen-= (uint32_t) nr;
}
}
}
- memcached_return_t rc= MEMCACHED_SUCCESS;
+ rc= MEMCACHED_SUCCESS;
unlikely(header.response.status != 0)
switch (header.response.status)
{