projects / m6w6 / libmemcached / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree | github
raw | inline | side by side
Merge in updates to doc/build of memaslap.
[m6w6/libmemcached] / libmemcached / protocol / binary_handler.c
diff --git a/libmemcached/protocol/binary_handler.c b/libmemcached/protocol/binary_handler.c
index 23aeb5f998ecb3a21866a9b571b78f661cec97a9..93fb316222276bfc859c196b0da20194492e2e59 100644 (file)
--- 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 <libmemcached/protocol/common.h>
+#include <libmemcached/byteorder.h>
 
 #include <stdlib.h>
 #include <sys/types.h>
-#include <sys/socket.h>
 #include <errno.h>
 #include <stdbool.h>
 #include <string.h>
@@ -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)
@@ -125,11 +160,12 @@ get_response_handler(const void *cookie,
       .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)
@@ -155,7 +191,7 @@ stat_response_handler(const void *cookie,
                      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= {
@@ -169,7 +205,7 @@ stat_response_handler(const void *cookie,
   };
 
   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 +227,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= {
@@ -204,7 +240,7 @@ version_response_handler(const void *cookie,
   };
 
   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 +264,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);
@@ -285,7 +321,7 @@ 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);
@@ -314,7 +350,7 @@ decrement_command_handler(const void *cookie,
             .cas= ntohll(cas),
             .bodylen= htonl(8)
           },
-          .body.value = htonll(result)
+          .body.value= htonll(result)
         }
       };
       rval= response_handler(cookie, header, (void*)&response);
@@ -343,7 +379,7 @@ 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);
@@ -390,7 +426,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 +477,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,7 +516,7 @@ 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);
@@ -509,7 +545,7 @@ increment_command_handler(const void *cookie,
             .cas= ntohll(cas),
             .bodylen= htonl(8)
           },
-          .body.value = htonll(result)
+          .body.value= htonll(result)
         }
       };
 
@@ -538,16 +574,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,7 +609,7 @@ 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);
@@ -627,7 +663,7 @@ 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);
@@ -677,15 +713,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 +736,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 +754,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);
@@ -776,7 +812,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);
@@ -834,7 +870,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 +904,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 +960,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 +1006,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 +1027,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 +1035,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 +1043,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 +1051,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 +1079,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 +1091,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 +1107,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;
 }
Resurrection of libmemcached https://launchpad.net/libmemcached