Fix return type from test functions (should be TEST_SUCCESS and not 0)

[awesomized/libmemcached] / example / interface_v0.c

diff --git a/example/interface_v0.c b/example/interface_v0.c
index b500ff8542a6f05d74c8426831b43fd51802cccb..041fe31e9ec767a5332e6e5c757c9294e69c9afa 100644 (file)
--- a/example/interface_v0.c
+++ b/example/interface_v0.c
@@ -4,6 +4,7 @@
  * 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>
@@ -92,6 +93,7 @@ static protocol_binary_response_status get_command_handler(const void *cookie,
     msg.response.message.header.response.bodylen= htonl(bodysize);
     msg.response.message.header.response.extlen= 4;
 
+    release_item(item);
     return response_handler(cookie, header, (void*)&msg);
   }
   else if (opcode == PROTOCOL_BINARY_CMD_GET || opcode == PROTOCOL_BINARY_CMD_GETK)
@@ -175,55 +177,47 @@ static protocol_binary_response_status arithmetic_command_handler(const void *co
   uint64_t initial= ntohll(req->message.body.initial);
   uint64_t delta= ntohll(req->message.body.delta);
   uint32_t expiration= ntohl(req->message.body.expiration);
+  uint32_t flags= 0;
   void *key= req->bytes + sizeof(req->bytes);
   protocol_binary_response_status rval= PROTOCOL_BINARY_RESPONSE_SUCCESS;
 
+  uint64_t value= initial;
+
   struct item *item= get_item(key, keylen);
-  if (item == NULL)
-  {
-    item= create_item(key, keylen, NULL, sizeof(initial), 0, expiration);
-    if (item == NULL)
-    {
-      rval= PROTOCOL_BINARY_RESPONSE_ENOMEM;
-    }
-    else
-    {
-      memcpy(item->data, &initial, sizeof(initial));
-      put_item(item);
-    }
-  }
-  else
+  if (item != NULL)
   {
     if (header->request.opcode == PROTOCOL_BINARY_CMD_INCREMENT ||
         header->request.opcode == PROTOCOL_BINARY_CMD_INCREMENTQ)
     {
-      (*(uint64_t*)item->data) += delta;
+      value= (*(uint64_t*)item->data) + delta;
     }
     else
     {
       if (delta > *(uint64_t*)item->data)
       {
-        *(uint64_t*)item->data= 0;
+        value= 0;
       }
       else
       {
-        *(uint64_t*)item->data -= delta;
+        value= *(uint64_t*)item->data - delta;
       }
     }
+    expiration= (uint32_t)item->exp;
+    flags= item->flags;
 
-    struct item *nitem= create_item(key, keylen, NULL, sizeof(initial), 0, item->exp);
-    if (item == NULL)
-    {
-      rval= PROTOCOL_BINARY_RESPONSE_ENOMEM;
-      delete_item(key, keylen);
-    }
-    else
-    {
-      memcpy(nitem->data, item->data, item->size);
-      delete_item(key, keylen);
-      put_item(nitem);
-      item = nitem;
-    }
+    release_item(item);
+    delete_item(key, keylen);
+  }
+
+  item= create_item(key, keylen, NULL, sizeof(value), flags, (time_t)expiration);
+  if (item == NULL)
+  {
+    rval= PROTOCOL_BINARY_RESPONSE_ENOMEM;
+  }
+  else
+  {
+    memcpy(item->data, &value, sizeof(value));
+    put_item(item);
   }
 
   response.message.header.response.status= htons(rval);
@@ -233,6 +227,7 @@ static protocol_binary_response_status arithmetic_command_handler(const void *co
     response.message.body.value= ntohll((*(uint64_t*)item->data));
     response.message.header.response.cas= ntohll(item->cas);
 
+    release_item(item);
     if (header->request.opcode == PROTOCOL_BINARY_CMD_INCREMENTQ ||
         header->request.opcode == PROTOCOL_BINARY_CMD_DECREMENTQ)
     {
@@ -278,7 +273,8 @@ static protocol_binary_response_status concat_command_handler(const void *cookie
   void *val= (char*)key + keylen;
 
   struct item *item= get_item(key, keylen);
-  struct item *nitem;
+  struct item *nitem= NULL;
+
   if (item == NULL)
   {
     rval= PROTOCOL_BINARY_RESPONSE_KEY_ENOENT;
@@ -290,6 +286,7 @@ static protocol_binary_response_status concat_command_handler(const void *cookie
   else if ((nitem= create_item(key, keylen, NULL, item->size + vallen,
                                item->flags, item->exp)) == NULL)
   {
+    release_item(item);
     rval= PROTOCOL_BINARY_RESPONSE_ENOMEM;
   }
   else
@@ -305,8 +302,12 @@ static protocol_binary_response_status concat_command_handler(const void *cookie
       memcpy(nitem->data, val, vallen);
       memcpy(((char*)(nitem->data)) + vallen, item->data, item->size);
     }
+    release_item(item);
     delete_item(key, keylen);
     put_item(nitem);
+    cas= nitem->cas;
+    release_item(nitem);
+
     if (header->request.opcode == PROTOCOL_BINARY_CMD_APPEND ||
         header->request.opcode == PROTOCOL_BINARY_CMD_PREPEND)
     {
@@ -317,7 +318,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(nitem->cas),
+            .cas= htonll(cas),
           }
         }
       };
@@ -336,7 +337,7 @@ static protocol_binary_response_status set_command_handler(const void *cookie,
   size_t datalen= ntohl(header->request.bodylen) - keylen - 8;
   protocol_binary_request_replace *request= (void*)header;
   uint32_t flags= ntohl(request->message.body.flags);
-  time_t timeout= ntohl(request->message.body.expiration);
+  time_t timeout= (time_t)ntohl(request->message.body.expiration);
   char *key= ((char*)header) + sizeof(*header) + 8;
   char *data= key + keylen;
 
@@ -355,16 +356,21 @@ static protocol_binary_response_status set_command_handler(const void *cookie,
   {
     /* validate cas */
     struct item* item= get_item(key, keylen);
-    if (item != NULL && item->cas != ntohll(header->request.cas))
+    if (item != NULL)
     {
-      response.message.header.response.status= htons(PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS);
-      return response_handler(cookie, header, (void*)&response);
+      if (item->cas != ntohll(header->request.cas))
+      {
+        release_item(item);
+        response.message.header.response.status= htons(PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS);
+        return response_handler(cookie, header, (void*)&response);
+      }
+      release_item(item);
     }
   }
 
   delete_item(key, keylen);
   struct item* item= create_item(key, keylen, data, datalen, flags, timeout);
-  if (item == 0)
+  if (item == NULL)
   {
     response.message.header.response.status= htons(PROTOCOL_BINARY_RESPONSE_ENOMEM);
   }
@@ -375,8 +381,11 @@ static protocol_binary_response_status set_command_handler(const void *cookie,
     if (header->request.opcode == PROTOCOL_BINARY_CMD_SET)
     {
       response.message.header.response.cas= htonll(item->cas);
+      release_item(item);
       return response_handler(cookie, header, (void*)&response);
     }
+    release_item(item);
+
     return PROTOCOL_BINARY_RESPONSE_SUCCESS;
   }
 
@@ -391,7 +400,7 @@ static protocol_binary_response_status add_command_handler(const void *cookie,
   size_t datalen= ntohl(header->request.bodylen) - keylen - 8;
   protocol_binary_request_add *request= (void*)header;
   uint32_t flags= ntohl(request->message.body.flags);
-  time_t timeout= ntohl(request->message.body.expiration);
+  time_t timeout= (time_t)ntohl(request->message.body.expiration);
   char *key= ((char*)header) + sizeof(*header) + 8;
   char *data= key + keylen;
 
@@ -410,7 +419,7 @@ static protocol_binary_response_status add_command_handler(const void *cookie,
   if (item == NULL)
   {
     item= create_item(key, keylen, data, datalen, flags, timeout);
-    if (item == 0)
+    if (item == NULL)
       response.message.header.response.status= htons(PROTOCOL_BINARY_RESPONSE_ENOMEM);
     else
     {
@@ -419,13 +428,16 @@ static protocol_binary_response_status add_command_handler(const void *cookie,
       if (header->request.opcode == PROTOCOL_BINARY_CMD_ADD)
       {
         response.message.header.response.cas= htonll(item->cas);
+        release_item(item);
         return response_handler(cookie, header, (void*)&response);
       }
+      release_item(item);
       return PROTOCOL_BINARY_RESPONSE_SUCCESS;
     }
   }
   else
   {
+    release_item(item);
     response.message.header.response.status= htons(PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS);
   }
 
@@ -440,7 +452,7 @@ static protocol_binary_response_status replace_command_handler(const void *cooki
   size_t datalen= ntohl(header->request.bodylen) - keylen - 8;
   protocol_binary_request_replace *request= (void*)header;
   uint32_t flags= ntohl(request->message.body.flags);
-  time_t timeout= ntohl(request->message.body.expiration);
+  time_t timeout= (time_t)ntohl(request->message.body.expiration);
   char *key= ((char*)header) + sizeof(*header) + 8;
   char *data= key + keylen;
 
@@ -460,9 +472,10 @@ static protocol_binary_response_status replace_command_handler(const void *cooki
     response.message.header.response.status= htons(PROTOCOL_BINARY_RESPONSE_KEY_ENOENT);
   else if (header->request.cas == 0 || ntohll(header->request.cas) == item->cas)
   {
+    release_item(item);
     delete_item(key, keylen);
     item= create_item(key, keylen, data, datalen, flags, timeout);
-    if (item == 0)
+    if (item == NULL)
       response.message.header.response.status= htons(PROTOCOL_BINARY_RESPONSE_ENOMEM);
     else
     {
@@ -471,13 +484,18 @@ static protocol_binary_response_status replace_command_handler(const void *cooki
       if (header->request.opcode == PROTOCOL_BINARY_CMD_REPLACE)
       {
         response.message.header.response.cas= htonll(item->cas);
+        release_item(item);
         return response_handler(cookie, header, (void*)&response);
       }
+      release_item(item);
       return PROTOCOL_BINARY_RESPONSE_SUCCESS;
     }
   }
   else
+  {
     response.message.header.response.status= htons(PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS);
+    release_item(item);
+  }
 
   return response_handler(cookie, header, (void*)&response);
 }
@@ -501,7 +519,7 @@ 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= {
+memcached_binary_protocol_callback_st interface_v0_impl= {
   .interface_version= 0,
   .interface.v0.comcode[PROTOCOL_BINARY_CMD_GET]= get_command_handler,
   .interface.v0.comcode[PROTOCOL_BINARY_CMD_SET]= set_command_handler,