projects / awesomized / libmemcached / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree | github
raw | inline | side by side
Update all of the build/spec files.
[awesomized/libmemcached] / example / interface_v0.c
diff --git a/example/interface_v0.c b/example/interface_v0.c
index 1fb5a0a998d04acc946fe89602db65ed59657eab..ef5ba47b57324b384a8c60e792205a57f5599cca 100644 (file)
--- a/example/interface_v0.c
+++ b/example/interface_v0.c
@@ -4,11 +4,11 @@
  * in the protocol library. You might want to have your copy of the protocol
  * specification next to your coffee ;-)
  */
+
+#include "config.h"
+
 #include <assert.h>
 #include <sys/types.h>
-#include <sys/socket.h>
-#include <netdb.h>
-#include <netinet/tcp.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <fcntl.h>
@@ -16,9 +16,10 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include <libmemcached/protocol_handler.h>
-#include <libmemcached/byteorder.h>
-#include "storage.h"
+#include <libmemcachedprotocol-0.0/handler.h>
+#include <example/byteorder.h>
+#include "example/storage.h"
+#include "example/memcached_light.h"
 
 static protocol_binary_response_status noop_command_handler(const void *cookie,
                                                             protocol_binary_request_header *header,
@@ -53,7 +54,7 @@ static protocol_binary_response_status quit_command_handler(const void *cookie,
     response_handler(cookie, header, (void*)&response);
 
   /* I need a better way to signal to close the connection */
-  return PROTOCOL_BINARY_RESPONSE_EIO;
+  return PROTOCOL_BINARY_RESPONSE_EINTERNAL;
 }
 
 static protocol_binary_response_status get_command_handler(const void *cookie,
@@ -79,7 +80,7 @@ static protocol_binary_response_status get_command_handler(const void *cookie,
     msg.response.message.body.flags= htonl(item->flags);
     char *ptr= (char*)(msg.response.bytes + sizeof(*header) + 4);
     uint32_t bodysize= 4;
-    msg.response.message.header.response.cas= htonll(item->cas);
+    msg.response.message.header.response.cas= example_htonll(item->cas);
     if (opcode == PROTOCOL_BINARY_CMD_GETK || opcode == PROTOCOL_BINARY_CMD_GETKQ)
     {
       memcpy(ptr, item->key, item->nkey);
@@ -173,8 +174,8 @@ static protocol_binary_response_status arithmetic_command_handler(const void *co
   };
 
   uint16_t keylen= ntohs(header->request.keylen);
-  uint64_t initial= ntohll(req->message.body.initial);
-  uint64_t delta= ntohll(req->message.body.delta);
+  uint64_t initial= example_ntohll(req->message.body.initial);
+  uint64_t delta= example_ntohll(req->message.body.delta);
   uint32_t expiration= ntohl(req->message.body.expiration);
   uint32_t flags= 0;
   void *key= req->bytes + sizeof(req->bytes);
@@ -223,8 +224,8 @@ static protocol_binary_response_status arithmetic_command_handler(const void *co
   if (rval == PROTOCOL_BINARY_RESPONSE_SUCCESS)
   {
     response.message.header.response.bodylen= ntohl(8);
-    response.message.body.value= ntohll((*(uint64_t*)item->data));
-    response.message.header.response.cas= ntohll(item->cas);
+    response.message.body.value= example_ntohll((*(uint64_t*)item->data));
+    response.message.header.response.cas= example_ntohll(item->cas);
 
     release_item(item);
     if (header->request.opcode == PROTOCOL_BINARY_CMD_INCREMENTQ ||
@@ -251,6 +252,7 @@ static protocol_binary_response_status version_command_handler(const void *cooki
       .opcode= PROTOCOL_BINARY_CMD_VERSION,
       .status= htons(PROTOCOL_BINARY_RESPONSE_SUCCESS),
       .opaque= header->request.opaque,
+      .cas= 0,
       .bodylen= htonl((uint32_t)strlen(versionstring))
     }
   };
@@ -266,7 +268,7 @@ static protocol_binary_response_status concat_command_handler(const void *cookie
 {
   protocol_binary_response_status rval= PROTOCOL_BINARY_RESPONSE_SUCCESS;
   uint16_t keylen= ntohs(header->request.keylen);
-  uint64_t cas= ntohll(header->request.cas);
+  uint64_t cas= example_ntohll(header->request.cas);
   void *key= header + 1;
   uint32_t vallen= ntohl(header->request.bodylen) - keylen;
   void *val= (char*)key + keylen;
@@ -317,7 +319,7 @@ static protocol_binary_response_status concat_command_handler(const void *cookie
             .opcode= header->request.opcode,
             .status= htons(rval),
             .opaque= header->request.opaque,
-            .cas= htonll(cas),
+            .cas= example_htonll(cas),
           }
         }
       };
@@ -357,7 +359,7 @@ static protocol_binary_response_status set_command_handler(const void *cookie,
     struct item* item= get_item(key, keylen);
     if (item != NULL)
     {
-      if (item->cas != ntohll(header->request.cas))
+      if (item->cas != example_ntohll(header->request.cas))
       {
         release_item(item);
         response.message.header.response.status= htons(PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS);
@@ -379,7 +381,7 @@ static protocol_binary_response_status set_command_handler(const void *cookie,
     /* SETQ shouldn't return a message */
     if (header->request.opcode == PROTOCOL_BINARY_CMD_SET)
     {
-      response.message.header.response.cas= htonll(item->cas);
+      response.message.header.response.cas= example_htonll(item->cas);
       release_item(item);
       return response_handler(cookie, header, (void*)&response);
     }
@@ -426,7 +428,7 @@ static protocol_binary_response_status add_command_handler(const void *cookie,
       /* ADDQ shouldn't return a message */
       if (header->request.opcode == PROTOCOL_BINARY_CMD_ADD)
       {
-        response.message.header.response.cas= htonll(item->cas);
+        response.message.header.response.cas= example_htonll(item->cas);
         release_item(item);
         return response_handler(cookie, header, (void*)&response);
       }
@@ -468,21 +470,26 @@ static protocol_binary_response_status replace_command_handler(const void *cooki
 
   struct item* item= get_item(key, keylen);
   if (item == NULL)
+  {
     response.message.header.response.status= htons(PROTOCOL_BINARY_RESPONSE_KEY_ENOENT);
-  else if (header->request.cas == 0 || ntohll(header->request.cas) == item->cas)
+  }
+  else if (header->request.cas == 0 || example_ntohll(header->request.cas) == item->cas)
   {
     release_item(item);
     delete_item(key, keylen);
     item= create_item(key, keylen, data, datalen, flags, timeout);
+
     if (item == NULL)
+    {
       response.message.header.response.status= htons(PROTOCOL_BINARY_RESPONSE_ENOMEM);
+    }
     else
     {
       put_item(item);
       /* REPLACEQ shouldn't return a message */
       if (header->request.opcode == PROTOCOL_BINARY_CMD_REPLACE)
       {
-        response.message.header.response.cas= htonll(item->cas);
+        response.message.header.response.cas= example_htonll(item->cas);
         release_item(item);
         return response_handler(cookie, header, (void*)&response);
       }
@@ -518,8 +525,15 @@ static protocol_binary_response_status stat_command_handler(const void *cookie,
   return response_handler(cookie, header, (void*)&response);
 }
 
-struct memcached_binary_protocol_callback_st interface_v0_impl= {
-  .interface_version= 0,
+memcached_binary_protocol_callback_st interface_v0_impl= {
+  .interface_version= MEMCACHED_PROTOCOL_HANDLER_V0,
+#ifdef FUTURE
+  /*
+  ** There is a number of bugs in the extra options for gcc causing
+  ** warning on these struct initializers. It hurts my heart to remove
+  ** it so I'll just leave it in here so that we can enable it when
+  ** we can drop support for the broken compilers
+  */
   .interface.v0.comcode[PROTOCOL_BINARY_CMD_GET]= get_command_handler,
   .interface.v0.comcode[PROTOCOL_BINARY_CMD_SET]= set_command_handler,
   .interface.v0.comcode[PROTOCOL_BINARY_CMD_ADD]= add_command_handler,
@@ -547,4 +561,36 @@ struct memcached_binary_protocol_callback_st interface_v0_impl= {
   .interface.v0.comcode[PROTOCOL_BINARY_CMD_FLUSHQ]= flush_command_handler,
   .interface.v0.comcode[PROTOCOL_BINARY_CMD_APPENDQ]= concat_command_handler,
   .interface.v0.comcode[PROTOCOL_BINARY_CMD_PREPENDQ]= concat_command_handler,
+#endif
 };
+
+void initialize_interface_v0_handler(void)
+{
+  interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_GET]= get_command_handler;
+  interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_SET]= set_command_handler;
+  interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_ADD]= add_command_handler;
+  interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_REPLACE]= replace_command_handler;
+  interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_DELETE]= delete_command_handler;
+  interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_INCREMENT]= arithmetic_command_handler;
+  interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_DECREMENT]= arithmetic_command_handler;
+  interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_QUIT]= quit_command_handler;
+  interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_FLUSH]= flush_command_handler;
+  interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_GETQ]= get_command_handler;
+  interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_NOOP]= noop_command_handler;
+  interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_VERSION]= version_command_handler;
+  interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_GETK]= get_command_handler;
+  interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_GETKQ]= get_command_handler;
+  interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_APPEND]= concat_command_handler;
+  interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_PREPEND]= concat_command_handler;
+  interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_STAT]= stat_command_handler;
+  interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_SETQ]= set_command_handler;
+  interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_ADDQ]= add_command_handler;
+  interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_REPLACEQ]= replace_command_handler;
+  interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_DELETEQ]= delete_command_handler;
+  interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_INCREMENTQ]= arithmetic_command_handler;
+  interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_DECREMENTQ]= arithmetic_command_handler;
+  interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_QUITQ]= quit_command_handler;
+  interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_FLUSHQ]= flush_command_handler;
+  interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_APPENDQ]= concat_command_handler;
+  interface_v0_impl.interface.v0.comcode[PROTOCOL_BINARY_CMD_PREPENDQ]= concat_command_handler;
+}
Resurrection of libmemcached