X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fget.cc;h=86d8cf2e13522b625cf35f4acd8a1de23636e733;hb=ae86283e79c226f2a24d5c74e3ffc8f38f0a66a8;hp=a78d73efecc2ef07d985795c6700ec09001ac3e4;hpb=098b147ae544499cda8b3c7333173bb5f6e01b82;p=awesomized%2Flibmemcached diff --git a/libmemcached/get.cc b/libmemcached/get.cc index a78d73ef..86d8cf2e 100644 --- a/libmemcached/get.cc +++ b/libmemcached/get.cc @@ -2,7 +2,7 @@ * * Libmemcached library * - * Copyright (C) 2011 Data Differential, http://datadifferential.com/ + * Copyright (C) 2011-2013 Data Differential, http://datadifferential.com/ * Copyright (C) 2006-2009 Brian Aker All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -50,15 +50,14 @@ char *memcached_get(memcached_st *ptr, const char *key, flags, error); } -static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr, - const char *group_key, - size_t group_key_length, - const char * const *keys, - const size_t *key_length, - size_t number_of_keys, - bool mget_mode); - -char *memcached_get_by_key(memcached_st *ptr, +static memcached_return_t __mget_by_key_real(memcached_st *ptr, + const char *group_key, + size_t group_key_length, + const char * const *keys, + const size_t *key_length, + size_t number_of_keys, + const bool mget_mode); +char *memcached_get_by_key(memcached_st *shell, const char *group_key, size_t group_key_length, const char *key, size_t key_length, @@ -66,38 +65,42 @@ char *memcached_get_by_key(memcached_st *ptr, uint32_t *flags, memcached_return_t *error) { + Memcached* ptr= memcached2Memcached(shell); memcached_return_t unused; if (error == NULL) + { error= &unused; + } - unlikely (ptr->flags.use_udp) + uint64_t query_id= 0; + if (ptr) { - if (value_length) - *value_length= 0; - - *error= memcached_set_error(*ptr, MEMCACHED_NOT_SUPPORTED, MEMCACHED_AT); - return NULL; + query_id= ptr->query_id; } - uint64_t query_id= ptr->query_id; - (void)query_id; - /* Request the key */ - *error= memcached_mget_by_key_real(ptr, group_key, group_key_length, - (const char * const *)&key, &key_length, - 1, false); - assert_msg(ptr->query_id == query_id +1, "Programmer error, the query_id was not incremented."); - + *error= __mget_by_key_real(ptr, group_key, group_key_length, + (const char * const *)&key, &key_length, + 1, false); + if (ptr) + { + assert_msg(ptr->query_id == query_id +1, "Programmer error, the query_id was not incremented."); + } if (memcached_failed(*error)) { - if (memcached_has_current_error(*ptr)) // Find the most accurate error + if (ptr) { - *error= memcached_last_error(ptr); + if (memcached_has_current_error(*ptr)) // Find the most accurate error + { + *error= memcached_last_error(ptr); + } } if (value_length) + { *value_length= 0; + } return NULL; } @@ -108,32 +111,36 @@ char *memcached_get_by_key(memcached_st *ptr, /* This is for historical reasons */ if (*error == MEMCACHED_END) + { *error= MEMCACHED_NOTFOUND; - + } if (value == NULL) { - if (ptr->get_key_failure && *error == MEMCACHED_NOTFOUND) + if (ptr->get_key_failure and *error == MEMCACHED_NOTFOUND) { - memcached_result_reset(&ptr->result); - memcached_return_t rc= ptr->get_key_failure(ptr, key, key_length, &ptr->result); + memcached_result_st key_failure_result; + memcached_result_st* result_ptr= memcached_result_create(ptr, &key_failure_result); + memcached_return_t rc= ptr->get_key_failure(ptr, key, key_length, result_ptr); /* On all failure drop to returning NULL */ - if (rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED) + if (rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED) { if (rc == MEMCACHED_BUFFERED) { uint64_t latch; /* We use latch to track the state of the original socket */ latch= memcached_behavior_get(ptr, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS); if (latch == 0) + { memcached_behavior_set(ptr, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1); + } rc= memcached_set(ptr, key, key_length, - (memcached_result_value(&ptr->result)), - (memcached_result_length(&ptr->result)), + (memcached_result_value(result_ptr)), + (memcached_result_length(result_ptr)), 0, - (memcached_result_flags(&ptr->result))); + (memcached_result_flags(result_ptr))); - if (rc == MEMCACHED_BUFFERED && latch == 0) + if (rc == MEMCACHED_BUFFERED and latch == 0) { memcached_behavior_set(ptr, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 0); } @@ -141,37 +148,31 @@ char *memcached_get_by_key(memcached_st *ptr, else { rc= memcached_set(ptr, key, key_length, - (memcached_result_value(&ptr->result)), - (memcached_result_length(&ptr->result)), + (memcached_result_value(result_ptr)), + (memcached_result_length(result_ptr)), 0, - (memcached_result_flags(&ptr->result))); + (memcached_result_flags(result_ptr))); } - if (rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED) + if (rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED) { *error= rc; - *value_length= memcached_result_length(&ptr->result); - *flags= memcached_result_flags(&ptr->result); - return memcached_string_take_value(&ptr->result.value); + *value_length= memcached_result_length(result_ptr); + *flags= memcached_result_flags(result_ptr); + char *result_value= memcached_string_take_value(&result_ptr->value); + memcached_result_free(result_ptr); + + return result_value; } } + + memcached_result_free(result_ptr); } assert_msg(ptr->query_id == query_id +1, "Programmer error, the query_id was not incremented."); return NULL; } - size_t dummy_length; - uint32_t dummy_flags; - memcached_return_t dummy_error; - - char *dummy_value= memcached_fetch(ptr, NULL, NULL, - &dummy_length, &dummy_flags, - &dummy_error); - assert_msg(dummy_value == 0, "memcached_fetch() returned additional values beyond the single get it expected"); - assert_msg(dummy_length == 0, "memcached_fetch() returned additional values beyond the single get it expected"); - assert_msg(ptr->query_id == query_id +1, "Programmer error, the query_id was not incremented."); - return value; } @@ -184,33 +185,33 @@ memcached_return_t memcached_mget(memcached_st *ptr, } static memcached_return_t binary_mget_by_key(memcached_st *ptr, - uint32_t master_server_key, - bool is_group_key_set, + const uint32_t master_server_key, + const bool is_group_key_set, + const char * const *keys, + const size_t *key_length, + const size_t number_of_keys, + const bool mget_mode); + +static memcached_return_t __mget_by_key_real(memcached_st *ptr, + const char *group_key, + const size_t group_key_length, const char * const *keys, const size_t *key_length, size_t number_of_keys, - bool mget_mode); - -static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr, - const char *group_key, - size_t group_key_length, - const char * const *keys, - const size_t *key_length, - size_t number_of_keys, - bool mget_mode) + const bool mget_mode) { bool failures_occured_in_sending= false; - const char *get_command= "get "; - uint8_t get_command_length= 4; + const char *get_command= "get"; + uint8_t get_command_length= 3; unsigned int master_server_key= (unsigned int)-1; /* 0 is a valid server id! */ memcached_return_t rc; - if (memcached_failed(rc= initialize_query(ptr))) + if (memcached_failed(rc= initialize_query(ptr, true))) { return rc; } - if (ptr->flags.use_udp) + if (memcached_is_udp(ptr)) { return memcached_set_error(*ptr, MEMCACHED_NOT_SUPPORTED, MEMCACHED_AT); } @@ -219,22 +220,19 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr, if (number_of_keys == 0) { - return memcached_set_error(*ptr, MEMCACHED_NOTFOUND, MEMCACHED_AT, memcached_literal_param("number_of_keys was zero")); + return memcached_set_error(*ptr, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT, memcached_literal_param("Numbers of keys provided was zero")); } - if (memcached_failed(memcached_key_test(*ptr, keys, key_length, number_of_keys))) + if (memcached_failed((rc= memcached_key_test(*ptr, keys, key_length, number_of_keys)))) { - return memcached_set_error(*ptr, MEMCACHED_BAD_KEY_PROVIDED, MEMCACHED_AT, memcached_literal_param("A bad key value was provided")); + assert(memcached_last_error(ptr) == rc); + + return rc; } bool is_group_key_set= false; if (group_key and group_key_length) { - if (memcached_failed(memcached_key_test(*ptr, (const char * const *)&group_key, &group_key_length, 1))) - { - return memcached_set_error(*ptr, MEMCACHED_BAD_KEY_PROVIDED, MEMCACHED_AT, memcached_literal_param("A bad group key was provided.")); - } - master_server_key= memcached_generate_hash_with_redistribution(ptr, group_key, group_key_length); is_group_key_set= true; } @@ -247,22 +245,25 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr, */ for (uint32_t x= 0; x < memcached_server_count(ptr); x++) { - memcached_server_write_instance_st instance= - memcached_server_instance_fetch(ptr, x); + memcached_instance_st* instance= memcached_instance_fetch(ptr, x); - if (memcached_server_response_count(instance)) + if (instance->response_count()) { char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE]; if (ptr->flags.no_block) - (void)memcached_io_write(instance, NULL, 0, true); + { + memcached_io_write(instance); + } - while(memcached_server_response_count(instance)) + while(instance->response_count()) + { (void)memcached_response(instance, buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, &ptr->result); + } } } - if (ptr->flags.binary_protocol) + if (memcached_is_binary(ptr)) { return binary_mget_by_key(ptr, master_server_key, is_group_key_set, keys, key_length, number_of_keys, mget_mode); @@ -270,8 +271,8 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr, if (ptr->flags.support_cas) { - get_command= "gets "; - get_command_length= 5; + get_command= "gets"; + get_command_length= 4; } /* @@ -282,7 +283,6 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr, size_t hosts_connected= 0; for (uint32_t x= 0; x < number_of_keys; x++) { - memcached_server_write_instance_st instance; uint32_t server_key; if (is_group_key_set) @@ -294,18 +294,18 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr, server_key= memcached_generate_hash_with_redistribution(ptr, keys[x], key_length[x]); } - instance= memcached_server_instance_fetch(ptr, server_key); + memcached_instance_st* instance= memcached_instance_fetch(ptr, server_key); - struct libmemcached_io_vector_st vector[]= + libmemcached_io_vector_st vector[]= { { get_command, get_command_length }, + { memcached_literal_param(" ") }, { memcached_array_string(ptr->_namespace), memcached_array_size(ptr->_namespace) }, - { keys[x], key_length[x] }, - { memcached_literal_param(" ") } + { keys[x], key_length[x] } }; - if (memcached_server_response_count(instance) == 0) + if (instance->response_count() == 0) { rc= memcached_connect(instance); @@ -316,20 +316,20 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr, } hosts_connected++; - if ((memcached_io_writev(instance, vector, 4, false)) == -1) + if ((memcached_io_writev(instance, vector, 1, false)) == false) { failures_occured_in_sending= true; continue; } - WATCHPOINT_ASSERT(instance->cursor_active == 0); - memcached_server_response_increment(instance); - WATCHPOINT_ASSERT(instance->cursor_active == 1); + WATCHPOINT_ASSERT(instance->cursor_active_ == 0); + memcached_instance_response_increment(instance); + WATCHPOINT_ASSERT(instance->cursor_active_ == 1); } - else + { - if ((memcached_io_writev(instance, (vector + 1), 3, false)) == -1) + if ((memcached_io_writev(instance, (vector + 1), 3, false)) == false) { - memcached_server_response_reset(instance); + memcached_instance_response_reset(instance); failures_occured_in_sending= true; continue; } @@ -341,7 +341,9 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr, LIBMEMCACHED_MEMCACHED_MGET_END(); if (memcached_failed(rc)) + { return rc; + } return memcached_set_error(*ptr, MEMCACHED_NO_SERVERS, MEMCACHED_AT); } @@ -353,10 +355,9 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr, bool success_happened= false; for (uint32_t x= 0; x < memcached_server_count(ptr); x++) { - memcached_server_write_instance_st instance= - memcached_server_instance_fetch(ptr, x); + memcached_instance_st* instance= memcached_instance_fetch(ptr, x); - if (memcached_server_response_count(instance)) + if (instance->response_count()) { /* We need to do something about non-connnected hosts in the future */ if ((memcached_io_write(instance, "\r\n", 2, true)) == -1) @@ -372,26 +373,28 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr, LIBMEMCACHED_MEMCACHED_MGET_END(); - if (failures_occured_in_sending && success_happened) + if (failures_occured_in_sending and success_happened) { return MEMCACHED_SOME_ERRORS; } if (success_happened) + { return MEMCACHED_SUCCESS; + } return MEMCACHED_FAILURE; // Complete failure occurred } -memcached_return_t memcached_mget_by_key(memcached_st *ptr, +memcached_return_t memcached_mget_by_key(memcached_st *shell, const char *group_key, size_t group_key_length, const char * const *keys, const size_t *key_length, size_t number_of_keys) { - return memcached_mget_by_key_real(ptr, group_key, group_key_length, keys, - key_length, number_of_keys, true); + Memcached* ptr= memcached2Memcached(shell); + return __mget_by_key_real(ptr, group_key, group_key_length, keys, key_length, number_of_keys, true); } memcached_return_t memcached_mget_execute(memcached_st *ptr, @@ -407,7 +410,7 @@ memcached_return_t memcached_mget_execute(memcached_st *ptr, context, number_of_callbacks); } -memcached_return_t memcached_mget_execute_by_key(memcached_st *ptr, +memcached_return_t memcached_mget_execute_by_key(memcached_st *shell, const char *group_key, size_t group_key_length, const char * const *keys, @@ -417,10 +420,24 @@ memcached_return_t memcached_mget_execute_by_key(memcached_st *ptr, void *context, unsigned int number_of_callbacks) { - if ((ptr->flags.binary_protocol) == 0) - return MEMCACHED_NOT_SUPPORTED; - + Memcached* ptr= memcached2Memcached(shell); memcached_return_t rc; + if (memcached_failed(rc= initialize_query(ptr, false))) + { + return rc; + } + + if (memcached_is_udp(ptr)) + { + return memcached_set_error(*ptr, MEMCACHED_NOT_SUPPORTED, MEMCACHED_AT); + } + + if (memcached_is_binary(ptr) == false) + { + return memcached_set_error(*ptr, MEMCACHED_NOT_SUPPORTED, MEMCACHED_AT, + memcached_literal_param("ASCII protocol is not supported for memcached_mget_execute_by_key()")); + } + memcached_callback_st *original_callbacks= ptr->callbacks; memcached_callback_st cb= { callback, @@ -432,20 +449,26 @@ memcached_return_t memcached_mget_execute_by_key(memcached_st *ptr, rc= memcached_mget_by_key(ptr, group_key, group_key_length, keys, key_length, number_of_keys); ptr->callbacks= original_callbacks; + return rc; } static memcached_return_t simple_binary_mget(memcached_st *ptr, - uint32_t master_server_key, + const uint32_t master_server_key, bool is_group_key_set, const char * const *keys, const size_t *key_length, - size_t number_of_keys, bool mget_mode) + const size_t number_of_keys, const bool mget_mode) { memcached_return_t rc= MEMCACHED_NOTFOUND; bool flush= (number_of_keys == 1); + if (memcached_failed(rc= memcached_key_test(*ptr, keys, key_length, number_of_keys))) + { + return rc; + } + /* If a server fails we warn about errors and start all over with sending keys to the server. @@ -463,9 +486,9 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr, server_key= memcached_generate_hash_with_redistribution(ptr, keys[x], key_length[x]); } - memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, server_key); + memcached_instance_st* instance= memcached_instance_fetch(ptr, server_key); - if (memcached_server_response_count(instance) == 0) + if (instance->response_count() == 0) { rc= memcached_connect(instance); if (memcached_failed(rc)) @@ -475,37 +498,45 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr, } protocol_binary_request_getk request= { }; //= {.bytes= {0}}; - request.message.header.request.magic= PROTOCOL_BINARY_REQ; + initialize_binary_request(instance, request.message.header); if (mget_mode) + { request.message.header.request.opcode= PROTOCOL_BINARY_CMD_GETKQ; + } else + { request.message.header.request.opcode= PROTOCOL_BINARY_CMD_GETK; + } - memcached_return_t vk; - vk= memcached_validate_key_length(key_length[x], - ptr->flags.binary_protocol); - unlikely (vk != MEMCACHED_SUCCESS) +#if 0 { - if (x > 0) + memcached_return_t vk= memcached_validate_key_length(key_length[x], ptr->flags.binary_protocol); + if (memcached_failed(rc= memcached_key_test(*memc, (const char **)&key, &key_length, 1))) { - memcached_io_reset(instance); - } + memcached_set_error(ptr, vk, MEMCACHED_AT, memcached_literal_param("Key was too long.")); + + if (x > 0) + { + memcached_io_reset(instance); + } - return vk; + return vk; + } } +#endif request.message.header.request.keylen= htons((uint16_t)(key_length[x] + memcached_array_size(ptr->_namespace))); request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES; request.message.header.request.bodylen= htonl((uint32_t)( key_length[x] + memcached_array_size(ptr->_namespace))); - struct libmemcached_io_vector_st vector[]= + libmemcached_io_vector_st vector[]= { { request.bytes, sizeof(request.bytes) }, { memcached_array_string(ptr->_namespace), memcached_array_size(ptr->_namespace) }, { keys[x], key_length[x] } }; - if (memcached_io_writev(instance, vector, 3, flush) == -1) + if (memcached_io_writev(instance, vector, 3, flush) == false) { memcached_server_response_reset(instance); rc= MEMCACHED_SOME_ERRORS; @@ -515,7 +546,7 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr, /* We just want one pending response per server */ memcached_server_response_reset(instance); memcached_server_response_increment(instance); - if ((x > 0 && x == ptr->io_key_prefetch) && memcached_flush_buffers(ptr) != MEMCACHED_SUCCESS) + if ((x > 0 and x == ptr->io_key_prefetch) and memcached_flush_buffers(ptr) != MEMCACHED_SUCCESS) { rc= MEMCACHED_SOME_ERRORS; } @@ -527,28 +558,20 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr, Send a noop command to flush the buffers */ protocol_binary_request_noop request= {}; //= {.bytes= {0}}; - request.message.header.request.magic= PROTOCOL_BINARY_REQ; request.message.header.request.opcode= PROTOCOL_BINARY_CMD_NOOP; request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES; for (uint32_t x= 0; x < memcached_server_count(ptr); ++x) { - memcached_server_write_instance_st instance= - memcached_server_instance_fetch(ptr, x); + memcached_instance_st* instance= memcached_instance_fetch(ptr, x); - if (memcached_server_response_count(instance)) + if (instance->response_count()) { - if (memcached_io_write(instance, NULL, 0, true) == -1) + initialize_binary_request(instance, request.message.header); + if ((memcached_io_write(instance) == false) or + (memcached_io_write(instance, request.bytes, sizeof(request.bytes), true) == -1)) { - memcached_server_response_reset(instance); - memcached_io_reset(instance); - rc= MEMCACHED_SOME_ERRORS; - } - - if (memcached_io_write(instance, request.bytes, - sizeof(request.bytes), true) == -1) - { - memcached_server_response_reset(instance); + memcached_instance_response_reset(instance); memcached_io_reset(instance); rc= MEMCACHED_SOME_ERRORS; } @@ -556,7 +579,6 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr, } } - return rc; } @@ -565,14 +587,16 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr, bool* dead_servers, const char *const *keys, const size_t *key_length, - size_t number_of_keys) + const size_t number_of_keys) { memcached_return_t rc= MEMCACHED_NOTFOUND; uint32_t start= 0; uint64_t randomize_read= memcached_behavior_get(ptr, MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ); if (randomize_read) + { start= (uint32_t)random() % (uint32_t)(ptr->number_of_replicas + 1); + } /* Loop for each replica */ for (uint32_t replica= 0; replica <= ptr->number_of_replicas; ++replica) @@ -582,13 +606,17 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr, for (uint32_t x= 0; x < number_of_keys; ++x) { if (hash[x] == memcached_server_count(ptr)) + { continue; /* Already successfully sent */ + } - uint32_t server= hash[x] + replica; + uint32_t server= hash[x] +replica; /* In case of randomized reads */ - if (randomize_read && ((server + start) <= (hash[x] + ptr->number_of_replicas))) - server += start; + if (randomize_read and ((server + start) <= (hash[x] + ptr->number_of_replicas))) + { + server+= start; + } while (server >= memcached_server_count(ptr)) { @@ -600,9 +628,9 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr, continue; } - memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, server); + memcached_instance_st* instance= memcached_instance_fetch(ptr, server); - if (memcached_server_response_count(instance) == 0) + if (instance->response_count() == 0) { rc= memcached_connect(instance); @@ -616,7 +644,7 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr, } protocol_binary_request_getk request= {}; - request.message.header.request.magic= PROTOCOL_BINARY_REQ; + initialize_binary_request(instance, request.message.header); request.message.header.request.opcode= PROTOCOL_BINARY_CMD_GETK; request.message.header.request.keylen= htons((uint16_t)(key_length[x] + memcached_array_size(ptr->_namespace))); request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES; @@ -632,14 +660,14 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr, * that we might have processed some of the responses etc. For now, * just make sure we work _correctly_ */ - struct libmemcached_io_vector_st vector[]= + libmemcached_io_vector_st vector[]= { { request.bytes, sizeof(request.bytes) }, { memcached_array_string(ptr->_namespace), memcached_array_size(ptr->_namespace) }, { keys[x], key_length[x] } }; - if (memcached_io_writev(instance, vector, 3, true) == -1) + if (memcached_io_writev(instance, vector, 3, true) == false) { memcached_io_reset(instance); dead_servers[server]= true; @@ -661,12 +689,12 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr, } static memcached_return_t binary_mget_by_key(memcached_st *ptr, - uint32_t master_server_key, + const uint32_t master_server_key, bool is_group_key_set, const char * const *keys, const size_t *key_length, - size_t number_of_keys, - bool mget_mode) + const size_t number_of_keys, + const bool mget_mode) { if (ptr->number_of_replicas == 0) { @@ -674,10 +702,10 @@ static memcached_return_t binary_mget_by_key(memcached_st *ptr, keys, key_length, number_of_keys, mget_mode); } - uint32_t* hash= static_cast(libmemcached_malloc(ptr, sizeof(uint32_t) * number_of_keys)); - bool* dead_servers= static_cast(libmemcached_calloc(ptr, memcached_server_count(ptr), sizeof(bool))); + uint32_t* hash= libmemcached_xvalloc(ptr, number_of_keys, uint32_t); + bool* dead_servers= libmemcached_xcalloc(ptr, memcached_server_count(ptr), bool); - if (hash == NULL || dead_servers == NULL) + if (hash == NULL or dead_servers == NULL) { libmemcached_free(ptr, hash); libmemcached_free(ptr, dead_servers);