X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=lib%2Fmemcached_get.c;h=38f6865b53a90d440a6771658c4800ad3d91a0f3;hb=45485a190a09b078c83f2dcf9e3668a1198fc0c9;hp=8ec8cb1c2eddd9e49ae91460ff1e8be296d9f20d;hpb=174e1d4d3011843e7e909c9b378b888c67d02538;p=awesomized%2Flibmemcached diff --git a/lib/memcached_get.c b/lib/memcached_get.c index 8ec8cb1c..38f6865b 100644 --- a/lib/memcached_get.c +++ b/lib/memcached_get.c @@ -1,28 +1,30 @@ #include "common.h" #include "memcached_io.h" -static char *memcached_value_fetch(memcached_st *ptr, char *key, size_t *key_length, - size_t *value_length, - uint16_t *flags, - memcached_return *error, - char load_key, - unsigned int server_key) +static memcached_return memcached_value_fetch(memcached_st *ptr, char *key, size_t *key_length, + memcached_string_st *value, + uint16_t *flags, + uint64_t *cas, + char load_key, + unsigned int server_key) { + memcached_return rc; char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE]; char *string_ptr; char *end_ptr; - memset(buffer, 0, MEMCACHED_DEFAULT_COMMAND_SIZE); end_ptr= buffer + MEMCACHED_DEFAULT_COMMAND_SIZE; - *value_length= 0; *flags= 0; - *error= memcached_response(ptr, buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, server_key); + memcached_string_reset(value); + + rc= memcached_response(ptr, buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, server_key); - if (*error == MEMCACHED_SUCCESS) + if (rc == MEMCACHED_SUCCESS) { char *next_ptr; + size_t value_length; string_ptr= buffer; string_ptr+= 6; /* "VALUE " */ @@ -30,7 +32,6 @@ static char *memcached_value_fetch(memcached_st *ptr, char *key, size_t *key_len /* We load the key */ if (load_key) { - memset(key, 0, MEMCACHED_MAX_KEY); *key_length= 0; for (; end_ptr > string_ptr && *string_ptr != ' '; string_ptr++) @@ -62,35 +63,43 @@ static char *memcached_value_fetch(memcached_st *ptr, char *key, size_t *key_len goto read_error; for (next_ptr= string_ptr; end_ptr > string_ptr && *string_ptr != ' '; string_ptr++); - *value_length= (size_t)strtoll(next_ptr, &string_ptr, 10); + value_length= (size_t)strtoll(next_ptr, &string_ptr, 10); if (end_ptr == string_ptr) goto read_error; - /* Skip past the \r\n */ - string_ptr+= 2; + /* Skip spaces */ + if (*string_ptr == '\r') + { + /* Skip past the \r\n */ + string_ptr+= 2; + } + else + { + string_ptr++; + for (next_ptr= string_ptr; end_ptr > string_ptr && *string_ptr != ' '; string_ptr++); + if (cas) + *cas= (size_t)strtoll(next_ptr, &string_ptr, 10); + } if (end_ptr < string_ptr) goto read_error; - if (*value_length) + if (value_length) { size_t read_length; size_t to_read; - char *value; char *value_ptr; /* We add two bytes so that we can walk the \r\n */ - value= (char *)malloc(((*value_length) +2) * sizeof(char)); - if (!value) + rc= memcached_string_check(value, value_length+2); + if (rc != MEMCACHED_SUCCESS) { - *value_length= 0; - *error= MEMCACHED_MEMORY_ALLOCATION_FAILURE; - return NULL; + value_length= 0; + return MEMCACHED_MEMORY_ALLOCATION_FAILURE; } - memset(value, 0, ((*value_length) +2) * sizeof(char)); - value_ptr= value; + value_ptr= memcached_string_value(value); read_length= 0; /* We read the \r\n into the string since not doing so is more @@ -99,30 +108,35 @@ static char *memcached_value_fetch(memcached_st *ptr, char *key, size_t *key_len We are null terminating through, which will most likely make some people lazy about using the return length. */ - to_read= (*value_length) + 2; + to_read= (value_length) + 2; read_length= memcached_io_read(ptr, server_key, value_ptr, to_read); - if (read_length != (size_t)(*value_length + 2)) + if (read_length != (size_t)(value_length + 2)) { - free(value); goto read_error; } - value[*value_length]= 0; - value[(*value_length) + 1]= 0; + /* This next bit blows the API, but this is internal....*/ + { + char *char_ptr; + char_ptr= memcached_string_value(value);; + char_ptr[value_length]= 0; + char_ptr[value_length + 1]= 0; + memcached_string_set_length(value, value_length); + } - return value; + return MEMCACHED_SUCCESS; } } - else if (*error == MEMCACHED_END) - *error= MEMCACHED_NOTFOUND; + else if (rc == MEMCACHED_END) + rc= MEMCACHED_NOTFOUND; + + return rc; - return NULL; read_error: - *error= MEMCACHED_PARTIAL_READ; - return NULL; + return MEMCACHED_PARTIAL_READ; } /* @@ -136,17 +150,25 @@ char *memcached_get(memcached_st *ptr, char *key, size_t key_length, char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE]; char *buf_ptr= buffer; unsigned int server_key; - char *value= NULL; + memcached_string_st *result_buffer; LIBMEMCACHED_MEMCACHED_GET_START(); - server_key= memcached_generate_hash(ptr, key, key_length); + if (key_length == 0) + { + *error= MEMCACHED_NO_KEY_PROVIDED; + return NULL; + } - *value_length= 0; - *error= memcached_connect(ptr, server_key); + if (ptr->hosts == NULL || ptr->number_of_hosts == 0) + { + *error= MEMCACHED_NO_SERVERS; + return NULL; + } - if (*error != MEMCACHED_SUCCESS) - goto error; + server_key= memcached_generate_hash(ptr, key, key_length); + result_buffer= &ptr->result_buffer; + *value_length= 0; memcpy(buf_ptr, "get ", 4); buf_ptr+= 4; memcpy(buf_ptr, key, key_length); @@ -154,14 +176,13 @@ char *memcached_get(memcached_st *ptr, char *key, size_t key_length, memcpy(buf_ptr, "\r\n", 2); buf_ptr+= 2; - if ((memcached_io_write(ptr, server_key, buffer, (size_t)(buf_ptr - buffer), 1)) == -1) - { - *error= MEMCACHED_WRITE_FAILURE; + *error= memcached_do(ptr, server_key, buffer, (size_t)(buf_ptr - buffer), 1); + if (*error != MEMCACHED_SUCCESS) goto error; - } - value= memcached_value_fetch(ptr, key, &key_length, value_length, flags, - error, 0, server_key); + *error= memcached_value_fetch(ptr, key, &key_length, result_buffer, + flags, NULL, 0, server_key); + *value_length= memcached_string_length(result_buffer); if (*error == MEMCACHED_END && *value_length == 0) { *error= MEMCACHED_NOTFOUND; @@ -188,10 +209,10 @@ char *memcached_get(memcached_st *ptr, char *key, size_t key_length, LIBMEMCACHED_MEMCACHED_GET_END(); - return value; + + return memcached_string_c_copy(result_buffer); error: - free(value); *value_length= 0; LIBMEMCACHED_MEMCACHED_GET_END(); @@ -205,15 +226,23 @@ memcached_return memcached_mget(memcached_st *ptr, { unsigned int x; memcached_return rc= MEMCACHED_NOTFOUND; - char *cursor_key_exec; + char *get_command= "get "; + uint8_t get_command_length= 4 + LIBMEMCACHED_MEMCACHED_MGET_START(); ptr->cursor_server= 0; if (number_of_keys == 0) return MEMCACHED_NOTFOUND; - cursor_key_exec= (char *)malloc(sizeof(char) * ptr->number_of_hosts); - memset(cursor_key_exec, 0, sizeof(char) * ptr->number_of_hosts); + if (ptr->number_of_hosts == 0) + return MEMCACHED_NO_SERVERS; + + if (ptr->flags & MEM_SUPPORT_CAS) + { + get_command= "gets "; + get_command_length= 5; + } for (x= 0; x < number_of_keys; x++) { @@ -221,32 +250,34 @@ memcached_return memcached_mget(memcached_st *ptr, server_key= memcached_generate_hash(ptr, keys[x], key_length[x]); - if (cursor_key_exec[server_key] == 0) + if (ptr->hosts[server_key].cursor_active == 0) { rc= memcached_connect(ptr, server_key); - if ((memcached_io_write(ptr, server_key, "get ", 4, 0)) == -1) + if ((memcached_io_write(ptr, server_key, get_command, get_command_length, 0)) == -1) { - memcached_quit(ptr); + memcached_quit_server(ptr, server_key); rc= MEMCACHED_SOME_ERRORS; - break; + continue; } + ptr->hosts[server_key].cursor_active= 1; } if ((memcached_io_write(ptr, server_key, keys[x], key_length[x], 0)) == -1) { - memcached_quit(ptr); + ptr->hosts[server_key].cursor_active = 0; + memcached_quit_server(ptr, server_key); rc= MEMCACHED_SOME_ERRORS; - break; + continue; } if ((memcached_io_write(ptr, server_key, " ", 1, 0)) == -1) { - memcached_quit(ptr); + ptr->hosts[server_key].cursor_active = 0; + memcached_quit_server(ptr, server_key); rc= MEMCACHED_SOME_ERRORS; - break; + continue; } - cursor_key_exec[server_key]= 1; } @@ -255,24 +286,17 @@ memcached_return memcached_mget(memcached_st *ptr, */ for (x= 0; x < ptr->number_of_hosts; x++) { - if (cursor_key_exec[x]) + if (ptr->hosts[x].cursor_active == 1) { /* We need to doo something about non-connnected hosts in the future */ if ((memcached_io_write(ptr, x, "\r\n", 2, 1)) == -1) { - memcached_quit(ptr); + memcached_quit_server(ptr, x); rc= MEMCACHED_SOME_ERRORS; - break; } - - ptr->hosts[x].cursor_active= 1; } - else - ptr->hosts[x].cursor_active= 0; } - free(cursor_key_exec); - LIBMEMCACHED_MEMCACHED_MGET_END(); return rc; } @@ -282,7 +306,8 @@ char *memcached_fetch(memcached_st *ptr, char *key, size_t *key_length, uint16_t *flags, memcached_return *error) { - char *value_check; + memcached_string_st *result_buffer; + result_buffer= &ptr->result_buffer; while (ptr->cursor_server < ptr->number_of_hosts) { @@ -292,21 +317,33 @@ char *memcached_fetch(memcached_st *ptr, char *key, size_t *key_length, continue; } - value_check= memcached_value_fetch(ptr, key, key_length, value_length, flags, - error, 1, ptr->cursor_server); + *error = memcached_value_fetch(ptr, key, key_length, result_buffer, + flags, NULL, 1, ptr->cursor_server); + *value_length= memcached_string_length(result_buffer); if (*error == MEMCACHED_NOTFOUND) + { + ptr->hosts[ptr->cursor_server].cursor_active = 0; ptr->cursor_server++; + } else if (*error == MEMCACHED_END && *value_length == 0) + { return NULL; + } else if (*error == MEMCACHED_END) { WATCHPOINT_ASSERT(0); /* If this happens we have somehow messed up the fetch */ + *value_length= 0; + return NULL; } else if (*error != MEMCACHED_SUCCESS) + { return NULL; + } else - return value_check; + { + return memcached_string_c_copy(result_buffer); + } } @@ -314,11 +351,12 @@ char *memcached_fetch(memcached_st *ptr, char *key, size_t *key_length, return NULL; } -#ifdef NOT_YET -char *memcached_fetch_result(memcached_st *ptr, memcached_result_st *result, - memcached_return *error) +memcached_result_st *memcached_fetch_result(memcached_st *ptr, + memcached_result_st *result, + memcached_return *error) { - char *value_check; + if (result == NULL) + result= memcached_result_create(ptr, NULL); while (ptr->cursor_server < ptr->number_of_hosts) { @@ -328,25 +366,40 @@ char *memcached_fetch_result(memcached_st *ptr, memcached_result_st *result, continue; } - value_check= memcached_value_fetch(ptr, key, key_length, value_length, flags, - error, 1, ptr->cursor_server); + result->cas= 0; /* We do this so we do not send in any junk */ + *error= memcached_value_fetch(ptr, result->key, &result->key_length, + &result->value, + &result->flags, + &result->cas, + 1, ptr->cursor_server); if (*error == MEMCACHED_NOTFOUND) + { + ptr->hosts[ptr->cursor_server].cursor_active = 0; ptr->cursor_server++; - else if (*error == MEMCACHED_END && *value_length == 0) - return NULL; + } + else if (*error == MEMCACHED_END && memcached_string_length((memcached_string_st *)(&result->value)) == 0) + { + goto error; + } else if (*error == MEMCACHED_END) { WATCHPOINT_ASSERT(0); /* If this happens we have somehow messed up the fetch */ + goto error; } else if (*error != MEMCACHED_SUCCESS) - return NULL; + { + goto error; + } else - return value_check; + { + return result; + } } - *value_length= 0; +error: + memcached_result_free(result); + return NULL; } -#endif