X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fstorage.cc;h=079fba1d62ac4a785f85de6115a66be53592a8a6;hb=9973d386ac8476cd09cc4d9cf7bd2234a42740c7;hp=3e29323286d667d7f5c9d1ad10fb654826fdd31f;hpb=51351e672a6a1626e09d5a9d41e3229df44fc3c8;p=awesomized%2Flibmemcached diff --git a/libmemcached/storage.cc b/libmemcached/storage.cc index 3e293232..079fba1d 100644 --- a/libmemcached/storage.cc +++ b/libmemcached/storage.cc @@ -74,6 +74,24 @@ static inline const char *storage_op_string(memcached_storage_action_t verb) return "set "; } +static inline uint8_t can_by_encrypted(const memcached_storage_action_t verb) +{ + switch (verb) + { + case SET_OP: + case ADD_OP: + case CAS_OP: + case REPLACE_OP: + return true; + + case APPEND_OP: + case PREPEND_OP: + break; + } + + return false; +} + static inline uint8_t get_com_code(const memcached_storage_action_t verb, const bool reply) { if (reply == false) @@ -120,8 +138,8 @@ static inline uint8_t get_com_code(const memcached_storage_action_t verb, const return PROTOCOL_BINARY_CMD_SET; } -static memcached_return_t memcached_send_binary(memcached_st *ptr, - memcached_server_write_instance_st server, +static memcached_return_t memcached_send_binary(Memcached *ptr, + memcached_instance_st* server, uint32_t server_key, const char *key, const size_t key_length, @@ -137,7 +155,8 @@ static memcached_return_t memcached_send_binary(memcached_st *ptr, protocol_binary_request_set request= {}; size_t send_length= sizeof(request.bytes); - request.message.header.request.magic= PROTOCOL_BINARY_REQ; + initialize_binary_request(server, request.message.header); + request.message.header.request.opcode= get_com_code(verb, reply); request.message.header.request.keylen= htons((uint16_t)(key_length + memcached_array_size(ptr->_namespace))); request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES; @@ -160,8 +179,9 @@ static memcached_return_t memcached_send_binary(memcached_st *ptr, request.message.header.request.cas= memcached_htonll(cas); } - struct libmemcached_io_vector_st vector[]= + libmemcached_io_vector_st vector[]= { + { NULL, 0 }, { request.bytes, send_length }, { memcached_array_string(ptr->_namespace), memcached_array_size(ptr->_namespace) }, { key, key_length }, @@ -170,16 +190,10 @@ static memcached_return_t memcached_send_binary(memcached_st *ptr, /* write the header */ memcached_return_t rc; - if ((rc= memcached_vdo(server, vector, 4, flush)) != MEMCACHED_SUCCESS) + if ((rc= memcached_vdo(server, vector, 5, flush)) != MEMCACHED_SUCCESS) { - memcached_io_reset(server); - - if (memcached_has_error(ptr)) - { - memcached_set_error(*server, rc, MEMCACHED_AT); - } - - return MEMCACHED_WRITE_FAILURE; + assert(memcached_last_error(server->root) != MEMCACHED_SUCCESS); + return memcached_last_error(server->root); } if (verb == SET_OP and ptr->number_of_replicas > 0) @@ -195,13 +209,9 @@ static memcached_return_t memcached_send_binary(memcached_st *ptr, server_key= 0; } - 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_vdo(instance, vector, 4, false) != MEMCACHED_SUCCESS) - { - memcached_io_reset(instance); - } - else + if (memcached_success(memcached_vdo(instance, vector, 5, false))) { memcached_server_response_decrement(instance); } @@ -222,8 +232,8 @@ static memcached_return_t memcached_send_binary(memcached_st *ptr, return memcached_response(server, NULL, 0, NULL); } -static memcached_return_t memcached_send_ascii(memcached_st *ptr, - memcached_server_write_instance_st instance, +static memcached_return_t memcached_send_ascii(Memcached *ptr, + memcached_instance_st* instance, const char *key, const size_t key_length, const char *value, @@ -271,15 +281,16 @@ static memcached_return_t memcached_send_ascii(memcached_st *ptr, } } - struct libmemcached_io_vector_st vector[]= + libmemcached_io_vector_st vector[]= { + { NULL, 0 }, { storage_op_string(verb), strlen(storage_op_string(verb))}, { memcached_array_string(ptr->_namespace), memcached_array_size(ptr->_namespace) }, { key, key_length }, - { flags_buffer, flags_buffer_length }, - { expiration_buffer, expiration_buffer_length }, - { value_buffer, value_buffer_length }, - { cas_buffer, cas_buffer_length }, + { flags_buffer, size_t(flags_buffer_length) }, + { expiration_buffer, size_t(expiration_buffer_length) }, + { value_buffer, size_t(value_buffer_length) }, + { cas_buffer, size_t(cas_buffer_length) }, { " noreply", reply ? 0 : memcached_literal_param_size(" noreply") }, { memcached_literal_param("\r\n") }, { value, value_length }, @@ -287,21 +298,23 @@ static memcached_return_t memcached_send_ascii(memcached_st *ptr, }; /* Send command header */ - memcached_return_t rc= memcached_vdo(instance, vector, 11, flush); - if (rc == MEMCACHED_SUCCESS) + memcached_return_t rc= memcached_vdo(instance, vector, 12, flush); + + // If we should not reply, return with MEMCACHED_SUCCESS, unless error + if (reply == false) { - if (flush == false) - { - return MEMCACHED_BUFFERED; - } + return memcached_success(rc) ? MEMCACHED_SUCCESS : rc; + } - if (reply == false) - { - return MEMCACHED_SUCCESS; - } + if (flush == false) + { + return memcached_success(rc) ? MEMCACHED_BUFFERED : rc; + } + if (rc == MEMCACHED_SUCCESS) + { char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE]; - rc= memcached_response(instance, buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, NULL); + rc= memcached_response(instance, buffer, sizeof(buffer), NULL); if (rc == MEMCACHED_STORED) { @@ -309,21 +322,18 @@ static memcached_return_t memcached_send_ascii(memcached_st *ptr, } } - if (rc == MEMCACHED_WRITE_FAILURE) - { - memcached_io_reset(instance); - } - assert(memcached_failed(rc)); +#if 0 if (memcached_has_error(ptr) == false) { return memcached_set_error(*ptr, rc, MEMCACHED_AT); } +#endif return rc; } -static inline memcached_return_t memcached_send(memcached_st *ptr, +static inline memcached_return_t memcached_send(memcached_st *shell, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, @@ -332,29 +342,24 @@ static inline memcached_return_t memcached_send(memcached_st *ptr, const uint64_t cas, memcached_storage_action_t verb) { + Memcached* ptr= memcached2Memcached(shell); memcached_return_t rc; - if (memcached_failed(rc= initialize_query(ptr))) - { - return rc; - } - - if (memcached_failed(rc= memcached_validate_key_length(key_length, memcached_is_binary(ptr)))) + if (memcached_failed(rc= initialize_query(ptr, true))) { return rc; } if (memcached_failed(memcached_key_test(*ptr, (const char **)&key, &key_length, 1))) { - return MEMCACHED_BAD_KEY_PROVIDED; + return memcached_last_error(ptr); } uint32_t server_key= memcached_generate_hash_with_redistribution(ptr, group_key, group_key_length); - memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, server_key); + memcached_instance_st* instance= memcached_instance_fetch(ptr, server_key); WATCHPOINT_SET(instance->io_wait_count.read= 0); WATCHPOINT_SET(instance->io_wait_count.write= 0); - bool flush= true; if (memcached_is_buffering(instance->root) and verb == SET_OP) { @@ -363,18 +368,42 @@ static inline memcached_return_t memcached_send(memcached_st *ptr, bool reply= memcached_is_replying(ptr); - if (memcached_is_binary(ptr)) + hashkit_string_st* destination= NULL; + + if (memcached_is_encrypted(ptr)) { - return memcached_send_binary(ptr, instance, server_key, - key, key_length, - value, value_length, expiration, - flags, cas, flush, reply, verb); + if (can_by_encrypted(verb) == false) + { + return memcached_set_error(*ptr, MEMCACHED_NOT_SUPPORTED, MEMCACHED_AT, + memcached_literal_param("Operation not allowed while encyrption is enabled")); + } + + if ((destination= hashkit_encrypt(&ptr->hashkit, value, value_length)) == NULL) + { + return rc; + } + value= hashkit_string_c_str(destination); + value_length= hashkit_string_length(destination); } - return memcached_send_ascii(ptr, instance, + if (memcached_is_binary(ptr)) + { + rc= memcached_send_binary(ptr, instance, server_key, key, key_length, value, value_length, expiration, flags, cas, flush, reply, verb); + } + else + { + rc= memcached_send_ascii(ptr, instance, + key, key_length, + value, value_length, expiration, + flags, cas, flush, reply, verb); + } + + hashkit_string_free(destination); + + return rc; } @@ -404,10 +433,6 @@ memcached_return_t memcached_add(memcached_st *ptr, key, key_length, value, value_length, expiration, flags, 0, ADD_OP); - if (rc == MEMCACHED_NOTSTORED or rc == MEMCACHED_DATA_EXISTS) - { - memcached_set_error(*ptr, rc, MEMCACHED_AT); - } LIBMEMCACHED_MEMCACHED_ADD_END(); return rc; }