* 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>
#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,
{
put_item(item);
*cas= item->cas;
+ release_item(item);
}
}
else
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;
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;
val= *(uint64_t*)item->data - delta;
expiration= (uint32_t)item->exp;
+ release_item(item);
delete_item(key, keylen);
}
put_item(item);
*result= val;
*result_cas= item->cas;
+ release_item(item);
}
return rval;
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);
}
}
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,
{
val= (*(uint64_t*)item->data) + delta;
expiration= (uint32_t)item->exp;
+ release_item(item);
delete_item(key, keylen);
}
put_item(item);
*result= val;
*result_cas= item->cas;
+ release_item(item);
}
return rval;
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;
{
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;
}
}
else if (cas == 0 || cas == item->cas)
{
+ release_item(item);
delete_item(key, keylen);
item= create_item(key, keylen, data, datalen, flags, (time_t)exptime);
if (item == 0)
{
put_item(item);
*result_cas= item->cas;
+ release_item(item);
}
}
else
{
rval= PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS;
+ release_item(item);
}
return rval;
if (item != NULL && cas != item->cas)
{
/* Invalid CAS value */
+ release_item(item);
return PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS;
}
}
{
put_item(item);
*result_cas= item->cas;
+ release_item(item);
}
return rval;
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,