X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fmemcached_response.c;h=ea13bb151ce09065cd37f4d958206a7140d1465b;hb=c204651e1ee8185224ccc78bd68801ab43740844;hp=5c44e5f2b78e494ac53d659d66827875faa196b3;hpb=d7de77de3f79dd9a478ee40dd034af45b6a3f8ef;p=awesomized%2Flibmemcached diff --git a/libmemcached/memcached_response.c b/libmemcached/memcached_response.c index 5c44e5f2..ea13bb15 100644 --- a/libmemcached/memcached_response.c +++ b/libmemcached/memcached_response.c @@ -21,6 +21,9 @@ memcached_return memcached_read_one_response(memcached_server_st *ptr, { memcached_server_response_decrement(ptr); + if (result == NULL) + result = &ptr->root->result; + memcached_return rc; if (ptr->root->flags & MEM_BINARY_PROTOCOL) rc= binary_read_one_response(ptr, buffer, buffer_length, result); @@ -50,7 +53,8 @@ memcached_return memcached_response(memcached_server_st *ptr, * compatibility. */ if ((ptr->root->flags & MEM_BINARY_PROTOCOL) == 0) - while (memcached_server_response_count(ptr) > 1) { + while (memcached_server_response_count(ptr) > 1) + { memcached_return rc= memcached_read_one_response(ptr, buffer, buffer_length, result); unlikely (rc != MEMCACHED_END && @@ -67,40 +71,141 @@ memcached_return memcached_response(memcached_server_st *ptr, return memcached_read_one_response(ptr, buffer, buffer_length, result); } -static memcached_return memcached_readline(memcached_server_st *ptr, - char *buffer, - size_t size) +static memcached_return textual_value_fetch(memcached_server_st *ptr, + char *buffer, + memcached_result_st *result) { - bool line_complete= false; - char *buffer_ptr= buffer; - int total_nr=0; + memcached_return rc= MEMCACHED_SUCCESS; + char *string_ptr; + char *end_ptr; + char *next_ptr; + size_t value_length; + size_t to_read; + char *value_ptr; + + if (ptr->root->flags & MEM_USE_UDP) + return MEMCACHED_NOT_SUPPORTED; + + WATCHPOINT_ASSERT(ptr->root); + end_ptr= buffer + MEMCACHED_DEFAULT_COMMAND_SIZE; + + memcached_result_reset(result); + + string_ptr= buffer; + string_ptr+= 6; /* "VALUE " */ + - while (!line_complete) + /* We load the key */ { - if (memcached_io_read(ptr, buffer_ptr, 1) != 1) - return MEMCACHED_UNKNOWN_READ_FAILURE; + char *key; + size_t prefix_length; - WATCHPOINT_ASSERT(*buffer_ptr != '\0'); - if (*buffer_ptr == '\n') - line_complete=true; - else + key= result->key; + result->key_length= 0; + + for (prefix_length= ptr->root->prefix_key_length; !(iscntrl(*string_ptr) || isspace(*string_ptr)) ; string_ptr++) { - ++buffer_ptr; - ++total_nr; + if (prefix_length == 0) + { + *key= *string_ptr; + key++; + result->key_length++; + } + else + prefix_length--; } + result->key[result->key_length]= 0; + } + + if (end_ptr == string_ptr) + goto read_error; + + /* Flags fetch move past space */ + 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); + + if (end_ptr == string_ptr) + goto read_error; + + /* Length fetch move past space*/ + string_ptr++; + if (end_ptr == string_ptr) + goto read_error; + + for (next_ptr= string_ptr; isdigit(*string_ptr); string_ptr++); + value_length= (size_t)strtoull(next_ptr, &string_ptr, 10); + + if (end_ptr == string_ptr) + goto read_error; + + /* Skip spaces */ + if (*string_ptr == '\r') + { + /* Skip past the \r\n */ + string_ptr+= 2; + } + else + { + string_ptr++; + for (next_ptr= string_ptr; isdigit(*string_ptr); string_ptr++); + result->cas= strtoull(next_ptr, &string_ptr, 10); + } + + if (end_ptr < string_ptr) + goto read_error; + + /* We add two bytes so that we can walk the \r\n */ + rc= memcached_string_check(&result->value, value_length+2); + if (rc != MEMCACHED_SUCCESS) + { + value_length= 0; + 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 + cycles then the waster of memory to do so. + + We are null terminating through, which will most likely make + some people lazy about using the return length. + */ + to_read= (value_length) + 2; + ssize_t read_length= 0; + memcached_return rrc= memcached_io_read(ptr, value_ptr, to_read, &read_length); + if (rrc != MEMCACHED_SUCCESS) + return rrc; - if (total_nr == size) - return MEMCACHED_PROTOCOL_ERROR; + if (read_length != (ssize_t)(value_length + 2)) + { + goto read_error; + } + +/* This next bit blows the API, but this is internal....*/ + { + char *char_ptr; + char_ptr= memcached_string_value(&result->value);; + char_ptr[value_length]= 0; + char_ptr[value_length + 1]= 0; + memcached_string_set_length(&result->value, value_length); } return MEMCACHED_SUCCESS; + +read_error: + memcached_io_reset(ptr); + + return MEMCACHED_PARTIAL_READ; } static memcached_return textual_read_one_response(memcached_server_st *ptr, char *buffer, size_t buffer_length, memcached_result_st *result) { - memcached_return rc=memcached_readline(ptr, buffer, buffer_length); + memcached_return rc= memcached_io_readline(ptr, buffer, buffer_length); if (rc != MEMCACHED_SUCCESS) return rc; @@ -109,16 +214,9 @@ static memcached_return textual_read_one_response(memcached_server_st *ptr, case 'V': /* VALUE || VERSION */ if (buffer[1] == 'A') /* VALUE */ { - memcached_return rc; - /* We add back in one because we will need to search for END */ memcached_server_response_increment(ptr); - if (result) - rc= value_fetch(ptr, buffer, result); - else - rc= value_fetch(ptr, buffer, &ptr->root->result); - - return rc; + return textual_value_fetch(ptr, buffer, result); } else if (buffer[1] == 'E') /* VERSION */ { @@ -139,8 +237,36 @@ static memcached_return textual_read_one_response(memcached_server_st *ptr, memcached_server_response_increment(ptr); return MEMCACHED_STAT; } - else if (buffer[1] == 'E') - return MEMCACHED_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 *)ptr->root->call_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 @@ -172,6 +298,10 @@ static memcached_return textual_read_one_response(memcached_server_st *ptr, else 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); + return MEMCACHED_ITEM; case 'C': /* CLIENT ERROR */ return MEMCACHED_CLIENT_ERROR; default: @@ -185,7 +315,7 @@ static memcached_return textual_read_one_response(memcached_server_st *ptr, } } - return MEMCACHED_SUCCESS; + /* NOTREACHED */ } char *memcached_result_value(memcached_result_st *ptr) @@ -293,13 +423,11 @@ static memcached_return binary_read_one_response(memcached_server_st *ptr, 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) @@ -329,13 +457,29 @@ static memcached_return binary_read_one_response(memcached_server_st *ptr, else if (header.response.bodylen) { /* What should I do with the error message??? just discard it for now */ - char buffer[SMALL_STRING_LEN]; + char hole[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) + if (memcached_safe_read(ptr, hole, nr) != MEMCACHED_SUCCESS) return MEMCACHED_UNKNOWN_READ_FAILURE; - bodylen -= nr; + 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: + return binary_read_one_response(ptr, buffer, buffer_length, result); + default: + break; } } @@ -349,11 +493,17 @@ static memcached_return binary_read_one_response(memcached_server_st *ptr, 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_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;