X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;ds=sidebyside;f=example%2Finterface_v1.c;h=d2b20712664ec8321b5b78be51fe38ef28e7e9a5;hb=9c5fa1db34c5fb1ffed88742caeffa5a9afd0a9e;hp=b77a0b618f7e12b88c096c901790928506ad426e;hpb=e6a6807ad79f55f49826d3c76498373197ad59a7;p=m6w6%2Flibmemcached

diff --git a/example/interface_v1.c b/example/interface_v1.c
index b77a0b61..d2b20712 100644
--- a/example/interface_v1.c
+++ b/example/interface_v1.c
@@ -8,11 +8,9 @@
  * you will not receive the next command before a answer to the previous
  * command is being sent.
  */
+#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>
@@ -20,8 +18,8 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include <libmemcached/protocol_handler.h>
-#include <libmemcached/byteorder.h>
+#include <libmemcachedprotocol-0.0/handler.h>
+#include <example/byteorder.h>
 #include "storage.h"
 
 static protocol_binary_response_status add_handler(const void *cookie,
@@ -38,7 +36,7 @@ static protocol_binary_response_status add_handler(const void *cookie,
   struct item* item= get_item(key, keylen);
   if (item == NULL)
   {
-    item= create_item(key, keylen, data, datalen, flags, exptime);
+    item= create_item(key, keylen, data, datalen, flags, (time_t)exptime);
     if (item == 0)
     {
       rval= PROTOCOL_BINARY_RESPONSE_ENOMEM;
@@ -47,6 +45,7 @@ static protocol_binary_response_status add_handler(const void *cookie,
     {
       put_item(item);
       *cas= item->cas;
+      release_item(item);
     }
   }
   else
@@ -63,7 +62,8 @@ static protocol_binary_response_status append_handler(const void *cookie,
                                                       const void* val,
                                                       uint32_t vallen,
                                                       uint64_t cas,
-                                                      uint64_t *result_cas) {
+                                                      uint64_t *result_cas)
+{
   (void)cookie;
   protocol_binary_response_status rval= PROTOCOL_BINARY_RESPONSE_SUCCESS;
 
@@ -81,15 +81,18 @@ static protocol_binary_response_status append_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
   {
     memcpy(nitem->data, item->data, item->size);
     memcpy(((char*)(nitem->data)) + item->size, val, vallen);
+    release_item(item);
     delete_item(key, keylen);
     put_item(nitem);
     *result_cas= nitem->cas;
+    release_item(nitem);
   }
 
   return rval;
@@ -105,35 +108,33 @@ static protocol_binary_response_status decrement_handler(const void *cookie,
                                                          uint64_t *result_cas) {
   (void)cookie;
   protocol_binary_response_status rval= PROTOCOL_BINARY_RESPONSE_SUCCESS;
+  uint64_t val= initial;
   struct item *item= get_item(key, keylen);
 
-  if (item == NULL)
+  if (item != NULL)
   {
-    item= create_item(key, keylen, NULL, sizeof(initial), 0, expiration);
-    if (item == 0)
-    {
-      rval= PROTOCOL_BINARY_RESPONSE_ENOMEM;
-    }
+    if (delta > *(uint64_t*)item->data)
+      val= 0;
     else
-    {
-      memcpy(item->data, &initial, sizeof(initial));
-      put_item(item);
-      *result= initial;
-      *result_cas= item->cas;
-    }
+      val= *(uint64_t*)item->data - delta;
+
+    expiration= (uint32_t)item->exp;
+    release_item(item);
+    delete_item(key, keylen);
+  }
+
+  item= create_item(key, keylen, NULL, sizeof(initial), 0, (time_t)expiration);
+  if (item == 0)
+  {
+    rval= PROTOCOL_BINARY_RESPONSE_ENOMEM;
   }
   else
   {
-    if (delta > *(uint64_t*)item->data)
-    {
-      *(uint64_t*)item->data= 0;
-    }
-    else
-    {
-      *(uint64_t*)item->data -= delta;
-    }
-    *result= (*(uint64_t*)item->data);
-    /* @todo fix cas */
+    memcpy(item->data, &val, sizeof(val));
+    put_item(item);
+    *result= val;
+    *result_cas= item->cas;
+    release_item(item);
   }
 
   return rval;
@@ -149,9 +150,14 @@ static protocol_binary_response_status delete_handler(const void *cookie,
   if (cas != 0)
   {
     struct item *item= get_item(key, keylen);
-    if (item != NULL && item->cas != cas)
+    if (item != NULL)
     {
-      return PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS;
+      if (item->cas != cas)
+      {
+        release_item(item);
+        return PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS;
+      }
+      release_item(item);
     }
   }
 
@@ -183,9 +189,12 @@ static protocol_binary_response_status get_handler(const void *cookie,
     return PROTOCOL_BINARY_RESPONSE_KEY_ENOENT;
   }
 
-  return response_handler(cookie, key, (uint16_t)keylen,
+  protocol_binary_response_status rc;
+  rc= response_handler(cookie, key, (uint16_t)keylen,
                           item->data, (uint32_t)item->size, item->flags,
                           item->cas);
+  release_item(item);
+  return rc;
 }
 
 static protocol_binary_response_status increment_handler(const void *cookie,
@@ -198,29 +207,31 @@ static protocol_binary_response_status increment_handler(const void *cookie,
                                                          uint64_t *result_cas) {
   (void)cookie;
   protocol_binary_response_status rval= PROTOCOL_BINARY_RESPONSE_SUCCESS;
+  uint64_t val= initial;
   struct item *item= get_item(key, keylen);
 
+  if (item != NULL)
+  {
+    val= (*(uint64_t*)item->data) + delta;
+    expiration= (uint32_t)item->exp;
+    release_item(item);
+    delete_item(key, keylen);
+  }
+
+  item= create_item(key, keylen, NULL, sizeof(initial), 0, (time_t)expiration);
   if (item == NULL)
   {
-    item= create_item(key, keylen, NULL, sizeof(initial), 0, expiration);
-    if (item == 0)
-    {
-      rval= PROTOCOL_BINARY_RESPONSE_ENOMEM;
-    }
-    else
-    {
-      memcpy(item->data, &initial, sizeof(initial));
-      put_item(item);
-      *result= initial;
-      *result_cas= item->cas;
-    }
+    rval= PROTOCOL_BINARY_RESPONSE_ENOMEM;
   }
   else
   {
-    (*(uint64_t*)item->data) += delta;
-    *result= (*(uint64_t*)item->data);
-    update_cas(item);
+    char buffer[1024] = {0};
+    memcpy(buffer, key, keylen);
+    memcpy(item->data, &val, sizeof(val));
+    put_item(item);
+    *result= val;
     *result_cas= item->cas;
+    release_item(item);
   }
 
   return rval;
@@ -242,7 +253,8 @@ static protocol_binary_response_status prepend_handler(const void *cookie,
   protocol_binary_response_status rval= PROTOCOL_BINARY_RESPONSE_SUCCESS;
 
   struct item *item= get_item(key, keylen);
-  struct item *nitem;
+  struct item *nitem= NULL;
+
   if (item == NULL)
   {
     rval= PROTOCOL_BINARY_RESPONSE_KEY_ENOENT;
@@ -260,11 +272,19 @@ static protocol_binary_response_status prepend_handler(const void *cookie,
   {
     memcpy(nitem->data, val, vallen);
     memcpy(((char*)(nitem->data)) + vallen, item->data, item->size);
+    release_item(item);
+    item= NULL;
     delete_item(key, keylen);
     put_item(nitem);
     *result_cas= nitem->cas;
   }
 
+  if (item)
+    release_item(item);
+
+  if (nitem)
+    release_item(nitem);
+
   return rval;
 }
 
@@ -292,8 +312,9 @@ static protocol_binary_response_status replace_handler(const void *cookie,
   }
   else if (cas == 0 || cas == item->cas)
   {
+    release_item(item);
     delete_item(key, keylen);
-    item= create_item(key, keylen, data, datalen, flags, exptime);
+    item= create_item(key, keylen, data, datalen, flags, (time_t)exptime);
     if (item == 0)
     {
       rval= PROTOCOL_BINARY_RESPONSE_ENOMEM;
@@ -302,11 +323,13 @@ static protocol_binary_response_status replace_handler(const void *cookie,
     {
       put_item(item);
       *result_cas= item->cas;
+      release_item(item);
     }
   }
   else
   {
     rval= PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS;
+    release_item(item);
   }
 
   return rval;
@@ -330,12 +353,13 @@ static protocol_binary_response_status set_handler(const void *cookie,
     if (item != NULL && cas != item->cas)
     {
       /* Invalid CAS value */
+      release_item(item);
       return PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS;
     }
   }
 
   delete_item(key, keylen);
-  struct item* item= create_item(key, keylen, data, datalen, flags, exptime);
+  struct item* item= create_item(key, keylen, data, datalen, flags, (time_t)exptime);
   if (item == 0)
   {
     rval= PROTOCOL_BINARY_RESPONSE_ENOMEM;
@@ -344,6 +368,7 @@ static protocol_binary_response_status set_handler(const void *cookie,
   {
     put_item(item);
     *result_cas= item->cas;
+    release_item(item);
   }
 
   return rval;
@@ -365,8 +390,8 @@ static protocol_binary_response_status version_handler(const void *cookie,
   return response_handler(cookie, version, (uint32_t)strlen(version));
 }
 
-struct memcached_binary_protocol_callback_st interface_v1_impl= {
-  .interface_version= 1,
+memcached_binary_protocol_callback_st interface_v1_impl= {
+  .interface_version= MEMCACHED_PROTOCOL_HANDLER_V1,
   .interface.v1= {
     .add= add_handler,
     .append= append_handler,