X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fprotocol%2Fbinary_handler.c;h=0997ebb03dcc96af572b3e5d85b40037e5abf60f;hb=e7855e43bbc4dd0a5e8fcbfd4888181001dcd1ec;hp=23aeb5f998ecb3a21866a9b571b78f661cec97a9;hpb=a148d541d261c9c867c412e773920f5a1973bbae;p=awesomized%2Flibmemcached diff --git a/libmemcached/protocol/binary_handler.c b/libmemcached/protocol/binary_handler.c index 23aeb5f9..0997ebb0 100644 --- a/libmemcached/protocol/binary_handler.c +++ b/libmemcached/protocol/binary_handler.c @@ -1,9 +1,44 @@ -/* -*- Mode: C; tab-width: 2; c-basic-offset: 2; indent-tabs-mode: nil -*- */ -#include "libmemcached/protocol/common.h" +/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab: + * + * Libmemcached library + * + * Copyright (C) 2011 Data Differential, http://datadifferential.com/ + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * + * * The names of its contributors may not be used to endorse or + * promote products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#include +#include #include #include -#include #include #include #include @@ -30,7 +65,7 @@ raw_response_handler(const void *cookie, protocol_binary_request_header *request, protocol_binary_response_header *response) { - struct memcached_protocol_client_st *client= (void*)cookie; + memcached_protocol_client_st *client= (void*)cookie; if (client->root->pedantic && !memcached_binary_protocol_pedantic_check_response(request, response)) @@ -40,7 +75,7 @@ raw_response_handler(const void *cookie, if (!client->root->drain(client)) { - return PROTOCOL_BINARY_RESPONSE_EIO; + return PROTOCOL_BINARY_RESPONSE_EINTERNAL; } size_t len= sizeof(*response) + htonl(response->response.bodylen); @@ -59,14 +94,14 @@ raw_response_handler(const void *cookie, num_bytes); if (nw == -1) { - if (errno == EWOULDBLOCK) + if (get_socket_errno() == EWOULDBLOCK) { break; } - else if (errno != EINTR) + else if (get_socket_errno() != EINTR) { client->error= errno; - return PROTOCOL_BINARY_RESPONSE_EIO; + return PROTOCOL_BINARY_RESPONSE_EINTERNAL; } } else @@ -106,7 +141,7 @@ get_response_handler(const void *cookie, uint32_t flags, uint64_t cas) { - struct memcached_protocol_client_st *client= (void*)cookie; + memcached_protocol_client_st *client= (void*)cookie; uint8_t opcode= client->current_command->request.opcode; if (opcode == PROTOCOL_BINARY_CMD_GET || opcode == PROTOCOL_BINARY_CMD_GETQ) @@ -120,16 +155,17 @@ get_response_handler(const void *cookie, .opcode= opcode, .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS), .opaque= client->current_command->request.opaque, - .cas= htonll(cas), + .cas= memcached_htonll(cas), .keylen= htons(keylen), .extlen= 4, .bodylen= htonl(bodylen + keylen + 4), }, - .message.body.flags= htonl(flags), }; + response.message.body.flags= htonl(flags); + protocol_binary_response_status rval; - const protocol_binary_response_status success = PROTOCOL_BINARY_RESPONSE_SUCCESS; + const protocol_binary_response_status success= PROTOCOL_BINARY_RESPONSE_SUCCESS; if ((rval= client->root->spool(client, response.bytes, sizeof(response.bytes))) != success || (rval= client->root->spool(client, key, keylen)) != success || (rval= client->root->spool(client, body, bodylen)) != success) @@ -148,14 +184,14 @@ get_response_handler(const void *cookie, * @param body the length of the body * @param bodylen the length of the body */ -static protocol_binary_response_status -stat_response_handler(const void *cookie, - const void *key, - uint16_t keylen, - const void *body, - uint32_t bodylen) { +static protocol_binary_response_status stat_response_handler(const void *cookie, + const void *key, + uint16_t keylen, + const void *body, + uint32_t bodylen) +{ - struct memcached_protocol_client_st *client= (void*)cookie; + memcached_protocol_client_st *client= (void*)cookie; protocol_binary_response_no_extras response= { .message.header.response= { @@ -165,11 +201,12 @@ stat_response_handler(const void *cookie, .opaque= client->current_command->request.opaque, .keylen= htons(keylen), .bodylen= htonl(bodylen + keylen), + .cas= 0 }, }; protocol_binary_response_status rval; - const protocol_binary_response_status success = PROTOCOL_BINARY_RESPONSE_SUCCESS; + const protocol_binary_response_status success= PROTOCOL_BINARY_RESPONSE_SUCCESS; if ((rval= client->root->spool(client, response.bytes, sizeof(response.bytes))) != success || (rval= client->root->spool(client, key, keylen)) != success || (rval= client->root->spool(client, body, bodylen)) != success) @@ -191,7 +228,7 @@ version_response_handler(const void *cookie, const void *text, uint32_t textlen) { - struct memcached_protocol_client_st *client= (void*)cookie; + memcached_protocol_client_st *client= (void*)cookie; protocol_binary_response_no_extras response= { .message.header.response= { @@ -200,11 +237,12 @@ version_response_handler(const void *cookie, .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS), .opaque= client->current_command->request.opaque, .bodylen= htonl(textlen), + .cas= 0 }, }; protocol_binary_response_status rval; - const protocol_binary_response_status success = PROTOCOL_BINARY_RESPONSE_SUCCESS; + const protocol_binary_response_status success= PROTOCOL_BINARY_RESPONSE_SUCCESS; if ((rval= client->root->spool(client, response.bytes, sizeof(response.bytes))) != success || (rval= client->root->spool(client, text, textlen)) != success) { @@ -228,7 +266,7 @@ add_command_handler(const void *cookie, { protocol_binary_response_status rval; - struct memcached_protocol_client_st *client= (void*)cookie; + memcached_protocol_client_st *client= (void*)cookie; if (client->root->callback->interface.v1.add != NULL) { uint16_t keylen= ntohs(header->request.keylen); @@ -255,7 +293,7 @@ add_command_handler(const void *cookie, .opcode= PROTOCOL_BINARY_CMD_ADD, .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS), .opaque= header->request.opaque, - .cas= ntohll(cas) + .cas= memcached_ntohll(cas) } } }; @@ -285,13 +323,13 @@ decrement_command_handler(const void *cookie, (void)response_handler; protocol_binary_response_status rval; - struct memcached_protocol_client_st *client= (void*)cookie; + memcached_protocol_client_st *client= (void*)cookie; if (client->root->callback->interface.v1.decrement != NULL) { uint16_t keylen= ntohs(header->request.keylen); protocol_binary_request_decr *request= (void*)header; - uint64_t init= ntohll(request->message.body.initial); - uint64_t delta= ntohll(request->message.body.delta); + uint64_t init= memcached_ntohll(request->message.body.initial); + uint64_t delta= memcached_ntohll(request->message.body.delta); uint32_t timeout= ntohl(request->message.body.expiration); void *key= request->bytes + sizeof(request->bytes); uint64_t result; @@ -311,10 +349,10 @@ decrement_command_handler(const void *cookie, .opcode= PROTOCOL_BINARY_CMD_DECREMENT, .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS), .opaque= header->request.opaque, - .cas= ntohll(cas), + .cas= memcached_ntohll(cas), .bodylen= htonl(8) }, - .body.value = htonll(result) + .body.value= memcached_htonll(result) } }; rval= response_handler(cookie, header, (void*)&response); @@ -343,12 +381,12 @@ delete_command_handler(const void *cookie, (void)response_handler; protocol_binary_response_status rval; - struct memcached_protocol_client_st *client= (void*)cookie; + memcached_protocol_client_st *client= (void*)cookie; if (client->root->callback->interface.v1.delete != NULL) { uint16_t keylen= ntohs(header->request.keylen); - void *key= (header + 1); - uint64_t cas= ntohll(header->request.cas); + void *key= (header +1); + uint64_t cas= memcached_ntohll(header->request.cas); rval= client->root->callback->interface.v1.delete(cookie, key, keylen, cas); if (rval == PROTOCOL_BINARY_RESPONSE_SUCCESS && header->request.opcode == PROTOCOL_BINARY_CMD_DELETE) @@ -390,7 +428,7 @@ flush_command_handler(const void *cookie, (void)response_handler; protocol_binary_response_status rval; - struct memcached_protocol_client_st *client= (void*)cookie; + memcached_protocol_client_st *client= (void*)cookie; if (client->root->callback->interface.v1.flush != NULL) { protocol_binary_request_flush *flush= (void*)header; @@ -441,7 +479,7 @@ get_command_handler(const void *cookie, (void)response_handler; protocol_binary_response_status rval; - struct memcached_protocol_client_st *client= (void*)cookie; + memcached_protocol_client_st *client= (void*)cookie; if (client->root->callback->interface.v1.get != NULL) { uint16_t keylen= ntohs(header->request.keylen); @@ -480,13 +518,13 @@ increment_command_handler(const void *cookie, (void)response_handler; protocol_binary_response_status rval; - struct memcached_protocol_client_st *client= (void*)cookie; + memcached_protocol_client_st *client= (void*)cookie; if (client->root->callback->interface.v1.increment != NULL) { uint16_t keylen= ntohs(header->request.keylen); protocol_binary_request_incr *request= (void*)header; - uint64_t init= ntohll(request->message.body.initial); - uint64_t delta= ntohll(request->message.body.delta); + uint64_t init= memcached_ntohll(request->message.body.initial); + uint64_t delta= memcached_ntohll(request->message.body.delta); uint32_t timeout= ntohl(request->message.body.expiration); void *key= request->bytes + sizeof(request->bytes); uint64_t cas; @@ -506,10 +544,10 @@ increment_command_handler(const void *cookie, .opcode= PROTOCOL_BINARY_CMD_INCREMENT, .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS), .opaque= header->request.opaque, - .cas= ntohll(cas), + .cas= memcached_ntohll(cas), .bodylen= htonl(8) }, - .body.value = htonll(result) + .body.value= memcached_htonll(result) } }; @@ -538,16 +576,16 @@ noop_command_handler(const void *cookie, protocol_binary_request_header *header, memcached_binary_protocol_raw_response_handler response_handler) { - struct memcached_protocol_client_st *client= (void*)cookie; + memcached_protocol_client_st *client= (void*)cookie; if (client->root->callback->interface.v1.noop != NULL) { client->root->callback->interface.v1.noop(cookie); } protocol_binary_response_no_extras response= { - .message = { - .header.response = { - .magic = PROTOCOL_BINARY_RES, + .message= { + .header.response= { + .magic= PROTOCOL_BINARY_RES, .opcode= PROTOCOL_BINARY_CMD_NOOP, .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS), .opaque= header->request.opaque, @@ -573,14 +611,14 @@ append_command_handler(const void *cookie, (void)response_handler; protocol_binary_response_status rval; - struct memcached_protocol_client_st *client= (void*)cookie; + memcached_protocol_client_st *client= (void*)cookie; if (client->root->callback->interface.v1.append != NULL) { uint16_t keylen= ntohs(header->request.keylen); uint32_t datalen= ntohl(header->request.bodylen) - keylen; - char *key= (void*)(header + 1); - char *data= key + keylen; - uint64_t cas= ntohll(header->request.cas); + char *key= (void*)(header +1); + char *data= key +keylen; + uint64_t cas= memcached_ntohll(header->request.cas); uint64_t result_cas; rval= client->root->callback->interface.v1.append(cookie, key, keylen, @@ -597,7 +635,7 @@ append_command_handler(const void *cookie, .opcode= PROTOCOL_BINARY_CMD_APPEND, .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS), .opaque= header->request.opaque, - .cas= ntohll(result_cas), + .cas= memcached_ntohll(result_cas), }, } }; @@ -627,14 +665,14 @@ prepend_command_handler(const void *cookie, (void)response_handler; protocol_binary_response_status rval; - struct memcached_protocol_client_st *client= (void*)cookie; + memcached_protocol_client_st *client= (void*)cookie; if (client->root->callback->interface.v1.prepend != NULL) { uint16_t keylen= ntohs(header->request.keylen); uint32_t datalen= ntohl(header->request.bodylen) - keylen; char *key= (char*)(header + 1); char *data= key + keylen; - uint64_t cas= ntohll(header->request.cas); + uint64_t cas= memcached_ntohll(header->request.cas); uint64_t result_cas; rval= client->root->callback->interface.v1.prepend(cookie, key, keylen, data, datalen, cas, @@ -650,7 +688,7 @@ prepend_command_handler(const void *cookie, .opcode= PROTOCOL_BINARY_CMD_PREPEND, .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS), .opaque= header->request.opaque, - .cas= ntohll(result_cas), + .cas= memcached_ntohll(result_cas), }, } }; @@ -677,15 +715,15 @@ quit_command_handler(const void *cookie, protocol_binary_request_header *header, memcached_binary_protocol_raw_response_handler response_handler) { - struct memcached_protocol_client_st *client= (void*)cookie; + memcached_protocol_client_st *client= (void*)cookie; if (client->root->callback->interface.v1.quit != NULL) { client->root->callback->interface.v1.quit(cookie); } protocol_binary_response_no_extras response= { - .message = { - .header.response = { + .message= { + .header.response= { .magic= PROTOCOL_BINARY_RES, .opcode= PROTOCOL_BINARY_CMD_QUIT, .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS), @@ -700,7 +738,7 @@ quit_command_handler(const void *cookie, } /* I need a better way to signal to close the connection */ - return PROTOCOL_BINARY_RESPONSE_EIO; + return PROTOCOL_BINARY_RESPONSE_EINTERNAL; } /** @@ -718,7 +756,7 @@ replace_command_handler(const void *cookie, (void)response_handler; protocol_binary_response_status rval; - struct memcached_protocol_client_st *client= (void*)cookie; + memcached_protocol_client_st *client= (void*)cookie; if (client->root->callback->interface.v1.replace != NULL) { uint16_t keylen= ntohs(header->request.keylen); @@ -728,7 +766,7 @@ replace_command_handler(const void *cookie, uint32_t timeout= ntohl(request->message.body.expiration); char *key= ((char*)header) + sizeof(*header) + 8; char *data= key + keylen; - uint64_t cas= ntohll(header->request.cas); + uint64_t cas= memcached_ntohll(header->request.cas); uint64_t result_cas; rval= client->root->callback->interface.v1.replace(cookie, key, keylen, @@ -746,7 +784,7 @@ replace_command_handler(const void *cookie, .opcode= PROTOCOL_BINARY_CMD_REPLACE, .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS), .opaque= header->request.opaque, - .cas= ntohll(result_cas), + .cas= memcached_ntohll(result_cas), }, } }; @@ -776,7 +814,7 @@ set_command_handler(const void *cookie, (void)response_handler; protocol_binary_response_status rval; - struct memcached_protocol_client_st *client= (void*)cookie; + memcached_protocol_client_st *client= (void*)cookie; if (client->root->callback->interface.v1.set != NULL) { uint16_t keylen= ntohs(header->request.keylen); @@ -786,7 +824,7 @@ set_command_handler(const void *cookie, uint32_t timeout= ntohl(request->message.body.expiration); char *key= ((char*)header) + sizeof(*header) + 8; char *data= key + keylen; - uint64_t cas= ntohll(header->request.cas); + uint64_t cas= memcached_ntohll(header->request.cas); uint64_t result_cas; @@ -804,7 +842,7 @@ set_command_handler(const void *cookie, .opcode= PROTOCOL_BINARY_CMD_SET, .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS), .opaque= header->request.opaque, - .cas= ntohll(result_cas), + .cas= memcached_ntohll(result_cas), }, } }; @@ -834,7 +872,7 @@ stat_command_handler(const void *cookie, (void)response_handler; protocol_binary_response_status rval; - struct memcached_protocol_client_st *client= (void*)cookie; + memcached_protocol_client_st *client= (void*)cookie; if (client->root->callback->interface.v1.stat != NULL) { uint16_t keylen= ntohs(header->request.keylen); @@ -868,7 +906,7 @@ version_command_handler(const void *cookie, (void)header; protocol_binary_response_status rval; - struct memcached_protocol_client_st *client= (void*)cookie; + memcached_protocol_client_st *client= (void*)cookie; if (client->root->callback->interface.v1.version != NULL) { rval= client->root->callback->interface.v1.version(cookie, @@ -924,7 +962,7 @@ static memcached_binary_protocol_command_handler comcode_v0_v1_remap[256]= { * @return true if success or false if a fatal error occured so that the * connection should be shut down. */ -static bool execute_command(struct memcached_protocol_client_st *client, protocol_binary_request_header *header) +static protocol_binary_response_status execute_command(memcached_protocol_client_st *client, protocol_binary_request_header *header) { if (client->root->pedantic && memcached_binary_protocol_pedantic_check_request(header)) @@ -970,7 +1008,8 @@ static bool execute_command(struct memcached_protocol_client_st *client, protoco } if (rval != PROTOCOL_BINARY_RESPONSE_SUCCESS && - rval != PROTOCOL_BINARY_RESPONSE_EIO) + rval != PROTOCOL_BINARY_RESPONSE_EINTERNAL && + rval != PROTOCOL_BINARY_RESPONSE_NOT_SUPPORTED) { protocol_binary_response_no_extras response= { .message= { @@ -990,7 +1029,7 @@ static bool execute_command(struct memcached_protocol_client_st *client, protoco client->root->callback->post_execute(client, header); } - return rval != PROTOCOL_BINARY_RESPONSE_EIO; + return rval; } /* @@ -998,7 +1037,7 @@ static bool execute_command(struct memcached_protocol_client_st *client, protoco ** "PROTOECTED" INTERFACE ** ********************************************************************** */ -enum MEMCACHED_PROTOCOL_EVENT memcached_binary_protocol_process_data(struct memcached_protocol_client_st *client, ssize_t *length, void **endptr) +memcached_protocol_event_t memcached_binary_protocol_process_data(memcached_protocol_client_st *client, ssize_t *length, void **endptr) { /* try to parse all of the received packets */ protocol_binary_request_header *header; @@ -1006,7 +1045,7 @@ enum MEMCACHED_PROTOCOL_EVENT memcached_binary_protocol_process_data(struct memc if (header->request.magic != (uint8_t)PROTOCOL_BINARY_REQ) { client->error= EINVAL; - return ERROR_EVENT; + return MEMCACHED_PROTOCOL_ERROR_EVENT; } ssize_t len= *length; @@ -1014,13 +1053,16 @@ enum MEMCACHED_PROTOCOL_EVENT memcached_binary_protocol_process_data(struct memc (len >= (ssize_t)(sizeof(*header) + ntohl(header->request.bodylen)))) { /* I have the complete package */ - client->current_command = header; - if (!execute_command(client, header)) + client->current_command= header; + protocol_binary_response_status rv= execute_command(client, header); + + if (rv == PROTOCOL_BINARY_RESPONSE_EINTERNAL) { *length= len; *endptr= (void*)header; - return ERROR_EVENT; - } + return MEMCACHED_PROTOCOL_ERROR_EVENT; + } else if (rv == PROTOCOL_BINARY_RESPONSE_NOT_SUPPORTED) + return MEMCACHED_PROTOCOL_PAUSE_EVENT; ssize_t total= (ssize_t)(sizeof(*header) + ntohl(header->request.bodylen)); len -= total; @@ -1039,12 +1081,11 @@ enum MEMCACHED_PROTOCOL_EVENT memcached_binary_protocol_process_data(struct memc header= (void*)client->root->input_buffer; } } + *length= len; + *endptr= (void*)header; } - *length= len; - *endptr= (void*)header; - - return READ_EVENT; + return MEMCACHED_PROTOCOL_READ_EVENT; } /* @@ -1052,12 +1093,12 @@ enum MEMCACHED_PROTOCOL_EVENT memcached_binary_protocol_process_data(struct memc ** PUBLIC INTERFACE ** ********************************************************************** */ -struct memcached_binary_protocol_callback_st *memcached_binary_protocol_get_callbacks(struct memcached_protocol_st *instance) +memcached_binary_protocol_callback_st *memcached_binary_protocol_get_callbacks(memcached_protocol_st *instance) { return instance->callback; } -void memcached_binary_protocol_set_callbacks(struct memcached_protocol_st *instance, struct memcached_binary_protocol_callback_st *callback) +void memcached_binary_protocol_set_callbacks(memcached_protocol_st *instance, memcached_binary_protocol_callback_st *callback) { instance->callback= callback; } @@ -1068,12 +1109,12 @@ memcached_binary_protocol_raw_response_handler memcached_binary_protocol_get_raw return raw_response_handler; } -void memcached_binary_protocol_set_pedantic(struct memcached_protocol_st *instance, bool enable) +void memcached_binary_protocol_set_pedantic(memcached_protocol_st *instance, bool enable) { instance->pedantic= enable; } -bool memcached_binary_protocol_get_pedantic(struct memcached_protocol_st *instance) +bool memcached_binary_protocol_get_pedantic(memcached_protocol_st *instance) { return instance->pedantic; }