*/Makefile
*/Makefile.in
*TAGS
+.deps
INSTALL
Makefile
Makefile.in
docs/*.html
docs/doctest/
docs/doctrees/
+docs/html/
+docs/linkcheck/
example/memcached_light
libhashkit/configure.h
libmemcached-*.tar.gz
ltversion.m4
lt~obsolete.m4
patch
-docs/html/
-docs/linkcheck/
patch2
stamp-h1
support/Makefile
support/libmemcached-fc.spec
support/libmemcached.pc
support/libmemcached.spec
+tags
tests/atomsmasher
tests/hash_plus
tests/hashplus
tests/testudp
tests/var/
unittests/unittests
-.deps
+ * Updates to C++ interface
+ * Custom free allocators need to now check for value before calling free.
+
0.49 Thu Apr 14 08:43:37 PDT 2011
* Fix calls to auto methods so that if value is not passed in nothing bad happens.
* New parser calls for generating memcached_st objects.
('hashkit_functions', 'hashkit_hsieh', u'libhashkit Documentation', [u'Brian Aker'], 3),
('hashkit_value', 'hashkit_value', u'libhashkit Documentation', [u'Brian Aker'], 3),
('libmemcached', 'libmemcached', u'Introducing the C Client Library for memcached', [u'Brian Aker'], 3),
- ('libmemcached_examples', 'libmemcached_examples', u'libmemcached Documentation', [u'Brian Aker'], 3),
+ ('libmemcached_configuration', 'libmemcached_check_configuration', u'libmemcached Documentation', [u'Brian Aker'], 3),
('libmemcached_configuration', 'libmemcached_configuration', u'libmemcached Documentation', [u'Brian Aker'], 3),
('libmemcached_configuration', 'memcached', u'libmemcached Documentation', [u'Brian Aker'], 3),
- ('libmemcached_configuration', 'libmemcached_check_configuration', u'libmemcached Documentation', [u'Brian Aker'], 3),
+ ('libmemcached_examples', 'libmemcached_examples', u'libmemcached Documentation', [u'Brian Aker'], 3),
('libmemcachedutil', 'libmemcachedutil', u'libmemcached Documentation', [u'Brian Aker'], 3),
('memcached_analyze', 'memcached_analyze', u'libmemcached Documentation', [u'Brian Aker'], 3),
+ ('memcached_append', 'memcached_append', u'Appending to or Prepending to data on the server', [u'Brian Aker'], 3),
+ ('memcached_append', 'memcached_append_by_key', u'Appending to or Prepending to data on the server', [u'Brian Aker'], 3),
+ ('memcached_append', 'memcached_prepend', u'Appending to or Prepending to data on the server', [u'Brian Aker'], 3),
+ ('memcached_append', 'memcached_prepend_by_key', u'Appending to or Prepending to data on the server', [u'Brian Aker'], 3),
('memcached_auto', 'memcached_auto', u'Incrementing and Decrementing Values', [u'Brian Aker'], 3),
('memcached_auto', 'memcached_decrement', u'Incrementing and Decrementing Values', [u'Brian Aker'], 3),
('memcached_auto', 'memcached_decrement_with_initial', u'Incrementing and Decrementing Values', [u'Brian Aker'], 3),
('memcached_dump', 'memcached_dump', u'libmemcached Documentation', [u'Brian Aker'], 3),
('memcached_flush', 'memcached_flush', u'libmemcached Documentation', [u'Brian Aker'], 3),
('memcached_flush_buffers', 'memcached_flush_buffers', u'libmemcached Documentation', [u'Brian Aker'], 3),
- ('memcached_generate_hash_value', 'memcached_generate_hash_value', u'Generating hash values directly', [u'Brian Aker'], 3),
('memcached_generate_hash_value', 'memcached_generate_hash', u'Generating hash values directly', [u'Brian Aker'], 3),
+ ('memcached_generate_hash_value', 'memcached_generate_hash_value', u'Generating hash values directly', [u'Brian Aker'], 3),
('memcached_get', 'memcached_fetch', u'Retrieving data from the server', [u'Brian Aker'], 3),
('memcached_get', 'memcached_fetch_execute', u'Retrieving data from the server', [u'Brian Aker'], 3),
('memcached_get', 'memcached_fetch_result', u'Retrieving data from the server', [u'Brian Aker'], 3),
('memcached_memory_allocators', 'memcached_set_memory_allocators', u'libmemcached Documentation', [u'Brian Aker'], 3),
('memcached_memory_allocators', 'memcached_set_memory_allocators_context', u'libmemcached Documentation', [u'Brian Aker'], 3),
('memcached_pool', 'memcached_pool', u'libmemcached Documentation', [u'Brian Aker'], 3),
- ('memcached_pool', 'memcached_pool_st', u'libmemcached Documentation', [u'Brian Aker'], 3),
('memcached_pool', 'memcached_pool_behavior_get', u'libmemcached Documentation', [u'Brian Aker'], 3),
('memcached_pool', 'memcached_pool_behavior_set', u'libmemcached Documentation', [u'Brian Aker'], 3),
('memcached_pool', 'memcached_pool_create', u'libmemcached Documentation', [u'Brian Aker'], 3),
('memcached_pool', 'memcached_pool_destroy', u'libmemcached Documentation', [u'Brian Aker'], 3),
- ('memcached_pool', 'memcached_pool_push', u'libmemcached Documentation', [u'Brian Aker'], 3),
('memcached_pool', 'memcached_pool_pop', u'libmemcached Documentation', [u'Brian Aker'], 3),
('memcached_pool', 'memcached_pool_push', u'libmemcached Documentation', [u'Brian Aker'], 3),
+ ('memcached_pool', 'memcached_pool_push', u'libmemcached Documentation', [u'Brian Aker'], 3),
+ ('memcached_pool', 'memcached_pool_st', u'libmemcached Documentation', [u'Brian Aker'], 3),
('memcached_quit', 'memcached_quit', u'libmemcached Documentation', [u'Brian Aker'], 3),
('memcached_result_st', 'memcached_result_cas', u'Working with result sets', [u'Brian Aker'], 3),
('memcached_result_st', 'memcached_result_create', u'Working with result sets', [u'Brian Aker'], 3),
('memcached_sasl', 'memcached_destroy_sasl_auth_data', u'libmemcached Documentation', [u'Brian Aker'], 3),
('memcached_sasl', 'memcached_get_sasl_callbacks', u'libmemcached Documentation', [u'Brian Aker'], 3),
('memcached_sasl', 'memcached_sasl', u'libmemcached Documentation', [u'Brian Aker'], 3),
- ('memcached_sasl', 'memcached_set_sasl_callbacks', u'libmemcached Documentation', [u'Brian Aker'], 3),
('memcached_sasl', 'memcached_sasl_set_auth_data', u'libmemcached Documentation', [u'Brian Aker'], 3),
+ ('memcached_sasl', 'memcached_set_sasl_callbacks', u'libmemcached Documentation', [u'Brian Aker'], 3),
('memcached_server_st', 'memcached_server_list_append', u'libmemcached Documentation', [u'Brian Aker'], 3),
('memcached_server_st', 'memcached_server_list_count', u'libmemcached Documentation', [u'Brian Aker'], 3),
('memcached_server_st', 'memcached_server_list_free', u'libmemcached Documentation', [u'Brian Aker'], 3),
('memcached_servers', 'memcached_servers', u'libmemcached Documentation', [u'Brian Aker'], 3),
('memcached_set', 'memcached_add', u'Storing and Replacing Data', [u'Brian Aker'], 3),
('memcached_set', 'memcached_add_by_key', u'Storing and Replacing Data', [u'Brian Aker'], 3),
- ('memcached_set', 'memcached_append', u'Storing and Replacing Data', [u'Brian Aker'], 3),
- ('memcached_set', 'memcached_append_by_key', u'Storing and Replacing Data', [u'Brian Aker'], 3),
- ('memcached_set', 'memcached_cas', u'Storing and Replacing Data', [u'Brian Aker'], 3),
- ('memcached_set', 'memcached_cas_by_key', u'Storing and Replacing Data', [u'Brian Aker'], 3),
- ('memcached_set', 'memcached_prepend', u'Storing and Replacing Data', [u'Brian Aker'], 3),
- ('memcached_set', 'memcached_prepend_by_key', u'Storing and Replacing Data', [u'Brian Aker'], 3),
+ ('memcached_cas', 'memcached_cas', u'Working with data on the server in an atomic fashion', [u'Brian Aker'], 3),
+ ('memcached_cas', 'memcached_cas_by_key', u'Storing and Replacing Data', [u'Brian Aker'], 3),
('memcached_set', 'memcached_replace', u'Storing and Replacing Data', [u'Brian Aker'], 3),
('memcached_set', 'memcached_replace_by_key', u'Storing and Replacing Data', [u'Brian Aker'], 3),
('memcached_set', 'memcached_set', u'Storing and Replacing Data', [u'Brian Aker'], 3),
Creating a hashkit structure
============================
+.. index:: object: hashkit_st
--------
SYNOPSIS
--------
-C Library for hashing algorithms (libmemcached, -lhashkit)
-
-
#include <libhashkit/hashkit.h>
.. c:function:: hashkit_st *hashkit_create(hashkit_st *hash);
.. c:function:: bool hashkit_is_allocated(const hashkit_st *hash);
-Compile and link with -lmemcached
+Compile and link with -lhashkit
-----------
Available Hashes
================
+.. index:: object: hashkit_st
Various hash functions to use for calculating values for keys
--------
-LIBRARY
--------
+--------
+SYNOPSIS
+--------
+#include <libhashkit/hashkit.h>
+
+.. c:function:: uint32_t hashkit_default(const char *key, size_t key_length);
-C Library for hashing algorithms (libmemcached, -lhashkit)
+.. c:function:: uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
+.. c:function:: uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
---------
-SYNOPSIS
---------
+.. c:function:: uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
+.. c:function:: uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
+.. c:function:: uint32_t hashkit_crc32(const char *key, size_t key_length);
-.. code-block:: perl
+.. c:function:: uint32_t hashkit_hsieh(const char *key, size_t key_length);
- #include <libmemcached/hashkit.h>
-
- uint32_t hashkit_default(const char *key, size_t key_length);
- uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
- uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
- uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
- uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
- uint32_t hashkit_crc32(const char *key, size_t key_length);
- uint32_t hashkit_hsieh(const char *key, size_t key_length);
- uint32_t hashkit_murmur(const char *key, size_t key_length);
- uint32_t hashkit_jenkins(const char *key, size_t key_length);
- uint32_t hashkit_md5(const char *key, size_t key_length);
+.. c:function:: uint32_t hashkit_murmur(const char *key, size_t key_length);
+
+.. c:function:: uint32_t hashkit_jenkins(const char *key, size_t key_length);
+
+.. c:function:: uint32_t hashkit_md5(const char *key, size_t key_length);
+Compile and link with -lhashkit
-----------
=============
-Generate a value for the given key
-
-
--------
-LIBRARY
--------
-
-
-C Library for hashing algorithms (libmemcached, -lhashkit)
+.. index:: object: hashkit_st
+Generate a value for the given key
--------
SYNOPSIS
--------
+#include <libhashkit/hashkit.h>
-.. code-block:: perl
-
- #include <libmemcached/hashkit.h>
+.. c:function:: uint32_t hashkit_value(hashkit_st *hash, const char *key, size_t key_length);
- uint32_t hashkit_value(hashkit_st *hash,
- const char *key,
- size_t key_length);
+
+Compile and link with -lhashkit
docs/libmemcachedutil.rst \
docs/memaslap.rst \
docs/memcached_analyze.rst \
+ docs/memcached_append.rst \
docs/memcached_auto.rst \
docs/memcached_behavior.rst \
docs/memcached_callback.rst \
+ docs/memcached_cas.rst \
docs/memcached_create.rst \
docs/memcached_delete.rst \
docs/memcached_dump.rst \
memcached_get
memcached_result_st
memcached_set
+ memcached_append
+ memcached_cas
###############
======================
--------
-LIBRARY
--------
-
-
-C library collection of useful hashing algorithm (libhashkit, -lhashkit)
-
-
---------
-SYNOPSIS
---------
-
-
-.. code-block:: perl
+.. code-block:: c
cc [ flag ... ] file ... -lhashkit
SEE ALSO
--------
-:manpage:`libmemcached(3)`
+:manpage:`libhashkit(3)`
Configuring Libmemcached
========================
+.. index:: object: memcached_st
+
--------
SYNOPSIS
--------
+#include <libmemcached/memcached.h>
.. c:function:: memcached_st *memcached(const char *string, size_t string_length)
-
.. c:function:: memcached_return_t libmemcached_check_configuration(const char *option_string, size_t length, char *error_buffer, size_t error_buffer_size)
Compile and link with -lmemcached
---------------------
-
.. code-block:: c
const char *config_string= "--SERVER=host10.example.com --SERVER=host11.example.com --SERVER=host10.example.com"
Utility library for libmemcached
--------
-LIBRARY
--------
-
-
-C Client Library containing utility functions for libmemcached (libmemcachedutil, -lmemcachedutil -lmemcached)
-
-
--------
SYNOPSIS
--------
-
-.. code-block:: perl
+.. code-block:: c
cc [ flag ... ] file ... -lmemcachedutil
-.TH "HASHKIT_CLONE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "HASHKIT_CLONE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
hashkit_clone \- libhashkit Documentation
.
..
.\" Man page generated from reStructeredText.
.
-.sp
-Create and destroy hashkit objects
-.SH LIBRARY
-.sp
-C Library for hashing algorithms (libmemcached, \-lhashkit)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/hashkit.h>
-
-hashkit_st *hashkit_create(hashkit_st *hash);
-
-hashkit_st *hashkit_clone(hashkit_st *destination, const hashkit_st *ptr);
-
-void hashkit_free(hashkit_st *hash);
-
-bool hashkit_is_allocated(const hashkit_st *hash);
-.ft P
-.fi
+#include <libhashkit/hashkit.h>
+.INDENT 0.0
+.TP
+.B hashkit_st *hashkit_create(hashkit_st *hash);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B hashkit_st *hashkit_clone(hashkit_st *destination, const hashkit_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void hashkit_free(hashkit_st *hash);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B bool hashkit_is_allocated(const hashkit_st *hash);
+.UNINDENT
+.sp
+Compile and link with \-lhashkit
.SH DESCRIPTION
.sp
The hashkit_create() function initializes a hashkit object for use. If
-.TH "HASHKIT_CRC32" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "HASHKIT_CRC32" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
hashkit_crc32 \- libhashkit Documentation
.
.
.sp
Various hash functions to use for calculating values for keys
-.SH LIBRARY
-.sp
-C Library for hashing algorithms (libmemcached, \-lhashkit)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/hashkit.h>
-
-uint32_t hashkit_default(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
-uint32_t hashkit_crc32(const char *key, size_t key_length);
-uint32_t hashkit_hsieh(const char *key, size_t key_length);
-uint32_t hashkit_murmur(const char *key, size_t key_length);
-uint32_t hashkit_jenkins(const char *key, size_t key_length);
-uint32_t hashkit_md5(const char *key, size_t key_length);
-.ft P
-.fi
+#include <libhashkit/hashkit.h>
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_default(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_crc32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_hsieh(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_murmur(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_jenkins(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_md5(const char *key, size_t key_length);
+.UNINDENT
+.sp
+Compile and link with \-lhashkit
.SH DESCRIPTION
.sp
These functions generate hash values from a key using a variety of
-.TH "HASHKIT_CREATE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "HASHKIT_CREATE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
hashkit_create \- libhashkit Documentation
.
..
.\" Man page generated from reStructeredText.
.
-.sp
-Create and destroy hashkit objects
-.SH LIBRARY
-.sp
-C Library for hashing algorithms (libmemcached, \-lhashkit)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/hashkit.h>
-
-hashkit_st *hashkit_create(hashkit_st *hash);
-
-hashkit_st *hashkit_clone(hashkit_st *destination, const hashkit_st *ptr);
-
-void hashkit_free(hashkit_st *hash);
-
-bool hashkit_is_allocated(const hashkit_st *hash);
-.ft P
-.fi
+#include <libhashkit/hashkit.h>
+.INDENT 0.0
+.TP
+.B hashkit_st *hashkit_create(hashkit_st *hash);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B hashkit_st *hashkit_clone(hashkit_st *destination, const hashkit_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void hashkit_free(hashkit_st *hash);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B bool hashkit_is_allocated(const hashkit_st *hash);
+.UNINDENT
+.sp
+Compile and link with \-lhashkit
.SH DESCRIPTION
.sp
The hashkit_create() function initializes a hashkit object for use. If
-.TH "HASHKIT_FNV1_32" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "HASHKIT_FNV1_32" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
hashkit_fnv1_32 \- libhashkit Documentation
.
.
.sp
Various hash functions to use for calculating values for keys
-.SH LIBRARY
-.sp
-C Library for hashing algorithms (libmemcached, \-lhashkit)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/hashkit.h>
-
-uint32_t hashkit_default(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
-uint32_t hashkit_crc32(const char *key, size_t key_length);
-uint32_t hashkit_hsieh(const char *key, size_t key_length);
-uint32_t hashkit_murmur(const char *key, size_t key_length);
-uint32_t hashkit_jenkins(const char *key, size_t key_length);
-uint32_t hashkit_md5(const char *key, size_t key_length);
-.ft P
-.fi
+#include <libhashkit/hashkit.h>
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_default(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_crc32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_hsieh(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_murmur(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_jenkins(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_md5(const char *key, size_t key_length);
+.UNINDENT
+.sp
+Compile and link with \-lhashkit
.SH DESCRIPTION
.sp
These functions generate hash values from a key using a variety of
-.TH "HASHKIT_FNV1_64" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "HASHKIT_FNV1_64" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
hashkit_fnv1_64 \- libhashkit Documentation
.
.
.sp
Various hash functions to use for calculating values for keys
-.SH LIBRARY
-.sp
-C Library for hashing algorithms (libmemcached, \-lhashkit)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/hashkit.h>
-
-uint32_t hashkit_default(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
-uint32_t hashkit_crc32(const char *key, size_t key_length);
-uint32_t hashkit_hsieh(const char *key, size_t key_length);
-uint32_t hashkit_murmur(const char *key, size_t key_length);
-uint32_t hashkit_jenkins(const char *key, size_t key_length);
-uint32_t hashkit_md5(const char *key, size_t key_length);
-.ft P
-.fi
+#include <libhashkit/hashkit.h>
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_default(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_crc32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_hsieh(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_murmur(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_jenkins(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_md5(const char *key, size_t key_length);
+.UNINDENT
+.sp
+Compile and link with \-lhashkit
.SH DESCRIPTION
.sp
These functions generate hash values from a key using a variety of
-.TH "HASHKIT_FNV1A_32" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "HASHKIT_FNV1A_32" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
hashkit_fnv1a_32 \- libhashkit Documentation
.
.
.sp
Various hash functions to use for calculating values for keys
-.SH LIBRARY
-.sp
-C Library for hashing algorithms (libmemcached, \-lhashkit)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/hashkit.h>
-
-uint32_t hashkit_default(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
-uint32_t hashkit_crc32(const char *key, size_t key_length);
-uint32_t hashkit_hsieh(const char *key, size_t key_length);
-uint32_t hashkit_murmur(const char *key, size_t key_length);
-uint32_t hashkit_jenkins(const char *key, size_t key_length);
-uint32_t hashkit_md5(const char *key, size_t key_length);
-.ft P
-.fi
+#include <libhashkit/hashkit.h>
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_default(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_crc32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_hsieh(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_murmur(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_jenkins(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_md5(const char *key, size_t key_length);
+.UNINDENT
+.sp
+Compile and link with \-lhashkit
.SH DESCRIPTION
.sp
These functions generate hash values from a key using a variety of
-.TH "HASHKIT_FNV1A_64" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "HASHKIT_FNV1A_64" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
hashkit_fnv1a_64 \- libhashkit Documentation
.
.
.sp
Various hash functions to use for calculating values for keys
-.SH LIBRARY
-.sp
-C Library for hashing algorithms (libmemcached, \-lhashkit)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/hashkit.h>
-
-uint32_t hashkit_default(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
-uint32_t hashkit_crc32(const char *key, size_t key_length);
-uint32_t hashkit_hsieh(const char *key, size_t key_length);
-uint32_t hashkit_murmur(const char *key, size_t key_length);
-uint32_t hashkit_jenkins(const char *key, size_t key_length);
-uint32_t hashkit_md5(const char *key, size_t key_length);
-.ft P
-.fi
+#include <libhashkit/hashkit.h>
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_default(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_crc32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_hsieh(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_murmur(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_jenkins(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_md5(const char *key, size_t key_length);
+.UNINDENT
+.sp
+Compile and link with \-lhashkit
.SH DESCRIPTION
.sp
These functions generate hash values from a key using a variety of
-.TH "HASHKIT_FREE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "HASHKIT_FREE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
hashkit_free \- libhashkit Documentation
.
..
.\" Man page generated from reStructeredText.
.
-.sp
-Create and destroy hashkit objects
-.SH LIBRARY
-.sp
-C Library for hashing algorithms (libmemcached, \-lhashkit)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/hashkit.h>
-
-hashkit_st *hashkit_create(hashkit_st *hash);
-
-hashkit_st *hashkit_clone(hashkit_st *destination, const hashkit_st *ptr);
-
-void hashkit_free(hashkit_st *hash);
-
-bool hashkit_is_allocated(const hashkit_st *hash);
-.ft P
-.fi
+#include <libhashkit/hashkit.h>
+.INDENT 0.0
+.TP
+.B hashkit_st *hashkit_create(hashkit_st *hash);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B hashkit_st *hashkit_clone(hashkit_st *destination, const hashkit_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void hashkit_free(hashkit_st *hash);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B bool hashkit_is_allocated(const hashkit_st *hash);
+.UNINDENT
+.sp
+Compile and link with \-lhashkit
.SH DESCRIPTION
.sp
The hashkit_create() function initializes a hashkit object for use. If
-.TH "HASHKIT_FUNCTIONS" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "HASHKIT_FUNCTIONS" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
hashkit_functions \- libhashkit Documentation
.
.
.sp
Various hash functions to use for calculating values for keys
-.SH LIBRARY
-.sp
-C Library for hashing algorithms (libmemcached, \-lhashkit)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/hashkit.h>
-
-uint32_t hashkit_default(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
-uint32_t hashkit_crc32(const char *key, size_t key_length);
-uint32_t hashkit_hsieh(const char *key, size_t key_length);
-uint32_t hashkit_murmur(const char *key, size_t key_length);
-uint32_t hashkit_jenkins(const char *key, size_t key_length);
-uint32_t hashkit_md5(const char *key, size_t key_length);
-.ft P
-.fi
+#include <libhashkit/hashkit.h>
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_default(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_crc32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_hsieh(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_murmur(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_jenkins(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_md5(const char *key, size_t key_length);
+.UNINDENT
+.sp
+Compile and link with \-lhashkit
.SH DESCRIPTION
.sp
These functions generate hash values from a key using a variety of
-.TH "HASHKIT_HSIEH" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "HASHKIT_HSIEH" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
hashkit_hsieh \- libhashkit Documentation
.
.
.sp
Various hash functions to use for calculating values for keys
-.SH LIBRARY
-.sp
-C Library for hashing algorithms (libmemcached, \-lhashkit)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/hashkit.h>
-
-uint32_t hashkit_default(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
-uint32_t hashkit_crc32(const char *key, size_t key_length);
-uint32_t hashkit_hsieh(const char *key, size_t key_length);
-uint32_t hashkit_murmur(const char *key, size_t key_length);
-uint32_t hashkit_jenkins(const char *key, size_t key_length);
-uint32_t hashkit_md5(const char *key, size_t key_length);
-.ft P
-.fi
+#include <libhashkit/hashkit.h>
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_default(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_crc32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_hsieh(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_murmur(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_jenkins(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_md5(const char *key, size_t key_length);
+.UNINDENT
+.sp
+Compile and link with \-lhashkit
.SH DESCRIPTION
.sp
These functions generate hash values from a key using a variety of
-.TH "HASHKIT_IS_ALLOCATED" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "HASHKIT_IS_ALLOCATED" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
hashkit_is_allocated \- libhashkit Documentation
.
..
.\" Man page generated from reStructeredText.
.
-.sp
-Create and destroy hashkit objects
-.SH LIBRARY
-.sp
-C Library for hashing algorithms (libmemcached, \-lhashkit)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/hashkit.h>
-
-hashkit_st *hashkit_create(hashkit_st *hash);
-
-hashkit_st *hashkit_clone(hashkit_st *destination, const hashkit_st *ptr);
-
-void hashkit_free(hashkit_st *hash);
-
-bool hashkit_is_allocated(const hashkit_st *hash);
-.ft P
-.fi
+#include <libhashkit/hashkit.h>
+.INDENT 0.0
+.TP
+.B hashkit_st *hashkit_create(hashkit_st *hash);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B hashkit_st *hashkit_clone(hashkit_st *destination, const hashkit_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void hashkit_free(hashkit_st *hash);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B bool hashkit_is_allocated(const hashkit_st *hash);
+.UNINDENT
+.sp
+Compile and link with \-lhashkit
.SH DESCRIPTION
.sp
The hashkit_create() function initializes a hashkit object for use. If
-.TH "HASHKIT_JENKINS" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "HASHKIT_JENKINS" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
hashkit_jenkins \- libhashkit Documentation
.
.
.sp
Various hash functions to use for calculating values for keys
-.SH LIBRARY
-.sp
-C Library for hashing algorithms (libmemcached, \-lhashkit)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/hashkit.h>
-
-uint32_t hashkit_default(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
-uint32_t hashkit_crc32(const char *key, size_t key_length);
-uint32_t hashkit_hsieh(const char *key, size_t key_length);
-uint32_t hashkit_murmur(const char *key, size_t key_length);
-uint32_t hashkit_jenkins(const char *key, size_t key_length);
-uint32_t hashkit_md5(const char *key, size_t key_length);
-.ft P
-.fi
+#include <libhashkit/hashkit.h>
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_default(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_crc32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_hsieh(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_murmur(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_jenkins(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_md5(const char *key, size_t key_length);
+.UNINDENT
+.sp
+Compile and link with \-lhashkit
.SH DESCRIPTION
.sp
These functions generate hash values from a key using a variety of
-.TH "HASHKIT_MD5" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "HASHKIT_MD5" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
hashkit_md5 \- libhashkit Documentation
.
.
.sp
Various hash functions to use for calculating values for keys
-.SH LIBRARY
-.sp
-C Library for hashing algorithms (libmemcached, \-lhashkit)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/hashkit.h>
-
-uint32_t hashkit_default(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
-uint32_t hashkit_crc32(const char *key, size_t key_length);
-uint32_t hashkit_hsieh(const char *key, size_t key_length);
-uint32_t hashkit_murmur(const char *key, size_t key_length);
-uint32_t hashkit_jenkins(const char *key, size_t key_length);
-uint32_t hashkit_md5(const char *key, size_t key_length);
-.ft P
-.fi
+#include <libhashkit/hashkit.h>
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_default(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_crc32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_hsieh(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_murmur(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_jenkins(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_md5(const char *key, size_t key_length);
+.UNINDENT
+.sp
+Compile and link with \-lhashkit
.SH DESCRIPTION
.sp
These functions generate hash values from a key using a variety of
-.TH "HASHKIT_MURMUR" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "HASHKIT_MURMUR" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
hashkit_murmur \- libhashkit Documentation
.
.
.sp
Various hash functions to use for calculating values for keys
-.SH LIBRARY
-.sp
-C Library for hashing algorithms (libmemcached, \-lhashkit)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/hashkit.h>
-
-uint32_t hashkit_default(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
-uint32_t hashkit_crc32(const char *key, size_t key_length);
-uint32_t hashkit_hsieh(const char *key, size_t key_length);
-uint32_t hashkit_murmur(const char *key, size_t key_length);
-uint32_t hashkit_jenkins(const char *key, size_t key_length);
-uint32_t hashkit_md5(const char *key, size_t key_length);
-.ft P
-.fi
+#include <libhashkit/hashkit.h>
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_default(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_crc32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_hsieh(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_murmur(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_jenkins(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_md5(const char *key, size_t key_length);
+.UNINDENT
+.sp
+Compile and link with \-lhashkit
.SH DESCRIPTION
.sp
These functions generate hash values from a key using a variety of
-.TH "HASHKIT_VALUE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "HASHKIT_VALUE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
hashkit_value \- libhashkit Documentation
.
.
.sp
Generate a value for the given key
-.SH LIBRARY
-.sp
-C Library for hashing algorithms (libmemcached, \-lhashkit)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/hashkit.h>
-
-uint32_t hashkit_value(hashkit_st *hash,
- const char *key,
- size_t key_length);
-.ft P
-.fi
+#include <libhashkit/hashkit.h>
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_value(hashkit_st *hash, const char *key, size_t key_length);
+.UNINDENT
+.sp
+Compile and link with \-lhashkit
.SH DESCRIPTION
.sp
The hashkit_value() function generates a 32\-bit hash value from the
-.TH "LIBHASHKIT" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "LIBHASHKIT" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
libhashkit \- libhashkit Documentation
.
..
.\" Man page generated from reStructeredText.
.
-.SH LIBRARY
-.sp
-C library collection of useful hashing algorithm (libhashkit, \-lhashkit)
-.SH SYNOPSIS
.sp
.nf
.ft C
\fI\%http://libmemcached.org/\fP
.SH SEE ALSO
.sp
-\fIlibmemcached(3)\fP
+\fIlibhashkit(3)\fP
.SH AUTHOR
Brian Aker
.SH COPYRIGHT
-.TH "LIBMEMCACHED" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "LIBMEMCACHED" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
libmemcached \- Introducing the C Client Library for memcached
.
#include <libmemcached/memcached.h>
.sp
Compile and link with \-lmemcached
+.sp
+libMemcached is an open source C/C++ client library and tools for the memcached server (\fI\%http://danga.com/memcached\fP). It has been designed to be light on memory usage, thread safe, and provide full access to server side methods.
+.sp
+libMemcached was designed to provide the greatest number of options to use Memcached. Some of the features provided:
+.INDENT 0.0
+.IP 1. 3
+.
+Asynchronous and Synchronous Transport Support.
+.IP 2. 3
+.
+Consistent Hashing and Distribution.
+.IP 3. 3
+.
+Tunable Hashing algorithm to match keys.
+.IP 4. 3
+.
+Access to large object support.
+.IP 5. 3
+.
+Local replication.
+.IP 6. 3
+.
+A complete reference guide and documentation to the API.
+.IP 7. 3
+.
+Tools to Manage your Memcached networks.
+.UNINDENT
.SH DESCRIPTION
.sp
"Memcached is a high\-performance, distributed memory object caching
applications by alleviating database load." \fI\%http://danga.com/memcached/\fP
.sp
\fBlibmemcached\fP is a small, thread\-safe client library for the
-memcached protocol. The code has all been written with an eye to allow
+memcached protocol. The code has all been written to allow
for both web and embedded usage. It handles the work behind routing
-particular keys to specific servers that you specify (and values are
-matched based on server order as supplied by you). It implements both
-a modula and consistent method of object distribution.
+individual keys to specific servers specified by the developer (and values are
+matched based on server order as supplied by the user). It implements
+a modular and consistent method of object distribution.
.sp
There are multiple implemented routing and hashing methods. See the
-memcached_behavior_set() manpage.
+memcached_behavior_set() manpage for more information.
.sp
All operations are performed against a \fBmemcached_st\fP structure.
These structures can either be dynamically allocated or statically
.UNINDENT
.SH THREADS AND PROCESSES
.sp
-When using threads or forked processes it is important to keep an instance
+When using threads or forked processes it is important to keep one instance
of \fBmemcached_st\fP per process or thread. Without creating your own locking
-structures you can not share a single \fBmemcached_st\fP. You can though call
+structures you can not share a single \fBmemcached_st\fP. However, you can call
memcached_quit(3) on a \fBmemcached_st\fP and then use the resulting cloned
structure.
.SH HOME
-.TH "LIBMEMCACHED_CHECK_CONFIGURATION" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "LIBMEMCACHED_CHECK_CONFIGURATION" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
libmemcached_check_configuration \- libmemcached Documentation
.
.\" Man page generated from reStructeredText.
.
.SH SYNOPSIS
+.sp
+#include <libmemcached/memcached.h>
.INDENT 0.0
.TP
.B memcached_st *memcached(const char\fI\ *string\fP, size_t\fI\ string_length\fP)
-.TH "LIBMEMCACHED_CONFIGURATION" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "LIBMEMCACHED_CONFIGURATION" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
libmemcached_configuration \- libmemcached Documentation
.
.\" Man page generated from reStructeredText.
.
.SH SYNOPSIS
+.sp
+#include <libmemcached/memcached.h>
.INDENT 0.0
.TP
.B memcached_st *memcached(const char\fI\ *string\fP, size_t\fI\ string_length\fP)
-.TH "LIBMEMCACHED_EXAMPLES" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "LIBMEMCACHED_EXAMPLES" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
libmemcached_examples \- libmemcached Documentation
.
-.TH "LIBMEMCACHEDUTIL" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "LIBMEMCACHEDUTIL" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
libmemcachedutil \- libmemcached Documentation
.
.
.sp
Utility library for libmemcached
-.SH LIBRARY
-.sp
-C Client Library containing utility functions for libmemcached (libmemcachedutil, \-lmemcachedutil \-lmemcached)
.SH SYNOPSIS
.sp
.nf
-.TH "MEMASLAP" "1" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMASLAP" "1" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memaslap \- libmemcached Documentation
.
-.TH "MEMCACHED" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached \- libmemcached Documentation
.
.\" Man page generated from reStructeredText.
.
.SH SYNOPSIS
+.sp
+#include <libmemcached/memcached.h>
.INDENT 0.0
.TP
.B memcached_st *memcached(const char\fI\ *string\fP, size_t\fI\ string_length\fP)
-.TH "MEMCACHED_ADD" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_ADD" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_add \- Storing and Replacing Data
.
..
.\" Man page generated from reStructeredText.
.
-.sp
-Store value on server
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.UNINDENT
.INDENT 0.0
.TP
-.B memcached_return_t memcached_prepend(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_append(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_cas(memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_set_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
.INDENT 0.0
.TP
.B memcached_return_t memcached_replace_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_prepend_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_append_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_cas_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
.sp
Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
memcached_set(), memcached_add(), and memcached_replace() are all used to
store information on the server. All methods take a key, and its length to
-store the object. Keys are currently limited to 250 characters by the
-memcached(1) server. You must also supply a value and a length. Optionally you
-may tests an expiration time for the object and a 16 byte value (it is
-meant to be used as a bitmap).
+store the object. Keys are currently limited to 250 characters when using either a version of memcached(1) which is 1.4 or below, or when using the text protocol.
+You must supply both a value and a length. Optionally you
+may test an expiration time for the object and a 16 byte value (it is
+meant to be used as a bitmap). "flags" is a 4byte space that is stored alongside of the main value. Many sub libraries make use of this field, so in most cases users should avoid making use of it.
.sp
memcached_set() will write an object to the server. If an object already
exists it will overwrite what is in the server. If the object does not exist
memcached_add() adds an object to the server. If the object is found on the
server an error occurs, otherwise the value is stored.
.sp
-memcached_prepend() places a segment of data before the last piece of data
-stored. Currently expiration and key are not used in the server.
-.sp
-memcached_append() places a segment of data at the end of the last piece of
-data stored. Currently expiration and key are not used in the server.
-.sp
memcached_cas() overwrites data in the server as long as the "cas" value is
still the same in the server. You can get the cas value of a result by
calling memcached_result_cas() on a memcached_result_st(3) structure. At the point
for it in libmemcached(3) is optional. Please see memcached_set() for
information on how to do this.
.sp
-memcached_set_by_key(), memcached_add_by_key(), memcached_replace_by_key(),
-memcached_prepend_by_key(), memcached_append_by_key_by_key(),
-memcached_cas_by_key() methods all behave in a similar method as the non key
+memcached_set_by_key(), memcached_add_by_key(), and memcached_replace_by_key()
+methods all behave in a similar method as the non key
methods. The difference is that they use their group_key parameter to map
objects to particular servers.
.sp
If you are looking for performance, memcached_set() with non\-blocking IO is
the fastest way to store data on the server.
.sp
-All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. But when using these operations with this behavior on, there
+All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. However, when using these operations with this behavior on, there
are limits to the size of the payload being sent to the server. The reason for
-these limits is that the Memcahed Server does not allow multi\-datagram requests
+these limits is that the Memcached Server does not allow multi\-datagram requests
and the current server implementation sets a datagram size to 1400 bytes. Due
to protocol overhead, the actual limit of the user supplied data is less than
-1400 bytes and depends on the protocol in use as well as the operation being
+1400 bytes and depends on the protocol in use as, well as the operation being
executed. When running with the binary protocol, \(ga\(ga MEMCACHED_BEHAVIOR_BINARY_PROTOCOL\(ga\(ga,
the size of the key,value, flags and expiry combined may not exceed 1368 bytes.
When running with the ASCII protocol, the exact limit fluctuates depending on
\fI\%http://libmemcached.org/\fP
.SH SEE ALSO
.sp
-memcached(1) libmemached(3) memcached_strerror(3)
+memcached(1) libmemached(3) memcached_strerror(3) memcached_prepend(3) memcached_cas(3) memcached_append(3)
.SH AUTHOR
Brian Aker
.SH COPYRIGHT
-.TH "MEMCACHED_ADD_BY_KEY" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_ADD_BY_KEY" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_add_by_key \- Storing and Replacing Data
.
..
.\" Man page generated from reStructeredText.
.
-.sp
-Store value on server
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.UNINDENT
.INDENT 0.0
.TP
-.B memcached_return_t memcached_prepend(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_append(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_cas(memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_set_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
.INDENT 0.0
.TP
.B memcached_return_t memcached_replace_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_prepend_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_append_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_cas_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
.sp
Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
memcached_set(), memcached_add(), and memcached_replace() are all used to
store information on the server. All methods take a key, and its length to
-store the object. Keys are currently limited to 250 characters by the
-memcached(1) server. You must also supply a value and a length. Optionally you
-may tests an expiration time for the object and a 16 byte value (it is
-meant to be used as a bitmap).
+store the object. Keys are currently limited to 250 characters when using either a version of memcached(1) which is 1.4 or below, or when using the text protocol.
+You must supply both a value and a length. Optionally you
+may test an expiration time for the object and a 16 byte value (it is
+meant to be used as a bitmap). "flags" is a 4byte space that is stored alongside of the main value. Many sub libraries make use of this field, so in most cases users should avoid making use of it.
.sp
memcached_set() will write an object to the server. If an object already
exists it will overwrite what is in the server. If the object does not exist
memcached_add() adds an object to the server. If the object is found on the
server an error occurs, otherwise the value is stored.
.sp
-memcached_prepend() places a segment of data before the last piece of data
-stored. Currently expiration and key are not used in the server.
-.sp
-memcached_append() places a segment of data at the end of the last piece of
-data stored. Currently expiration and key are not used in the server.
-.sp
memcached_cas() overwrites data in the server as long as the "cas" value is
still the same in the server. You can get the cas value of a result by
calling memcached_result_cas() on a memcached_result_st(3) structure. At the point
for it in libmemcached(3) is optional. Please see memcached_set() for
information on how to do this.
.sp
-memcached_set_by_key(), memcached_add_by_key(), memcached_replace_by_key(),
-memcached_prepend_by_key(), memcached_append_by_key_by_key(),
-memcached_cas_by_key() methods all behave in a similar method as the non key
+memcached_set_by_key(), memcached_add_by_key(), and memcached_replace_by_key()
+methods all behave in a similar method as the non key
methods. The difference is that they use their group_key parameter to map
objects to particular servers.
.sp
If you are looking for performance, memcached_set() with non\-blocking IO is
the fastest way to store data on the server.
.sp
-All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. But when using these operations with this behavior on, there
+All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. However, when using these operations with this behavior on, there
are limits to the size of the payload being sent to the server. The reason for
-these limits is that the Memcahed Server does not allow multi\-datagram requests
+these limits is that the Memcached Server does not allow multi\-datagram requests
and the current server implementation sets a datagram size to 1400 bytes. Due
to protocol overhead, the actual limit of the user supplied data is less than
-1400 bytes and depends on the protocol in use as well as the operation being
+1400 bytes and depends on the protocol in use as, well as the operation being
executed. When running with the binary protocol, \(ga\(ga MEMCACHED_BEHAVIOR_BINARY_PROTOCOL\(ga\(ga,
the size of the key,value, flags and expiry combined may not exceed 1368 bytes.
When running with the ASCII protocol, the exact limit fluctuates depending on
\fI\%http://libmemcached.org/\fP
.SH SEE ALSO
.sp
-memcached(1) libmemached(3) memcached_strerror(3)
+memcached(1) libmemached(3) memcached_strerror(3) memcached_prepend(3) memcached_cas(3) memcached_append(3)
.SH AUTHOR
Brian Aker
.SH COPYRIGHT
-.TH "MEMCACHED_ANALYZE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_ANALYZE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_analyze \- libmemcached Documentation
.
.
.sp
Analyze server information
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-memcached_analysis_st *
- memcached_analyze (memcached_st *ptr,
- memcached_stat_st *stat,
- memcached_return_t *error);
-.ft P
-.fi
+.INDENT 0.0
+.TP
+.B memcached_analysis_st * memcached_analyze (memcached_st *ptr, memcached_stat_st *stat, memcached_return_t *error);
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) has the ability to query a memcached server (or collection
-.TH "MEMCACHED_APPEND" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_APPEND" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
-memcached_append \- Storing and Replacing Data
+memcached_append \- Appending to or Prepending to data on the server
.
.nr rst2man-indent-level 0
.
.\" Man page generated from reStructeredText.
.
.sp
-Store value on server
+Appending or Prepending to data on the server
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.INDENT 0.0
.TP
-.B memcached_return_t memcached_set (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_add (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_replace (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_prepend(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
.UNINDENT
.INDENT 0.0
.UNINDENT
.INDENT 0.0
.TP
-.B memcached_return_t memcached_cas(memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_set_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_add_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_replace_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_prepend_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
.INDENT 0.0
.TP
.B memcached_return_t memcached_append_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_cas_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
.sp
Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
-memcached_set(), memcached_add(), and memcached_replace() are all used to
-store information on the server. All methods take a key, and its length to
-store the object. Keys are currently limited to 250 characters by the
-memcached(1) server. You must also supply a value and a length. Optionally you
-may tests an expiration time for the object and a 16 byte value (it is
-meant to be used as a bitmap).
-.sp
-memcached_set() will write an object to the server. If an object already
-exists it will overwrite what is in the server. If the object does not exist
-it will be written. If you are using the non\-blocking mode this function
-will always return true unless a network error occurs.
-.sp
-memcached_replace() replaces an object on the server. If the object is not
-found on the server an error occurs.
-.sp
-memcached_add() adds an object to the server. If the object is found on the
-server an error occurs, otherwise the value is stored.
+memcached_prepend() and memcached_append are used to
+modify information on a server. All methods take a key, and its length to
+store the object. Keys are currently limited to 250 characters when using either a version of memcached(1) which is 1.4 or below, or when using the text protocol.
+You must supply both a value and a length. Optionally you
+may test an expiration time for the object and a 16 byte value (it is
+meant to be used as a bitmap). "flags" is a 4byte space that is stored alongside of the main value. Many sub libraries make use of this field, so in most cases users should avoid making use of it.
.sp
memcached_prepend() places a segment of data before the last piece of data
stored. Currently expiration and key are not used in the server.
memcached_append() places a segment of data at the end of the last piece of
data stored. Currently expiration and key are not used in the server.
.sp
-memcached_cas() overwrites data in the server as long as the "cas" value is
-still the same in the server. You can get the cas value of a result by
-calling memcached_result_cas() on a memcached_result_st(3) structure. At the point
-that this note was written cas is still buggy in memached. Turning on tests
-for it in libmemcached(3) is optional. Please see memcached_set() for
-information on how to do this.
-.sp
-memcached_set_by_key(), memcached_add_by_key(), memcached_replace_by_key(),
-memcached_prepend_by_key(), memcached_append_by_key_by_key(),
-memcached_cas_by_key() methods all behave in a similar method as the non key
+memcached_prepend_by_key() and memcached_append_by_key_by_key(,
+methods both behave in a similar method as the non key
methods. The difference is that they use their group_key parameter to map
objects to particular servers.
.sp
If you are looking for performance, memcached_set() with non\-blocking IO is
the fastest way to store data on the server.
.sp
-All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. But when using these operations with this behavior on, there
+All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. However, when using these operations with this behavior on, there
are limits to the size of the payload being sent to the server. The reason for
-these limits is that the Memcahed Server does not allow multi\-datagram requests
+these limits is that the Memcached Server does not allow multi\-datagram requests
and the current server implementation sets a datagram size to 1400 bytes. Due
to protocol overhead, the actual limit of the user supplied data is less than
-1400 bytes and depends on the protocol in use as well as the operation being
+1400 bytes and depends on the protocol in use as, well as the operation being
executed. When running with the binary protocol, \(ga\(ga MEMCACHED_BEHAVIOR_BINARY_PROTOCOL\(ga\(ga,
the size of the key,value, flags and expiry combined may not exceed 1368 bytes.
When running with the ASCII protocol, the exact limit fluctuates depending on
All methods return a value of type \fBmemcached_return_t\fP.
On success the value will be \fBMEMCACHED_SUCCESS\fP.
Use memcached_strerror() to translate this value to a printable string.
-.sp
-For memcached_replace() and memcached_add(), \fBMEMCACHED_NOTSTORED\fP is a
-legitmate error in the case of a collision.
.SH HOME
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
.SH SEE ALSO
.sp
-memcached(1) libmemached(3) memcached_strerror(3)
+memcached(1) libmemached(3) memcached_strerror(3) memcached_set(3) memcached_add(3) memcached_cas(3) memcached_replace(3)
.SH AUTHOR
Brian Aker
.SH COPYRIGHT
-.TH "MEMCACHED_APPEND_BY_KEY" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_APPEND_BY_KEY" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
-memcached_append_by_key \- Storing and Replacing Data
+memcached_append_by_key \- Appending to or Prepending to data on the server
.
.nr rst2man-indent-level 0
.
.\" Man page generated from reStructeredText.
.
.sp
-Store value on server
+Appending or Prepending to data on the server
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.INDENT 0.0
.TP
-.B memcached_return_t memcached_set (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_add (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_replace (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_prepend(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
.UNINDENT
.INDENT 0.0
.UNINDENT
.INDENT 0.0
.TP
-.B memcached_return_t memcached_cas(memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_set_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_add_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_replace_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_prepend_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
.INDENT 0.0
.TP
.B memcached_return_t memcached_append_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_cas_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
.sp
Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
-memcached_set(), memcached_add(), and memcached_replace() are all used to
-store information on the server. All methods take a key, and its length to
-store the object. Keys are currently limited to 250 characters by the
-memcached(1) server. You must also supply a value and a length. Optionally you
-may tests an expiration time for the object and a 16 byte value (it is
-meant to be used as a bitmap).
-.sp
-memcached_set() will write an object to the server. If an object already
-exists it will overwrite what is in the server. If the object does not exist
-it will be written. If you are using the non\-blocking mode this function
-will always return true unless a network error occurs.
-.sp
-memcached_replace() replaces an object on the server. If the object is not
-found on the server an error occurs.
-.sp
-memcached_add() adds an object to the server. If the object is found on the
-server an error occurs, otherwise the value is stored.
+memcached_prepend() and memcached_append are used to
+modify information on a server. All methods take a key, and its length to
+store the object. Keys are currently limited to 250 characters when using either a version of memcached(1) which is 1.4 or below, or when using the text protocol.
+You must supply both a value and a length. Optionally you
+may test an expiration time for the object and a 16 byte value (it is
+meant to be used as a bitmap). "flags" is a 4byte space that is stored alongside of the main value. Many sub libraries make use of this field, so in most cases users should avoid making use of it.
.sp
memcached_prepend() places a segment of data before the last piece of data
stored. Currently expiration and key are not used in the server.
memcached_append() places a segment of data at the end of the last piece of
data stored. Currently expiration and key are not used in the server.
.sp
-memcached_cas() overwrites data in the server as long as the "cas" value is
-still the same in the server. You can get the cas value of a result by
-calling memcached_result_cas() on a memcached_result_st(3) structure. At the point
-that this note was written cas is still buggy in memached. Turning on tests
-for it in libmemcached(3) is optional. Please see memcached_set() for
-information on how to do this.
-.sp
-memcached_set_by_key(), memcached_add_by_key(), memcached_replace_by_key(),
-memcached_prepend_by_key(), memcached_append_by_key_by_key(),
-memcached_cas_by_key() methods all behave in a similar method as the non key
+memcached_prepend_by_key() and memcached_append_by_key_by_key(,
+methods both behave in a similar method as the non key
methods. The difference is that they use their group_key parameter to map
objects to particular servers.
.sp
If you are looking for performance, memcached_set() with non\-blocking IO is
the fastest way to store data on the server.
.sp
-All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. But when using these operations with this behavior on, there
+All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. However, when using these operations with this behavior on, there
are limits to the size of the payload being sent to the server. The reason for
-these limits is that the Memcahed Server does not allow multi\-datagram requests
+these limits is that the Memcached Server does not allow multi\-datagram requests
and the current server implementation sets a datagram size to 1400 bytes. Due
to protocol overhead, the actual limit of the user supplied data is less than
-1400 bytes and depends on the protocol in use as well as the operation being
+1400 bytes and depends on the protocol in use as, well as the operation being
executed. When running with the binary protocol, \(ga\(ga MEMCACHED_BEHAVIOR_BINARY_PROTOCOL\(ga\(ga,
the size of the key,value, flags and expiry combined may not exceed 1368 bytes.
When running with the ASCII protocol, the exact limit fluctuates depending on
All methods return a value of type \fBmemcached_return_t\fP.
On success the value will be \fBMEMCACHED_SUCCESS\fP.
Use memcached_strerror() to translate this value to a printable string.
-.sp
-For memcached_replace() and memcached_add(), \fBMEMCACHED_NOTSTORED\fP is a
-legitmate error in the case of a collision.
.SH HOME
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
.SH SEE ALSO
.sp
-memcached(1) libmemached(3) memcached_strerror(3)
+memcached(1) libmemached(3) memcached_strerror(3) memcached_set(3) memcached_add(3) memcached_cas(3) memcached_replace(3)
.SH AUTHOR
Brian Aker
.SH COPYRIGHT
-.TH "MEMCACHED_AUTO" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_AUTO" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_auto \- Incrementing and Decrementing Values
.
-.TH "MEMCACHED_BEHAVIOR" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_BEHAVIOR" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_behavior \- libmemcached Documentation
.
.\" Man page generated from reStructeredText.
.
.sp
-Manipulate behavior
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
+Manipulate the behavior of a memcached_st structure.
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.TP
.B memcached_return_t memcached_behavior_set (memcached_st *ptr, memcached_behavior flag, uint64_t data);
.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
\fIlibmemcached(3)\fP behavior can be modified by use memcached_behavior_set().
-.TH "MEMCACHED_BEHAVIOR_GET" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_BEHAVIOR_GET" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_behavior_get \- libmemcached Documentation
.
.\" Man page generated from reStructeredText.
.
.sp
-Manipulate behavior
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
+Manipulate the behavior of a memcached_st structure.
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.TP
.B memcached_return_t memcached_behavior_set (memcached_st *ptr, memcached_behavior flag, uint64_t data);
.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
\fIlibmemcached(3)\fP behavior can be modified by use memcached_behavior_set().
-.TH "MEMCACHED_BEHAVIOR_SET" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_BEHAVIOR_SET" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_behavior_set \- libmemcached Documentation
.
.\" Man page generated from reStructeredText.
.
.sp
-Manipulate behavior
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
+Manipulate the behavior of a memcached_st structure.
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.TP
.B memcached_return_t memcached_behavior_set (memcached_st *ptr, memcached_behavior flag, uint64_t data);
.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
\fIlibmemcached(3)\fP behavior can be modified by use memcached_behavior_set().
-.TH "MEMCACHED_CALLBACK" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_CALLBACK" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_callback \- libmemcached Documentation
.
.
.sp
Get and set a callback
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.TP
.B void * memcached_callback_get (memcached_st *ptr, memcached_callback_t flag, memcached_return_t *error);
.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) can have callbacks set key execution points. These either
memcached_callback_set() changes the function/structure assigned by a
callback flag. No connections are reset.
.sp
-You can use MEMCACHED_CALLBACK_USER_DATA to provide custom context if required for any
-of the callbacks
+You can use MEMCACHED_CALLBACK_USER_DATA to provide custom context if required for any of the callbacks.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_CLEANUP_FUNCTION
-.
-When memcached_delete() is called this function will be excuted. At the
-point of its execution all connections have been closed.
.UNINDENT
+.sp
+When memcached_delete() is called this function will be excuted. At the point of its execution all connections are closed.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_CLONE_FUNCTION
-.
-When memcached_delete() is called this function will be excuted. At the
-point of its execution all connections have been closed.
.UNINDENT
+.sp
+When memcached_delete() is called this function will be excuted. At the
+point of its execution all connections are closed.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_PREFIX_KEY
-.
+.UNINDENT
+.sp
You can set a value which will be used to create a domain for your keys.
-The value specified here will be prefixed to each of your keys. The value can not
-be greater then MEMCACHED_PREFIX_KEY_MAX_SIZE \- 1 and will reduce MEMCACHED_MAX_KEY by
-the value of your key. The prefix key is only applied to the primary key,
-not the master key. MEMCACHED_FAILURE will be returned if no key is set. In the case
-of a key which is too long MEMCACHED_BAD_KEY_PROVIDED will be returned.
+The value specified here will be prefixed to each of your keys. The value can not be greater then MEMCACHED_PREFIX_KEY_MAX_SIZE \- 1 and will reduce MEMCACHED_MAX_KEY by the value of your key.
+.sp
+The prefix key is only applied to the primary key, not the master key. MEMCACHED_FAILURE will be returned if no key is set. In the case of a key which is too long, MEMCACHED_BAD_KEY_PROVIDED will be returned.
.sp
If you set a value with the value being NULL then the prefix key is disabled.
-.UNINDENT
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_USER_DATA
-.
+.UNINDENT
+.sp
This allows you to store a pointer to a specifc piece of data. This can be
retrieved from inside of memcached_fetch_execute(). Cloning a memcached_st
will copy the pointer to the clone.
-.UNINDENT
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_MALLOC_FUNCTION
-.
-DEPRECATED: use memcached_set_memory_allocators instead.
.UNINDENT
+.sp
+DEPRECATED: use memcached_set_memory_allocators instead.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_REALLOC_FUNCTION
-.
-DEPRECATED: use memcached_set_memory_allocators instead.
.UNINDENT
+.sp
+DEPRECATED: use memcached_set_memory_allocators instead.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_FREE_FUNCTION
-.
-DEPRECATED: use memcached_set_memory_allocators instead.
.UNINDENT
+.sp
+DEPRECATED: use memcached_set_memory_allocators instead.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_GET_FAILURE
-.
+.UNINDENT
+.sp
This function implements the read through cache behavior. On failure of retrieval this callback will be called.
-You are responsible for populating the result object provided. This result object will then be stored in the server and
-returned to the calling process. You must clone the memcached_st in order to
+.sp
+You are responsible for populating the result object provided. This result object will then be stored in the server and returned to the calling process.
+.sp
+You must clone the memcached_st in order to
make use of it. The value will be stored only if you return
MEMCACHED_SUCCESS or MEMCACHED_BUFFERED. Returning MEMCACHED_BUFFERED will
cause the object to be buffered and not sent immediatly (if this is the default behavior based on your connection setup this will happen automatically).
.sp
The prototype for this is:
memcached_return_t (*memcached_trigger_key)(memcached_st *ptr, char *key, size_t key_length, memcached_result_st *result);
-.UNINDENT
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_DELETE_TRIGGER
-.TH "MEMCACHED_CALLBACK_GET" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_CALLBACK_GET" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_callback_get \- libmemcached Documentation
.
.
.sp
Get and set a callback
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.TP
.B void * memcached_callback_get (memcached_st *ptr, memcached_callback_t flag, memcached_return_t *error);
.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) can have callbacks set key execution points. These either
memcached_callback_set() changes the function/structure assigned by a
callback flag. No connections are reset.
.sp
-You can use MEMCACHED_CALLBACK_USER_DATA to provide custom context if required for any
-of the callbacks
+You can use MEMCACHED_CALLBACK_USER_DATA to provide custom context if required for any of the callbacks.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_CLEANUP_FUNCTION
-.
-When memcached_delete() is called this function will be excuted. At the
-point of its execution all connections have been closed.
.UNINDENT
+.sp
+When memcached_delete() is called this function will be excuted. At the point of its execution all connections are closed.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_CLONE_FUNCTION
-.
-When memcached_delete() is called this function will be excuted. At the
-point of its execution all connections have been closed.
.UNINDENT
+.sp
+When memcached_delete() is called this function will be excuted. At the
+point of its execution all connections are closed.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_PREFIX_KEY
-.
+.UNINDENT
+.sp
You can set a value which will be used to create a domain for your keys.
-The value specified here will be prefixed to each of your keys. The value can not
-be greater then MEMCACHED_PREFIX_KEY_MAX_SIZE \- 1 and will reduce MEMCACHED_MAX_KEY by
-the value of your key. The prefix key is only applied to the primary key,
-not the master key. MEMCACHED_FAILURE will be returned if no key is set. In the case
-of a key which is too long MEMCACHED_BAD_KEY_PROVIDED will be returned.
+The value specified here will be prefixed to each of your keys. The value can not be greater then MEMCACHED_PREFIX_KEY_MAX_SIZE \- 1 and will reduce MEMCACHED_MAX_KEY by the value of your key.
+.sp
+The prefix key is only applied to the primary key, not the master key. MEMCACHED_FAILURE will be returned if no key is set. In the case of a key which is too long, MEMCACHED_BAD_KEY_PROVIDED will be returned.
.sp
If you set a value with the value being NULL then the prefix key is disabled.
-.UNINDENT
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_USER_DATA
-.
+.UNINDENT
+.sp
This allows you to store a pointer to a specifc piece of data. This can be
retrieved from inside of memcached_fetch_execute(). Cloning a memcached_st
will copy the pointer to the clone.
-.UNINDENT
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_MALLOC_FUNCTION
-.
-DEPRECATED: use memcached_set_memory_allocators instead.
.UNINDENT
+.sp
+DEPRECATED: use memcached_set_memory_allocators instead.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_REALLOC_FUNCTION
-.
-DEPRECATED: use memcached_set_memory_allocators instead.
.UNINDENT
+.sp
+DEPRECATED: use memcached_set_memory_allocators instead.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_FREE_FUNCTION
-.
-DEPRECATED: use memcached_set_memory_allocators instead.
.UNINDENT
+.sp
+DEPRECATED: use memcached_set_memory_allocators instead.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_GET_FAILURE
-.
+.UNINDENT
+.sp
This function implements the read through cache behavior. On failure of retrieval this callback will be called.
-You are responsible for populating the result object provided. This result object will then be stored in the server and
-returned to the calling process. You must clone the memcached_st in order to
+.sp
+You are responsible for populating the result object provided. This result object will then be stored in the server and returned to the calling process.
+.sp
+You must clone the memcached_st in order to
make use of it. The value will be stored only if you return
MEMCACHED_SUCCESS or MEMCACHED_BUFFERED. Returning MEMCACHED_BUFFERED will
cause the object to be buffered and not sent immediatly (if this is the default behavior based on your connection setup this will happen automatically).
.sp
The prototype for this is:
memcached_return_t (*memcached_trigger_key)(memcached_st *ptr, char *key, size_t key_length, memcached_result_st *result);
-.UNINDENT
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_DELETE_TRIGGER
-.TH "MEMCACHED_CALLBACK_SET" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_CALLBACK_SET" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_callback_set \- libmemcached Documentation
.
.
.sp
Get and set a callback
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.TP
.B void * memcached_callback_get (memcached_st *ptr, memcached_callback_t flag, memcached_return_t *error);
.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) can have callbacks set key execution points. These either
memcached_callback_set() changes the function/structure assigned by a
callback flag. No connections are reset.
.sp
-You can use MEMCACHED_CALLBACK_USER_DATA to provide custom context if required for any
-of the callbacks
+You can use MEMCACHED_CALLBACK_USER_DATA to provide custom context if required for any of the callbacks.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_CLEANUP_FUNCTION
-.
-When memcached_delete() is called this function will be excuted. At the
-point of its execution all connections have been closed.
.UNINDENT
+.sp
+When memcached_delete() is called this function will be excuted. At the point of its execution all connections are closed.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_CLONE_FUNCTION
-.
-When memcached_delete() is called this function will be excuted. At the
-point of its execution all connections have been closed.
.UNINDENT
+.sp
+When memcached_delete() is called this function will be excuted. At the
+point of its execution all connections are closed.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_PREFIX_KEY
-.
+.UNINDENT
+.sp
You can set a value which will be used to create a domain for your keys.
-The value specified here will be prefixed to each of your keys. The value can not
-be greater then MEMCACHED_PREFIX_KEY_MAX_SIZE \- 1 and will reduce MEMCACHED_MAX_KEY by
-the value of your key. The prefix key is only applied to the primary key,
-not the master key. MEMCACHED_FAILURE will be returned if no key is set. In the case
-of a key which is too long MEMCACHED_BAD_KEY_PROVIDED will be returned.
+The value specified here will be prefixed to each of your keys. The value can not be greater then MEMCACHED_PREFIX_KEY_MAX_SIZE \- 1 and will reduce MEMCACHED_MAX_KEY by the value of your key.
+.sp
+The prefix key is only applied to the primary key, not the master key. MEMCACHED_FAILURE will be returned if no key is set. In the case of a key which is too long, MEMCACHED_BAD_KEY_PROVIDED will be returned.
.sp
If you set a value with the value being NULL then the prefix key is disabled.
-.UNINDENT
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_USER_DATA
-.
+.UNINDENT
+.sp
This allows you to store a pointer to a specifc piece of data. This can be
retrieved from inside of memcached_fetch_execute(). Cloning a memcached_st
will copy the pointer to the clone.
-.UNINDENT
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_MALLOC_FUNCTION
-.
-DEPRECATED: use memcached_set_memory_allocators instead.
.UNINDENT
+.sp
+DEPRECATED: use memcached_set_memory_allocators instead.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_REALLOC_FUNCTION
-.
-DEPRECATED: use memcached_set_memory_allocators instead.
.UNINDENT
+.sp
+DEPRECATED: use memcached_set_memory_allocators instead.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_FREE_FUNCTION
-.
-DEPRECATED: use memcached_set_memory_allocators instead.
.UNINDENT
+.sp
+DEPRECATED: use memcached_set_memory_allocators instead.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_GET_FAILURE
-.
+.UNINDENT
+.sp
This function implements the read through cache behavior. On failure of retrieval this callback will be called.
-You are responsible for populating the result object provided. This result object will then be stored in the server and
-returned to the calling process. You must clone the memcached_st in order to
+.sp
+You are responsible for populating the result object provided. This result object will then be stored in the server and returned to the calling process.
+.sp
+You must clone the memcached_st in order to
make use of it. The value will be stored only if you return
MEMCACHED_SUCCESS or MEMCACHED_BUFFERED. Returning MEMCACHED_BUFFERED will
cause the object to be buffered and not sent immediatly (if this is the default behavior based on your connection setup this will happen automatically).
.sp
The prototype for this is:
memcached_return_t (*memcached_trigger_key)(memcached_st *ptr, char *key, size_t key_length, memcached_result_st *result);
-.UNINDENT
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_DELETE_TRIGGER
-.TH "MEMCACHED_CAS" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_CAS" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
-memcached_cas \- Storing and Replacing Data
+memcached_cas \- Working with data on the server in an atomic fashion
.
.nr rst2man-indent-level 0
.
..
.\" Man page generated from reStructeredText.
.
-.sp
-Store value on server
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.INDENT 0.0
.TP
-.B memcached_return_t memcached_set (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_add (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_replace (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_prepend(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_append(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_cas(memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
.UNINDENT
.INDENT 0.0
.TP
-.B memcached_return_t memcached_set_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_add_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_replace_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_prepend_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_append_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_cas_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
.UNINDENT
.sp
Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
-memcached_set(), memcached_add(), and memcached_replace() are all used to
-store information on the server. All methods take a key, and its length to
-store the object. Keys are currently limited to 250 characters by the
-memcached(1) server. You must also supply a value and a length. Optionally you
-may tests an expiration time for the object and a 16 byte value (it is
-meant to be used as a bitmap).
-.sp
-memcached_set() will write an object to the server. If an object already
-exists it will overwrite what is in the server. If the object does not exist
-it will be written. If you are using the non\-blocking mode this function
-will always return true unless a network error occurs.
-.sp
-memcached_replace() replaces an object on the server. If the object is not
-found on the server an error occurs.
-.sp
-memcached_add() adds an object to the server. If the object is found on the
-server an error occurs, otherwise the value is stored.
-.sp
-memcached_prepend() places a segment of data before the last piece of data
-stored. Currently expiration and key are not used in the server.
-.sp
-memcached_append() places a segment of data at the end of the last piece of
-data stored. Currently expiration and key are not used in the server.
-.sp
memcached_cas() overwrites data in the server as long as the "cas" value is
still the same in the server. You can get the cas value of a result by
calling memcached_result_cas() on a memcached_result_st(3) structure. At the point
for it in libmemcached(3) is optional. Please see memcached_set() for
information on how to do this.
.sp
-memcached_set_by_key(), memcached_add_by_key(), memcached_replace_by_key(),
-memcached_prepend_by_key(), memcached_append_by_key_by_key(),
-memcached_cas_by_key() methods all behave in a similar method as the non key
-methods. The difference is that they use their group_key parameter to map
+memcached_cas_by_key() method behaves in a similar method as the non key
+methods. The difference is that it uses the group_key parameter to map
objects to particular servers.
.sp
-If you are looking for performance, memcached_set() with non\-blocking IO is
-the fastest way to store data on the server.
-.sp
-All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. But when using these operations with this behavior on, there
+memcached_cas() is testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. However, when using these operations with this behavior on, there
are limits to the size of the payload being sent to the server. The reason for
-these limits is that the Memcahed Server does not allow multi\-datagram requests
+these limits is that the Memcached Server does not allow multi\-datagram requests
and the current server implementation sets a datagram size to 1400 bytes. Due
to protocol overhead, the actual limit of the user supplied data is less than
-1400 bytes and depends on the protocol in use as well as the operation being
+1400 bytes and depends on the protocol in use as, well as the operation being
executed. When running with the binary protocol, \(ga\(ga MEMCACHED_BEHAVIOR_BINARY_PROTOCOL\(ga\(ga,
the size of the key,value, flags and expiry combined may not exceed 1368 bytes.
When running with the ASCII protocol, the exact limit fluctuates depending on
All methods return a value of type \fBmemcached_return_t\fP.
On success the value will be \fBMEMCACHED_SUCCESS\fP.
Use memcached_strerror() to translate this value to a printable string.
-.sp
-For memcached_replace() and memcached_add(), \fBMEMCACHED_NOTSTORED\fP is a
-legitmate error in the case of a collision.
.SH HOME
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
.SH SEE ALSO
.sp
-memcached(1) libmemached(3) memcached_strerror(3)
+memcached(1) libmemached(3) memcached_strerror(3) memcached_set(3) memcached_append(3) memcached_add(3) memcached_prepend(3) memcached_replace(3)
.SH AUTHOR
Brian Aker
.SH COPYRIGHT
-.TH "MEMCACHED_CAS_BY_KEY" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_CAS_BY_KEY" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_cas_by_key \- Storing and Replacing Data
.
..
.\" Man page generated from reStructeredText.
.
-.sp
-Store value on server
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.INDENT 0.0
.TP
-.B memcached_return_t memcached_set (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_add (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_replace (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_prepend(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_append(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_cas(memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
.UNINDENT
.INDENT 0.0
.TP
-.B memcached_return_t memcached_set_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_add_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_replace_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_prepend_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_append_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_cas_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
.UNINDENT
.sp
Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
-memcached_set(), memcached_add(), and memcached_replace() are all used to
-store information on the server. All methods take a key, and its length to
-store the object. Keys are currently limited to 250 characters by the
-memcached(1) server. You must also supply a value and a length. Optionally you
-may tests an expiration time for the object and a 16 byte value (it is
-meant to be used as a bitmap).
-.sp
-memcached_set() will write an object to the server. If an object already
-exists it will overwrite what is in the server. If the object does not exist
-it will be written. If you are using the non\-blocking mode this function
-will always return true unless a network error occurs.
-.sp
-memcached_replace() replaces an object on the server. If the object is not
-found on the server an error occurs.
-.sp
-memcached_add() adds an object to the server. If the object is found on the
-server an error occurs, otherwise the value is stored.
-.sp
-memcached_prepend() places a segment of data before the last piece of data
-stored. Currently expiration and key are not used in the server.
-.sp
-memcached_append() places a segment of data at the end of the last piece of
-data stored. Currently expiration and key are not used in the server.
-.sp
memcached_cas() overwrites data in the server as long as the "cas" value is
still the same in the server. You can get the cas value of a result by
calling memcached_result_cas() on a memcached_result_st(3) structure. At the point
for it in libmemcached(3) is optional. Please see memcached_set() for
information on how to do this.
.sp
-memcached_set_by_key(), memcached_add_by_key(), memcached_replace_by_key(),
-memcached_prepend_by_key(), memcached_append_by_key_by_key(),
-memcached_cas_by_key() methods all behave in a similar method as the non key
-methods. The difference is that they use their group_key parameter to map
+memcached_cas_by_key() method behaves in a similar method as the non key
+methods. The difference is that it uses the group_key parameter to map
objects to particular servers.
.sp
-If you are looking for performance, memcached_set() with non\-blocking IO is
-the fastest way to store data on the server.
-.sp
-All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. But when using these operations with this behavior on, there
+memcached_cas() is testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. However, when using these operations with this behavior on, there
are limits to the size of the payload being sent to the server. The reason for
-these limits is that the Memcahed Server does not allow multi\-datagram requests
+these limits is that the Memcached Server does not allow multi\-datagram requests
and the current server implementation sets a datagram size to 1400 bytes. Due
to protocol overhead, the actual limit of the user supplied data is less than
-1400 bytes and depends on the protocol in use as well as the operation being
+1400 bytes and depends on the protocol in use as, well as the operation being
executed. When running with the binary protocol, \(ga\(ga MEMCACHED_BEHAVIOR_BINARY_PROTOCOL\(ga\(ga,
the size of the key,value, flags and expiry combined may not exceed 1368 bytes.
When running with the ASCII protocol, the exact limit fluctuates depending on
All methods return a value of type \fBmemcached_return_t\fP.
On success the value will be \fBMEMCACHED_SUCCESS\fP.
Use memcached_strerror() to translate this value to a printable string.
-.sp
-For memcached_replace() and memcached_add(), \fBMEMCACHED_NOTSTORED\fP is a
-legitmate error in the case of a collision.
.SH HOME
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
.SH SEE ALSO
.sp
-memcached(1) libmemached(3) memcached_strerror(3)
+memcached(1) libmemached(3) memcached_strerror(3) memcached_set(3) memcached_append(3) memcached_add(3) memcached_prepend(3) memcached_replace(3)
.SH AUTHOR
Brian Aker
.SH COPYRIGHT
-.TH "MEMCACHED_CLONE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_CLONE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_clone \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
-.sp
-Create a memcached_st structure
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
-.TH "MEMCACHED_CREATE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_CREATE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_create \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
-.sp
-Create a memcached_st structure
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
-.TH "MEMCACHED_DECREMENT" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_DECREMENT" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_decrement \- Incrementing and Decrementing Values
.
-.TH "MEMCACHED_DECREMENT_WITH_INITIAL" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_DECREMENT_WITH_INITIAL" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_decrement_with_initial \- Incrementing and Decrementing Values
.
-.TH "MEMCACHED_DELETE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_DELETE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_delete \- libmemcached Documentation
.
find the given value.
.sp
Expiration works by placing the item into a delete queue, which means that
-it won\(aqt possible to retrieve it by the "get" command, but "add" and
-"replace" command with this key will also fail (the "set" command will
+it won\(aqt be possible to retrieve it by the "get" command. The "add" and
+"replace" commands with this key will also fail (the "set" command will
succeed, however). After the time passes, the item is finally deleted from server memory.
.sp
Please note the the Danga memcached server removed tests for expiration in
-.TH "MEMCACHED_DELETE_BY_KEY" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_DELETE_BY_KEY" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_delete_by_key \- libmemcached Documentation
.
find the given value.
.sp
Expiration works by placing the item into a delete queue, which means that
-it won\(aqt possible to retrieve it by the "get" command, but "add" and
-"replace" command with this key will also fail (the "set" command will
+it won\(aqt be possible to retrieve it by the "get" command. The "add" and
+"replace" commands with this key will also fail (the "set" command will
succeed, however). After the time passes, the item is finally deleted from server memory.
.sp
Please note the the Danga memcached server removed tests for expiration in
-.TH "MEMCACHED_DESTROY_SASL_AUTH_DATA" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_DESTROY_SASL_AUTH_DATA" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_destroy_sasl_auth_data \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/memcached.h>
-
-void memcached_set_sasl_callbacks(memcached_st *ptr,
- const sasl_callback_t *callbacks)
-
-const sasl_callback_t *memcached_get_sasl_callbacks(memcached_st *ptr)
-
-memcached_return memcached_set_sasl_auth_data(memcached_st *ptr,
- const char *username,
- const char *password)
-memcached_return memcached_destroy_sasl_auth_data(memcached_st *ptr)
-.ft P
-.fi
+#include <libmemcached/memcached_pool.h>
+.INDENT 0.0
+.TP
+.B void memcached_set_sasl_callbacks(memcached_st\fI\ *ptr\fP, const sasl_callback_t\fI\ *callbacks\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const sasl_callback_t *memcached_get_sasl_callbacks(memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return memcached_set_sasl_auth_data(memcached_st\fI\ *ptr\fP, const char\fI\ *username\fP, const char\fI\ *password\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return memcached_destroy_sasl_auth_data(memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) allows you to plug in your own callbacks function used by
Please note that SASL requires the memcached binary protocol, and you have
to specify the callbacks before you connect to the server.
.sp
-memcached_set_sasl_auth_data() is a helper function for you defining
+memcached_set_sasl_auth_data() is a helper function defining
the basic functionality for you, but it will store the username and password
in memory. If you choose to use this method you have to call
memcached_destroy_sasl_auth_data before calling memcached_free to avoid
-.TH "MEMCACHED_DUMP" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_DUMP" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_dump \- libmemcached Documentation
.
.
.sp
Get a list of keys found on memcached servers
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-memcached_return_t
- memcached_dump (memcached_st *ptr,
- memcached_dump_fn *function,
- void *context,
- uint32_t number_of_callbacks);
-
-typedef memcached_return_t (*memcached_dump_fn)(memcached_st *ptr,
- const char *key,
- size_t key_length,
- void *context);
-.ft P
-.fi
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_dump (memcached_st *ptr, memcached_dump_fn *function, void *context, uint32_t number_of_callbacks);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B typedef memcached_return_t (*memcached_dump_fn)(memcached_st *ptr, const char *key, size_t key_length, void *context);
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
-memcached_dump() is used to get a list of keys found memcached(1) servers.
+memcached_dump() is used to get a list of keys found in memcached(1) servers.
Because memcached(1) does not guarentee to dump all keys you can not assume
you have fetched all keys from the server. The function takes an array
of callbacks that it will use to execute on keys as they are found.
.sp
-Currently the binar protocol is not testsed.
+Currently the binary protocol is not testsed.
.SH RETURN
.sp
A value of type \fBmemcached_return_t\fP is returned
-.TH "MEMCACHED_FETCH" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_FETCH" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_fetch \- Retrieving data from the server
.
upon success and NULL will be returned on failure. MEMCACHD_END is returned
by the *error value when all objects that have been found are returned.
The final value upon MEMCACHED_END is null. Values returned by
-memcached_fetch() musted be free\(aqed by the caller. memcached_fetch() will
+memcached_fetch() must be freed by the caller. memcached_fetch() will
be DEPRECATED in the near future, memcached_fetch_result() should be used
instead.
.sp
similar to memcached_mget(), but it may trigger the supplied callbacks
with result sets while sending out the queries. If you try to perform
a really large multiget with memcached_mget() you may encounter a
-deadlock in the OS kernel (we fail to write data to the socket because
+deadlock in the OS kernel (it will fail to write data to the socket because
the input buffer is full). memcached_mget_execute() solves this
problem by processing some of the results before continuing sending
out requests. Please note that this function is only available in the
a master key that is used for determining which server an object was stored
if key partitioning was used for storage.
.sp
-All of the above functions are not testsed when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
-\fBMEMCACHED_NOT_SUPPORTED\fP being returned or, for those functions which do not return
+All of the above functions are not tested when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
+\fBMEMCACHED_NOT_SUPPORTED\fP being returned, or for those functions which do not return
a \fBmemcached_return_t\fP, the error function parameter will be set to
\fBMEMCACHED_NOT_SUPPORTED\fP.
.SH RETURN
-.TH "MEMCACHED_FETCH_EXECUTE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_FETCH_EXECUTE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_fetch_execute \- Retrieving data from the server
.
upon success and NULL will be returned on failure. MEMCACHD_END is returned
by the *error value when all objects that have been found are returned.
The final value upon MEMCACHED_END is null. Values returned by
-memcached_fetch() musted be free\(aqed by the caller. memcached_fetch() will
+memcached_fetch() must be freed by the caller. memcached_fetch() will
be DEPRECATED in the near future, memcached_fetch_result() should be used
instead.
.sp
similar to memcached_mget(), but it may trigger the supplied callbacks
with result sets while sending out the queries. If you try to perform
a really large multiget with memcached_mget() you may encounter a
-deadlock in the OS kernel (we fail to write data to the socket because
+deadlock in the OS kernel (it will fail to write data to the socket because
the input buffer is full). memcached_mget_execute() solves this
problem by processing some of the results before continuing sending
out requests. Please note that this function is only available in the
a master key that is used for determining which server an object was stored
if key partitioning was used for storage.
.sp
-All of the above functions are not testsed when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
-\fBMEMCACHED_NOT_SUPPORTED\fP being returned or, for those functions which do not return
+All of the above functions are not tested when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
+\fBMEMCACHED_NOT_SUPPORTED\fP being returned, or for those functions which do not return
a \fBmemcached_return_t\fP, the error function parameter will be set to
\fBMEMCACHED_NOT_SUPPORTED\fP.
.SH RETURN
-.TH "MEMCACHED_FETCH_RESULT" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_FETCH_RESULT" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_fetch_result \- Retrieving data from the server
.
upon success and NULL will be returned on failure. MEMCACHD_END is returned
by the *error value when all objects that have been found are returned.
The final value upon MEMCACHED_END is null. Values returned by
-memcached_fetch() musted be free\(aqed by the caller. memcached_fetch() will
+memcached_fetch() must be freed by the caller. memcached_fetch() will
be DEPRECATED in the near future, memcached_fetch_result() should be used
instead.
.sp
similar to memcached_mget(), but it may trigger the supplied callbacks
with result sets while sending out the queries. If you try to perform
a really large multiget with memcached_mget() you may encounter a
-deadlock in the OS kernel (we fail to write data to the socket because
+deadlock in the OS kernel (it will fail to write data to the socket because
the input buffer is full). memcached_mget_execute() solves this
problem by processing some of the results before continuing sending
out requests. Please note that this function is only available in the
a master key that is used for determining which server an object was stored
if key partitioning was used for storage.
.sp
-All of the above functions are not testsed when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
-\fBMEMCACHED_NOT_SUPPORTED\fP being returned or, for those functions which do not return
+All of the above functions are not tested when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
+\fBMEMCACHED_NOT_SUPPORTED\fP being returned, or for those functions which do not return
a \fBmemcached_return_t\fP, the error function parameter will be set to
\fBMEMCACHED_NOT_SUPPORTED\fP.
.SH RETURN
-.TH "MEMCACHED_FLUSH" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_FLUSH" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_flush \- libmemcached Documentation
.
-.TH "MEMCACHED_FLUSH_BUFFERS" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_FLUSH_BUFFERS" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_flush_buffers \- libmemcached Documentation
.
.\" Man page generated from reStructeredText.
.
.sp
-Flush buffers and send buffered commands
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
+Flush and senf buffered commands
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.TP
.B memcached_return_t memcached_flush_buffers (memcached_st *ptr);
.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
memcached_flush_buffers() is used in conjunction with
-.TH "MEMCACHED_FREE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_FREE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_free \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
-.sp
-Create a memcached_st structure
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
-.TH "MEMCACHED_GENERATE_HASH" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_GENERATE_HASH" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_generate_hash \- Generating hash values directly
.
-.TH "MEMCACHED_GENERATE_HASH_VALUE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_GENERATE_HASH_VALUE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_generate_hash_value \- Generating hash values directly
.
-.TH "MEMCACHED_GET" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_GET" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_get \- Retrieving data from the server
.
upon success and NULL will be returned on failure. MEMCACHD_END is returned
by the *error value when all objects that have been found are returned.
The final value upon MEMCACHED_END is null. Values returned by
-memcached_fetch() musted be free\(aqed by the caller. memcached_fetch() will
+memcached_fetch() must be freed by the caller. memcached_fetch() will
be DEPRECATED in the near future, memcached_fetch_result() should be used
instead.
.sp
similar to memcached_mget(), but it may trigger the supplied callbacks
with result sets while sending out the queries. If you try to perform
a really large multiget with memcached_mget() you may encounter a
-deadlock in the OS kernel (we fail to write data to the socket because
+deadlock in the OS kernel (it will fail to write data to the socket because
the input buffer is full). memcached_mget_execute() solves this
problem by processing some of the results before continuing sending
out requests. Please note that this function is only available in the
a master key that is used for determining which server an object was stored
if key partitioning was used for storage.
.sp
-All of the above functions are not testsed when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
-\fBMEMCACHED_NOT_SUPPORTED\fP being returned or, for those functions which do not return
+All of the above functions are not tested when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
+\fBMEMCACHED_NOT_SUPPORTED\fP being returned, or for those functions which do not return
a \fBmemcached_return_t\fP, the error function parameter will be set to
\fBMEMCACHED_NOT_SUPPORTED\fP.
.SH RETURN
-.TH "MEMCACHED_GET_BY_KEY" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_GET_BY_KEY" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_get_by_key \- Retrieving data from the server
.
upon success and NULL will be returned on failure. MEMCACHD_END is returned
by the *error value when all objects that have been found are returned.
The final value upon MEMCACHED_END is null. Values returned by
-memcached_fetch() musted be free\(aqed by the caller. memcached_fetch() will
+memcached_fetch() must be freed by the caller. memcached_fetch() will
be DEPRECATED in the near future, memcached_fetch_result() should be used
instead.
.sp
similar to memcached_mget(), but it may trigger the supplied callbacks
with result sets while sending out the queries. If you try to perform
a really large multiget with memcached_mget() you may encounter a
-deadlock in the OS kernel (we fail to write data to the socket because
+deadlock in the OS kernel (it will fail to write data to the socket because
the input buffer is full). memcached_mget_execute() solves this
problem by processing some of the results before continuing sending
out requests. Please note that this function is only available in the
a master key that is used for determining which server an object was stored
if key partitioning was used for storage.
.sp
-All of the above functions are not testsed when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
-\fBMEMCACHED_NOT_SUPPORTED\fP being returned or, for those functions which do not return
+All of the above functions are not tested when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
+\fBMEMCACHED_NOT_SUPPORTED\fP being returned, or for those functions which do not return
a \fBmemcached_return_t\fP, the error function parameter will be set to
\fBMEMCACHED_NOT_SUPPORTED\fP.
.SH RETURN
-.TH "MEMCACHED_GET_MEMORY_ALLOCATORS" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_GET_MEMORY_ALLOCATORS" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_get_memory_allocators \- libmemcached Documentation
.
.
.sp
Manage memory allocator functions
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-memcached_return_t memcached_set_memory_allocators (memcached_st *ptr, memcached_malloc_fn mem_malloc, memcached_free_fn mem_free, memcached_realloc_fn mem_realloc, memcached_calloc_fn mem_calloc, void *context);
-
-void memcached_get_memory_allocators (memcached_st *ptr, memcached_malloc_fn *mem_malloc, memcached_free_fn *mem_free, memcached_realloc_fn *mem_realloc, memcached_calloc_fn *mem_calloc);
-
-void * memcached_get_memory_allocators_context(const memcached_st *ptr);
-
-void * (*memcached_malloc_fn) (memcached_st *ptr, const size_t size, void *context);
-
-void * (*memcached_realloc_fn) (memcached_st *ptr, void *mem, const size_t size, void *context);
-
-void (*memcached_free_fn) (memcached_st *ptr, void *mem, void *context);
-
-void * (*memcached_calloc_fn) (memcached_st *ptr, size_t nelem, const size_t elsize, void *context);
-.ft P
-.fi
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_set_memory_allocators (memcached_st *ptr, memcached_malloc_fn mem_malloc, memcached_free_fn mem_free, memcached_realloc_fn mem_realloc, memcached_calloc_fn mem_calloc, void *context);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_get_memory_allocators (memcached_st *ptr, memcached_malloc_fn *mem_malloc, memcached_free_fn *mem_free, memcached_realloc_fn *mem_realloc, memcached_calloc_fn *mem_calloc);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void * memcached_get_memory_allocators_context(const memcached_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void * (*memcached_malloc_fn) (memcached_st *ptr, const size_t size, void *context);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void * (*memcached_realloc_fn) (memcached_st *ptr, void *mem, const size_t size, void *context);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void (*memcached_free_fn) (memcached_st *ptr, void *mem, void *context);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void * (*memcached_calloc_fn) (memcached_st *ptr, size_t nelem, const size_t elsize, void *context);
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
-libmemcached(3) allows you to specify your own memory allocators optimized
+libmemcached(3) allows you to specify your own memory allocators, optimized
for your application. This enables libmemcached to be used inside of applications that have their own malloc implementation.
.sp
memcached_set_memory_allocators() is used to set the memory allocators used
-.TH "MEMCACHED_GET_SASL_CALLBACKS" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_GET_SASL_CALLBACKS" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_get_sasl_callbacks \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/memcached.h>
-
-void memcached_set_sasl_callbacks(memcached_st *ptr,
- const sasl_callback_t *callbacks)
-
-const sasl_callback_t *memcached_get_sasl_callbacks(memcached_st *ptr)
-
-memcached_return memcached_set_sasl_auth_data(memcached_st *ptr,
- const char *username,
- const char *password)
-memcached_return memcached_destroy_sasl_auth_data(memcached_st *ptr)
-.ft P
-.fi
+#include <libmemcached/memcached_pool.h>
+.INDENT 0.0
+.TP
+.B void memcached_set_sasl_callbacks(memcached_st\fI\ *ptr\fP, const sasl_callback_t\fI\ *callbacks\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const sasl_callback_t *memcached_get_sasl_callbacks(memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return memcached_set_sasl_auth_data(memcached_st\fI\ *ptr\fP, const char\fI\ *username\fP, const char\fI\ *password\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return memcached_destroy_sasl_auth_data(memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) allows you to plug in your own callbacks function used by
Please note that SASL requires the memcached binary protocol, and you have
to specify the callbacks before you connect to the server.
.sp
-memcached_set_sasl_auth_data() is a helper function for you defining
+memcached_set_sasl_auth_data() is a helper function defining
the basic functionality for you, but it will store the username and password
in memory. If you choose to use this method you have to call
memcached_destroy_sasl_auth_data before calling memcached_free to avoid
-.TH "MEMCACHED_GET_USER_DATA" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_GET_USER_DATA" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_get_user_data \- libmemcached Documentation
.
.SH LIBRARY
.sp
C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
+.SH SYNOPSIS
.sp
.nf
.ft C
void *memcached_set_user_data (memcached_st *ptr, void *data);
.ft P
.fi
-.SS DESCRIPTION
+.SH DESCRIPTION
.sp
libmemcached(3) allows you to store a pointer to a user specific data inside
the memcached_st structure.
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
-.SH AUTHOR
-.sp
-Trond Norbye, <\fI\%trond.norbye@gmail.com\fP>
-.SS SEE ALSO
+.SH SEE ALSO
.sp
memcached(1) libmemcached(3)
.SH AUTHOR
-.TH "MEMCACHED_INCREMENT" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_INCREMENT" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_increment \- Incrementing and Decrementing Values
.
-.TH "MEMCACHED_INCREMENT_WITH_INITIAL" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_INCREMENT_WITH_INITIAL" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_increment_with_initial \- Incrementing and Decrementing Values
.
-.TH "MEMCACHED_LIB_VERSION" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_LIB_VERSION" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_lib_version \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
+.SH SYNOPSIS
.sp
-Get library version
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-const char *
- memcached_lib_version (void)
-
-
-memcached_return_t
- memcached_version (memcached_st *ptr)
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B const char * memcached_lib_version(void)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_version(memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
memcached_lib_version() is used to return a simple version string representing
-the libmemcached version (version of the client library, not server)
+the libmemcached version (client library version, not server version)
.sp
memcached_version() is used to set the major, minor, and micro versions of each
memcached server being used by the memcached_st connection structure. It returns the
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
-.SH AUTHOR
-.sp
-Brian Aker, <\fI\%brian@tangent.org\fP>
-.SS SEE ALSO
+.SH SEE ALSO
.sp
memcached(1) libmemcached(3) memcached_strerror(3)
.SH AUTHOR
-.TH "MEMCACHED_MEMORY_ALLOCATORS" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_MEMORY_ALLOCATORS" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_memory_allocators \- libmemcached Documentation
.
.
.sp
Manage memory allocator functions
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-memcached_return_t memcached_set_memory_allocators (memcached_st *ptr, memcached_malloc_fn mem_malloc, memcached_free_fn mem_free, memcached_realloc_fn mem_realloc, memcached_calloc_fn mem_calloc, void *context);
-
-void memcached_get_memory_allocators (memcached_st *ptr, memcached_malloc_fn *mem_malloc, memcached_free_fn *mem_free, memcached_realloc_fn *mem_realloc, memcached_calloc_fn *mem_calloc);
-
-void * memcached_get_memory_allocators_context(const memcached_st *ptr);
-
-void * (*memcached_malloc_fn) (memcached_st *ptr, const size_t size, void *context);
-
-void * (*memcached_realloc_fn) (memcached_st *ptr, void *mem, const size_t size, void *context);
-
-void (*memcached_free_fn) (memcached_st *ptr, void *mem, void *context);
-
-void * (*memcached_calloc_fn) (memcached_st *ptr, size_t nelem, const size_t elsize, void *context);
-.ft P
-.fi
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_set_memory_allocators (memcached_st *ptr, memcached_malloc_fn mem_malloc, memcached_free_fn mem_free, memcached_realloc_fn mem_realloc, memcached_calloc_fn mem_calloc, void *context);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_get_memory_allocators (memcached_st *ptr, memcached_malloc_fn *mem_malloc, memcached_free_fn *mem_free, memcached_realloc_fn *mem_realloc, memcached_calloc_fn *mem_calloc);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void * memcached_get_memory_allocators_context(const memcached_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void * (*memcached_malloc_fn) (memcached_st *ptr, const size_t size, void *context);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void * (*memcached_realloc_fn) (memcached_st *ptr, void *mem, const size_t size, void *context);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void (*memcached_free_fn) (memcached_st *ptr, void *mem, void *context);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void * (*memcached_calloc_fn) (memcached_st *ptr, size_t nelem, const size_t elsize, void *context);
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
-libmemcached(3) allows you to specify your own memory allocators optimized
+libmemcached(3) allows you to specify your own memory allocators, optimized
for your application. This enables libmemcached to be used inside of applications that have their own malloc implementation.
.sp
memcached_set_memory_allocators() is used to set the memory allocators used
-.TH "MEMCACHED_MGET" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_MGET" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_mget \- Retrieving data from the server
.
upon success and NULL will be returned on failure. MEMCACHD_END is returned
by the *error value when all objects that have been found are returned.
The final value upon MEMCACHED_END is null. Values returned by
-memcached_fetch() musted be free\(aqed by the caller. memcached_fetch() will
+memcached_fetch() must be freed by the caller. memcached_fetch() will
be DEPRECATED in the near future, memcached_fetch_result() should be used
instead.
.sp
similar to memcached_mget(), but it may trigger the supplied callbacks
with result sets while sending out the queries. If you try to perform
a really large multiget with memcached_mget() you may encounter a
-deadlock in the OS kernel (we fail to write data to the socket because
+deadlock in the OS kernel (it will fail to write data to the socket because
the input buffer is full). memcached_mget_execute() solves this
problem by processing some of the results before continuing sending
out requests. Please note that this function is only available in the
a master key that is used for determining which server an object was stored
if key partitioning was used for storage.
.sp
-All of the above functions are not testsed when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
-\fBMEMCACHED_NOT_SUPPORTED\fP being returned or, for those functions which do not return
+All of the above functions are not tested when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
+\fBMEMCACHED_NOT_SUPPORTED\fP being returned, or for those functions which do not return
a \fBmemcached_return_t\fP, the error function parameter will be set to
\fBMEMCACHED_NOT_SUPPORTED\fP.
.SH RETURN
-.TH "MEMCACHED_MGET_BY_KEY" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_MGET_BY_KEY" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_mget_by_key \- Retrieving data from the server
.
upon success and NULL will be returned on failure. MEMCACHD_END is returned
by the *error value when all objects that have been found are returned.
The final value upon MEMCACHED_END is null. Values returned by
-memcached_fetch() musted be free\(aqed by the caller. memcached_fetch() will
+memcached_fetch() must be freed by the caller. memcached_fetch() will
be DEPRECATED in the near future, memcached_fetch_result() should be used
instead.
.sp
similar to memcached_mget(), but it may trigger the supplied callbacks
with result sets while sending out the queries. If you try to perform
a really large multiget with memcached_mget() you may encounter a
-deadlock in the OS kernel (we fail to write data to the socket because
+deadlock in the OS kernel (it will fail to write data to the socket because
the input buffer is full). memcached_mget_execute() solves this
problem by processing some of the results before continuing sending
out requests. Please note that this function is only available in the
a master key that is used for determining which server an object was stored
if key partitioning was used for storage.
.sp
-All of the above functions are not testsed when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
-\fBMEMCACHED_NOT_SUPPORTED\fP being returned or, for those functions which do not return
+All of the above functions are not tested when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
+\fBMEMCACHED_NOT_SUPPORTED\fP being returned, or for those functions which do not return
a \fBmemcached_return_t\fP, the error function parameter will be set to
\fBMEMCACHED_NOT_SUPPORTED\fP.
.SH RETURN
-.TH "MEMCACHED_MGET_EXECUTE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_MGET_EXECUTE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_mget_execute \- Retrieving data from the server
.
upon success and NULL will be returned on failure. MEMCACHD_END is returned
by the *error value when all objects that have been found are returned.
The final value upon MEMCACHED_END is null. Values returned by
-memcached_fetch() musted be free\(aqed by the caller. memcached_fetch() will
+memcached_fetch() must be freed by the caller. memcached_fetch() will
be DEPRECATED in the near future, memcached_fetch_result() should be used
instead.
.sp
similar to memcached_mget(), but it may trigger the supplied callbacks
with result sets while sending out the queries. If you try to perform
a really large multiget with memcached_mget() you may encounter a
-deadlock in the OS kernel (we fail to write data to the socket because
+deadlock in the OS kernel (it will fail to write data to the socket because
the input buffer is full). memcached_mget_execute() solves this
problem by processing some of the results before continuing sending
out requests. Please note that this function is only available in the
a master key that is used for determining which server an object was stored
if key partitioning was used for storage.
.sp
-All of the above functions are not testsed when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
-\fBMEMCACHED_NOT_SUPPORTED\fP being returned or, for those functions which do not return
+All of the above functions are not tested when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
+\fBMEMCACHED_NOT_SUPPORTED\fP being returned, or for those functions which do not return
a \fBmemcached_return_t\fP, the error function parameter will be set to
\fBMEMCACHED_NOT_SUPPORTED\fP.
.SH RETURN
-.TH "MEMCACHED_MGET_EXECUTE_BY_KEY" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_MGET_EXECUTE_BY_KEY" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_mget_execute_by_key \- Retrieving data from the server
.
upon success and NULL will be returned on failure. MEMCACHD_END is returned
by the *error value when all objects that have been found are returned.
The final value upon MEMCACHED_END is null. Values returned by
-memcached_fetch() musted be free\(aqed by the caller. memcached_fetch() will
+memcached_fetch() must be freed by the caller. memcached_fetch() will
be DEPRECATED in the near future, memcached_fetch_result() should be used
instead.
.sp
similar to memcached_mget(), but it may trigger the supplied callbacks
with result sets while sending out the queries. If you try to perform
a really large multiget with memcached_mget() you may encounter a
-deadlock in the OS kernel (we fail to write data to the socket because
+deadlock in the OS kernel (it will fail to write data to the socket because
the input buffer is full). memcached_mget_execute() solves this
problem by processing some of the results before continuing sending
out requests. Please note that this function is only available in the
a master key that is used for determining which server an object was stored
if key partitioning was used for storage.
.sp
-All of the above functions are not testsed when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
-\fBMEMCACHED_NOT_SUPPORTED\fP being returned or, for those functions which do not return
+All of the above functions are not tested when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
+\fBMEMCACHED_NOT_SUPPORTED\fP being returned, or for those functions which do not return
a \fBmemcached_return_t\fP, the error function parameter will be set to
\fBMEMCACHED_NOT_SUPPORTED\fP.
.SH RETURN
-.TH "MEMCACHED_POOL" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_POOL" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_pool \- libmemcached Documentation
.
-.TH "MEMCACHED_POOL_BEHAVIOR_GET" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_POOL_BEHAVIOR_GET" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_pool_behavior_get \- libmemcached Documentation
.
-.TH "MEMCACHED_POOL_BEHAVIOR_SET" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_POOL_BEHAVIOR_SET" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_pool_behavior_set \- libmemcached Documentation
.
-.TH "MEMCACHED_POOL_CREATE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_POOL_CREATE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_pool_create \- libmemcached Documentation
.
-.TH "MEMCACHED_POOL_DESTROY" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_POOL_DESTROY" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_pool_destroy \- libmemcached Documentation
.
-.TH "MEMCACHED_POOL_POP" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_POOL_POP" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_pool_pop \- libmemcached Documentation
.
-.TH "MEMCACHED_POOL_PUSH" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_POOL_PUSH" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_pool_push \- libmemcached Documentation
.
-.TH "MEMCACHED_POOL_ST" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_POOL_ST" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_pool_st \- libmemcached Documentation
.
-.TH "MEMCACHED_PREPEND" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_PREPEND" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
-memcached_prepend \- Storing and Replacing Data
+memcached_prepend \- Appending to or Prepending to data on the server
.
.nr rst2man-indent-level 0
.
.\" Man page generated from reStructeredText.
.
.sp
-Store value on server
+Appending or Prepending to data on the server
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.INDENT 0.0
.TP
-.B memcached_return_t memcached_set (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_add (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_replace (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_prepend(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
.UNINDENT
.INDENT 0.0
.UNINDENT
.INDENT 0.0
.TP
-.B memcached_return_t memcached_cas(memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_set_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_add_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_replace_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_prepend_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
.INDENT 0.0
.TP
.B memcached_return_t memcached_append_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_cas_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
.sp
Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
-memcached_set(), memcached_add(), and memcached_replace() are all used to
-store information on the server. All methods take a key, and its length to
-store the object. Keys are currently limited to 250 characters by the
-memcached(1) server. You must also supply a value and a length. Optionally you
-may tests an expiration time for the object and a 16 byte value (it is
-meant to be used as a bitmap).
-.sp
-memcached_set() will write an object to the server. If an object already
-exists it will overwrite what is in the server. If the object does not exist
-it will be written. If you are using the non\-blocking mode this function
-will always return true unless a network error occurs.
-.sp
-memcached_replace() replaces an object on the server. If the object is not
-found on the server an error occurs.
-.sp
-memcached_add() adds an object to the server. If the object is found on the
-server an error occurs, otherwise the value is stored.
+memcached_prepend() and memcached_append are used to
+modify information on a server. All methods take a key, and its length to
+store the object. Keys are currently limited to 250 characters when using either a version of memcached(1) which is 1.4 or below, or when using the text protocol.
+You must supply both a value and a length. Optionally you
+may test an expiration time for the object and a 16 byte value (it is
+meant to be used as a bitmap). "flags" is a 4byte space that is stored alongside of the main value. Many sub libraries make use of this field, so in most cases users should avoid making use of it.
.sp
memcached_prepend() places a segment of data before the last piece of data
stored. Currently expiration and key are not used in the server.
memcached_append() places a segment of data at the end of the last piece of
data stored. Currently expiration and key are not used in the server.
.sp
-memcached_cas() overwrites data in the server as long as the "cas" value is
-still the same in the server. You can get the cas value of a result by
-calling memcached_result_cas() on a memcached_result_st(3) structure. At the point
-that this note was written cas is still buggy in memached. Turning on tests
-for it in libmemcached(3) is optional. Please see memcached_set() for
-information on how to do this.
-.sp
-memcached_set_by_key(), memcached_add_by_key(), memcached_replace_by_key(),
-memcached_prepend_by_key(), memcached_append_by_key_by_key(),
-memcached_cas_by_key() methods all behave in a similar method as the non key
+memcached_prepend_by_key() and memcached_append_by_key_by_key(,
+methods both behave in a similar method as the non key
methods. The difference is that they use their group_key parameter to map
objects to particular servers.
.sp
If you are looking for performance, memcached_set() with non\-blocking IO is
the fastest way to store data on the server.
.sp
-All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. But when using these operations with this behavior on, there
+All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. However, when using these operations with this behavior on, there
are limits to the size of the payload being sent to the server. The reason for
-these limits is that the Memcahed Server does not allow multi\-datagram requests
+these limits is that the Memcached Server does not allow multi\-datagram requests
and the current server implementation sets a datagram size to 1400 bytes. Due
to protocol overhead, the actual limit of the user supplied data is less than
-1400 bytes and depends on the protocol in use as well as the operation being
+1400 bytes and depends on the protocol in use as, well as the operation being
executed. When running with the binary protocol, \(ga\(ga MEMCACHED_BEHAVIOR_BINARY_PROTOCOL\(ga\(ga,
the size of the key,value, flags and expiry combined may not exceed 1368 bytes.
When running with the ASCII protocol, the exact limit fluctuates depending on
All methods return a value of type \fBmemcached_return_t\fP.
On success the value will be \fBMEMCACHED_SUCCESS\fP.
Use memcached_strerror() to translate this value to a printable string.
-.sp
-For memcached_replace() and memcached_add(), \fBMEMCACHED_NOTSTORED\fP is a
-legitmate error in the case of a collision.
.SH HOME
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
.SH SEE ALSO
.sp
-memcached(1) libmemached(3) memcached_strerror(3)
+memcached(1) libmemached(3) memcached_strerror(3) memcached_set(3) memcached_add(3) memcached_cas(3) memcached_replace(3)
.SH AUTHOR
Brian Aker
.SH COPYRIGHT
-.TH "MEMCACHED_PREPEND_BY_KEY" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_PREPEND_BY_KEY" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
-memcached_prepend_by_key \- Storing and Replacing Data
+memcached_prepend_by_key \- Appending to or Prepending to data on the server
.
.nr rst2man-indent-level 0
.
.\" Man page generated from reStructeredText.
.
.sp
-Store value on server
+Appending or Prepending to data on the server
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.INDENT 0.0
.TP
-.B memcached_return_t memcached_set (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_add (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_replace (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_prepend(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
.UNINDENT
.INDENT 0.0
.UNINDENT
.INDENT 0.0
.TP
-.B memcached_return_t memcached_cas(memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_set_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_add_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_replace_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_prepend_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
.INDENT 0.0
.TP
.B memcached_return_t memcached_append_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_cas_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
.sp
Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
-memcached_set(), memcached_add(), and memcached_replace() are all used to
-store information on the server. All methods take a key, and its length to
-store the object. Keys are currently limited to 250 characters by the
-memcached(1) server. You must also supply a value and a length. Optionally you
-may tests an expiration time for the object and a 16 byte value (it is
-meant to be used as a bitmap).
-.sp
-memcached_set() will write an object to the server. If an object already
-exists it will overwrite what is in the server. If the object does not exist
-it will be written. If you are using the non\-blocking mode this function
-will always return true unless a network error occurs.
-.sp
-memcached_replace() replaces an object on the server. If the object is not
-found on the server an error occurs.
-.sp
-memcached_add() adds an object to the server. If the object is found on the
-server an error occurs, otherwise the value is stored.
+memcached_prepend() and memcached_append are used to
+modify information on a server. All methods take a key, and its length to
+store the object. Keys are currently limited to 250 characters when using either a version of memcached(1) which is 1.4 or below, or when using the text protocol.
+You must supply both a value and a length. Optionally you
+may test an expiration time for the object and a 16 byte value (it is
+meant to be used as a bitmap). "flags" is a 4byte space that is stored alongside of the main value. Many sub libraries make use of this field, so in most cases users should avoid making use of it.
.sp
memcached_prepend() places a segment of data before the last piece of data
stored. Currently expiration and key are not used in the server.
memcached_append() places a segment of data at the end of the last piece of
data stored. Currently expiration and key are not used in the server.
.sp
-memcached_cas() overwrites data in the server as long as the "cas" value is
-still the same in the server. You can get the cas value of a result by
-calling memcached_result_cas() on a memcached_result_st(3) structure. At the point
-that this note was written cas is still buggy in memached. Turning on tests
-for it in libmemcached(3) is optional. Please see memcached_set() for
-information on how to do this.
-.sp
-memcached_set_by_key(), memcached_add_by_key(), memcached_replace_by_key(),
-memcached_prepend_by_key(), memcached_append_by_key_by_key(),
-memcached_cas_by_key() methods all behave in a similar method as the non key
+memcached_prepend_by_key() and memcached_append_by_key_by_key(,
+methods both behave in a similar method as the non key
methods. The difference is that they use their group_key parameter to map
objects to particular servers.
.sp
If you are looking for performance, memcached_set() with non\-blocking IO is
the fastest way to store data on the server.
.sp
-All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. But when using these operations with this behavior on, there
+All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. However, when using these operations with this behavior on, there
are limits to the size of the payload being sent to the server. The reason for
-these limits is that the Memcahed Server does not allow multi\-datagram requests
+these limits is that the Memcached Server does not allow multi\-datagram requests
and the current server implementation sets a datagram size to 1400 bytes. Due
to protocol overhead, the actual limit of the user supplied data is less than
-1400 bytes and depends on the protocol in use as well as the operation being
+1400 bytes and depends on the protocol in use as, well as the operation being
executed. When running with the binary protocol, \(ga\(ga MEMCACHED_BEHAVIOR_BINARY_PROTOCOL\(ga\(ga,
the size of the key,value, flags and expiry combined may not exceed 1368 bytes.
When running with the ASCII protocol, the exact limit fluctuates depending on
All methods return a value of type \fBmemcached_return_t\fP.
On success the value will be \fBMEMCACHED_SUCCESS\fP.
Use memcached_strerror() to translate this value to a printable string.
-.sp
-For memcached_replace() and memcached_add(), \fBMEMCACHED_NOTSTORED\fP is a
-legitmate error in the case of a collision.
.SH HOME
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
.SH SEE ALSO
.sp
-memcached(1) libmemached(3) memcached_strerror(3)
+memcached(1) libmemached(3) memcached_strerror(3) memcached_set(3) memcached_add(3) memcached_cas(3) memcached_replace(3)
.SH AUTHOR
Brian Aker
.SH COPYRIGHT
-.TH "MEMCACHED_QUIT" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_QUIT" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_quit \- libmemcached Documentation
.
-.TH "MEMCACHED_REPLACE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_REPLACE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_replace \- Storing and Replacing Data
.
..
.\" Man page generated from reStructeredText.
.
-.sp
-Store value on server
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.UNINDENT
.INDENT 0.0
.TP
-.B memcached_return_t memcached_prepend(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_append(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_cas(memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_set_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
.INDENT 0.0
.TP
.B memcached_return_t memcached_replace_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_prepend_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_append_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_cas_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
.sp
Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
memcached_set(), memcached_add(), and memcached_replace() are all used to
store information on the server. All methods take a key, and its length to
-store the object. Keys are currently limited to 250 characters by the
-memcached(1) server. You must also supply a value and a length. Optionally you
-may tests an expiration time for the object and a 16 byte value (it is
-meant to be used as a bitmap).
+store the object. Keys are currently limited to 250 characters when using either a version of memcached(1) which is 1.4 or below, or when using the text protocol.
+You must supply both a value and a length. Optionally you
+may test an expiration time for the object and a 16 byte value (it is
+meant to be used as a bitmap). "flags" is a 4byte space that is stored alongside of the main value. Many sub libraries make use of this field, so in most cases users should avoid making use of it.
.sp
memcached_set() will write an object to the server. If an object already
exists it will overwrite what is in the server. If the object does not exist
memcached_add() adds an object to the server. If the object is found on the
server an error occurs, otherwise the value is stored.
.sp
-memcached_prepend() places a segment of data before the last piece of data
-stored. Currently expiration and key are not used in the server.
-.sp
-memcached_append() places a segment of data at the end of the last piece of
-data stored. Currently expiration and key are not used in the server.
-.sp
memcached_cas() overwrites data in the server as long as the "cas" value is
still the same in the server. You can get the cas value of a result by
calling memcached_result_cas() on a memcached_result_st(3) structure. At the point
for it in libmemcached(3) is optional. Please see memcached_set() for
information on how to do this.
.sp
-memcached_set_by_key(), memcached_add_by_key(), memcached_replace_by_key(),
-memcached_prepend_by_key(), memcached_append_by_key_by_key(),
-memcached_cas_by_key() methods all behave in a similar method as the non key
+memcached_set_by_key(), memcached_add_by_key(), and memcached_replace_by_key()
+methods all behave in a similar method as the non key
methods. The difference is that they use their group_key parameter to map
objects to particular servers.
.sp
If you are looking for performance, memcached_set() with non\-blocking IO is
the fastest way to store data on the server.
.sp
-All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. But when using these operations with this behavior on, there
+All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. However, when using these operations with this behavior on, there
are limits to the size of the payload being sent to the server. The reason for
-these limits is that the Memcahed Server does not allow multi\-datagram requests
+these limits is that the Memcached Server does not allow multi\-datagram requests
and the current server implementation sets a datagram size to 1400 bytes. Due
to protocol overhead, the actual limit of the user supplied data is less than
-1400 bytes and depends on the protocol in use as well as the operation being
+1400 bytes and depends on the protocol in use as, well as the operation being
executed. When running with the binary protocol, \(ga\(ga MEMCACHED_BEHAVIOR_BINARY_PROTOCOL\(ga\(ga,
the size of the key,value, flags and expiry combined may not exceed 1368 bytes.
When running with the ASCII protocol, the exact limit fluctuates depending on
\fI\%http://libmemcached.org/\fP
.SH SEE ALSO
.sp
-memcached(1) libmemached(3) memcached_strerror(3)
+memcached(1) libmemached(3) memcached_strerror(3) memcached_prepend(3) memcached_cas(3) memcached_append(3)
.SH AUTHOR
Brian Aker
.SH COPYRIGHT
-.TH "MEMCACHED_REPLACE_BY_KEY" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_REPLACE_BY_KEY" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_replace_by_key \- Storing and Replacing Data
.
..
.\" Man page generated from reStructeredText.
.
-.sp
-Store value on server
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.UNINDENT
.INDENT 0.0
.TP
-.B memcached_return_t memcached_prepend(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_append(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_cas(memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_set_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
.INDENT 0.0
.TP
.B memcached_return_t memcached_replace_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_prepend_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_append_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_cas_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
.sp
Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
memcached_set(), memcached_add(), and memcached_replace() are all used to
store information on the server. All methods take a key, and its length to
-store the object. Keys are currently limited to 250 characters by the
-memcached(1) server. You must also supply a value and a length. Optionally you
-may tests an expiration time for the object and a 16 byte value (it is
-meant to be used as a bitmap).
+store the object. Keys are currently limited to 250 characters when using either a version of memcached(1) which is 1.4 or below, or when using the text protocol.
+You must supply both a value and a length. Optionally you
+may test an expiration time for the object and a 16 byte value (it is
+meant to be used as a bitmap). "flags" is a 4byte space that is stored alongside of the main value. Many sub libraries make use of this field, so in most cases users should avoid making use of it.
.sp
memcached_set() will write an object to the server. If an object already
exists it will overwrite what is in the server. If the object does not exist
memcached_add() adds an object to the server. If the object is found on the
server an error occurs, otherwise the value is stored.
.sp
-memcached_prepend() places a segment of data before the last piece of data
-stored. Currently expiration and key are not used in the server.
-.sp
-memcached_append() places a segment of data at the end of the last piece of
-data stored. Currently expiration and key are not used in the server.
-.sp
memcached_cas() overwrites data in the server as long as the "cas" value is
still the same in the server. You can get the cas value of a result by
calling memcached_result_cas() on a memcached_result_st(3) structure. At the point
for it in libmemcached(3) is optional. Please see memcached_set() for
information on how to do this.
.sp
-memcached_set_by_key(), memcached_add_by_key(), memcached_replace_by_key(),
-memcached_prepend_by_key(), memcached_append_by_key_by_key(),
-memcached_cas_by_key() methods all behave in a similar method as the non key
+memcached_set_by_key(), memcached_add_by_key(), and memcached_replace_by_key()
+methods all behave in a similar method as the non key
methods. The difference is that they use their group_key parameter to map
objects to particular servers.
.sp
If you are looking for performance, memcached_set() with non\-blocking IO is
the fastest way to store data on the server.
.sp
-All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. But when using these operations with this behavior on, there
+All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. However, when using these operations with this behavior on, there
are limits to the size of the payload being sent to the server. The reason for
-these limits is that the Memcahed Server does not allow multi\-datagram requests
+these limits is that the Memcached Server does not allow multi\-datagram requests
and the current server implementation sets a datagram size to 1400 bytes. Due
to protocol overhead, the actual limit of the user supplied data is less than
-1400 bytes and depends on the protocol in use as well as the operation being
+1400 bytes and depends on the protocol in use as, well as the operation being
executed. When running with the binary protocol, \(ga\(ga MEMCACHED_BEHAVIOR_BINARY_PROTOCOL\(ga\(ga,
the size of the key,value, flags and expiry combined may not exceed 1368 bytes.
When running with the ASCII protocol, the exact limit fluctuates depending on
\fI\%http://libmemcached.org/\fP
.SH SEE ALSO
.sp
-memcached(1) libmemached(3) memcached_strerror(3)
+memcached(1) libmemached(3) memcached_strerror(3) memcached_prepend(3) memcached_cas(3) memcached_append(3)
.SH AUTHOR
Brian Aker
.SH COPYRIGHT
-.TH "MEMCACHED_RESULT_CAS" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_RESULT_CAS" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_result_cas \- Working with result sets
.
.
.sp
Work with memcached_result_st
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/memcached.h>
-
-memcached_result_st *
- memcached_result_create (memcached_st *ptr,
- memcached_result_st *result);
-
-void memcached_result_free (memcached_result_st *result);
-
-const char * memcached_result_key_value (memcached_result_st *result);
-
-size_t memcached_result_key_length (const memcached_result_st *result);
-
-const char *memcached_result_value (memcached_result_st *ptr);
-
-size_t memcached_result_length (const memcached_result_st *ptr);
-
-uint32_t memcached_result_flags (const memcached_result_st *result)
-
-uint64_t memcached_result_cas (const memcached_result_st *result);
-
-memcached_return_t
- memcached_result_set_value (memcached_result_st *ptr,
- const char *value, size_t length)
-
-void memcached_result_set_flags (memcached_result_st *ptr, uint32_t flags)
-
-void memcached_result_set_expiration (memcached_result_st *ptr, time_t)
-.ft P
-.fi
+#include <libmemcached/memcached_pool.h>
+.INDENT 0.0
+.TP
+.B memcached_result_st * memcached_result_create (memcached_st *ptr, memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_free (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char * memcached_result_key_value (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_key_length (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char *memcached_result_value (memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_length (const memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t memcached_result_flags(const memcached_result_st\fI\ *result\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint64_t memcached_result_cas (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_result_set_value(memcached_result_st\fI\ *ptr\fP, const char\fI\ *value\fP, size_t\fI\ length\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_flags(memcached_result_st\fI\ *ptr\fP, uint32_t\fI\ flags\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_expiration(memcached_result_st\fI\ *ptr\fP, time_t)
+.UNINDENT
+.sp
+Compile and link with \-lmemcachedutil \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) can optionally return a memcached_result_st which acts as a
result object. The result objects have added benefits over the character
-pointer returns in that they are forward compatible with new return items
+pointer returns, in that they are forward compatible with new return items
that future memcached servers may implement (the best current example of
-this is the CAS return item). The structures can also be reused which will
+this is the CAS return item). The structures can also be reused, which will
save on calls to malloc(3). It is suggested that you use result objects over
char * return functions.
.sp
memcached_result_st or will initialize a structure passed to it.
.sp
memcached_result_free() will deallocate any memory attached to the
-structure. If the structure was also alloacted, it will deallocate it.
+structure. If the structure was also allocated, it will deallocate it.
.sp
memcached_result_key_value() returns the key value associated with the
current result object.
.sp
memcached_result_cas() returns the cas associated with the
current result object. This value will only be available if the server
-testss it.
+tests it.
.sp
memcached_result_set_value() takes a byte array and a size and sets
the result to this value. This function is used for trigger responses.
-.TH "MEMCACHED_RESULT_CREATE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_RESULT_CREATE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_result_create \- Working with result sets
.
.
.sp
Work with memcached_result_st
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/memcached.h>
-
-memcached_result_st *
- memcached_result_create (memcached_st *ptr,
- memcached_result_st *result);
-
-void memcached_result_free (memcached_result_st *result);
-
-const char * memcached_result_key_value (memcached_result_st *result);
-
-size_t memcached_result_key_length (const memcached_result_st *result);
-
-const char *memcached_result_value (memcached_result_st *ptr);
-
-size_t memcached_result_length (const memcached_result_st *ptr);
-
-uint32_t memcached_result_flags (const memcached_result_st *result)
-
-uint64_t memcached_result_cas (const memcached_result_st *result);
-
-memcached_return_t
- memcached_result_set_value (memcached_result_st *ptr,
- const char *value, size_t length)
-
-void memcached_result_set_flags (memcached_result_st *ptr, uint32_t flags)
-
-void memcached_result_set_expiration (memcached_result_st *ptr, time_t)
-.ft P
-.fi
+#include <libmemcached/memcached_pool.h>
+.INDENT 0.0
+.TP
+.B memcached_result_st * memcached_result_create (memcached_st *ptr, memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_free (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char * memcached_result_key_value (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_key_length (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char *memcached_result_value (memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_length (const memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t memcached_result_flags(const memcached_result_st\fI\ *result\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint64_t memcached_result_cas (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_result_set_value(memcached_result_st\fI\ *ptr\fP, const char\fI\ *value\fP, size_t\fI\ length\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_flags(memcached_result_st\fI\ *ptr\fP, uint32_t\fI\ flags\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_expiration(memcached_result_st\fI\ *ptr\fP, time_t)
+.UNINDENT
+.sp
+Compile and link with \-lmemcachedutil \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) can optionally return a memcached_result_st which acts as a
result object. The result objects have added benefits over the character
-pointer returns in that they are forward compatible with new return items
+pointer returns, in that they are forward compatible with new return items
that future memcached servers may implement (the best current example of
-this is the CAS return item). The structures can also be reused which will
+this is the CAS return item). The structures can also be reused, which will
save on calls to malloc(3). It is suggested that you use result objects over
char * return functions.
.sp
memcached_result_st or will initialize a structure passed to it.
.sp
memcached_result_free() will deallocate any memory attached to the
-structure. If the structure was also alloacted, it will deallocate it.
+structure. If the structure was also allocated, it will deallocate it.
.sp
memcached_result_key_value() returns the key value associated with the
current result object.
.sp
memcached_result_cas() returns the cas associated with the
current result object. This value will only be available if the server
-testss it.
+tests it.
.sp
memcached_result_set_value() takes a byte array and a size and sets
the result to this value. This function is used for trigger responses.
-.TH "MEMCACHED_RESULT_FLAGS" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_RESULT_FLAGS" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_result_flags \- Working with result sets
.
.
.sp
Work with memcached_result_st
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/memcached.h>
-
-memcached_result_st *
- memcached_result_create (memcached_st *ptr,
- memcached_result_st *result);
-
-void memcached_result_free (memcached_result_st *result);
-
-const char * memcached_result_key_value (memcached_result_st *result);
-
-size_t memcached_result_key_length (const memcached_result_st *result);
-
-const char *memcached_result_value (memcached_result_st *ptr);
-
-size_t memcached_result_length (const memcached_result_st *ptr);
-
-uint32_t memcached_result_flags (const memcached_result_st *result)
-
-uint64_t memcached_result_cas (const memcached_result_st *result);
-
-memcached_return_t
- memcached_result_set_value (memcached_result_st *ptr,
- const char *value, size_t length)
-
-void memcached_result_set_flags (memcached_result_st *ptr, uint32_t flags)
-
-void memcached_result_set_expiration (memcached_result_st *ptr, time_t)
-.ft P
-.fi
+#include <libmemcached/memcached_pool.h>
+.INDENT 0.0
+.TP
+.B memcached_result_st * memcached_result_create (memcached_st *ptr, memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_free (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char * memcached_result_key_value (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_key_length (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char *memcached_result_value (memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_length (const memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t memcached_result_flags(const memcached_result_st\fI\ *result\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint64_t memcached_result_cas (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_result_set_value(memcached_result_st\fI\ *ptr\fP, const char\fI\ *value\fP, size_t\fI\ length\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_flags(memcached_result_st\fI\ *ptr\fP, uint32_t\fI\ flags\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_expiration(memcached_result_st\fI\ *ptr\fP, time_t)
+.UNINDENT
+.sp
+Compile and link with \-lmemcachedutil \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) can optionally return a memcached_result_st which acts as a
result object. The result objects have added benefits over the character
-pointer returns in that they are forward compatible with new return items
+pointer returns, in that they are forward compatible with new return items
that future memcached servers may implement (the best current example of
-this is the CAS return item). The structures can also be reused which will
+this is the CAS return item). The structures can also be reused, which will
save on calls to malloc(3). It is suggested that you use result objects over
char * return functions.
.sp
memcached_result_st or will initialize a structure passed to it.
.sp
memcached_result_free() will deallocate any memory attached to the
-structure. If the structure was also alloacted, it will deallocate it.
+structure. If the structure was also allocated, it will deallocate it.
.sp
memcached_result_key_value() returns the key value associated with the
current result object.
.sp
memcached_result_cas() returns the cas associated with the
current result object. This value will only be available if the server
-testss it.
+tests it.
.sp
memcached_result_set_value() takes a byte array and a size and sets
the result to this value. This function is used for trigger responses.
-.TH "MEMCACHED_RESULT_FREE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_RESULT_FREE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_result_free \- Working with result sets
.
.
.sp
Work with memcached_result_st
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/memcached.h>
-
-memcached_result_st *
- memcached_result_create (memcached_st *ptr,
- memcached_result_st *result);
-
-void memcached_result_free (memcached_result_st *result);
-
-const char * memcached_result_key_value (memcached_result_st *result);
-
-size_t memcached_result_key_length (const memcached_result_st *result);
-
-const char *memcached_result_value (memcached_result_st *ptr);
-
-size_t memcached_result_length (const memcached_result_st *ptr);
-
-uint32_t memcached_result_flags (const memcached_result_st *result)
-
-uint64_t memcached_result_cas (const memcached_result_st *result);
-
-memcached_return_t
- memcached_result_set_value (memcached_result_st *ptr,
- const char *value, size_t length)
-
-void memcached_result_set_flags (memcached_result_st *ptr, uint32_t flags)
-
-void memcached_result_set_expiration (memcached_result_st *ptr, time_t)
-.ft P
-.fi
+#include <libmemcached/memcached_pool.h>
+.INDENT 0.0
+.TP
+.B memcached_result_st * memcached_result_create (memcached_st *ptr, memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_free (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char * memcached_result_key_value (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_key_length (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char *memcached_result_value (memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_length (const memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t memcached_result_flags(const memcached_result_st\fI\ *result\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint64_t memcached_result_cas (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_result_set_value(memcached_result_st\fI\ *ptr\fP, const char\fI\ *value\fP, size_t\fI\ length\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_flags(memcached_result_st\fI\ *ptr\fP, uint32_t\fI\ flags\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_expiration(memcached_result_st\fI\ *ptr\fP, time_t)
+.UNINDENT
+.sp
+Compile and link with \-lmemcachedutil \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) can optionally return a memcached_result_st which acts as a
result object. The result objects have added benefits over the character
-pointer returns in that they are forward compatible with new return items
+pointer returns, in that they are forward compatible with new return items
that future memcached servers may implement (the best current example of
-this is the CAS return item). The structures can also be reused which will
+this is the CAS return item). The structures can also be reused, which will
save on calls to malloc(3). It is suggested that you use result objects over
char * return functions.
.sp
memcached_result_st or will initialize a structure passed to it.
.sp
memcached_result_free() will deallocate any memory attached to the
-structure. If the structure was also alloacted, it will deallocate it.
+structure. If the structure was also allocated, it will deallocate it.
.sp
memcached_result_key_value() returns the key value associated with the
current result object.
.sp
memcached_result_cas() returns the cas associated with the
current result object. This value will only be available if the server
-testss it.
+tests it.
.sp
memcached_result_set_value() takes a byte array and a size and sets
the result to this value. This function is used for trigger responses.
-.TH "MEMCACHED_RESULT_KEY_LENGTH" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_RESULT_KEY_LENGTH" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_result_key_length \- Working with result sets
.
.
.sp
Work with memcached_result_st
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/memcached.h>
-
-memcached_result_st *
- memcached_result_create (memcached_st *ptr,
- memcached_result_st *result);
-
-void memcached_result_free (memcached_result_st *result);
-
-const char * memcached_result_key_value (memcached_result_st *result);
-
-size_t memcached_result_key_length (const memcached_result_st *result);
-
-const char *memcached_result_value (memcached_result_st *ptr);
-
-size_t memcached_result_length (const memcached_result_st *ptr);
-
-uint32_t memcached_result_flags (const memcached_result_st *result)
-
-uint64_t memcached_result_cas (const memcached_result_st *result);
-
-memcached_return_t
- memcached_result_set_value (memcached_result_st *ptr,
- const char *value, size_t length)
-
-void memcached_result_set_flags (memcached_result_st *ptr, uint32_t flags)
-
-void memcached_result_set_expiration (memcached_result_st *ptr, time_t)
-.ft P
-.fi
+#include <libmemcached/memcached_pool.h>
+.INDENT 0.0
+.TP
+.B memcached_result_st * memcached_result_create (memcached_st *ptr, memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_free (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char * memcached_result_key_value (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_key_length (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char *memcached_result_value (memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_length (const memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t memcached_result_flags(const memcached_result_st\fI\ *result\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint64_t memcached_result_cas (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_result_set_value(memcached_result_st\fI\ *ptr\fP, const char\fI\ *value\fP, size_t\fI\ length\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_flags(memcached_result_st\fI\ *ptr\fP, uint32_t\fI\ flags\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_expiration(memcached_result_st\fI\ *ptr\fP, time_t)
+.UNINDENT
+.sp
+Compile and link with \-lmemcachedutil \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) can optionally return a memcached_result_st which acts as a
result object. The result objects have added benefits over the character
-pointer returns in that they are forward compatible with new return items
+pointer returns, in that they are forward compatible with new return items
that future memcached servers may implement (the best current example of
-this is the CAS return item). The structures can also be reused which will
+this is the CAS return item). The structures can also be reused, which will
save on calls to malloc(3). It is suggested that you use result objects over
char * return functions.
.sp
memcached_result_st or will initialize a structure passed to it.
.sp
memcached_result_free() will deallocate any memory attached to the
-structure. If the structure was also alloacted, it will deallocate it.
+structure. If the structure was also allocated, it will deallocate it.
.sp
memcached_result_key_value() returns the key value associated with the
current result object.
.sp
memcached_result_cas() returns the cas associated with the
current result object. This value will only be available if the server
-testss it.
+tests it.
.sp
memcached_result_set_value() takes a byte array and a size and sets
the result to this value. This function is used for trigger responses.
-.TH "MEMCACHED_RESULT_KEY_VALUE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_RESULT_KEY_VALUE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_result_key_value \- Working with result sets
.
.
.sp
Work with memcached_result_st
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/memcached.h>
-
-memcached_result_st *
- memcached_result_create (memcached_st *ptr,
- memcached_result_st *result);
-
-void memcached_result_free (memcached_result_st *result);
-
-const char * memcached_result_key_value (memcached_result_st *result);
-
-size_t memcached_result_key_length (const memcached_result_st *result);
-
-const char *memcached_result_value (memcached_result_st *ptr);
-
-size_t memcached_result_length (const memcached_result_st *ptr);
-
-uint32_t memcached_result_flags (const memcached_result_st *result)
-
-uint64_t memcached_result_cas (const memcached_result_st *result);
-
-memcached_return_t
- memcached_result_set_value (memcached_result_st *ptr,
- const char *value, size_t length)
-
-void memcached_result_set_flags (memcached_result_st *ptr, uint32_t flags)
-
-void memcached_result_set_expiration (memcached_result_st *ptr, time_t)
-.ft P
-.fi
+#include <libmemcached/memcached_pool.h>
+.INDENT 0.0
+.TP
+.B memcached_result_st * memcached_result_create (memcached_st *ptr, memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_free (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char * memcached_result_key_value (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_key_length (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char *memcached_result_value (memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_length (const memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t memcached_result_flags(const memcached_result_st\fI\ *result\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint64_t memcached_result_cas (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_result_set_value(memcached_result_st\fI\ *ptr\fP, const char\fI\ *value\fP, size_t\fI\ length\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_flags(memcached_result_st\fI\ *ptr\fP, uint32_t\fI\ flags\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_expiration(memcached_result_st\fI\ *ptr\fP, time_t)
+.UNINDENT
+.sp
+Compile and link with \-lmemcachedutil \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) can optionally return a memcached_result_st which acts as a
result object. The result objects have added benefits over the character
-pointer returns in that they are forward compatible with new return items
+pointer returns, in that they are forward compatible with new return items
that future memcached servers may implement (the best current example of
-this is the CAS return item). The structures can also be reused which will
+this is the CAS return item). The structures can also be reused, which will
save on calls to malloc(3). It is suggested that you use result objects over
char * return functions.
.sp
memcached_result_st or will initialize a structure passed to it.
.sp
memcached_result_free() will deallocate any memory attached to the
-structure. If the structure was also alloacted, it will deallocate it.
+structure. If the structure was also allocated, it will deallocate it.
.sp
memcached_result_key_value() returns the key value associated with the
current result object.
.sp
memcached_result_cas() returns the cas associated with the
current result object. This value will only be available if the server
-testss it.
+tests it.
.sp
memcached_result_set_value() takes a byte array and a size and sets
the result to this value. This function is used for trigger responses.
-.TH "MEMCACHED_RESULT_LENGTH" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_RESULT_LENGTH" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_result_length \- Working with result sets
.
.
.sp
Work with memcached_result_st
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/memcached.h>
-
-memcached_result_st *
- memcached_result_create (memcached_st *ptr,
- memcached_result_st *result);
-
-void memcached_result_free (memcached_result_st *result);
-
-const char * memcached_result_key_value (memcached_result_st *result);
-
-size_t memcached_result_key_length (const memcached_result_st *result);
-
-const char *memcached_result_value (memcached_result_st *ptr);
-
-size_t memcached_result_length (const memcached_result_st *ptr);
-
-uint32_t memcached_result_flags (const memcached_result_st *result)
-
-uint64_t memcached_result_cas (const memcached_result_st *result);
-
-memcached_return_t
- memcached_result_set_value (memcached_result_st *ptr,
- const char *value, size_t length)
-
-void memcached_result_set_flags (memcached_result_st *ptr, uint32_t flags)
-
-void memcached_result_set_expiration (memcached_result_st *ptr, time_t)
-.ft P
-.fi
+#include <libmemcached/memcached_pool.h>
+.INDENT 0.0
+.TP
+.B memcached_result_st * memcached_result_create (memcached_st *ptr, memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_free (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char * memcached_result_key_value (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_key_length (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char *memcached_result_value (memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_length (const memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t memcached_result_flags(const memcached_result_st\fI\ *result\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint64_t memcached_result_cas (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_result_set_value(memcached_result_st\fI\ *ptr\fP, const char\fI\ *value\fP, size_t\fI\ length\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_flags(memcached_result_st\fI\ *ptr\fP, uint32_t\fI\ flags\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_expiration(memcached_result_st\fI\ *ptr\fP, time_t)
+.UNINDENT
+.sp
+Compile and link with \-lmemcachedutil \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) can optionally return a memcached_result_st which acts as a
result object. The result objects have added benefits over the character
-pointer returns in that they are forward compatible with new return items
+pointer returns, in that they are forward compatible with new return items
that future memcached servers may implement (the best current example of
-this is the CAS return item). The structures can also be reused which will
+this is the CAS return item). The structures can also be reused, which will
save on calls to malloc(3). It is suggested that you use result objects over
char * return functions.
.sp
memcached_result_st or will initialize a structure passed to it.
.sp
memcached_result_free() will deallocate any memory attached to the
-structure. If the structure was also alloacted, it will deallocate it.
+structure. If the structure was also allocated, it will deallocate it.
.sp
memcached_result_key_value() returns the key value associated with the
current result object.
.sp
memcached_result_cas() returns the cas associated with the
current result object. This value will only be available if the server
-testss it.
+tests it.
.sp
memcached_result_set_value() takes a byte array and a size and sets
the result to this value. This function is used for trigger responses.
-.TH "MEMCACHED_RESULT_ST" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_RESULT_ST" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_result_st \- Working with result sets
.
.
.sp
Work with memcached_result_st
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/memcached.h>
-
-memcached_result_st *
- memcached_result_create (memcached_st *ptr,
- memcached_result_st *result);
-
-void memcached_result_free (memcached_result_st *result);
-
-const char * memcached_result_key_value (memcached_result_st *result);
-
-size_t memcached_result_key_length (const memcached_result_st *result);
-
-const char *memcached_result_value (memcached_result_st *ptr);
-
-size_t memcached_result_length (const memcached_result_st *ptr);
-
-uint32_t memcached_result_flags (const memcached_result_st *result)
-
-uint64_t memcached_result_cas (const memcached_result_st *result);
-
-memcached_return_t
- memcached_result_set_value (memcached_result_st *ptr,
- const char *value, size_t length)
-
-void memcached_result_set_flags (memcached_result_st *ptr, uint32_t flags)
-
-void memcached_result_set_expiration (memcached_result_st *ptr, time_t)
-.ft P
-.fi
+#include <libmemcached/memcached_pool.h>
+.INDENT 0.0
+.TP
+.B memcached_result_st * memcached_result_create (memcached_st *ptr, memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_free (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char * memcached_result_key_value (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_key_length (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char *memcached_result_value (memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_length (const memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t memcached_result_flags(const memcached_result_st\fI\ *result\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint64_t memcached_result_cas (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_result_set_value(memcached_result_st\fI\ *ptr\fP, const char\fI\ *value\fP, size_t\fI\ length\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_flags(memcached_result_st\fI\ *ptr\fP, uint32_t\fI\ flags\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_expiration(memcached_result_st\fI\ *ptr\fP, time_t)
+.UNINDENT
+.sp
+Compile and link with \-lmemcachedutil \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) can optionally return a memcached_result_st which acts as a
result object. The result objects have added benefits over the character
-pointer returns in that they are forward compatible with new return items
+pointer returns, in that they are forward compatible with new return items
that future memcached servers may implement (the best current example of
-this is the CAS return item). The structures can also be reused which will
+this is the CAS return item). The structures can also be reused, which will
save on calls to malloc(3). It is suggested that you use result objects over
char * return functions.
.sp
memcached_result_st or will initialize a structure passed to it.
.sp
memcached_result_free() will deallocate any memory attached to the
-structure. If the structure was also alloacted, it will deallocate it.
+structure. If the structure was also allocated, it will deallocate it.
.sp
memcached_result_key_value() returns the key value associated with the
current result object.
.sp
memcached_result_cas() returns the cas associated with the
current result object. This value will only be available if the server
-testss it.
+tests it.
.sp
memcached_result_set_value() takes a byte array and a size and sets
the result to this value. This function is used for trigger responses.
-.TH "MEMCACHED_RESULT_VALUE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_RESULT_VALUE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_result_value \- Working with result sets
.
.
.sp
Work with memcached_result_st
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/memcached.h>
-
-memcached_result_st *
- memcached_result_create (memcached_st *ptr,
- memcached_result_st *result);
-
-void memcached_result_free (memcached_result_st *result);
-
-const char * memcached_result_key_value (memcached_result_st *result);
-
-size_t memcached_result_key_length (const memcached_result_st *result);
-
-const char *memcached_result_value (memcached_result_st *ptr);
-
-size_t memcached_result_length (const memcached_result_st *ptr);
-
-uint32_t memcached_result_flags (const memcached_result_st *result)
-
-uint64_t memcached_result_cas (const memcached_result_st *result);
-
-memcached_return_t
- memcached_result_set_value (memcached_result_st *ptr,
- const char *value, size_t length)
-
-void memcached_result_set_flags (memcached_result_st *ptr, uint32_t flags)
-
-void memcached_result_set_expiration (memcached_result_st *ptr, time_t)
-.ft P
-.fi
+#include <libmemcached/memcached_pool.h>
+.INDENT 0.0
+.TP
+.B memcached_result_st * memcached_result_create (memcached_st *ptr, memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_free (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char * memcached_result_key_value (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_key_length (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char *memcached_result_value (memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_length (const memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t memcached_result_flags(const memcached_result_st\fI\ *result\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint64_t memcached_result_cas (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_result_set_value(memcached_result_st\fI\ *ptr\fP, const char\fI\ *value\fP, size_t\fI\ length\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_flags(memcached_result_st\fI\ *ptr\fP, uint32_t\fI\ flags\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_expiration(memcached_result_st\fI\ *ptr\fP, time_t)
+.UNINDENT
+.sp
+Compile and link with \-lmemcachedutil \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) can optionally return a memcached_result_st which acts as a
result object. The result objects have added benefits over the character
-pointer returns in that they are forward compatible with new return items
+pointer returns, in that they are forward compatible with new return items
that future memcached servers may implement (the best current example of
-this is the CAS return item). The structures can also be reused which will
+this is the CAS return item). The structures can also be reused, which will
save on calls to malloc(3). It is suggested that you use result objects over
char * return functions.
.sp
memcached_result_st or will initialize a structure passed to it.
.sp
memcached_result_free() will deallocate any memory attached to the
-structure. If the structure was also alloacted, it will deallocate it.
+structure. If the structure was also allocated, it will deallocate it.
.sp
memcached_result_key_value() returns the key value associated with the
current result object.
.sp
memcached_result_cas() returns the cas associated with the
current result object. This value will only be available if the server
-testss it.
+tests it.
.sp
memcached_result_set_value() takes a byte array and a size and sets
the result to this value. This function is used for trigger responses.
-.TH "MEMCACHED_SASL" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SASL" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_sasl \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/memcached.h>
-
-void memcached_set_sasl_callbacks(memcached_st *ptr,
- const sasl_callback_t *callbacks)
-
-const sasl_callback_t *memcached_get_sasl_callbacks(memcached_st *ptr)
-
-memcached_return memcached_set_sasl_auth_data(memcached_st *ptr,
- const char *username,
- const char *password)
-memcached_return memcached_destroy_sasl_auth_data(memcached_st *ptr)
-.ft P
-.fi
+#include <libmemcached/memcached_pool.h>
+.INDENT 0.0
+.TP
+.B void memcached_set_sasl_callbacks(memcached_st\fI\ *ptr\fP, const sasl_callback_t\fI\ *callbacks\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const sasl_callback_t *memcached_get_sasl_callbacks(memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return memcached_set_sasl_auth_data(memcached_st\fI\ *ptr\fP, const char\fI\ *username\fP, const char\fI\ *password\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return memcached_destroy_sasl_auth_data(memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) allows you to plug in your own callbacks function used by
Please note that SASL requires the memcached binary protocol, and you have
to specify the callbacks before you connect to the server.
.sp
-memcached_set_sasl_auth_data() is a helper function for you defining
+memcached_set_sasl_auth_data() is a helper function defining
the basic functionality for you, but it will store the username and password
in memory. If you choose to use this method you have to call
memcached_destroy_sasl_auth_data before calling memcached_free to avoid
-.TH "MEMCACHED_SASL_SET_AUTH_DATA" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SASL_SET_AUTH_DATA" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_sasl_set_auth_data \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/memcached.h>
-
-void memcached_set_sasl_callbacks(memcached_st *ptr,
- const sasl_callback_t *callbacks)
-
-const sasl_callback_t *memcached_get_sasl_callbacks(memcached_st *ptr)
-
-memcached_return memcached_set_sasl_auth_data(memcached_st *ptr,
- const char *username,
- const char *password)
-memcached_return memcached_destroy_sasl_auth_data(memcached_st *ptr)
-.ft P
-.fi
+#include <libmemcached/memcached_pool.h>
+.INDENT 0.0
+.TP
+.B void memcached_set_sasl_callbacks(memcached_st\fI\ *ptr\fP, const sasl_callback_t\fI\ *callbacks\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const sasl_callback_t *memcached_get_sasl_callbacks(memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return memcached_set_sasl_auth_data(memcached_st\fI\ *ptr\fP, const char\fI\ *username\fP, const char\fI\ *password\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return memcached_destroy_sasl_auth_data(memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) allows you to plug in your own callbacks function used by
Please note that SASL requires the memcached binary protocol, and you have
to specify the callbacks before you connect to the server.
.sp
-memcached_set_sasl_auth_data() is a helper function for you defining
+memcached_set_sasl_auth_data() is a helper function defining
the basic functionality for you, but it will store the username and password
in memory. If you choose to use this method you have to call
memcached_destroy_sasl_auth_data before calling memcached_free to avoid
-.TH "MEMCACHED_SERVER_ADD" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SERVER_ADD" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_server_add \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
+.SH SYNOPSIS
.sp
-Manage server list
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-uint32_t memcached_server_count (memcached_st *ptr);
-
-memcached_return_t memcached_server_add (memcached_st *ptr, const char *hostname, in_port_t port);
-
-memcached_return_t memcached_server_add_udp (memcached_st *ptr, const char *hostname, in_port_t port);
-
-memcached_return_t memcached_server_add_unix_socket (memcached_st *ptr, const char *socket);
-
-memcached_return_t memcached_server_push (memcached_st *ptr, const memcached_server_st *list);
-
-memcached_server_instance_st memcached_server_by_key (const memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error);
-
-memcached_server_instance_st memcached_server_get_last_disconnect (const memcached_st *ptr)
-
-memcached_return_t memcached_server_cursor(const memcached_st *ptr, const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks);
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B uint32_t memcached_server_count (memcached_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add (memcached_st *ptr, const char *hostname, in_port_t port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add_udp (memcached_st *ptr, const char *hostname, in_port_t port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add_unix_socket (memcached_st *ptr, const char *socket);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_push (memcached_st *ptr, const memcached_server_st *list);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_server_instance_st memcached_server_by_key (const memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_server_instance_st memcached_server_get_last_disconnect(const memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_cursor(const memcached_st *ptr, const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks);
+.UNINDENT
+.sp
+compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
libmemcached(3) performs operations on a list of hosts. The order of these
hosts determine routing to keys. Functions are provided to add keys to
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
-.SS SEE ALSO
+.SH SEE ALSO
.sp
\fImemcached(1)\fP \fIlibmemcached(3)\fP \fImemcached_strerror(3)\fP
.SH AUTHOR
-.TH "MEMCACHED_SERVER_ADD_UNIX_SOCKET" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SERVER_ADD_UNIX_SOCKET" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_server_add_unix_socket \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
+.SH SYNOPSIS
.sp
-Manage server list
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-uint32_t memcached_server_count (memcached_st *ptr);
-
-memcached_return_t memcached_server_add (memcached_st *ptr, const char *hostname, in_port_t port);
-
-memcached_return_t memcached_server_add_udp (memcached_st *ptr, const char *hostname, in_port_t port);
-
-memcached_return_t memcached_server_add_unix_socket (memcached_st *ptr, const char *socket);
-
-memcached_return_t memcached_server_push (memcached_st *ptr, const memcached_server_st *list);
-
-memcached_server_instance_st memcached_server_by_key (const memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error);
-
-memcached_server_instance_st memcached_server_get_last_disconnect (const memcached_st *ptr)
-
-memcached_return_t memcached_server_cursor(const memcached_st *ptr, const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks);
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B uint32_t memcached_server_count (memcached_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add (memcached_st *ptr, const char *hostname, in_port_t port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add_udp (memcached_st *ptr, const char *hostname, in_port_t port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add_unix_socket (memcached_st *ptr, const char *socket);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_push (memcached_st *ptr, const memcached_server_st *list);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_server_instance_st memcached_server_by_key (const memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_server_instance_st memcached_server_get_last_disconnect(const memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_cursor(const memcached_st *ptr, const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks);
+.UNINDENT
+.sp
+compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
libmemcached(3) performs operations on a list of hosts. The order of these
hosts determine routing to keys. Functions are provided to add keys to
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
-.SS SEE ALSO
+.SH SEE ALSO
.sp
\fImemcached(1)\fP \fIlibmemcached(3)\fP \fImemcached_strerror(3)\fP
.SH AUTHOR
-.TH "MEMCACHED_SERVER_COUNT" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SERVER_COUNT" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_server_count \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
+.SH SYNOPSIS
.sp
-Manage server list
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-uint32_t memcached_server_count (memcached_st *ptr);
-
-memcached_return_t memcached_server_add (memcached_st *ptr, const char *hostname, in_port_t port);
-
-memcached_return_t memcached_server_add_udp (memcached_st *ptr, const char *hostname, in_port_t port);
-
-memcached_return_t memcached_server_add_unix_socket (memcached_st *ptr, const char *socket);
-
-memcached_return_t memcached_server_push (memcached_st *ptr, const memcached_server_st *list);
-
-memcached_server_instance_st memcached_server_by_key (const memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error);
-
-memcached_server_instance_st memcached_server_get_last_disconnect (const memcached_st *ptr)
-
-memcached_return_t memcached_server_cursor(const memcached_st *ptr, const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks);
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B uint32_t memcached_server_count (memcached_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add (memcached_st *ptr, const char *hostname, in_port_t port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add_udp (memcached_st *ptr, const char *hostname, in_port_t port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add_unix_socket (memcached_st *ptr, const char *socket);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_push (memcached_st *ptr, const memcached_server_st *list);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_server_instance_st memcached_server_by_key (const memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_server_instance_st memcached_server_get_last_disconnect(const memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_cursor(const memcached_st *ptr, const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks);
+.UNINDENT
+.sp
+compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
libmemcached(3) performs operations on a list of hosts. The order of these
hosts determine routing to keys. Functions are provided to add keys to
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
-.SS SEE ALSO
+.SH SEE ALSO
.sp
\fImemcached(1)\fP \fIlibmemcached(3)\fP \fImemcached_strerror(3)\fP
.SH AUTHOR
-.TH "MEMCACHED_SERVER_CURSOR" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SERVER_CURSOR" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_server_cursor \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
+.SH SYNOPSIS
.sp
-Manage server list
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-uint32_t memcached_server_count (memcached_st *ptr);
-
-memcached_return_t memcached_server_add (memcached_st *ptr, const char *hostname, in_port_t port);
-
-memcached_return_t memcached_server_add_udp (memcached_st *ptr, const char *hostname, in_port_t port);
-
-memcached_return_t memcached_server_add_unix_socket (memcached_st *ptr, const char *socket);
-
-memcached_return_t memcached_server_push (memcached_st *ptr, const memcached_server_st *list);
-
-memcached_server_instance_st memcached_server_by_key (const memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error);
-
-memcached_server_instance_st memcached_server_get_last_disconnect (const memcached_st *ptr)
-
-memcached_return_t memcached_server_cursor(const memcached_st *ptr, const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks);
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B uint32_t memcached_server_count (memcached_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add (memcached_st *ptr, const char *hostname, in_port_t port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add_udp (memcached_st *ptr, const char *hostname, in_port_t port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add_unix_socket (memcached_st *ptr, const char *socket);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_push (memcached_st *ptr, const memcached_server_st *list);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_server_instance_st memcached_server_by_key (const memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_server_instance_st memcached_server_get_last_disconnect(const memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_cursor(const memcached_st *ptr, const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks);
+.UNINDENT
+.sp
+compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
libmemcached(3) performs operations on a list of hosts. The order of these
hosts determine routing to keys. Functions are provided to add keys to
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
-.SS SEE ALSO
+.SH SEE ALSO
.sp
\fImemcached(1)\fP \fIlibmemcached(3)\fP \fImemcached_strerror(3)\fP
.SH AUTHOR
-.TH "MEMCACHED_SERVER_LIST" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SERVER_LIST" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_server_list \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
+.SH SYNOPSIS
.sp
-Manage server list
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-uint32_t memcached_server_count (memcached_st *ptr);
-
-memcached_return_t memcached_server_add (memcached_st *ptr, const char *hostname, in_port_t port);
-
-memcached_return_t memcached_server_add_udp (memcached_st *ptr, const char *hostname, in_port_t port);
-
-memcached_return_t memcached_server_add_unix_socket (memcached_st *ptr, const char *socket);
-
-memcached_return_t memcached_server_push (memcached_st *ptr, const memcached_server_st *list);
-
-memcached_server_instance_st memcached_server_by_key (const memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error);
-
-memcached_server_instance_st memcached_server_get_last_disconnect (const memcached_st *ptr)
-
-memcached_return_t memcached_server_cursor(const memcached_st *ptr, const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks);
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B uint32_t memcached_server_count (memcached_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add (memcached_st *ptr, const char *hostname, in_port_t port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add_udp (memcached_st *ptr, const char *hostname, in_port_t port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add_unix_socket (memcached_st *ptr, const char *socket);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_push (memcached_st *ptr, const memcached_server_st *list);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_server_instance_st memcached_server_by_key (const memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_server_instance_st memcached_server_get_last_disconnect(const memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_cursor(const memcached_st *ptr, const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks);
+.UNINDENT
+.sp
+compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
libmemcached(3) performs operations on a list of hosts. The order of these
hosts determine routing to keys. Functions are provided to add keys to
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
-.SS SEE ALSO
+.SH SEE ALSO
.sp
\fImemcached(1)\fP \fIlibmemcached(3)\fP \fImemcached_strerror(3)\fP
.SH AUTHOR
-.TH "MEMCACHED_SERVER_LIST_APPEND" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SERVER_LIST_APPEND" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_server_list_append \- libmemcached Documentation
.
-.TH "MEMCACHED_SERVER_LIST_COUNT" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SERVER_LIST_COUNT" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_server_list_count \- libmemcached Documentation
.
-.TH "MEMCACHED_SERVER_LIST_FREE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SERVER_LIST_FREE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_server_list_free \- libmemcached Documentation
.
-.TH "MEMCACHED_SERVER_PUSH" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SERVER_PUSH" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_server_push \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
+.SH SYNOPSIS
.sp
-Manage server list
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-uint32_t memcached_server_count (memcached_st *ptr);
-
-memcached_return_t memcached_server_add (memcached_st *ptr, const char *hostname, in_port_t port);
-
-memcached_return_t memcached_server_add_udp (memcached_st *ptr, const char *hostname, in_port_t port);
-
-memcached_return_t memcached_server_add_unix_socket (memcached_st *ptr, const char *socket);
-
-memcached_return_t memcached_server_push (memcached_st *ptr, const memcached_server_st *list);
-
-memcached_server_instance_st memcached_server_by_key (const memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error);
-
-memcached_server_instance_st memcached_server_get_last_disconnect (const memcached_st *ptr)
-
-memcached_return_t memcached_server_cursor(const memcached_st *ptr, const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks);
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B uint32_t memcached_server_count (memcached_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add (memcached_st *ptr, const char *hostname, in_port_t port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add_udp (memcached_st *ptr, const char *hostname, in_port_t port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add_unix_socket (memcached_st *ptr, const char *socket);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_push (memcached_st *ptr, const memcached_server_st *list);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_server_instance_st memcached_server_by_key (const memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_server_instance_st memcached_server_get_last_disconnect(const memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_cursor(const memcached_st *ptr, const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks);
+.UNINDENT
+.sp
+compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
libmemcached(3) performs operations on a list of hosts. The order of these
hosts determine routing to keys. Functions are provided to add keys to
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
-.SS SEE ALSO
+.SH SEE ALSO
.sp
\fImemcached(1)\fP \fIlibmemcached(3)\fP \fImemcached_strerror(3)\fP
.SH AUTHOR
-.TH "MEMCACHED_SERVER_ST" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SERVER_ST" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_server_st \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
+.SH SYNOPSIS
.sp
-Manage server list
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-uint32_t memcached_server_count (memcached_st *ptr);
-
-memcached_return_t memcached_server_add (memcached_st *ptr, const char *hostname, in_port_t port);
-
-memcached_return_t memcached_server_add_udp (memcached_st *ptr, const char *hostname, in_port_t port);
-
-memcached_return_t memcached_server_add_unix_socket (memcached_st *ptr, const char *socket);
-
-memcached_return_t memcached_server_push (memcached_st *ptr, const memcached_server_st *list);
-
-memcached_server_instance_st memcached_server_by_key (const memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error);
-
-memcached_server_instance_st memcached_server_get_last_disconnect (const memcached_st *ptr)
-
-memcached_return_t memcached_server_cursor(const memcached_st *ptr, const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks);
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B uint32_t memcached_server_count (memcached_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add (memcached_st *ptr, const char *hostname, in_port_t port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add_udp (memcached_st *ptr, const char *hostname, in_port_t port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add_unix_socket (memcached_st *ptr, const char *socket);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_push (memcached_st *ptr, const memcached_server_st *list);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_server_instance_st memcached_server_by_key (const memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_server_instance_st memcached_server_get_last_disconnect(const memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_cursor(const memcached_st *ptr, const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks);
+.UNINDENT
+.sp
+compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
libmemcached(3) performs operations on a list of hosts. The order of these
hosts determine routing to keys. Functions are provided to add keys to
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
-.SS SEE ALSO
+.SH SEE ALSO
.sp
\fImemcached(1)\fP \fIlibmemcached(3)\fP \fImemcached_strerror(3)\fP
.SH AUTHOR
-.TH "MEMCACHED_SERVERS" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SERVERS" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_servers \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
+.SH SYNOPSIS
.sp
-Manage server list
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-uint32_t memcached_server_count (memcached_st *ptr);
-
-memcached_return_t memcached_server_add (memcached_st *ptr, const char *hostname, in_port_t port);
-
-memcached_return_t memcached_server_add_udp (memcached_st *ptr, const char *hostname, in_port_t port);
-
-memcached_return_t memcached_server_add_unix_socket (memcached_st *ptr, const char *socket);
-
-memcached_return_t memcached_server_push (memcached_st *ptr, const memcached_server_st *list);
-
-memcached_server_instance_st memcached_server_by_key (const memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error);
-
-memcached_server_instance_st memcached_server_get_last_disconnect (const memcached_st *ptr)
-
-memcached_return_t memcached_server_cursor(const memcached_st *ptr, const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks);
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B uint32_t memcached_server_count (memcached_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add (memcached_st *ptr, const char *hostname, in_port_t port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add_udp (memcached_st *ptr, const char *hostname, in_port_t port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add_unix_socket (memcached_st *ptr, const char *socket);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_push (memcached_st *ptr, const memcached_server_st *list);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_server_instance_st memcached_server_by_key (const memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_server_instance_st memcached_server_get_last_disconnect(const memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_cursor(const memcached_st *ptr, const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks);
+.UNINDENT
+.sp
+compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
libmemcached(3) performs operations on a list of hosts. The order of these
hosts determine routing to keys. Functions are provided to add keys to
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
-.SS SEE ALSO
+.SH SEE ALSO
.sp
\fImemcached(1)\fP \fIlibmemcached(3)\fP \fImemcached_strerror(3)\fP
.SH AUTHOR
-.TH "MEMCACHED_SERVERS_PARSE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SERVERS_PARSE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_servers_parse \- libmemcached Documentation
.
-.TH "MEMCACHED_SERVERS_RESET" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SERVERS_RESET" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_servers_reset \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
-.sp
-Create a memcached_st structure
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
-.TH "MEMCACHED_SET" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SET" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_set \- Storing and Replacing Data
.
..
.\" Man page generated from reStructeredText.
.
-.sp
-Store value on server
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.UNINDENT
.INDENT 0.0
.TP
-.B memcached_return_t memcached_prepend(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_append(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_cas(memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_set_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
.INDENT 0.0
.TP
.B memcached_return_t memcached_replace_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_prepend_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_append_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_cas_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
.sp
Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
memcached_set(), memcached_add(), and memcached_replace() are all used to
store information on the server. All methods take a key, and its length to
-store the object. Keys are currently limited to 250 characters by the
-memcached(1) server. You must also supply a value and a length. Optionally you
-may tests an expiration time for the object and a 16 byte value (it is
-meant to be used as a bitmap).
+store the object. Keys are currently limited to 250 characters when using either a version of memcached(1) which is 1.4 or below, or when using the text protocol.
+You must supply both a value and a length. Optionally you
+may test an expiration time for the object and a 16 byte value (it is
+meant to be used as a bitmap). "flags" is a 4byte space that is stored alongside of the main value. Many sub libraries make use of this field, so in most cases users should avoid making use of it.
.sp
memcached_set() will write an object to the server. If an object already
exists it will overwrite what is in the server. If the object does not exist
memcached_add() adds an object to the server. If the object is found on the
server an error occurs, otherwise the value is stored.
.sp
-memcached_prepend() places a segment of data before the last piece of data
-stored. Currently expiration and key are not used in the server.
-.sp
-memcached_append() places a segment of data at the end of the last piece of
-data stored. Currently expiration and key are not used in the server.
-.sp
memcached_cas() overwrites data in the server as long as the "cas" value is
still the same in the server. You can get the cas value of a result by
calling memcached_result_cas() on a memcached_result_st(3) structure. At the point
for it in libmemcached(3) is optional. Please see memcached_set() for
information on how to do this.
.sp
-memcached_set_by_key(), memcached_add_by_key(), memcached_replace_by_key(),
-memcached_prepend_by_key(), memcached_append_by_key_by_key(),
-memcached_cas_by_key() methods all behave in a similar method as the non key
+memcached_set_by_key(), memcached_add_by_key(), and memcached_replace_by_key()
+methods all behave in a similar method as the non key
methods. The difference is that they use their group_key parameter to map
objects to particular servers.
.sp
If you are looking for performance, memcached_set() with non\-blocking IO is
the fastest way to store data on the server.
.sp
-All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. But when using these operations with this behavior on, there
+All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. However, when using these operations with this behavior on, there
are limits to the size of the payload being sent to the server. The reason for
-these limits is that the Memcahed Server does not allow multi\-datagram requests
+these limits is that the Memcached Server does not allow multi\-datagram requests
and the current server implementation sets a datagram size to 1400 bytes. Due
to protocol overhead, the actual limit of the user supplied data is less than
-1400 bytes and depends on the protocol in use as well as the operation being
+1400 bytes and depends on the protocol in use as, well as the operation being
executed. When running with the binary protocol, \(ga\(ga MEMCACHED_BEHAVIOR_BINARY_PROTOCOL\(ga\(ga,
the size of the key,value, flags and expiry combined may not exceed 1368 bytes.
When running with the ASCII protocol, the exact limit fluctuates depending on
\fI\%http://libmemcached.org/\fP
.SH SEE ALSO
.sp
-memcached(1) libmemached(3) memcached_strerror(3)
+memcached(1) libmemached(3) memcached_strerror(3) memcached_prepend(3) memcached_cas(3) memcached_append(3)
.SH AUTHOR
Brian Aker
.SH COPYRIGHT
-.TH "MEMCACHED_SET_BY_KEY" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SET_BY_KEY" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_set_by_key \- Storing and Replacing Data
.
..
.\" Man page generated from reStructeredText.
.
-.sp
-Store value on server
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.UNINDENT
.INDENT 0.0
.TP
-.B memcached_return_t memcached_prepend(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_append(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_cas(memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_set_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
.INDENT 0.0
.TP
.B memcached_return_t memcached_replace_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_prepend_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_append_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_cas_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
.sp
Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
memcached_set(), memcached_add(), and memcached_replace() are all used to
store information on the server. All methods take a key, and its length to
-store the object. Keys are currently limited to 250 characters by the
-memcached(1) server. You must also supply a value and a length. Optionally you
-may tests an expiration time for the object and a 16 byte value (it is
-meant to be used as a bitmap).
+store the object. Keys are currently limited to 250 characters when using either a version of memcached(1) which is 1.4 or below, or when using the text protocol.
+You must supply both a value and a length. Optionally you
+may test an expiration time for the object and a 16 byte value (it is
+meant to be used as a bitmap). "flags" is a 4byte space that is stored alongside of the main value. Many sub libraries make use of this field, so in most cases users should avoid making use of it.
.sp
memcached_set() will write an object to the server. If an object already
exists it will overwrite what is in the server. If the object does not exist
memcached_add() adds an object to the server. If the object is found on the
server an error occurs, otherwise the value is stored.
.sp
-memcached_prepend() places a segment of data before the last piece of data
-stored. Currently expiration and key are not used in the server.
-.sp
-memcached_append() places a segment of data at the end of the last piece of
-data stored. Currently expiration and key are not used in the server.
-.sp
memcached_cas() overwrites data in the server as long as the "cas" value is
still the same in the server. You can get the cas value of a result by
calling memcached_result_cas() on a memcached_result_st(3) structure. At the point
for it in libmemcached(3) is optional. Please see memcached_set() for
information on how to do this.
.sp
-memcached_set_by_key(), memcached_add_by_key(), memcached_replace_by_key(),
-memcached_prepend_by_key(), memcached_append_by_key_by_key(),
-memcached_cas_by_key() methods all behave in a similar method as the non key
+memcached_set_by_key(), memcached_add_by_key(), and memcached_replace_by_key()
+methods all behave in a similar method as the non key
methods. The difference is that they use their group_key parameter to map
objects to particular servers.
.sp
If you are looking for performance, memcached_set() with non\-blocking IO is
the fastest way to store data on the server.
.sp
-All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. But when using these operations with this behavior on, there
+All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. However, when using these operations with this behavior on, there
are limits to the size of the payload being sent to the server. The reason for
-these limits is that the Memcahed Server does not allow multi\-datagram requests
+these limits is that the Memcached Server does not allow multi\-datagram requests
and the current server implementation sets a datagram size to 1400 bytes. Due
to protocol overhead, the actual limit of the user supplied data is less than
-1400 bytes and depends on the protocol in use as well as the operation being
+1400 bytes and depends on the protocol in use as, well as the operation being
executed. When running with the binary protocol, \(ga\(ga MEMCACHED_BEHAVIOR_BINARY_PROTOCOL\(ga\(ga,
the size of the key,value, flags and expiry combined may not exceed 1368 bytes.
When running with the ASCII protocol, the exact limit fluctuates depending on
\fI\%http://libmemcached.org/\fP
.SH SEE ALSO
.sp
-memcached(1) libmemached(3) memcached_strerror(3)
+memcached(1) libmemached(3) memcached_strerror(3) memcached_prepend(3) memcached_cas(3) memcached_append(3)
.SH AUTHOR
Brian Aker
.SH COPYRIGHT
-.TH "MEMCACHED_SET_MEMORY_ALLOCATORS" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SET_MEMORY_ALLOCATORS" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_set_memory_allocators \- libmemcached Documentation
.
.
.sp
Manage memory allocator functions
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-memcached_return_t memcached_set_memory_allocators (memcached_st *ptr, memcached_malloc_fn mem_malloc, memcached_free_fn mem_free, memcached_realloc_fn mem_realloc, memcached_calloc_fn mem_calloc, void *context);
-
-void memcached_get_memory_allocators (memcached_st *ptr, memcached_malloc_fn *mem_malloc, memcached_free_fn *mem_free, memcached_realloc_fn *mem_realloc, memcached_calloc_fn *mem_calloc);
-
-void * memcached_get_memory_allocators_context(const memcached_st *ptr);
-
-void * (*memcached_malloc_fn) (memcached_st *ptr, const size_t size, void *context);
-
-void * (*memcached_realloc_fn) (memcached_st *ptr, void *mem, const size_t size, void *context);
-
-void (*memcached_free_fn) (memcached_st *ptr, void *mem, void *context);
-
-void * (*memcached_calloc_fn) (memcached_st *ptr, size_t nelem, const size_t elsize, void *context);
-.ft P
-.fi
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_set_memory_allocators (memcached_st *ptr, memcached_malloc_fn mem_malloc, memcached_free_fn mem_free, memcached_realloc_fn mem_realloc, memcached_calloc_fn mem_calloc, void *context);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_get_memory_allocators (memcached_st *ptr, memcached_malloc_fn *mem_malloc, memcached_free_fn *mem_free, memcached_realloc_fn *mem_realloc, memcached_calloc_fn *mem_calloc);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void * memcached_get_memory_allocators_context(const memcached_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void * (*memcached_malloc_fn) (memcached_st *ptr, const size_t size, void *context);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void * (*memcached_realloc_fn) (memcached_st *ptr, void *mem, const size_t size, void *context);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void (*memcached_free_fn) (memcached_st *ptr, void *mem, void *context);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void * (*memcached_calloc_fn) (memcached_st *ptr, size_t nelem, const size_t elsize, void *context);
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
-libmemcached(3) allows you to specify your own memory allocators optimized
+libmemcached(3) allows you to specify your own memory allocators, optimized
for your application. This enables libmemcached to be used inside of applications that have their own malloc implementation.
.sp
memcached_set_memory_allocators() is used to set the memory allocators used
-.TH "MEMCACHED_SET_MEMORY_ALLOCATORS_CONTEXT" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SET_MEMORY_ALLOCATORS_CONTEXT" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_set_memory_allocators_context \- libmemcached Documentation
.
.
.sp
Manage memory allocator functions
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-memcached_return_t memcached_set_memory_allocators (memcached_st *ptr, memcached_malloc_fn mem_malloc, memcached_free_fn mem_free, memcached_realloc_fn mem_realloc, memcached_calloc_fn mem_calloc, void *context);
-
-void memcached_get_memory_allocators (memcached_st *ptr, memcached_malloc_fn *mem_malloc, memcached_free_fn *mem_free, memcached_realloc_fn *mem_realloc, memcached_calloc_fn *mem_calloc);
-
-void * memcached_get_memory_allocators_context(const memcached_st *ptr);
-
-void * (*memcached_malloc_fn) (memcached_st *ptr, const size_t size, void *context);
-
-void * (*memcached_realloc_fn) (memcached_st *ptr, void *mem, const size_t size, void *context);
-
-void (*memcached_free_fn) (memcached_st *ptr, void *mem, void *context);
-
-void * (*memcached_calloc_fn) (memcached_st *ptr, size_t nelem, const size_t elsize, void *context);
-.ft P
-.fi
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_set_memory_allocators (memcached_st *ptr, memcached_malloc_fn mem_malloc, memcached_free_fn mem_free, memcached_realloc_fn mem_realloc, memcached_calloc_fn mem_calloc, void *context);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_get_memory_allocators (memcached_st *ptr, memcached_malloc_fn *mem_malloc, memcached_free_fn *mem_free, memcached_realloc_fn *mem_realloc, memcached_calloc_fn *mem_calloc);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void * memcached_get_memory_allocators_context(const memcached_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void * (*memcached_malloc_fn) (memcached_st *ptr, const size_t size, void *context);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void * (*memcached_realloc_fn) (memcached_st *ptr, void *mem, const size_t size, void *context);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void (*memcached_free_fn) (memcached_st *ptr, void *mem, void *context);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void * (*memcached_calloc_fn) (memcached_st *ptr, size_t nelem, const size_t elsize, void *context);
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
-libmemcached(3) allows you to specify your own memory allocators optimized
+libmemcached(3) allows you to specify your own memory allocators, optimized
for your application. This enables libmemcached to be used inside of applications that have their own malloc implementation.
.sp
memcached_set_memory_allocators() is used to set the memory allocators used
-.TH "MEMCACHED_SET_SASL_CALLBACKS" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SET_SASL_CALLBACKS" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_set_sasl_callbacks \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/memcached.h>
-
-void memcached_set_sasl_callbacks(memcached_st *ptr,
- const sasl_callback_t *callbacks)
-
-const sasl_callback_t *memcached_get_sasl_callbacks(memcached_st *ptr)
-
-memcached_return memcached_set_sasl_auth_data(memcached_st *ptr,
- const char *username,
- const char *password)
-memcached_return memcached_destroy_sasl_auth_data(memcached_st *ptr)
-.ft P
-.fi
+#include <libmemcached/memcached_pool.h>
+.INDENT 0.0
+.TP
+.B void memcached_set_sasl_callbacks(memcached_st\fI\ *ptr\fP, const sasl_callback_t\fI\ *callbacks\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const sasl_callback_t *memcached_get_sasl_callbacks(memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return memcached_set_sasl_auth_data(memcached_st\fI\ *ptr\fP, const char\fI\ *username\fP, const char\fI\ *password\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return memcached_destroy_sasl_auth_data(memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) allows you to plug in your own callbacks function used by
Please note that SASL requires the memcached binary protocol, and you have
to specify the callbacks before you connect to the server.
.sp
-memcached_set_sasl_auth_data() is a helper function for you defining
+memcached_set_sasl_auth_data() is a helper function defining
the basic functionality for you, but it will store the username and password
in memory. If you choose to use this method you have to call
memcached_destroy_sasl_auth_data before calling memcached_free to avoid
-.TH "MEMCACHED_SET_USER_DATA" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SET_USER_DATA" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_set_user_data \- libmemcached Documentation
.
.SH LIBRARY
.sp
C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
+.SH SYNOPSIS
.sp
.nf
.ft C
void *memcached_set_user_data (memcached_st *ptr, void *data);
.ft P
.fi
-.SS DESCRIPTION
+.SH DESCRIPTION
.sp
libmemcached(3) allows you to store a pointer to a user specific data inside
the memcached_st structure.
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
-.SH AUTHOR
-.sp
-Trond Norbye, <\fI\%trond.norbye@gmail.com\fP>
-.SS SEE ALSO
+.SH SEE ALSO
.sp
memcached(1) libmemcached(3)
.SH AUTHOR
-.TH "MEMCACHED_STAT" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_STAT" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_stat \- libmemcached Documentation
.
.
.sp
Get memcached statistics
-.SH LIBRARY
+.SH SYNOPSIS
.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-memcached_stat_st *memcached_stat (memcached_st *ptr,
- char *args,
- memcached_return_t *error);
-
-memcached_return_t memcached_stat_servername (memcached_stat_st *stat,
- char *args,
- const char *hostname,
- unsigned int port);
-
-char *
- memcached_stat_get_value (memcached_st *ptr,
- memcached_stat_st *stat,
- const char *key,
- memcached_return_t *error);
-
-char **
- memcached_stat_get_keys (memcached_st *ptr,
- memcached_stat_st *stat,
- memcached_return_t *error);
-
-memcached_return_t
- memcached_stat_execute (memcached_st *memc,
- const char *args,
- memcached_stat_fn func,
- void *context);
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B memcached_stat_st *memcached_stat (memcached_st *ptr, char *args, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_stat_servername (memcached_stat_st *stat, char *args, const char *hostname, unsigned int port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B char * memcached_stat_get_value (memcached_st *ptr, memcached_stat_st *stat, const char *key, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B char ** memcached_stat_get_keys (memcached_st *ptr, memcached_stat_st *stat, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_stat_execute (memcached_st *memc, const char *args, memcached_stat_fn func, void *context);
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
libmemcached(3) has the ability to query a memcached server (or collection
of servers) for their current state. Queries to find state return a
.SH AUTHOR
.sp
Brian Aker, <\fI\%brian@tangent.org\fP>
-.SS SEE ALSO
+.SH SEE ALSO
.sp
memcached(1) libmemcached(3) memcached_strerror(3)
.SH AUTHOR
-.TH "MEMCACHED_STAT_EXECUTE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_STAT_EXECUTE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_stat_execute \- libmemcached Documentation
.
.
.sp
Get memcached statistics
-.SH LIBRARY
+.SH SYNOPSIS
.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-memcached_stat_st *memcached_stat (memcached_st *ptr,
- char *args,
- memcached_return_t *error);
-
-memcached_return_t memcached_stat_servername (memcached_stat_st *stat,
- char *args,
- const char *hostname,
- unsigned int port);
-
-char *
- memcached_stat_get_value (memcached_st *ptr,
- memcached_stat_st *stat,
- const char *key,
- memcached_return_t *error);
-
-char **
- memcached_stat_get_keys (memcached_st *ptr,
- memcached_stat_st *stat,
- memcached_return_t *error);
-
-memcached_return_t
- memcached_stat_execute (memcached_st *memc,
- const char *args,
- memcached_stat_fn func,
- void *context);
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B memcached_stat_st *memcached_stat (memcached_st *ptr, char *args, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_stat_servername (memcached_stat_st *stat, char *args, const char *hostname, unsigned int port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B char * memcached_stat_get_value (memcached_st *ptr, memcached_stat_st *stat, const char *key, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B char ** memcached_stat_get_keys (memcached_st *ptr, memcached_stat_st *stat, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_stat_execute (memcached_st *memc, const char *args, memcached_stat_fn func, void *context);
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
libmemcached(3) has the ability to query a memcached server (or collection
of servers) for their current state. Queries to find state return a
.SH AUTHOR
.sp
Brian Aker, <\fI\%brian@tangent.org\fP>
-.SS SEE ALSO
+.SH SEE ALSO
.sp
memcached(1) libmemcached(3) memcached_strerror(3)
.SH AUTHOR
-.TH "MEMCACHED_STAT_GET_KEYS" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_STAT_GET_KEYS" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_stat_get_keys \- libmemcached Documentation
.
.
.sp
Get memcached statistics
-.SH LIBRARY
+.SH SYNOPSIS
.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-memcached_stat_st *memcached_stat (memcached_st *ptr,
- char *args,
- memcached_return_t *error);
-
-memcached_return_t memcached_stat_servername (memcached_stat_st *stat,
- char *args,
- const char *hostname,
- unsigned int port);
-
-char *
- memcached_stat_get_value (memcached_st *ptr,
- memcached_stat_st *stat,
- const char *key,
- memcached_return_t *error);
-
-char **
- memcached_stat_get_keys (memcached_st *ptr,
- memcached_stat_st *stat,
- memcached_return_t *error);
-
-memcached_return_t
- memcached_stat_execute (memcached_st *memc,
- const char *args,
- memcached_stat_fn func,
- void *context);
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B memcached_stat_st *memcached_stat (memcached_st *ptr, char *args, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_stat_servername (memcached_stat_st *stat, char *args, const char *hostname, unsigned int port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B char * memcached_stat_get_value (memcached_st *ptr, memcached_stat_st *stat, const char *key, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B char ** memcached_stat_get_keys (memcached_st *ptr, memcached_stat_st *stat, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_stat_execute (memcached_st *memc, const char *args, memcached_stat_fn func, void *context);
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
libmemcached(3) has the ability to query a memcached server (or collection
of servers) for their current state. Queries to find state return a
.SH AUTHOR
.sp
Brian Aker, <\fI\%brian@tangent.org\fP>
-.SS SEE ALSO
+.SH SEE ALSO
.sp
memcached(1) libmemcached(3) memcached_strerror(3)
.SH AUTHOR
-.TH "MEMCACHED_STAT_GET_VALUE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_STAT_GET_VALUE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_stat_get_value \- libmemcached Documentation
.
.
.sp
Get memcached statistics
-.SH LIBRARY
+.SH SYNOPSIS
.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-memcached_stat_st *memcached_stat (memcached_st *ptr,
- char *args,
- memcached_return_t *error);
-
-memcached_return_t memcached_stat_servername (memcached_stat_st *stat,
- char *args,
- const char *hostname,
- unsigned int port);
-
-char *
- memcached_stat_get_value (memcached_st *ptr,
- memcached_stat_st *stat,
- const char *key,
- memcached_return_t *error);
-
-char **
- memcached_stat_get_keys (memcached_st *ptr,
- memcached_stat_st *stat,
- memcached_return_t *error);
-
-memcached_return_t
- memcached_stat_execute (memcached_st *memc,
- const char *args,
- memcached_stat_fn func,
- void *context);
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B memcached_stat_st *memcached_stat (memcached_st *ptr, char *args, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_stat_servername (memcached_stat_st *stat, char *args, const char *hostname, unsigned int port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B char * memcached_stat_get_value (memcached_st *ptr, memcached_stat_st *stat, const char *key, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B char ** memcached_stat_get_keys (memcached_st *ptr, memcached_stat_st *stat, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_stat_execute (memcached_st *memc, const char *args, memcached_stat_fn func, void *context);
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
libmemcached(3) has the ability to query a memcached server (or collection
of servers) for their current state. Queries to find state return a
.SH AUTHOR
.sp
Brian Aker, <\fI\%brian@tangent.org\fP>
-.SS SEE ALSO
+.SH SEE ALSO
.sp
memcached(1) libmemcached(3) memcached_strerror(3)
.SH AUTHOR
-.TH "MEMCACHED_STAT_SERVERNAME" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_STAT_SERVERNAME" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_stat_servername \- libmemcached Documentation
.
.
.sp
Get memcached statistics
-.SH LIBRARY
+.SH SYNOPSIS
.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-memcached_stat_st *memcached_stat (memcached_st *ptr,
- char *args,
- memcached_return_t *error);
-
-memcached_return_t memcached_stat_servername (memcached_stat_st *stat,
- char *args,
- const char *hostname,
- unsigned int port);
-
-char *
- memcached_stat_get_value (memcached_st *ptr,
- memcached_stat_st *stat,
- const char *key,
- memcached_return_t *error);
-
-char **
- memcached_stat_get_keys (memcached_st *ptr,
- memcached_stat_st *stat,
- memcached_return_t *error);
-
-memcached_return_t
- memcached_stat_execute (memcached_st *memc,
- const char *args,
- memcached_stat_fn func,
- void *context);
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B memcached_stat_st *memcached_stat (memcached_st *ptr, char *args, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_stat_servername (memcached_stat_st *stat, char *args, const char *hostname, unsigned int port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B char * memcached_stat_get_value (memcached_st *ptr, memcached_stat_st *stat, const char *key, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B char ** memcached_stat_get_keys (memcached_st *ptr, memcached_stat_st *stat, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_stat_execute (memcached_st *memc, const char *args, memcached_stat_fn func, void *context);
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
libmemcached(3) has the ability to query a memcached server (or collection
of servers) for their current state. Queries to find state return a
.SH AUTHOR
.sp
Brian Aker, <\fI\%brian@tangent.org\fP>
-.SS SEE ALSO
+.SH SEE ALSO
.sp
memcached(1) libmemcached(3) memcached_strerror(3)
.SH AUTHOR
-.TH "MEMCACHED_STATS" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_STATS" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_stats \- libmemcached Documentation
.
.
.sp
Get memcached statistics
-.SH LIBRARY
+.SH SYNOPSIS
.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-memcached_stat_st *memcached_stat (memcached_st *ptr,
- char *args,
- memcached_return_t *error);
-
-memcached_return_t memcached_stat_servername (memcached_stat_st *stat,
- char *args,
- const char *hostname,
- unsigned int port);
-
-char *
- memcached_stat_get_value (memcached_st *ptr,
- memcached_stat_st *stat,
- const char *key,
- memcached_return_t *error);
-
-char **
- memcached_stat_get_keys (memcached_st *ptr,
- memcached_stat_st *stat,
- memcached_return_t *error);
-
-memcached_return_t
- memcached_stat_execute (memcached_st *memc,
- const char *args,
- memcached_stat_fn func,
- void *context);
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B memcached_stat_st *memcached_stat (memcached_st *ptr, char *args, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_stat_servername (memcached_stat_st *stat, char *args, const char *hostname, unsigned int port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B char * memcached_stat_get_value (memcached_st *ptr, memcached_stat_st *stat, const char *key, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B char ** memcached_stat_get_keys (memcached_st *ptr, memcached_stat_st *stat, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_stat_execute (memcached_st *memc, const char *args, memcached_stat_fn func, void *context);
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
libmemcached(3) has the ability to query a memcached server (or collection
of servers) for their current state. Queries to find state return a
.SH AUTHOR
.sp
Brian Aker, <\fI\%brian@tangent.org\fP>
-.SS SEE ALSO
+.SH SEE ALSO
.sp
memcached(1) libmemcached(3) memcached_strerror(3)
.SH AUTHOR
-.TH "MEMCACHED_STRERROR" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_STRERROR" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_strerror \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
-.SH LIBRARY
+.SH SYNOPSIS
.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-const char *
- memcached_strerror (memcached_st *ptr,
- memcached_return_t rc);
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B const char * memcached_strerror (memcached_st *ptr, memcached_return_t rc);
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
memcached_strerror() takes a \fBmemcached_return_t\fP value and returns a string
describing the error.
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
-.SH AUTHOR
-.sp
-Brian Aker, <\fI\%brian@tangent.org\fP>
-.SS SEE ALSO
+.SH SEE ALSO
.sp
memcached(1) libmemcached(3)
.SH AUTHOR
-.TH "MEMCACHED_USER_DATA" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_USER_DATA" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_user_data \- libmemcached Documentation
.
.SH LIBRARY
.sp
C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
+.SH SYNOPSIS
.sp
.nf
.ft C
void *memcached_set_user_data (memcached_st *ptr, void *data);
.ft P
.fi
-.SS DESCRIPTION
+.SH DESCRIPTION
.sp
libmemcached(3) allows you to store a pointer to a user specific data inside
the memcached_st structure.
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
-.SH AUTHOR
-.sp
-Trond Norbye, <\fI\%trond.norbye@gmail.com\fP>
-.SS SEE ALSO
+.SH SEE ALSO
.sp
memcached(1) libmemcached(3)
.SH AUTHOR
-.TH "MEMCACHED_VERBOSITY" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_VERBOSITY" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_verbosity \- libmemcached Documentation
.
.
.sp
Modifiy verbosity of servers
-.SH LIBRARY
+.SH SYNOPSIS
.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-memcached_return_t
- memcached_verbosity (memcached_st *ptr,
- unsigned int verbosity);
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_verbosity (memcached_st *ptr, unsigned int verbosity);
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
memcached_verbosity() modifies the "verbosity" of the
memcached(1) servers referenced in the \fBmemcached_st\fP parameter.
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
-.SH AUTHOR
-.sp
-Brian Aker, <\fI\%brian@tangent.org\fP>
-.SS SEE ALSO
+.SH SEE ALSO
.sp
memcached(1) libmemcached(3) memcached_strerror(3)
.SH AUTHOR
-.TH "MEMCACHED_VERSION" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_VERSION" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_version \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
+.SH SYNOPSIS
.sp
-Get library version
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-const char *
- memcached_lib_version (void)
-
-
-memcached_return_t
- memcached_version (memcached_st *ptr)
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B const char * memcached_lib_version(void)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_version(memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
memcached_lib_version() is used to return a simple version string representing
-the libmemcached version (version of the client library, not server)
+the libmemcached version (client library version, not server version)
.sp
memcached_version() is used to set the major, minor, and micro versions of each
memcached server being used by the memcached_st connection structure. It returns the
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
-.SH AUTHOR
-.sp
-Brian Aker, <\fI\%brian@tangent.org\fP>
-.SS SEE ALSO
+.SH SEE ALSO
.sp
memcached(1) libmemcached(3) memcached_strerror(3)
.SH AUTHOR
-.TH "MEMCAPABLE" "1" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCAPABLE" "1" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcapable \- libmemcached Documentation
.
.INDENT 0.0
.TP
.B \-h hostname
+.UNINDENT
.sp
Specify the hostname to connect to. The default is \fIlocalhost\fP
-.UNINDENT
.INDENT 0.0
.TP
.B \-p port
+.UNINDENT
.sp
Specify the port number to connect to. The default is \fI11211\fP
-.UNINDENT
.INDENT 0.0
.TP
.B \-c
-.
-Generate a coredump when it detects an error from the server.
.UNINDENT
+.sp
+Generate a coredump when it detects an error from the server.
.INDENT 0.0
.TP
.B \-v
-.
-Print out the comparison when it detects an error from the server.
.UNINDENT
+.sp
+Print out the comparison when it detects an error from the server.
.INDENT 0.0
.TP
.B \-t n
+.UNINDENT
.sp
Set the timeout from an IO operation to/from the server to \fIn\fP seconds.
-.UNINDENT
.SH DESCRIPTION
.sp
\fBmemcapable\fP connects to the specified memcached server and tries to
-.TH "MEMCAT" "1" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCAT" "1" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcat \- libmemcached Documentation
.
-.TH "MEMCP" "1" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCP" "1" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcp \- libmemcached Documentation
.
It is similar to the standard UNIX cp(1) command.
.sp
The key names will be the names of the files,
-without any directory path part.
+without any directory path.
.sp
You can specify servers via the \fB\-\-servers\fP option or via the
-environment variable \fBMEMCACHED_SERVERS\fP. If you specify neither of
-these, the final value in the command line list is the name of a
+environment variable \fBMEMCACHED_SERVERS\fP. If you do not specify either these, the final value in the command line list is the name of a
server(s).
.sp
For a full list of operations run the tool with the \fB\-\-help\fP option.
-.TH "MEMDUMP" "1" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMDUMP" "1" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memdump \- libmemcached Documentation
.
.UNINDENT
.SH DESCRIPTION
.sp
-\fBmemdump\fP currently dumps a list of "keys" from all servers that
+\fBmemdump\fP dumps a list of "keys" from all servers that
it is told to fetch from. Because memcached does not guarentee to
provide all keys it is not possible to get a complete "dump".
.sp
-.TH "MEMERROR" "1" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMERROR" "1" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memerror \- libmemcached Documentation
.
.\" Man page generated from reStructeredText.
.
.sp
-Translate a memcached error code to a string
+Translates a memcached error code into a string
.SH SYNOPSIS
.INDENT 0.0
.TP
.UNINDENT
.SH DESCRIPTION
.sp
-\fBmemerror\fP translate an error code from libmemcached(3) to a human
+\fBmemerror\fP translate an error code from libmemcached(3) into a human
readable string.
.sp
For a full list of operations run the tool with the \fB\-\-help\fP option.
-.SS HOME
+.SH HOME
.sp
To find out more infoerroration please check:
\fI\%http://libmemcached.org/\fP
-.SS AUTHOR
-.sp
-Brian Aker, <\fI\%brian@tangent.org\fP>
.SH SEE ALSO
.sp
memcached(1) libmemcached(3)
-.TH "MEMFLUSH" "1" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMFLUSH" "1" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memflush \- libmemcached Documentation
.
.SH DESCRIPTION
.sp
\fBmemflush\fP resets the contents of memcached(1) servers.
-This means all data in these servers will be deleted.
+This means that all data in the specified servers will be deleted.
.sp
You can specify servers via the \fB\-\-servers\fP option or via the
environment variable \fBMEMCACHED_SERVERS\fP.
-.TH "MEMRM" "1" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMRM" "1" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memrm \- libmemcached Documentation
.
-.TH "MEMSLAP" "1" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMSLAP" "1" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memslap \- libmemcached Documentation
.
.SH DESCRIPTION
.sp
\fBmemslap\fP is a load generation and benchmark tool for memcached(1)
-servers. It generates configurable workload such as threads, concurrencies, connections,
-run time, overwrite, miss rate, key size, value size, get/set proportion,
-expected throughput, and so on.
+servers. It generates configurable workload such as threads, concurrencies, connections, run time, overwrite, miss rate, key size, value size, get/set proportion, expected throughput, and so on.
.sp
-You can specify servers via the \fB\-\-servers\fP option or via the
-environment variable \fBMEMCACHED_SERVERS\fP.
+You can specify servers via the \fB\-\-servers\fP option or via the environment variable \fBMEMCACHED_SERVERS\fP.
.SH SEE ALSO
.sp
\fImemcached(1)\fP \fIlibmemcached(3)\fP
-.TH "MEMSTAT" "1" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMSTAT" "1" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memstat \- libmemcached Documentation
.
Analyze server information
--------
-LIBRARY
--------
-
-
-C Client Library for memcached (libmemcached, -lmemcached)
-
-
--------
SYNOPSIS
--------
+.. index:: object: memcached_analysis_st
-.. code-block:: perl
-
- #include <libmemcached/memcached.h>
+#include <libmemcached/memcached.h>
- memcached_analysis_st *
- memcached_analyze (memcached_st *ptr,
- memcached_stat_st *stat,
- memcached_return_t *error);
-
+.. c:function:: memcached_analysis_st * memcached_analyze (memcached_st *ptr, memcached_stat_st *stat, memcached_return_t *error);
+Compile and link with -lmemcached
-----------
DESCRIPTION
--- /dev/null
+=============================================
+Appending or Prepending to data on the server
+=============================================
+
+.. index:: object: memcached_st
+
+Appending or Prepending to data on the server
+
+
+--------
+SYNOPSIS
+--------
+
+
+#include <libmemcached/memcached.h>
+
+.. c:function:: memcached_return_t memcached_prepend(memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags)
+
+.. c:function:: memcached_return_t memcached_append(memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags)
+
+.. c:function:: memcached_return_t memcached_prepend_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
+
+.. c:function:: memcached_return_t memcached_append_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
+
+Compile and link with -lmemcached
+
+
+-----------
+DESCRIPTION
+-----------
+
+
+memcached_prepend() and memcached_append are used to
+modify information on a server. All methods take a key, and its length to
+store the object. Keys are currently limited to 250 characters when using either a version of memcached(1) which is 1.4 or below, or when using the text protocol.
+You must supply both a value and a length. Optionally you
+may test an expiration time for the object and a 16 byte value (it is
+meant to be used as a bitmap). "flags" is a 4byte space that is stored alongside of the main value. Many sub libraries make use of this field, so in most cases users should avoid making use of it.
+
+memcached_prepend() places a segment of data before the last piece of data
+stored. Currently expiration and key are not used in the server.
+
+memcached_append() places a segment of data at the end of the last piece of
+data stored. Currently expiration and key are not used in the server.
+
+memcached_prepend_by_key() and memcached_append_by_key_by_key(,
+methods both behave in a similar method as the non key
+methods. The difference is that they use their group_key parameter to map
+objects to particular servers.
+
+If you are looking for performance, memcached_set() with non-blocking IO is
+the fastest way to store data on the server.
+
+All of the above functions are testsed with the \ ``MEMCACHED_BEHAVIOR_USE_UDP``\
+behavior enabled. However, when using these operations with this behavior on, there
+are limits to the size of the payload being sent to the server. The reason for
+these limits is that the Memcached Server does not allow multi-datagram requests
+and the current server implementation sets a datagram size to 1400 bytes. Due
+to protocol overhead, the actual limit of the user supplied data is less than
+1400 bytes and depends on the protocol in use as, well as the operation being
+executed. When running with the binary protocol, \ `` MEMCACHED_BEHAVIOR_BINARY_PROTOCOL``\ ,
+the size of the key,value, flags and expiry combined may not exceed 1368 bytes.
+When running with the ASCII protocol, the exact limit fluctuates depending on
+which function is being executed and whether the function is a cas operation
+or not. For non-cas ASCII set operations, there are at least 1335 bytes available
+to split among the key, key_prefix, and value; for cas ASCII operations there are
+at least 1318 bytes available to split among the key, key_prefix and value. If the
+total size of the command, including overhead, exceeds 1400 bytes, a \ ``MEMCACHED_WRITE_FAILURE``\
+will be returned.
+
+
+------
+RETURN
+------
+
+
+All methods return a value of type \ ``memcached_return_t``\ .
+On success the value will be \ ``MEMCACHED_SUCCESS``\ .
+Use memcached_strerror() to translate this value to a printable string.
+
+
+----
+HOME
+----
+
+
+To find out more information please check:
+`http://libmemcached.org/ <http://libmemcached.org/>`_
+
+
+--------
+SEE ALSO
+--------
+
+
+memcached(1) libmemached(3) memcached_strerror(3) memcached_set(3) memcached_add(3) memcached_cas(3) memcached_replace(3)
+
Incrementing and Decrementing Values
====================================
-
+.. index:: object: memcached_st
--------
SYNOPSIS
--------
-
-
#include <libmemcached/memcached.h>
.. c:function:: memcached_return_t memcached_increment (memcached_st *ptr, const char *key, size_t key_length, unsigned int offset, uint64_t *value);
================================
-Manipulate behavior
+Manipulate the behavior of a memcached_st structure.
-
--------
-LIBRARY
--------
-
-
-C Client Library for memcached (libmemcached, -lmemcached)
+.. index:: object: memcached_st
--------
.. c:function:: memcached_return_t memcached_behavior_set (memcached_st *ptr, memcached_behavior flag, uint64_t data);
+Compile and link with -lmemcached
-----------
Get and set a callback
-
--------
-LIBRARY
--------
-
-
-C Client Library for memcached (libmemcached, -lmemcached)
+.. index:: object: memcached_st
--------
.. c:function:: void * memcached_callback_get (memcached_st *ptr, memcached_callback_t flag, memcached_return_t *error);
+Compile and link with -lmemcached
-----------
--- /dev/null
+====================================================
+Working with data on the server in an atomic fashion
+====================================================
+
+.. index:: object: memcached_st
+
+
+--------
+SYNOPSIS
+--------
+
+
+#include <libmemcached/memcached.h>
+
+.. c:function:: memcached_return_t memcached_cas(memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
+
+.. c:function:: memcached_return_t memcached_cas_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
+
+Compile and link with -lmemcached
+
+
+-----------
+DESCRIPTION
+-----------
+
+memcached_cas() overwrites data in the server as long as the "cas" value is
+still the same in the server. You can get the cas value of a result by
+calling memcached_result_cas() on a memcached_result_st(3) structure. At the point
+that this note was written cas is still buggy in memached. Turning on tests
+for it in libmemcached(3) is optional. Please see memcached_set() for
+information on how to do this.
+
+memcached_cas_by_key() method behaves in a similar method as the non key
+methods. The difference is that it uses the group_key parameter to map
+objects to particular servers.
+
+memcached_cas() is testsed with the \ ``MEMCACHED_BEHAVIOR_USE_UDP``\
+behavior enabled. However, when using these operations with this behavior on, there
+are limits to the size of the payload being sent to the server. The reason for
+these limits is that the Memcached Server does not allow multi-datagram requests
+and the current server implementation sets a datagram size to 1400 bytes. Due
+to protocol overhead, the actual limit of the user supplied data is less than
+1400 bytes and depends on the protocol in use as, well as the operation being
+executed. When running with the binary protocol, \ `` MEMCACHED_BEHAVIOR_BINARY_PROTOCOL``\ ,
+the size of the key,value, flags and expiry combined may not exceed 1368 bytes.
+When running with the ASCII protocol, the exact limit fluctuates depending on
+which function is being executed and whether the function is a cas operation
+or not. For non-cas ASCII set operations, there are at least 1335 bytes available
+to split among the key, key_prefix, and value; for cas ASCII operations there are
+at least 1318 bytes available to split among the key, key_prefix and value. If the
+total size of the command, including overhead, exceeds 1400 bytes, a \ ``MEMCACHED_WRITE_FAILURE``\
+will be returned.
+
+
+------
+RETURN
+------
+
+
+All methods return a value of type \ ``memcached_return_t``\ .
+On success the value will be \ ``MEMCACHED_SUCCESS``\ .
+Use memcached_strerror() to translate this value to a printable string.
+
+
+----
+HOME
+----
+
+
+To find out more information please check:
+`http://libmemcached.org/ <http://libmemcached.org/>`_
+
+
+--------
+SEE ALSO
+--------
+
+
+memcached(1) libmemached(3) memcached_strerror(3) memcached_set(3) memcached_append(3) memcached_add(3) memcached_prepend(3) memcached_replace(3)
+
Creating and destroying a memcached_st
======================================
-
-Create a memcached_st structure
-
.. index:: object: memcached_st
--------
Deleting data from a server
===========================
+.. index:: object: memcached_st
+
--------
SYNOPSIS
--------
Get a list of keys found on memcached servers
-
--------
-LIBRARY
--------
-
-
-C Client Library for memcached (libmemcached, -lmemcached)
+.. index:: object: memcached_st
--------
--------
+#include <libmemcached/memcached.h>
-.. code-block:: perl
-
- #include <libmemcached/memcached.h>
-
- memcached_return_t
- memcached_dump (memcached_st *ptr,
- memcached_dump_fn *function,
- void *context,
- uint32_t number_of_callbacks);
+.. c:function:: memcached_return_t memcached_dump (memcached_st *ptr, memcached_dump_fn *function, void *context, uint32_t number_of_callbacks);
- typedef memcached_return_t (*memcached_dump_fn)(memcached_st *ptr,
- const char *key,
- size_t key_length,
- void *context);
+.. c:function:: typedef memcached_return_t (*memcached_dump_fn)(memcached_st *ptr, const char *key, size_t key_length, void *context);
+
+Compile and link with -lmemcached
Wiping clean the contents of a server
=====================================
+.. index:: object: memcached_st
Wipe contents of memcached servers
=======================
-Flush buffers and send buffered commands
-
-
--------
-LIBRARY
--------
-
-
-C Client Library for memcached (libmemcached, -lmemcached)
+.. index:: object: memcached_st
+Flush and senf buffered commands
--------
SYNOPSIS
.. c:function:: memcached_return_t memcached_flush_buffers (memcached_st *ptr);
+Compile and link with -lmemcached
-----------
Generating hash values directly
===============================
+.. index:: object: memcached_st
Hash a key value
Retrieving data from the server
===============================
+.. index:: object: memcached_st
--------
SYNOPSIS
Use custom allocators for embedded usage
========================================
+.. index:: object: memcached_st
Manage memory allocator functions
+--------
+SYNOPSIS
+--------
--------
-LIBRARY
--------
+#include <libmemcached/memcached.h>
-C Client Library for memcached (libmemcached, -lmemcached)
+.. c:function:: memcached_return_t memcached_set_memory_allocators (memcached_st *ptr, memcached_malloc_fn mem_malloc, memcached_free_fn mem_free, memcached_realloc_fn mem_realloc, memcached_calloc_fn mem_calloc, void *context);
+.. c:function:: void memcached_get_memory_allocators (memcached_st *ptr, memcached_malloc_fn *mem_malloc, memcached_free_fn *mem_free, memcached_realloc_fn *mem_realloc, memcached_calloc_fn *mem_calloc);
---------
-SYNOPSIS
---------
+.. c:function:: void * memcached_get_memory_allocators_context(const memcached_st *ptr);
+
+.. c:function:: void * (*memcached_malloc_fn) (memcached_st *ptr, const size_t size, void *context);
+
+.. c:function:: void * (*memcached_realloc_fn) (memcached_st *ptr, void *mem, const size_t size, void *context);
+.. c:function:: void (*memcached_free_fn) (memcached_st *ptr, void *mem, void *context);
+.. c:function:: void * (*memcached_calloc_fn) (memcached_st *ptr, size_t nelem, const size_t elsize, void *context);
-.. code-block:: perl
-
- #include <libmemcached/memcached.h>
-
- memcached_return_t memcached_set_memory_allocators (memcached_st *ptr, memcached_malloc_fn mem_malloc, memcached_free_fn mem_free, memcached_realloc_fn mem_realloc, memcached_calloc_fn mem_calloc, void *context);
-
- void memcached_get_memory_allocators (memcached_st *ptr, memcached_malloc_fn *mem_malloc, memcached_free_fn *mem_free, memcached_realloc_fn *mem_realloc, memcached_calloc_fn *mem_calloc);
-
- void * memcached_get_memory_allocators_context(const memcached_st *ptr);
-
- void * (*memcached_malloc_fn) (memcached_st *ptr, const size_t size, void *context);
-
- void * (*memcached_realloc_fn) (memcached_st *ptr, void *mem, const size_t size, void *context);
-
- void (*memcached_free_fn) (memcached_st *ptr, void *mem, void *context);
-
- void * (*memcached_calloc_fn) (memcached_st *ptr, size_t nelem, const size_t elsize, void *context);
+Compile and link with -lmemcached
Disconnecting a client from a server
====================================
+.. index:: object: memcached_st
--------
SYNOPSIS
Working with result sets
========================
+.. index:: object: memcached_result_st
Work with memcached_result_st
--------
-LIBRARY
--------
+--------
+SYNOPSIS
+--------
+#include <libmemcached/memcached_pool.h>
-C Client Library for memcached (libmemcached, -lmemcached)
+.. c:function:: memcached_result_st * memcached_result_create (memcached_st *ptr, memcached_result_st *result);
+.. c:function:: void memcached_result_free (memcached_result_st *result);
---------
-SYNOPSIS
---------
+.. c:function:: const char * memcached_result_key_value (memcached_result_st *result);
+
+.. c:function:: size_t memcached_result_key_length (const memcached_result_st *result);
+
+.. c:function:: const char *memcached_result_value (memcached_result_st *ptr);
+
+.. c:function:: size_t memcached_result_length (const memcached_result_st *ptr);
+
+.. c:function:: uint32_t memcached_result_flags (const memcached_result_st *result)
+
+.. c:function:: uint64_t memcached_result_cas (const memcached_result_st *result);
+
+.. c:function:: memcached_return_t memcached_result_set_value (memcached_result_st *ptr, const char *value, size_t length)
+.. c:function:: void memcached_result_set_flags (memcached_result_st *ptr, uint32_t flags)
+.. c:function:: void memcached_result_set_expiration (memcached_result_st *ptr, time_t)
-.. code-block:: perl
-
- #include <libmemcached/memcached.h>
-
- memcached_result_st *
- memcached_result_create (memcached_st *ptr,
- memcached_result_st *result);
-
- void memcached_result_free (memcached_result_st *result);
-
- const char * memcached_result_key_value (memcached_result_st *result);
-
- size_t memcached_result_key_length (const memcached_result_st *result);
-
- const char *memcached_result_value (memcached_result_st *ptr);
-
- size_t memcached_result_length (const memcached_result_st *ptr);
-
- uint32_t memcached_result_flags (const memcached_result_st *result)
-
- uint64_t memcached_result_cas (const memcached_result_st *result);
-
- memcached_return_t
- memcached_result_set_value (memcached_result_st *ptr,
- const char *value, size_t length)
-
- void memcached_result_set_flags (memcached_result_st *ptr, uint32_t flags)
-
- void memcached_result_set_expiration (memcached_result_st *ptr, time_t)
+Compile and link with -lmemcachedutil -lmemcached
SASL support
============
-
--------
-LIBRARY
--------
-
-
-C Client Library for memcached (libmemcached, -lmemcached)
+.. index:: object: memcached_st
--------
SYNOPSIS
--------
+#include <libmemcached/memcached_pool.h>
+
+.. c:function:: void memcached_set_sasl_callbacks(memcached_st *ptr, const sasl_callback_t *callbacks)
+
+.. c:function:: const sasl_callback_t *memcached_get_sasl_callbacks(memcached_st *ptr)
+.. c:function:: memcached_return memcached_set_sasl_auth_data(memcached_st *ptr, const char *username, const char *password)
-.. code-block:: perl
+.. c:function:: memcached_return memcached_destroy_sasl_auth_data(memcached_st *ptr)
- #include <libmemcached/memcached.h>
-
- void memcached_set_sasl_callbacks(memcached_st *ptr,
- const sasl_callback_t *callbacks)
-
- const sasl_callback_t *memcached_get_sasl_callbacks(memcached_st *ptr)
-
- memcached_return memcached_set_sasl_auth_data(memcached_st *ptr,
- const char *username,
- const char *password)
- memcached_return memcached_destroy_sasl_auth_data(memcached_st *ptr)
+Compile and link with -lmemcached
=========================
+.. index:: object: memcached_server_instance_st
--------
SYNOPSIS
Manipulate the server information stored in memcached_st
========================================================
+.. index:: object: memcached_st
-Manage server list
-
-
-*******
-LIBRARY
-*******
+--------
+SYNOPSIS
+--------
+#include <libmemcached/memcached.h>
+
+.. c:function:: uint32_t memcached_server_count (memcached_st *ptr);
-C Client Library for memcached (libmemcached, -lmemcached)
+.. c:function:: memcached_return_t memcached_server_add (memcached_st *ptr, const char *hostname, in_port_t port);
+.. c:function:: memcached_return_t memcached_server_add_udp (memcached_st *ptr, const char *hostname, in_port_t port);
---------
-SYNOPSIS
---------
+.. c:function:: memcached_return_t memcached_server_add_unix_socket (memcached_st *ptr, const char *socket);
+.. c:function:: memcached_return_t memcached_server_push (memcached_st *ptr, const memcached_server_st *list);
+.. c:function:: memcached_server_instance_st memcached_server_by_key (const memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error);
-.. code-block:: perl
+.. c:function:: memcached_server_instance_st memcached_server_get_last_disconnect (const memcached_st *ptr)
- #include <libmemcached/memcached.h>
-
- uint32_t memcached_server_count (memcached_st *ptr);
-
- memcached_return_t memcached_server_add (memcached_st *ptr, const char *hostname, in_port_t port);
-
- memcached_return_t memcached_server_add_udp (memcached_st *ptr, const char *hostname, in_port_t port);
-
- memcached_return_t memcached_server_add_unix_socket (memcached_st *ptr, const char *socket);
-
- memcached_return_t memcached_server_push (memcached_st *ptr, const memcached_server_st *list);
+.. c:function:: memcached_return_t memcached_server_cursor(const memcached_st *ptr, const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks);
- memcached_server_instance_st memcached_server_by_key (const memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error);
-
- memcached_server_instance_st memcached_server_get_last_disconnect (const memcached_st *ptr)
-
- memcached_return_t memcached_server_cursor(const memcached_st *ptr, const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks);
+compile and link with -lmemcached
is passed the original caller memcached_st in its current state.
-******
+------
RETURN
-******
+------
Varies, see particular functions.
-****
+----
HOME
-****
+----
To find out more information please check:
-==========================
-Storing and Replacing Data
-==========================
+=========================================================
+Store, replace, add, or atomically add data to the server
+=========================================================
-
-Store value on server
+.. index:: object: memcached_st
--------
--------
-
#include <libmemcached/memcached.h>
.. c:function:: memcached_return_t memcached_set (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.. c:function:: memcached_return_t memcached_replace (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.. c:function:: memcached_return_t memcached_prepend(memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags)
-
-.. c:function:: memcached_return_t memcached_append(memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags)
-
-.. c:function:: memcached_return_t memcached_cas(memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-
.. c:function:: memcached_return_t memcached_set_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.. c:function:: memcached_return_t memcached_add_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.. c:function:: memcached_return_t memcached_replace_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.. c:function:: memcached_return_t memcached_prepend_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-
-.. c:function:: memcached_return_t memcached_append_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-
-.. c:function:: memcached_return_t memcached_cas_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-
Compile and link with -lmemcached
memcached_set(), memcached_add(), and memcached_replace() are all used to
store information on the server. All methods take a key, and its length to
-store the object. Keys are currently limited to 250 characters by the
-memcached(1) server. You must supply both a value and a length. Optionally you
+store the object. Keys are currently limited to 250 characters when using either a version of memcached(1) which is 1.4 or below, or when using the text protocol.
+You must supply both a value and a length. Optionally you
may test an expiration time for the object and a 16 byte value (it is
-meant to be used as a bitmap).
+meant to be used as a bitmap). "flags" is a 4byte space that is stored alongside of the main value. Many sub libraries make use of this field, so in most cases users should avoid making use of it.
memcached_set() will write an object to the server. If an object already
exists it will overwrite what is in the server. If the object does not exist
memcached_add() adds an object to the server. If the object is found on the
server an error occurs, otherwise the value is stored.
-memcached_prepend() places a segment of data before the last piece of data
-stored. Currently expiration and key are not used in the server.
-
-memcached_append() places a segment of data at the end of the last piece of
-data stored. Currently expiration and key are not used in the server.
-
memcached_cas() overwrites data in the server as long as the "cas" value is
still the same in the server. You can get the cas value of a result by
calling memcached_result_cas() on a memcached_result_st(3) structure. At the point
for it in libmemcached(3) is optional. Please see memcached_set() for
information on how to do this.
-memcached_set_by_key(), memcached_add_by_key(), memcached_replace_by_key(),
-memcached_prepend_by_key(), memcached_append_by_key_by_key(),
-memcached_cas_by_key() methods all behave in a similar method as the non key
+memcached_set_by_key(), memcached_add_by_key(), and memcached_replace_by_key()
+methods all behave in a similar method as the non key
methods. The difference is that they use their group_key parameter to map
objects to particular servers.
--------
-memcached(1) libmemached(3) memcached_strerror(3)
+memcached(1) libmemached(3) memcached_strerror(3) memcached_prepend(3) memcached_cas(3) memcached_append(3)
Get memcached statistics
-
-*******
-LIBRARY
-*******
-
-
-C Client Library for memcached (libmemcached, -lmemcached)
+.. index:: object: memcached_st
--------
SYNOPSIS
--------
+#include <libmemcached/memcached.h>
+
+.. c:function:: memcached_stat_st *memcached_stat (memcached_st *ptr, char *args, memcached_return_t *error);
+
+.. c:function:: memcached_return_t memcached_stat_servername (memcached_stat_st *stat, char *args, const char *hostname, unsigned int port);
+.. c:function:: char * memcached_stat_get_value (memcached_st *ptr, memcached_stat_st *stat, const char *key, memcached_return_t *error);
-.. code-block:: perl
-
- #include <libmemcached/memcached.h>
-
- memcached_stat_st *memcached_stat (memcached_st *ptr,
- char *args,
- memcached_return_t *error);
-
- memcached_return_t memcached_stat_servername (memcached_stat_st *stat,
- char *args,
- const char *hostname,
- unsigned int port);
-
- char *
- memcached_stat_get_value (memcached_st *ptr,
- memcached_stat_st *stat,
- const char *key,
- memcached_return_t *error);
-
- char **
- memcached_stat_get_keys (memcached_st *ptr,
- memcached_stat_st *stat,
- memcached_return_t *error);
-
- memcached_return_t
- memcached_stat_execute (memcached_st *memc,
- const char *args,
- memcached_stat_fn func,
- void *context);
+.. c:function:: char ** memcached_stat_get_keys (memcached_st *ptr, memcached_stat_st *stat, memcached_return_t *error);
+.. c:function:: memcached_return_t memcached_stat_execute (memcached_st *memc, const char *args, memcached_stat_fn func, void *context);
+Compile and link with -lmemcached
-----------
DESCRIPTION
an application to do this.
-******
+------
RETURN
-******
+------
Varies, see particular functions.
memory allocated for it.
-****
+----
HOME
-****
+----
To find out more information please check:
`http://libmemcached.org/ <http://libmemcached.org/>`_
-******
+------
AUTHOR
-******
+------
Brian Aker, <brian@tangent.org>
================================================
-*******
-LIBRARY
-*******
-
-
-C Client Library for memcached (libmemcached, -lmemcached)
-
+.. index:: object: memcached_st
--------
SYNOPSIS
--------
+#include <libmemcached/memcached.h>
+.. c:function:: const char * memcached_strerror (memcached_st *ptr, memcached_return_t rc);
-.. code-block:: perl
-
- #include <libmemcached/memcached.h>
-
- const char *
- memcached_strerror (memcached_st *ptr,
- memcached_return_t rc);
-
+Compile and link with -lmemcached
-----------
with switch/case and know that you are capturing all possible return values.
-******
+------
RETURN
-******
+------
memcached_strerror() returns a string describing a \ ``memcached_return_t``\ value.
-****
+----
HOME
-****
+----
To find out more information please check:
`http://libmemcached.org/ <http://libmemcached.org/>`_
-******
-AUTHOR
-******
-
-
-Brian Aker, <brian@tangent.org>
-
--------
SEE ALSO
Storing custom user information in the client.
==============================================
+.. index:: object: memcached_st
Manage user specific data
-*******
+-------
LIBRARY
-*******
+-------
C Client Library for memcached (libmemcached, -lmemcached)
the memcached_st structure.
-******
+------
RETURN
-******
+------
memcached_set_user_data() returns the previous value of the user specific
data.
-****
+----
HOME
-****
+----
To find out more information please check:
`http://libmemcached.org/ <http://libmemcached.org/>`_
-******
-AUTHOR
-******
-
-
-Trond Norbye, <trond.norbye@gmail.com>
-
-
--------
SEE ALSO
--------
Setting the verbosity of a server
=================================
+.. index:: object: memcached_st
Modifiy verbosity of servers
-
-*******
-LIBRARY
-*******
-
-
-C Client Library for memcached (libmemcached, -lmemcached)
-
-
--------
SYNOPSIS
--------
+#include <libmemcached/memcached.h>
+.. c:function:: memcached_return_t memcached_verbosity (memcached_st *ptr, unsigned int verbosity);
-.. code-block:: perl
-
- #include <libmemcached/memcached.h>
-
- memcached_return_t
- memcached_verbosity (memcached_st *ptr,
- unsigned int verbosity);
-
+Compile and link with -lmemcached
-----------
memcached(1) servers referenced in the \ ``memcached_st``\ parameter.
-******
+------
RETURN
-******
+------
A value of type \ ``memcached_return_t``\ is returned
Use memcached_strerror() to translate this value to a printable string.
-****
+----
HOME
-****
+----
To find out more information please check:
`http://libmemcached.org/ <http://libmemcached.org/>`_
-******
-AUTHOR
-******
-
-
-Brian Aker, <brian@tangent.org>
-
-
--------
SEE ALSO
--------
Getting version information about the client and server
=======================================================
-
-Get library version
-
-
-*******
-LIBRARY
-*******
-
-
-C Client Library for memcached (libmemcached, -lmemcached)
-
-
+
--------
SYNOPSIS
--------
+#include <libmemcached/memcached.h>
+.. c:function:: const char * memcached_lib_version (void)
-.. code-block:: perl
+.. c:function:: memcached_return_t memcached_version (memcached_st *ptr)
- #include <libmemcached/memcached.h>
-
- const char *
- memcached_lib_version (void)
-
-
- memcached_return_t
- memcached_version (memcached_st *ptr)
+
+Compile and link with -lmemcached
memcached server return code.
-******
+------
RETURN
-******
+------
A string with the version of libmemcached driver is returned from
a printable string.
-****
+----
HOME
-****
+----
To find out more information please check:
`http://libmemcached.org/ <http://libmemcached.org/>`_
-******
-AUTHOR
-******
-
-
-Brian Aker, <brian@tangent.org>
-
-
--------
SEE ALSO
--------
memcapable - Checking a Memcached server capibilities and compatibility
=======================================================================
+.. index:: object: memcached_st
Check the server for compatibility and capabilities
For a full list of operations run the tool with the \ **--help**\ option.
-****
+----
HOME
-****
+----
To find out more infoerroration please check:
`http://libmemcached.org/ <http://libmemcached.org/>`_
-******
-AUTHOR
-******
-
-
-Brian Aker, <brian@tangent.org>
-
-
--------
SEE ALSO
--------
#include <libhashkit/common.h>
-static inline bool _hashkit_init(hashkit_st *self)
+static inline void _hashkit_init(hashkit_st *self)
{
self->base_hash.function= hashkit_one_at_a_time;
self->base_hash.context= NULL;
- self->distribution_hash.function= self->base_hash.function;
- self->flags.is_base_same_distributed= false;
- return true;
+ self->distribution_hash.function= hashkit_one_at_a_time;
+ self->distribution_hash.context= NULL;
+
+ self->flags.is_base_same_distributed= true;
}
static inline hashkit_st *_hashkit_create(hashkit_st *self)
{
- if (self == NULL)
+ if (not self)
{
- self= (hashkit_st *)malloc(sizeof(hashkit_st));
- if (self == NULL)
+ self= new hashkit_st;
+ if (not self)
{
return NULL;
}
hashkit_st *hashkit_create(hashkit_st *self)
{
self= _hashkit_create(self);
- if (! self)
+ if (not self)
return self;
- if (! _hashkit_init(self))
- {
- hashkit_free(self);
- }
+ _hashkit_init(self);
return self;
}
{
if (hashkit_is_allocated(self))
{
- free(self);
+ delete self;
}
}
bool hashkit_compare(const hashkit_st *first, const hashkit_st *second)
{
- if (first->base_hash.function == second->base_hash.function &&
- first->base_hash.context == second->base_hash.context &&
- first->distribution_hash.function == second->distribution_hash.function &&
- first->distribution_hash.context == second->distribution_hash.context &&
+ if (not first or not second)
+ return false;
+
+ if (first->base_hash.function == second->base_hash.function and
+ first->base_hash.context == second->base_hash.context and
+ first->distribution_hash.function == second->distribution_hash.function and
+ first->distribution_hash.context == second->distribution_hash.context and
first->flags.is_base_same_distributed == second->flags.is_base_same_distributed)
{
return true;
*/
-#ifndef HASHKIT_TYPES_H
-#define HASHKIT_TYPES_H
-
-#ifdef __cplusplus
-
-extern "C" {
-#endif
+#pragma once
typedef enum {
HASHKIT_SUCCESS,
HASHKIT_MAXIMUM_RETURN /* Always add new error code before */
} hashkit_return_t;
+#define hashkit_success(X) ((X) == HASHKIT_SUCCESS)
+#define hashkit_failed(X) ((X) != HASHKIT_SUCCESS)
+
typedef enum {
HASHKIT_HASH_DEFAULT= 0, // hashkit_one_at_a_time()
HASHKIT_HASH_MD5,
HASHKIT_DISTRIBUTION_MAX /* Always add new values before this. */
} hashkit_distribution_t;
+#ifdef __cplusplus
+extern "C" {
+#endif
typedef struct hashkit_st hashkit_st;
#ifdef __cplusplus
}
#endif
-
-#endif /* HASHKIT_TYPES_H */
-#include "common.h"
+/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ * Libmemcached library
+ *
+ * Copyright (C) 2011 Data Differential, http://datadifferential.com/
+ * Copyright (C) 2006-2009 Brian Aker All rights reserved.
+ *
+ * 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.
+ *
+ */
-void _libmemcached_free(const memcached_st *ptr, void *mem, void *context)
+#include <libmemcached/common.h>
+
+void _libmemcached_free(const memcached_st*, void *mem, void*)
{
- (void) ptr;
- (void) context;
- free(mem);
+ if (mem)
+ free(mem);
}
-void *_libmemcached_malloc(const memcached_st *ptr, size_t size, void *context)
+void *_libmemcached_malloc(const memcached_st *, size_t size, void *)
{
- (void) ptr;
- (void) context;
return malloc(size);
}
-void *_libmemcached_realloc(const memcached_st *ptr, void *mem, size_t size, void *context)
+void *_libmemcached_realloc(const memcached_st*, void *mem, size_t size, void *)
{
- (void) ptr;
- (void) context;
return realloc(mem, size);
}
-void *_libmemcached_calloc(const memcached_st *ptr, size_t nelem, size_t size, void *context)
+void *_libmemcached_calloc(const memcached_st *self, size_t nelem, size_t size, void *context)
{
- if (ptr->allocators.malloc != _libmemcached_malloc)
+ if (self->allocators.malloc != _libmemcached_malloc)
{
- void *ret = _libmemcached_malloc(ptr, nelem * size, context);
- if (ret != NULL)
+ void *ret = _libmemcached_malloc(self, nelem * size, context);
+ if (not ret)
memset(ret, 0, nelem * size);
return ret;
return global_default_allocator;
}
-memcached_return_t memcached_set_memory_allocators(memcached_st *ptr,
+memcached_return_t memcached_set_memory_allocators(memcached_st *self,
memcached_malloc_fn mem_malloc,
memcached_free_fn mem_free,
memcached_realloc_fn mem_realloc,
/* All should be set, or none should be set */
if (mem_malloc == NULL && mem_free == NULL && mem_realloc == NULL && mem_calloc == NULL)
{
- ptr->allocators= memcached_allocators_return_default();
+ self->allocators= memcached_allocators_return_default();
}
else if (mem_malloc == NULL || mem_free == NULL || mem_realloc == NULL || mem_calloc == NULL)
{
}
else
{
- ptr->allocators.malloc= mem_malloc;
- ptr->allocators.free= mem_free;
- ptr->allocators.realloc= mem_realloc;
- ptr->allocators.calloc= mem_calloc;
- ptr->allocators.context= context;
+ self->allocators.malloc= mem_malloc;
+ self->allocators.free= mem_free;
+ self->allocators.realloc= mem_realloc;
+ self->allocators.calloc= mem_calloc;
+ self->allocators.context= context;
}
return MEMCACHED_SUCCESS;
}
-void *memcached_get_memory_allocators_context(const memcached_st *ptr)
+void *memcached_get_memory_allocators_context(const memcached_st *self)
{
- return ptr->allocators.context;
+ return self->allocators.context;
}
-void memcached_get_memory_allocators(const memcached_st *ptr,
+void memcached_get_memory_allocators(const memcached_st *self,
memcached_malloc_fn *mem_malloc,
memcached_free_fn *mem_free,
memcached_realloc_fn *mem_realloc,
memcached_calloc_fn *mem_calloc)
{
- *mem_malloc= ptr->allocators.malloc;
- *mem_free= ptr->allocators.free;
- *mem_realloc= ptr->allocators.realloc;
- *mem_calloc= ptr->allocators.calloc;
+ *mem_malloc= self->allocators.malloc;
+ *mem_free= self->allocators.free;
+ *mem_realloc= self->allocators.realloc;
+ *mem_calloc= self->allocators.calloc;
}
*
*/
-#include "libmemcached/common.h"
+#include <libmemcached/common.h>
+#include <assert.h>
+#include <iso646.h>
struct memcached_array_st
{
- memcached_st *root;
+ struct memcached_st *root;
size_t size;
char c_str[];
};
-memcached_array_st *memcached_array_clone(memcached_st *memc, const memcached_array_st *original)
+
+memcached_array_st *memcached_array_clone(struct memcached_st *memc, const memcached_array_st *original)
{
- if (! original)
+ if (not original)
return NULL;
return memcached_strcpy(memc, original->c_str, original->size);
}
-memcached_array_st *memcached_strcpy(memcached_st *memc, const char *str, size_t str_length)
+memcached_array_st *memcached_strcpy(struct memcached_st *memc, const char *str, size_t str_length)
{
+ assert(memc);
+ assert(str);
+ assert(str_length);
+
memcached_array_st *array= (struct memcached_array_st *)libmemcached_malloc(memc, sizeof(struct memcached_array_st) +str_length +1);
- if (! array)
+ if (not array)
return NULL;
array->root= memc;
- array->size= str_length -1; // We don't count the NULL ending
+ array->size= str_length; // We don't count the NULL ending
memcpy(array->c_str, str, str_length);
array->c_str[str_length]= 0;
return array;
}
+bool memcached_array_is_null(memcached_array_st *array)
+{
+ assert(array);
+ assert(array->root);
+
+ if (not array)
+ return false;
+
+ if (array->size and array->c_str)
+ return false;
+
+ assert(not array->size and not array->c_str);
+
+ return true;
+}
+
memcached_string_t memcached_array_to_string(memcached_array_st *array)
{
+ assert(array);
+ assert(array->c_str);
+ assert(array->size);
memcached_string_t tmp;
tmp.c_str= array->c_str;
tmp.size= array->size;
void memcached_array_free(memcached_array_st *array)
{
- if (! array)
+ if (not array)
return;
WATCHPOINT_ASSERT(array->root);
- if (array && array->root)
- {
- libmemcached_free(array->root, array);
- }
- else if (array)
- {
- free(array);
- }
+ libmemcached_free(array->root, array);
}
size_t memcached_array_size(memcached_array_st *array)
{
- if (! array)
+ if (not array)
return 0;
return array->size;
const char *memcached_array_string(memcached_array_st *array)
{
- if (! array)
+ if (not array)
return NULL;
return array->c_str;
LIBMEMCACHED_LOCAL
memcached_string_t memcached_array_to_string(memcached_array_st *array);
+LIBMEMCACHED_LOCAL
+bool memcached_array_is_null(memcached_array_st *array);
+
#ifdef __cplusplus
} // extern "C"
#endif
uint64_t offset,
uint64_t *value)
{
- memcached_return_t rc;
char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
uint32_t server_key;
memcached_server_write_instance_st instance;
bool no_reply= ptr->flags.no_reply;
if (ptr->flags.verify_key && (memcached_key_test((const char **)&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED))
- return MEMCACHED_BAD_KEY_PROVIDED;
+ return memcached_set_error(*ptr, MEMCACHED_BAD_KEY_PROVIDED, MEMCACHED_AT);
server_key= memcached_generate_hash_with_redistribution(ptr, group_key, group_key_length);
instance= memcached_server_instance_fetch(ptr, server_key);
(int)key_length, key,
offset, no_reply ? " noreply" : "");
if (send_length >= MEMCACHED_DEFAULT_COMMAND_SIZE || send_length < 0)
- return MEMCACHED_WRITE_FAILURE;
+ {
+ return memcached_set_error(*ptr, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT,
+ memcached_literal_param("snprintf(MEMCACHED_DEFAULT_COMMAND_SIZE)"));
+ }
- rc= memcached_do(instance, buffer, (size_t)send_length, true);
- if (no_reply || rc != MEMCACHED_SUCCESS)
+ memcached_return_t rc= memcached_do(instance, buffer, (size_t)send_length, true);
+ if (no_reply or memcached_failed(rc))
return rc;
rc= memcached_response(instance, buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, NULL);
use it. We still called memcached_response() though since it
worked its magic for non-blocking IO.
*/
- if (! strncmp(buffer, "ERROR\r\n", 7))
+ if (not strncmp(buffer, memcached_literal_param("ERROR\r\n")))
{
*value= 0;
rc= MEMCACHED_PROTOCOL_ERROR;
}
- else if (! strncmp(buffer, "CLIENT_ERROR\r\n", 14))
+ else if (not strncmp(buffer, memcached_literal_param("CLIENT_ERROR\r\n")))
{
*value= 0;
rc= MEMCACHED_PROTOCOL_ERROR;
}
- else if (!strncmp(buffer, "NOT_FOUND\r\n", 11))
+ else if (not strncmp(buffer, memcached_literal_param("NOT_FOUND\r\n")))
{
*value= 0;
rc= MEMCACHED_NOTFOUND;
rc= MEMCACHED_SUCCESS;
}
- return rc;
+ return memcached_set_error(*instance, rc, MEMCACHED_AT);
}
static memcached_return_t binary_incr_decr(memcached_st *ptr, uint8_t cmd,
bool no_reply= ptr->flags.no_reply;
if (memcached_server_count(ptr) == 0)
- return memcached_set_error(ptr, MEMCACHED_NO_SERVERS, NULL);
+ return memcached_set_error(*ptr, MEMCACHED_NO_SERVERS, MEMCACHED_AT);
server_key= memcached_generate_hash_with_redistribution(ptr, group_key, group_key_length);
instance= memcached_server_instance_fetch(ptr, server_key);
{
if(cmd == PROTOCOL_BINARY_CMD_DECREMENT)
cmd= PROTOCOL_BINARY_CMD_DECREMENTQ;
+
if(cmd == PROTOCOL_BINARY_CMD_INCREMENT)
cmd= PROTOCOL_BINARY_CMD_INCREMENTQ;
}
--- /dev/null
+/* 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.
+ *
+ */
+
+#pragma once
+
+// No assumptions of NULL should be made
+
+struct memcached_string_t {
+ const char *c_str;
+ size_t size;
+};
+
+#define memcached_size(X) (X).size;
+#define memcached_c_str(X) (X).c_str;
+#define memcached_string_param(X) (X).c_str, (X).size
+
+#ifdef __cplusplus
+#define memcached_string_printf(X) int((X).size), (X).c_str
+#else
+#define memcached_string_printf(X) (int)((X).size), (X).c_str
+#endif
+
-/* LibMemcached
- * Copyright (C) 2006-2009 Brian Aker
- * All rights reserved.
+/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ * Libmemcached library
*
- * Use and distribution licensed under the BSD license. See
- * the COPYING file in the parent directory for full text.
+ * Copyright (C) 2011 Data Differential, http://datadifferential.com/
+ * Copyright (C) 2006-2009 Brian Aker All rights reserved.
*
- * Summary: Change the behavior of the memcached connection.
+ * 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/common.h>
#include <libmemcached/virtual_bucket.h>
-#include <time.h>
+#include <ctime>
#include <sys/types.h>
-static bool set_flag(uint64_t data)
-{
- // Wordy :)
- return data ? true : false;
-}
-
/*
This function is used to modify the behavior of running client.
const memcached_behavior_t flag,
uint64_t data)
{
+ if (not ptr)
+ return MEMCACHED_INVALID_ARGUMENTS;
+
switch (flag)
{
case MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS:
ptr->number_of_replicas= (uint32_t)data;
break;
+
case MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK:
ptr->io_msg_watermark= (uint32_t) data;
break;
+
case MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK:
ptr->io_bytes_watermark= (uint32_t)data;
break;
+
case MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH:
ptr->io_key_prefetch = (uint32_t)data;
break;
+
case MEMCACHED_BEHAVIOR_SND_TIMEOUT:
ptr->snd_timeout= (int32_t)data;
break;
+
case MEMCACHED_BEHAVIOR_RCV_TIMEOUT:
ptr->rcv_timeout= (int32_t)data;
break;
case MEMCACHED_BEHAVIOR_REMOVE_FAILED_SERVERS:
- ptr->flags.auto_eject_hosts= set_flag(data);
+ ptr->flags.auto_eject_hosts= bool(data);
+
case MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT:
ptr->server_failure_limit= (uint32_t)data;
break;
{
ptr->flags.verify_key= false;
}
- ptr->flags.binary_protocol= set_flag(data);
+ ptr->flags.binary_protocol= bool(data);
break;
+
case MEMCACHED_BEHAVIOR_SUPPORT_CAS:
- ptr->flags.support_cas= set_flag(data);
+ ptr->flags.support_cas= bool(data);
break;
+
case MEMCACHED_BEHAVIOR_NO_BLOCK:
- ptr->flags.no_block= set_flag(data);
+ ptr->flags.no_block= bool(data);
send_quit(ptr);
break;
+
case MEMCACHED_BEHAVIOR_BUFFER_REQUESTS:
- ptr->flags.buffer_requests= set_flag(data);
+ ptr->flags.buffer_requests= bool(data);
send_quit(ptr);
break;
+
case MEMCACHED_BEHAVIOR_USE_UDP:
if (memcached_server_count(ptr))
{
return MEMCACHED_FAILURE;
}
- ptr->flags.use_udp= set_flag(data);
+ ptr->flags.use_udp= bool(data);
if (data)
{
- ptr->flags.no_reply= set_flag(data);
+ ptr->flags.no_reply= bool(data);
}
break;
+
case MEMCACHED_BEHAVIOR_TCP_NODELAY:
- ptr->flags.tcp_nodelay= set_flag(data);
+ ptr->flags.tcp_nodelay= bool(data);
send_quit(ptr);
break;
+
case MEMCACHED_BEHAVIOR_TCP_KEEPALIVE:
- ptr->flags.tcp_keepalive= set_flag(data);
+ ptr->flags.tcp_keepalive= bool(data);
send_quit(ptr);
break;
+
case MEMCACHED_BEHAVIOR_DISTRIBUTION:
return memcached_behavior_set_distribution(ptr, (memcached_server_distribution_t)data);
+
case MEMCACHED_BEHAVIOR_KETAMA:
{
if (data) // Turn on
return memcached_behavior_set_distribution(ptr, MEMCACHED_DISTRIBUTION_MODULA);
}
+
case MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED:
{
(void)memcached_behavior_set_key_hash(ptr, MEMCACHED_HASH_MD5);
(void)memcached_behavior_set_distribution_hash(ptr, MEMCACHED_HASH_MD5);
- ptr->ketama.weighted= set_flag(data);
+ ptr->ketama.weighted= bool(data);
/**
@note We try to keep the same distribution going. This should be deprecated and rewritten.
*/
return memcached_behavior_set_distribution(ptr, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA);
}
+
case MEMCACHED_BEHAVIOR_HASH:
return memcached_behavior_set_key_hash(ptr, (memcached_hash_t)(data));
+
case MEMCACHED_BEHAVIOR_KETAMA_HASH:
return memcached_behavior_set_distribution_hash(ptr, (memcached_hash_t)(data));
case MEMCACHED_BEHAVIOR_CACHE_LOOKUPS:
- return memcached_set_error_string(ptr, MEMCACHED_DEPRECATED,
- memcached_string_with_size("MEMCACHED_BEHAVIOR_CACHE_LOOKUPS has been deprecated."));
+ return memcached_set_error(*ptr, MEMCACHED_DEPRECATED, MEMCACHED_AT,
+ memcached_literal_param("MEMCACHED_BEHAVIOR_CACHE_LOOKUPS has been deprecated."));
case MEMCACHED_BEHAVIOR_VERIFY_KEY:
if (ptr->flags.binary_protocol)
- return memcached_set_error_string(ptr, MEMCACHED_INVALID_ARGUMENTS,
- memcached_string_with_size("MEMCACHED_BEHAVIOR_VERIFY_KEY if the binary protocol has been enabled."));
- ptr->flags.verify_key= set_flag(data);
+ return memcached_set_error(*ptr, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT,
+ memcached_literal_param("MEMCACHED_BEHAVIOR_VERIFY_KEY if the binary protocol has been enabled."));
+ ptr->flags.verify_key= bool(data);
break;
+
case MEMCACHED_BEHAVIOR_SORT_HOSTS:
{
- ptr->flags.use_sort_hosts= set_flag(data);
+ ptr->flags.use_sort_hosts= bool(data);
run_distribution(ptr);
break;
}
+
case MEMCACHED_BEHAVIOR_POLL_TIMEOUT:
ptr->poll_timeout= (int32_t)data;
break;
+
case MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT:
ptr->connect_timeout= (int32_t)data;
break;
+
case MEMCACHED_BEHAVIOR_RETRY_TIMEOUT:
ptr->retry_timeout= (int32_t)data;
break;
+
case MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE:
ptr->send_size= (int32_t)data;
send_quit(ptr);
break;
+
case MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE:
ptr->recv_size= (int32_t)data;
send_quit(ptr);
break;
+
case MEMCACHED_BEHAVIOR_TCP_KEEPIDLE:
ptr->tcp_keepidle= (uint32_t)data;
send_quit(ptr);
break;
+
case MEMCACHED_BEHAVIOR_USER_DATA:
- return memcached_set_error_string(ptr, MEMCACHED_DEPRECATED,
- memcached_string_with_size("MEMCACHED_BEHAVIOR_USER_DATA deprecated."));
+ return memcached_set_error(*ptr, MEMCACHED_DEPRECATED, MEMCACHED_AT,
+ memcached_literal_param("MEMCACHED_BEHAVIOR_USER_DATA deprecated."));
+
case MEMCACHED_BEHAVIOR_HASH_WITH_PREFIX_KEY:
- ptr->flags.hash_with_prefix_key= set_flag(data);
+ ptr->flags.hash_with_prefix_key= bool(data);
break;
+
case MEMCACHED_BEHAVIOR_NOREPLY:
- ptr->flags.no_reply= set_flag(data);
+ ptr->flags.no_reply= bool(data);
break;
+
case MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS:
- ptr->flags.auto_eject_hosts= set_flag(data);
+ ptr->flags.auto_eject_hosts= bool(data);
break;
+
case MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ:
srandom((uint32_t) time(NULL));
- ptr->flags.randomize_replica_read= set_flag(data);
+ ptr->flags.randomize_replica_read= bool(data);
break;
+
case MEMCACHED_BEHAVIOR_CORK:
- {
- return memcached_set_error_string(ptr, MEMCACHED_DEPRECATED,
- memcached_string_with_size("MEMCACHED_BEHAVIOR_CORK is now incorporated into the driver by default."));
- }
- break;
+ return memcached_set_error(*ptr, MEMCACHED_DEPRECATED, MEMCACHED_AT,
+ memcached_literal_param("MEMCACHED_BEHAVIOR_CORK is now incorporated into the driver by default."));
+
case MEMCACHED_BEHAVIOR_LOAD_FROM_FILE:
- return memcached_set_error_string(ptr, MEMCACHED_INVALID_ARGUMENTS,
- memcached_string_with_size("MEMCACHED_BEHAVIOR_LOAD_FROM_FILE can not be set with memcached_behavior_set()"));
+ return memcached_set_error(*ptr, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT,
+ memcached_literal_param("MEMCACHED_BEHAVIOR_LOAD_FROM_FILE can not be set with memcached_behavior_set()"));
+
case MEMCACHED_BEHAVIOR_MAX:
default:
/* Shouldn't get here */
WATCHPOINT_ASSERT(0);
- return memcached_set_error_string(ptr, MEMCACHED_INVALID_ARGUMENTS,
- memcached_string_with_size("Invalid behavior passed to memcached_behavior_set()"));
+ return memcached_set_error(*ptr, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT,
+ memcached_literal_param("Invalid behavior passed to memcached_behavior_set()"));
}
return MEMCACHED_SUCCESS;
{
case MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS:
return ptr->number_of_replicas;
+
case MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK:
return ptr->io_msg_watermark;
+
case MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK:
return ptr->io_bytes_watermark;
+
case MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH:
return ptr->io_key_prefetch;
+
case MEMCACHED_BEHAVIOR_BINARY_PROTOCOL:
return ptr->flags.binary_protocol;
+
case MEMCACHED_BEHAVIOR_SUPPORT_CAS:
return ptr->flags.support_cas;
case MEMCACHED_BEHAVIOR_NO_BLOCK:
return ptr->flags.no_block;
+
case MEMCACHED_BEHAVIOR_BUFFER_REQUESTS:
return ptr->flags.buffer_requests;
+
case MEMCACHED_BEHAVIOR_USE_UDP:
return ptr->flags.use_udp;
+
case MEMCACHED_BEHAVIOR_TCP_NODELAY:
return ptr->flags.tcp_nodelay;
+
case MEMCACHED_BEHAVIOR_VERIFY_KEY:
return ptr->flags.verify_key;
+
case MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED:
return ptr->ketama.weighted;
+
case MEMCACHED_BEHAVIOR_DISTRIBUTION:
return ptr->distribution;
+
case MEMCACHED_BEHAVIOR_KETAMA:
return (ptr->distribution == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA) ? (uint64_t) 1 : 0;
+
case MEMCACHED_BEHAVIOR_HASH:
return hashkit_get_function(&ptr->hashkit);
+
case MEMCACHED_BEHAVIOR_KETAMA_HASH:
- return hashkit_get_function(&ptr->distribution_hashkit);
+ return hashkit_get_function(&ptr->hashkit);
+
case MEMCACHED_BEHAVIOR_REMOVE_FAILED_SERVERS:
case MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT:
return ptr->server_failure_limit;
+
case MEMCACHED_BEHAVIOR_SORT_HOSTS:
return ptr->flags.use_sort_hosts;
+
case MEMCACHED_BEHAVIOR_POLL_TIMEOUT:
return (uint64_t)ptr->poll_timeout;
+
case MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT:
return (uint64_t)ptr->connect_timeout;
+
case MEMCACHED_BEHAVIOR_RETRY_TIMEOUT:
return (uint64_t)ptr->retry_timeout;
+
case MEMCACHED_BEHAVIOR_SND_TIMEOUT:
return (uint64_t)ptr->snd_timeout;
+
case MEMCACHED_BEHAVIOR_RCV_TIMEOUT:
return (uint64_t)ptr->rcv_timeout;
+
case MEMCACHED_BEHAVIOR_TCP_KEEPIDLE:
return (uint64_t)ptr->tcp_keepidle;
+
case MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE:
{
int sock_size= 0;
socklen_t sock_length= sizeof(int);
- memcached_server_write_instance_st instance;
if (ptr->send_size != -1) // If value is -1 then we are using the default
return (uint64_t) ptr->send_size;
- instance= memcached_server_instance_fetch(ptr, 0);
+ memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, 0);
if (instance) // If we have an instance we test, otherwise we just set and pray
{
/* REFACTOR */
/* We just try the first host, and if it is down we return zero */
- if ((memcached_connect(instance)) != MEMCACHED_SUCCESS)
+ if (memcached_failed(memcached_connect(instance)))
{
return 0;
}
- if (memcached_io_wait_for_write(instance) != MEMCACHED_SUCCESS)
+ if (memcached_failed(memcached_io_wait_for_write(instance)))
{
return 0;
}
if (getsockopt(instance->fd, SOL_SOCKET, SO_SNDBUF, &sock_size, &sock_length) < 0)
{
- memcached_set_errno(ptr, errno, NULL);
+ memcached_set_errno(*ptr, errno, MEMCACHED_AT);
return 0; /* Zero means error */
}
}
return (uint64_t) sock_size;
}
+
case MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE:
{
int sock_size= 0;
socklen_t sock_length= sizeof(int);
- memcached_server_write_instance_st instance;
if (ptr->recv_size != -1) // If value is -1 then we are using the default
return (uint64_t) ptr->recv_size;
- instance= memcached_server_instance_fetch(ptr, 0);
+ memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, 0);
/**
@note REFACTOR
if (instance)
{
/* We just try the first host, and if it is down we return zero */
- if ((memcached_connect(instance)) != MEMCACHED_SUCCESS)
+ if (memcached_failed(memcached_connect(instance)))
{
return 0;
}
- if (memcached_io_wait_for_write(instance) != MEMCACHED_SUCCESS)
+ if (memcached_failed(memcached_io_wait_for_write(instance)))
{
return 0;
}
if (getsockopt(instance->fd, SOL_SOCKET, SO_RCVBUF, &sock_size, &sock_length) < 0)
{
- memcached_set_errno(ptr, errno, NULL);
+ memcached_set_errno(*ptr, errno, MEMCACHED_AT);
return 0; /* Zero means error */
}
return (uint64_t) sock_size;
}
+
case MEMCACHED_BEHAVIOR_USER_DATA:
- memcached_set_error_string(ptr, MEMCACHED_DEPRECATED,
- memcached_string_with_size("MEMCACHED_BEHAVIOR_USER_DATA deprecated."));
+ memcached_set_error(*ptr, MEMCACHED_DEPRECATED, MEMCACHED_AT,
+ memcached_literal_param("MEMCACHED_BEHAVIOR_USER_DATA deprecated."));
return 0;
+
case MEMCACHED_BEHAVIOR_HASH_WITH_PREFIX_KEY:
return ptr->flags.hash_with_prefix_key;
+
case MEMCACHED_BEHAVIOR_NOREPLY:
return ptr->flags.no_reply;
+
case MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS:
return ptr->flags.auto_eject_hosts;
+
case MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ:
return ptr->flags.randomize_replica_read;
+
case MEMCACHED_BEHAVIOR_CORK:
#ifdef HAVE_MSG_MORE
return true;
#else
return false;
#endif
+
case MEMCACHED_BEHAVIOR_TCP_KEEPALIVE:
return ptr->flags.tcp_keepalive;
+
case MEMCACHED_BEHAVIOR_LOAD_FROM_FILE:
- return ptr->configure.filename ? true : false;
+ return bool(memcached_parse_filename(ptr));
+
case MEMCACHED_BEHAVIOR_MAX:
default:
WATCHPOINT_ASSERT(0); /* Programming mistake if it gets this far */
return MEMCACHED_SUCCESS;
}
- return memcached_set_error_string(ptr, MEMCACHED_INVALID_ARGUMENTS,
- memcached_string_with_size("Invalid memcached_server_distribution_t"));
+ return memcached_set_error(*ptr, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT,
+ memcached_literal_param("Invalid memcached_server_distribution_t"));
}
memcached_return_t memcached_behavior_set_key_hash(memcached_st *ptr, memcached_hash_t type)
{
- if (hashkit_set_function(&ptr->hashkit, (hashkit_hash_algorithm_t)type) == HASHKIT_SUCCESS)
+ if (hashkit_success(hashkit_set_function(&ptr->hashkit, (hashkit_hash_algorithm_t)type)))
return MEMCACHED_SUCCESS;
- return memcached_set_error_string(ptr, MEMCACHED_INVALID_ARGUMENTS,
- memcached_string_with_size("Invalid memcached_hash_t()"));
+ return memcached_set_error(*ptr, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT,
+ memcached_literal_param("Invalid memcached_hash_t()"));
}
memcached_hash_t memcached_behavior_get_key_hash(memcached_st *ptr)
memcached_return_t memcached_behavior_set_distribution_hash(memcached_st *ptr, memcached_hash_t type)
{
- if (hashkit_set_function(&ptr->distribution_hashkit, (hashkit_hash_algorithm_t)type) == HASHKIT_SUCCESS)
+ if (hashkit_success(hashkit_set_distribution_function(&ptr->hashkit, (hashkit_hash_algorithm_t)type)))
return MEMCACHED_SUCCESS;
- return memcached_set_error_string(ptr, MEMCACHED_INVALID_ARGUMENTS,
- memcached_string_with_size("Invalid memcached_hash_t()"));
+ return memcached_set_error(*ptr, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT,
+ memcached_literal_param("Invalid memcached_hash_t()"));
}
memcached_hash_t memcached_behavior_get_distribution_hash(memcached_st *ptr)
{
- return (memcached_hash_t)hashkit_get_function(&ptr->distribution_hashkit);
+ return (memcached_hash_t)hashkit_get_function(&ptr->hashkit);
}
const char *libmemcached_string_behavior(const memcached_behavior_t flag)
{
memcached_return_t rc;
- if (! self)
+ if (not self)
return MEMCACHED_INVALID_ARGUMENTS;
- if (! host_map)
+ if (not host_map)
return MEMCACHED_INVALID_ARGUMENTS;
- memcached_server_distribution_t old;
- old= memcached_behavior_get_distribution(self);
+ memcached_server_distribution_t old= memcached_behavior_get_distribution(self);
- rc =memcached_behavior_set_distribution(self, MEMCACHED_DISTRIBUTION_VIRTUAL_BUCKET);
- if (rc != MEMCACHED_SUCCESS)
+ if (memcached_failed(rc =memcached_behavior_set_distribution(self, MEMCACHED_DISTRIBUTION_VIRTUAL_BUCKET)))
{
return rc;
}
- rc= memcached_virtual_bucket_create(self, host_map, forward_map, buckets, replicas);
- if (rc != MEMCACHED_SUCCESS)
+ if (memcached_failed(rc= memcached_virtual_bucket_create(self, host_map, forward_map, buckets, replicas)))
{
memcached_behavior_set_distribution(self, old);
}
#include <config.h>
+#ifdef __cplusplus
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <ctime>
+#include <ctype.h>
+#else
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
-#include <strings.h>
-#include <ctype.h>
-#include <sys/types.h>
-#include <unistd.h>
-#include <limits.h>
-#include <errno.h>
-#include <fcntl.h>
-#ifdef TIME_WITH_SYS_TIME
-# include <sys/time.h>
-# include <time.h>
-#else
-# ifdef HAVE_SYS_TIME_H
-# include <sys/time.h>
-# else
-# include <time.h>
-# endif
+#include <time.h>
#endif
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <sys/types.h>
+#include <unistd.h>
#include <libmemcached/memcached.h>
#include <libmemcached/watchpoint.h>
/* These are private not to be installed headers */
+#include <libmemcached/error.hpp>
+#include <libmemcached/memory.h>
#include <libmemcached/io.h>
#include <libmemcached/do.h>
#include <libmemcached/internal.h>
return MEMCACHED_SUCCESS;
}
-static inline void libmemcached_free(const memcached_st *ptr, void *mem)
-{
- ptr->allocators.free(ptr, mem, ptr->allocators.context);
-}
-
-static inline void *libmemcached_malloc(const memcached_st *ptr, const size_t size)
-{
- return ptr->allocators.malloc(ptr, size, ptr->allocators.context);
-}
-
-static inline void *libmemcached_realloc(const memcached_st *ptr, void *mem, const size_t size)
-{
- return ptr->allocators.realloc(ptr, mem, size, ptr->allocators.context);
-}
-
-static inline void *libmemcached_calloc(const memcached_st *ptr, size_t nelem, size_t size)
-{
- return ptr->allocators.calloc(ptr, nelem, size, ptr->allocators.context);
-}
-
#ifdef __cplusplus
}
#endif
#include <libmemcached/common.h>
-#include <assert.h>
+#include <cassert>
+#include <ctime>
#include <sys/time.h>
-#include <time.h>
static memcached_return_t connect_poll(memcached_server_st *ptr)
{
hints.ai_protocol= IPPROTO_TCP;
}
- uint32_t counter= 5;
- while (--counter)
+ int errcode;
+ switch(errcode= getaddrinfo(server->hostname, str_port, &hints, &server->address_info))
{
- int e= getaddrinfo(server->hostname, str_port, &hints, &server->address_info);
+ case 0:
+ break;
- if (e == 0)
- {
- break;
- }
- else if (e == EAI_AGAIN)
- {
-#ifndef WIN32
- struct timespec dream, rem;
+ case EAI_AGAIN:
+ return memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT, memcached_string_make_from_cstr(gai_strerror(errcode)));
- dream.tv_nsec= 1000;
- dream.tv_sec= 0;
+ case EAI_SYSTEM:
+ return memcached_set_errno(*server, errno, MEMCACHED_AT, memcached_literal_param("getaddrinfo(EAI_SYSTEM)"));
- nanosleep(&dream, &rem);
-#endif
- continue;
- }
- else
+ case EAI_BADFLAGS:
+ return memcached_set_error(*server, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT, memcached_literal_param("getaddrinfo(EAI_BADFLAGS)"));
+
+ case EAI_MEMORY:
+ return memcached_set_error(*server, MEMCACHED_ERRNO, MEMCACHED_AT, memcached_literal_param("getaddrinfo(EAI_MEMORY)"));
+
+ default:
{
WATCHPOINT_STRING(server->hostname);
WATCHPOINT_STRING(gai_strerror(e));
- return MEMCACHED_HOST_LOOKUP_FAILURE;
+ return memcached_set_error(*server, MEMCACHED_HOST_LOOKUP_FAILURE, MEMCACHED_AT, memcached_string_make_from_cstr(gai_strerror(errcode)));
}
}
-
server->address_info_next= server->address_info;
return MEMCACHED_SUCCESS;
u_long arg = 1;
if (ioctlsocket(ptr->fd, FIONBIO, &arg) == SOCKET_ERROR)
{
- ptr->cached_errno= get_socket_errno();
- return MEMCACHED_CONNECTION_FAILURE;
+ return memcached_set_errno(*ptr, get_socket_errno(), NULL);
}
#else
int flags;
unlikely (flags == -1)
{
- ptr->cached_errno= errno;
- return MEMCACHED_CONNECTION_FAILURE;
+ return memcached_set_errno(*ptr, errno, NULL);
}
else if ((flags & O_NONBLOCK) == 0)
{
unlikely (rval == -1)
{
- ptr->cached_errno= errno;
- return MEMCACHED_CONNECTION_FAILURE;
+ return memcached_set_errno(*ptr, errno, NULL);
}
}
#endif
if ((ptr->fd= socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
{
- ptr->cached_errno= errno;
- return MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE;
+ return memcached_set_errno(*ptr, errno, NULL);
}
struct sockaddr_un servAddr;
}
}
- WATCHPOINT_ASSERT(ptr->fd != -1);
+ WATCHPOINT_ASSERT(ptr->fd != INVALID_SOCKET);
return MEMCACHED_SUCCESS;
#else
WATCHPOINT_ASSERT(ptr->fd == INVALID_SOCKET);
WATCHPOINT_ASSERT(ptr->cursor_active == 0);
- if (! ptr->address_info)
+ if (not ptr->address_info)
{
- memcached_return_t rc= set_hostinfo(ptr);
- if (rc != MEMCACHED_SUCCESS)
+ memcached_return_t rc;
+ uint32_t counter= 5;
+ while (--counter)
+ {
+ if ((rc= set_hostinfo(ptr)) != MEMCACHED_TIMEOUT)
+ break;
+
+#ifndef WIN32
+ struct timespec dream, rem;
+
+ dream.tv_nsec= 1000;
+ dream.tv_sec= 0;
+
+ nanosleep(&dream, &rem);
+#endif
+ }
+
+ if (memcached_failed(rc))
return rc;
}
ptr->address_info_next->ai_socktype,
ptr->address_info_next->ai_protocol)) < 0)
{
- ptr->cached_errno= get_socket_errno();
- WATCHPOINT_ERRNO(get_socket_errno());
- return MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE;
+ return memcached_set_errno(*ptr, get_socket_errno(), NULL);
}
(void)set_socket_options(ptr);
if (ptr->fd != INVALID_SOCKET && ptr->root->sasl.callbacks)
{
rc= memcached_sasl_authenticate_connection(ptr);
- if (rc != MEMCACHED_SUCCESS)
+ if (memcached_failed(rc))
{
(void)closesocket(ptr->fd);
ptr->fd= INVALID_SOCKET;
*
*/
-#include "libmemcached/common.h"
+#include <libmemcached/common.h>
#define MAX_ERROR_LENGTH 2048
struct memcached_error_t
char message[MAX_ERROR_LENGTH];
};
-static void _set(memcached_st *memc, memcached_string_t *str, const memcached_return_t rc, const int local_errno)
+static void _set(memcached_st& memc, memcached_string_t *str, memcached_return_t &rc, const char *at, int local_errno= 0)
{
- WATCHPOINT_ASSERT(memc);
- if (! memc)
- return;
+ (void)at;
+ if (memc.error_messages && memc.error_messages->query_id != memc.query_id)
+ {
+ memcached_error_free(&memc);
+ }
+
+ // For memory allocation we use our error since it is a bit more specific
+ if (local_errno == ENOMEM and rc == MEMCACHED_ERRNO)
+ {
+ local_errno= ENOMEM;
+ rc= MEMCACHED_MEMORY_ALLOCATION_FAILURE;
+ }
- if (memc->error_messages && memc->error_messages->query_id != memc->query_id)
+ if (rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE)
{
- memcached_error_free(memc);
+ local_errno= ENOMEM;
}
- memcached_error_t *error;
- error= (struct memcached_error_t *)libmemcached_malloc(memc, sizeof(struct memcached_error_t));
+ if (rc == MEMCACHED_ERRNO and not local_errno)
+ {
+ local_errno= errno;
+ rc= MEMCACHED_ERRNO;
+ }
- if (! error)
+ memcached_error_t *error= (struct memcached_error_t *)libmemcached_malloc(&memc, sizeof(struct memcached_error_t));
+ if (not error) // Bad business if this happens
return;
- error->root= memc;
- error->query_id= memc->query_id;
+ error->root= &memc;
+ error->query_id= memc.query_id;
error->rc= rc;
error->local_errno= local_errno;
error->size= 0;
}
- error->next= memc->error_messages;
- memc->error_messages= error;
+ error->next= memc.error_messages;
+ memc.error_messages= error;
+}
+
+memcached_return_t memcached_set_error(memcached_st& memc, memcached_return_t rc, const char *at, const char *str, size_t length)
+{
+ memcached_string_t tmp= { str, length };
+ return memcached_set_error(memc, rc, at, tmp);
+}
+
+memcached_return_t memcached_set_error(memcached_server_st& self, memcached_return_t rc, const char *at, const char *str, size_t length)
+{
+ memcached_string_t tmp= { str, length };
+ return memcached_set_error(self, rc, at, tmp);
+}
+
+memcached_return_t memcached_set_error(memcached_st& memc, memcached_return_t rc, const char *at, memcached_string_t& str)
+{
+ if (memcached_success(rc))
+ return MEMCACHED_SUCCESS;
+
+ _set(memc, &str, rc, at);
+
+ return rc;
+}
+
+memcached_return_t memcached_set_error(memcached_server_st& self, memcached_return_t rc, const char *at, memcached_string_t& str)
+{
+ if (memcached_success(rc))
+ return MEMCACHED_SUCCESS;
+
+ char hostname_port_message[MAX_ERROR_LENGTH];
+ int size;
+ if (str.size)
+ {
+ size= snprintf(hostname_port_message, sizeof(hostname_port_message), "%.*s, host: %s:%d",
+ memcached_string_printf(str),
+ self.hostname, int(self.port));
+ }
+ else
+ {
+ size= snprintf(hostname_port_message, sizeof(hostname_port_message), "host: %s:%d",
+ self.hostname, int(self.port));
+ }
+
+ memcached_string_t error_host= { hostname_port_message, size };
+
+ if (not self.root)
+ return rc;
+
+ _set(*self.root, &error_host, rc, at);
+
+ return rc;
+}
+
+memcached_return_t memcached_set_error(memcached_server_st& self, memcached_return_t rc, const char *at)
+{
+ if (memcached_success(rc))
+ return MEMCACHED_SUCCESS;
+
+ char hostname_port[NI_MAXHOST +NI_MAXSERV + sizeof("host : ")];
+ int size= snprintf(hostname_port, sizeof(hostname_port), "host: %s:%d", self.hostname, int(self.port));
+
+ memcached_string_t error_host= { hostname_port, size};
+
+ if (not self.root)
+ return rc;
+
+ _set(*self.root, &error_host, rc, at);
+
+ return rc;
+}
+
+memcached_return_t memcached_set_error(memcached_st& self, memcached_return_t rc, const char *at)
+{
+ if (memcached_success(rc))
+ return MEMCACHED_SUCCESS;
+
+ _set(self, NULL, rc, at);
+
+ return rc;
+}
+
+memcached_return_t memcached_set_errno(memcached_st& self, int local_errno, const char *at, const char *str, size_t length)
+{
+ memcached_string_t tmp= { str, length };
+ return memcached_set_errno(self, local_errno, at, tmp);
}
-memcached_return_t memcached_set_error_string(memcached_st *memc, memcached_return_t rc, const char *str, size_t length)
+memcached_return_t memcached_set_errno(memcached_server_st& self, int local_errno, const char *at, const char *str, size_t length)
{
- memcached_string_t tmp;
- tmp.c_str= str;
- tmp.size= length;
- return memcached_set_error(memc, rc, &tmp);
+ memcached_string_t tmp= { str, length };
+ return memcached_set_errno(self, local_errno, at, tmp);
}
-memcached_return_t memcached_set_error(memcached_st *memc, memcached_return_t rc, memcached_string_t *str)
+memcached_return_t memcached_set_errno(memcached_st& self, int local_errno, const char *at)
{
- if (rc == MEMCACHED_SUCCESS)
+ if (not local_errno)
return MEMCACHED_SUCCESS;
- _set(memc, str, rc, 0);
+ memcached_return_t rc= MEMCACHED_ERRNO;
+ _set(self, NULL, rc, at, local_errno);
return rc;
}
-memcached_return_t memcached_set_errno(memcached_st *memc, int local_errno, memcached_string_t *str)
+memcached_return_t memcached_set_errno(memcached_st& memc, int local_errno, const char *at, memcached_string_t& str)
{
- _set(memc, str, MEMCACHED_ERRNO, local_errno);
+ if (not local_errno)
+ return MEMCACHED_SUCCESS;
- return MEMCACHED_ERRNO;
+ memcached_return_t rc= MEMCACHED_ERRNO;
+ _set(memc, &str, rc, at, local_errno);
+
+ return rc;
+}
+
+memcached_return_t memcached_set_errno(memcached_server_st& self, int local_errno, const char *at, memcached_string_t& str)
+{
+ if (not local_errno)
+ return MEMCACHED_SUCCESS;
+
+ char hostname_port_message[MAX_ERROR_LENGTH];
+ int size;
+ if (str.size)
+ {
+ size= snprintf(hostname_port_message, sizeof(hostname_port_message), "%.*s, host: %s:%d",
+ memcached_string_printf(str),
+ self.hostname, int(self.port));
+ }
+ else
+ {
+ size= snprintf(hostname_port_message, sizeof(hostname_port_message), "host: %s:%d",
+ self.hostname, int(self.port));
+ }
+
+ memcached_string_t error_host= { hostname_port_message, size };
+
+ self.cached_errno= local_errno; // Store in the actual server
+
+ memcached_return_t rc= MEMCACHED_ERRNO;
+ if (not self.root)
+ return rc;
+
+ _set(*self.root, &error_host, rc, at, local_errno);
+
+ return rc;
+}
+
+memcached_return_t memcached_set_errno(memcached_server_st& self, int local_errno, const char *at)
+{
+ if (not local_errno)
+ return MEMCACHED_SUCCESS;
+
+ char hostname_port_message[MAX_ERROR_LENGTH];
+ int size = snprintf(hostname_port_message, sizeof(hostname_port_message), "host: %s:%d",
+ self.hostname, int(self.port));
+
+ memcached_string_t error_host= { hostname_port_message, size };
+
+ self.cached_errno= local_errno; // Store in the actual server
+
+ memcached_return_t rc= MEMCACHED_ERRNO;
+ if (not self.root)
+ return rc;
+
+ _set(*self.root, &error_host, rc, at, local_errno);
+
+ return rc;
}
static void _error_print(const memcached_error_t *error)
{
- if (! error)
+ if (not error)
return;
- if (! error->size)
+ if (not error->size)
{
fprintf(stderr, "%s\n", memcached_strerror(NULL, error->rc) );
}
void memcached_error_print(const memcached_st *self)
{
- if (! self)
+ if (not self)
return;
_error_print(self->error_messages);
const char *memcached_last_error_message(memcached_st *memc)
{
- if (! memc)
+ if (not memc)
return memcached_strerror(memc, MEMCACHED_INVALID_ARGUMENTS);
- if (! memc->error_messages)
+ if (not memc->error_messages)
return memcached_strerror(memc, MEMCACHED_SUCCESS);
- if (! memc->error_messages->size)
- {
+ if (not memc->error_messages->size)
return memcached_strerror(memc, memc->error_messages->rc);
- }
return memc->error_messages->message;
}
memcached_return_t memcached_last_error(memcached_st *memc)
{
- if (! memc)
+ if (not memc)
return MEMCACHED_INVALID_ARGUMENTS;
- if (! memc->error_messages)
+ if (not memc->error_messages)
return MEMCACHED_SUCCESS;
return memc->error_messages->rc;
int memcached_last_error_errno(memcached_st *memc)
{
- if (! memc)
+ if (not memc)
return 0;
- if (! memc->error_messages)
+ if (not memc->error_messages)
return 0;
return memc->error_messages->local_errno;
extern "C" {
#endif
-LIBMEMCACHED_LOCAL
- memcached_return_t memcached_set_error(memcached_st *memc, memcached_return_t rc, memcached_string_t *str);
-
-LIBMEMCACHED_LOCAL
- memcached_return_t memcached_set_error_string(memcached_st *memc, memcached_return_t rc, const char *str, size_t length);
-
-LIBMEMCACHED_LOCAL
- memcached_return_t memcached_set_errno(memcached_st *memc, int local_errno, memcached_string_t *str);
-
LIBMEMCACHED_LOCAL
void memcached_error_free(memcached_st *error);
--- /dev/null
+/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ * LibMemcached
+ *
+ * Copyright (C) 2011 Data Differential, http://datadifferential.com/
+ * All rights reserved.
+ *
+ * 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.
+ *
+ */
+
+#pragma once
+
+#include <libmemcached/error.h>
+
+#ifdef __cplusplus
+
+#define STRINGIFY(x) #x
+#define TOSTRING(x) STRINGIFY(x)
+#define MEMCACHED_AT __FILE__ ":" TOSTRING(__LINE__)
+
+LIBMEMCACHED_LOCAL
+ memcached_return_t memcached_set_error(memcached_st&, memcached_return_t rc, const char *at);
+
+LIBMEMCACHED_LOCAL
+ memcached_return_t memcached_set_error(memcached_server_st&, memcached_return_t rc, const char *at);
+
+LIBMEMCACHED_LOCAL
+ memcached_return_t memcached_set_error(memcached_st&, memcached_return_t rc, const char *at, const char *str, size_t length);
+
+LIBMEMCACHED_LOCAL
+ memcached_return_t memcached_set_error(memcached_server_st&, memcached_return_t rc, const char *at, const char *str, size_t length);
+
+LIBMEMCACHED_LOCAL
+ memcached_return_t memcached_set_error(memcached_st& memc, memcached_return_t rc, const char *at, memcached_string_t& str);
+
+LIBMEMCACHED_LOCAL
+ memcached_return_t memcached_set_error(memcached_server_st&, memcached_return_t rc, const char *at, memcached_string_t& str);
+
+LIBMEMCACHED_LOCAL
+ memcached_return_t memcached_set_errno(memcached_st& memc, int local_errno, const char *at, memcached_string_t& str);
+
+LIBMEMCACHED_LOCAL
+ memcached_return_t memcached_set_errno(memcached_server_st&, int local_errno, const char *at, memcached_string_t& str);
+
+LIBMEMCACHED_LOCAL
+ memcached_return_t memcached_set_errno(memcached_st& memc, int local_errno, const char *at, const char *str, size_t length);
+
+LIBMEMCACHED_LOCAL
+ memcached_return_t memcached_set_errno(memcached_server_st&, int local_errno, const char *at, const char *str, size_t length);
+
+LIBMEMCACHED_LOCAL
+ memcached_return_t memcached_set_errno(memcached_st& memc, int local_errno, const char *at);
+
+LIBMEMCACHED_LOCAL
+ memcached_return_t memcached_set_errno(memcached_server_st&, int local_errno, const char *at);
+
+#endif
+++ /dev/null
-#include "common.h"
-
-char *memcached_fetch(memcached_st *ptr, char *key, size_t *key_length,
- size_t *value_length,
- uint32_t *flags,
- memcached_return_t *error)
-{
- memcached_result_st *result_buffer= &ptr->result;
-
- unlikely (ptr->flags.use_udp)
- {
- *error= MEMCACHED_NOT_SUPPORTED;
- return NULL;
- }
-
- result_buffer= memcached_fetch_result(ptr, result_buffer, error);
-
- if (result_buffer == NULL || *error != MEMCACHED_SUCCESS)
- {
- WATCHPOINT_ASSERT(result_buffer == NULL);
- *value_length= 0;
- return NULL;
- }
-
- *value_length= memcached_string_length(&result_buffer->value);
-
- if (key)
- {
- if (result_buffer->key_length > MEMCACHED_MAX_KEY)
- {
- *error= MEMCACHED_KEY_TOO_BIG;
- *value_length= 0;
-
- return NULL;
- }
- strncpy(key, result_buffer->item_key, result_buffer->key_length); // For the binary protocol we will cut off the key :(
- *key_length= result_buffer->key_length;
- }
-
- *flags= result_buffer->item_flags;
-
- return memcached_string_c_copy(&result_buffer->value);
-}
-
-memcached_result_st *memcached_fetch_result(memcached_st *ptr,
- memcached_result_st *result,
- memcached_return_t *error)
-{
- memcached_server_st *server;
-
- unlikely (ptr->flags.use_udp)
- {
- *error= MEMCACHED_NOT_SUPPORTED;
- return NULL;
- }
-
- if (result == NULL)
- if ((result= memcached_result_create(ptr, NULL)) == NULL)
- return NULL;
-
- while ((server= memcached_io_get_readable_server(ptr)) != NULL)
- {
- char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
- *error= memcached_response(server, buffer, sizeof(buffer), result);
-
- if (*error == MEMCACHED_SUCCESS)
- return result;
- else if (*error == MEMCACHED_END)
- memcached_server_response_reset(server);
- else if (*error != MEMCACHED_NOTFOUND)
- break;
- }
-
- /* We have completed reading data */
- if (memcached_is_allocated(result))
- {
- memcached_result_free(result);
- }
- else
- {
- memcached_string_reset(&result->value);
- }
-
- return NULL;
-}
-
-memcached_return_t memcached_fetch_execute(memcached_st *ptr,
- memcached_execute_fn *callback,
- void *context,
- uint32_t number_of_callbacks)
-{
- memcached_result_st *result= &ptr->result;
- memcached_return_t rc= MEMCACHED_FAILURE;
-
- while ((result= memcached_fetch_result(ptr, result, &rc)) != NULL)
- {
- if (rc == MEMCACHED_SUCCESS)
- {
- for (uint32_t x= 0; x < number_of_callbacks; x++)
- {
- rc= (*callback[x])(ptr, result, context);
- if (rc != MEMCACHED_SUCCESS)
- break;
- }
- }
- }
- return rc;
-}
--- /dev/null
+/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ * Libmemcached library
+ *
+ * Copyright (C) 2011 Data Differential, http://datadifferential.com/
+ * Copyright (C) 2006-2009 Brian Aker All rights reserved.
+ *
+ * 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/common.h>
+
+char *memcached_fetch(memcached_st *ptr, char *key, size_t *key_length,
+ size_t *value_length,
+ uint32_t *flags,
+ memcached_return_t *error)
+{
+ memcached_result_st *result_buffer= &ptr->result;
+ memcached_return_t unused;
+ if (not error)
+ error= &unused;
+
+
+ unlikely (ptr->flags.use_udp)
+ {
+ *error= MEMCACHED_NOT_SUPPORTED;
+ return NULL;
+ }
+
+ result_buffer= memcached_fetch_result(ptr, result_buffer, error);
+
+ if (result_buffer == NULL || *error != MEMCACHED_SUCCESS)
+ {
+ WATCHPOINT_ASSERT(result_buffer == NULL);
+ *value_length= 0;
+ return NULL;
+ }
+
+ *value_length= memcached_string_length(&result_buffer->value);
+
+ if (key)
+ {
+ if (result_buffer->key_length > MEMCACHED_MAX_KEY)
+ {
+ *error= MEMCACHED_KEY_TOO_BIG;
+ *value_length= 0;
+
+ return NULL;
+ }
+ strncpy(key, result_buffer->item_key, result_buffer->key_length); // For the binary protocol we will cut off the key :(
+ *key_length= result_buffer->key_length;
+ }
+
+ *flags= result_buffer->item_flags;
+
+ return memcached_string_c_copy(&result_buffer->value);
+}
+
+memcached_result_st *memcached_fetch_result(memcached_st *ptr,
+ memcached_result_st *result,
+ memcached_return_t *error)
+{
+ memcached_server_st *server;
+
+ unlikely (ptr->flags.use_udp)
+ {
+ *error= MEMCACHED_NOT_SUPPORTED;
+ return NULL;
+ }
+
+ if (result == NULL)
+ if ((result= memcached_result_create(ptr, NULL)) == NULL)
+ return NULL;
+
+ while ((server= memcached_io_get_readable_server(ptr)) != NULL)
+ {
+ char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
+ *error= memcached_response(server, buffer, sizeof(buffer), result);
+
+ if (*error == MEMCACHED_SUCCESS)
+ return result;
+ else if (*error == MEMCACHED_END)
+ memcached_server_response_reset(server);
+ else if (*error != MEMCACHED_NOTFOUND)
+ break;
+ }
+
+ /* We have completed reading data */
+ if (memcached_is_allocated(result))
+ {
+ memcached_result_free(result);
+ }
+ else
+ {
+ memcached_string_reset(&result->value);
+ }
+
+ return NULL;
+}
+
+memcached_return_t memcached_fetch_execute(memcached_st *ptr,
+ memcached_execute_fn *callback,
+ void *context,
+ uint32_t number_of_callbacks)
+{
+ memcached_result_st *result= &ptr->result;
+ memcached_return_t rc= MEMCACHED_FAILURE;
+
+ while ((result= memcached_fetch_result(ptr, result, &rc)) != NULL)
+ {
+ if (rc == MEMCACHED_SUCCESS)
+ {
+ for (uint32_t x= 0; x < number_of_callbacks; x++)
+ {
+ rc= (*callback[x])(ptr, result, context);
+ if (rc != MEMCACHED_SUCCESS)
+ break;
+ }
+ }
+ }
+ return rc;
+}
#include <libmemcached/common.h>
-#include <libmemcached/virtual_bucket.h>
+#include <sys/time.h>
+
+#include <libmemcached/virtual_bucket.h>
uint32_t memcached_generate_hash_value(const char *key, size_t key_length, memcached_hash_t hash_algorithm)
{
-/* LibMemcached
- * Copyright (C) 2006-2010 Brian Aker
- * All rights reserved.
+/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ * Libmemcached library
*
- * Use and distribution licensed under the BSD license. See
- * the COPYING file in the parent directory for full text.
+ * Copyright (C) 2011 Data Differential, http://datadifferential.com/
+ * Copyright (C) 2006-2010 Brian Aker All rights reserved.
*
- * Summary:
+ * 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 "common.h"
-#include <math.h>
+#include <libmemcached/common.h>
+
+#include <cmath>
+#include <sys/time.h>
/* Protoypes (static) */
static memcached_return_t server_add(memcached_st *ptr, const char *hostname,
uint32_t live_servers= 0;
struct timeval now;
- if (gettimeofday(&now, NULL) != 0)
+ if (gettimeofday(&now, NULL))
{
- memcached_set_errno(ptr, errno, NULL);
- return MEMCACHED_ERRNO;
+ return memcached_set_errno(*ptr, errno, MEMCACHED_AT);
}
list= memcached_server_list(ptr);
for (uint32_t host_index= 0; host_index < memcached_server_count(ptr); ++host_index)
{
if (list[host_index].next_retry <= now.tv_sec)
+ {
live_servers++;
+ }
else
{
if (ptr->ketama.next_distribution_rebuild == 0 || list[host_index].next_retry < ptr->ketama.next_distribution_rebuild)
+ {
ptr->ketama.next_distribution_rebuild= list[host_index].next_retry;
+ }
}
}
}
uint64_t is_ketama_weighted= memcached_behavior_get(ptr, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
uint32_t points_per_server= (uint32_t) (is_ketama_weighted ? MEMCACHED_POINTS_PER_SERVER_KETAMA : MEMCACHED_POINTS_PER_SERVER);
- if (live_servers == 0)
+ if (not live_servers)
+ {
return MEMCACHED_SUCCESS;
+ }
if (live_servers > ptr->ketama.continuum_count)
{
}
else
{
- uint32_t value= hashkit_digest(&ptr->distribution_hashkit, sort_host, (size_t)sort_host_length);
+ uint32_t value= hashkit_digest(&ptr->hashkit, sort_host, (size_t)sort_host_length);
ptr->ketama.continuum[continuum_index].index= host_index;
ptr->ketama.continuum[continuum_index++].value= value;
}
}
else
{
- uint32_t value= hashkit_digest(&ptr->distribution_hashkit, sort_host, (size_t)sort_host_length);
+ uint32_t value= hashkit_digest(&ptr->hashkit, sort_host, (size_t)sort_host_length);
ptr->ketama.continuum[continuum_index].index= host_index;
ptr->ketama.continuum[continuum_index++].value= value;
}
/* TODO check return type */
instance= memcached_server_create_with(ptr, instance, list[x].hostname,
list[x].port, list[x].weight, list[x].type);
- if (! instance)
+ if (not instance)
{
- return memcached_set_error(ptr, MEMCACHED_MEMORY_ALLOCATION_FAILURE, NULL);
+ return memcached_set_error(*ptr, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT);
}
+
+ if (list[x].weight > 1)
+ {
+ ptr->ketama.weighted= true;
+ }
+
ptr->number_of_hosts++;
}
in_port_t port,
uint32_t weight)
{
- if (! port)
+ if (not port)
port= MEMCACHED_DEFAULT_PORT;
- if (! hostname)
+ if (not hostname)
hostname= "localhost";
return server_add(ptr, hostname, port, weight, MEMCACHED_CONNECTION_UDP);
/* TODO: Check return type */
instance= memcached_server_instance_fetch(ptr, memcached_server_count(ptr));
+
(void)memcached_server_create_with(ptr, instance, hostname, port, weight, type);
+
+ if (weight > 1)
+ {
+ ptr->ketama.weighted= true;
+ }
+
ptr->number_of_hosts++;
instance= memcached_server_instance_fetch(ptr, 0);
libmemcached/byteorder.h \
libmemcached/common.h \
libmemcached/do.h \
+ libmemcached/error.hpp \
libmemcached/initialize_query.h \
libmemcached/internal.h \
libmemcached/io.h \
libmemcached/is.h \
libmemcached/libmemcached_probes.h \
+ libmemcached/memory.h \
libmemcached/protocol/ascii_handler.h \
libmemcached/protocol/binary_handler.h \
libmemcached/protocol/common.h \
libmemcached/analyze.h \
libmemcached/array.h \
libmemcached/auto.h \
+ libmemcached/basic_string.h \
libmemcached/behavior.h \
libmemcached/callback.h \
libmemcached/configure.h \
# These symbols will not be exposed in the shipped .so
noinst_LTLIBRARIES+= libmemcached/libmemcachedinternal.la
libmemcached_libmemcachedinternal_la_SOURCES= \
+ libmemcached/array.c \
libmemcached/error.cc \
libmemcached/string.cc
+libmemcached_libmemcachedinternal_la_CFLAGS= \
+ ${AM_CFLAGS} \
+ ${NO_CONVERSION} \
+ -DBUILDING_LIBMEMCACHED
+
+libmemcached_libmemcachedinternal_la_CXXFLAGS= \
+ ${AM_CXXFLAGS} \
+ ${NO_CONVERSION} \
+ -DBUILDING_LIBMEMCACHED
lib_LTLIBRARIES+= libmemcached/libmemcached.la
libmemcached_libmemcached_la_CFLAGS= \
libmemcached/do.cc \
libmemcached/dump.cc \
libmemcached/error.cc \
- libmemcached/fetch.c \
+ libmemcached/fetch.cc \
libmemcached/flush.cc \
libmemcached/flush_buffers.cc \
libmemcached/get.cc \
if (memcached_server_count(self) == 0)
{
- return memcached_set_error(self, MEMCACHED_NO_SERVERS, NULL);
+ return memcached_set_error(*self, MEMCACHED_NO_SERVERS, MEMCACHED_AT);
}
return MEMCACHED_SUCCESS;
{
memcached_quit_server(ptr, true);
*nread= -1;
- return rc;
+ return memcached_set_error(*ptr, rc, MEMCACHED_AT);
}
}
}
WATCHPOINT_STRING("We had a zero length recv()");
memcached_quit_server(ptr, true);
*nread= -1;
- return MEMCACHED_UNKNOWN_READ_FAILURE;
+ return memcached_set_error(*ptr, MEMCACHED_UNKNOWN_READ_FAILURE, MEMCACHED_AT);
}
}
return NULL;
}
- int err= poll(fds, host_index, memc->poll_timeout);
- switch (err) {
+ switch (poll(fds, host_index, memc->poll_timeout))
+ {
case -1:
- memcached_set_errno(memc, get_socket_errno(), NULL);
+ memcached_set_errno(*memc, get_socket_errno(), MEMCACHED_AT);
/* FALLTHROUGH */
case 0:
break;
+
default:
for (size_t x= 0; x < host_index; ++x)
{
self->distribution= MEMCACHED_DISTRIBUTION_MODULA;
- hashkit_st *hash_ptr;
- hash_ptr= hashkit_create(&self->hashkit);
- if (! hash_ptr)
+ if (not hashkit_create(&self->hashkit))
return false;
self->ketama.continuum= NULL;
self->user_data= NULL;
self->number_of_replicas= 0;
- hash_ptr= hashkit_create(&self->distribution_hashkit);
- if (! hash_ptr)
- return false;
self->allocators= memcached_allocators_return_default();
if (ptr->on_cleanup)
ptr->on_cleanup(ptr);
- if (ptr->ketama.continuum)
- libmemcached_free(ptr, ptr->ketama.continuum);
+ libmemcached_free(ptr, ptr->ketama.continuum);
memcached_array_free(ptr->prefix_key);
ptr->prefix_key= NULL;
{
ptr= (memcached_st *)malloc(sizeof(memcached_st));
- if (! ptr)
+ if (not ptr)
{
return NULL; /* MEMCACHED_MEMORY_ALLOCATION_FAILURE */
}
memcached_st *memcached(const char *string, size_t length)
{
- if (! length || ! string)
- {
- errno= EINVAL;
- return NULL;
- }
-
memcached_st *self= memcached_create(NULL);
- if (! self)
+ if (not self)
{
errno= ENOMEM;
return NULL;
}
- memcached_return_t rc;
- rc= memcached_parse_configuration(self, string, length);
+ if (not length)
+ return self;
+
+ memcached_return_t rc= memcached_parse_configuration(self, string, length);
- if (rc == MEMCACHED_SUCCESS && memcached_parse_filename(self))
+ if (memcached_success(rc) and memcached_parse_filename(self))
{
rc= memcached_parse_configure_file(self, memcached_parse_filename(self), memcached_parse_filename_length(self));
}
- if (rc != MEMCACHED_SUCCESS)
+ if (memcached_failed(rc))
{
memcached_free(self);
errno= EINVAL;
return NULL;
}
- errno= 0;
-
return self;
}
void memcached_servers_reset(memcached_st *ptr)
{
- if (! ptr)
+ if (not ptr)
return;
memcached_server_list_free(memcached_server_list(ptr));
void memcached_reset_last_disconnected_server(memcached_st *ptr)
{
- if (! ptr)
+ if (not ptr)
return;
if (ptr->last_disconnected_server)
void memcached_free(memcached_st *ptr)
{
- if (! ptr)
+ if (not ptr)
return;
_free(ptr, true);
new_clone->retry_timeout= source->retry_timeout;
new_clone->distribution= source->distribution;
- hashkit_st *hash_ptr;
-
- hash_ptr= hashkit_clone(&new_clone->hashkit, &source->hashkit);
- if (! hash_ptr)
- {
- memcached_free(new_clone);
- return NULL;
- }
-
- hash_ptr= hashkit_clone(&new_clone->distribution_hashkit, &source->distribution_hashkit);
- if (! hash_ptr)
+ if (not hashkit_clone(&new_clone->hashkit, &source->hashkit))
{
memcached_free(new_clone);
return NULL;
new_clone->prefix_key= memcached_array_clone(new_clone, source->prefix_key);
+ new_clone->configure.filename= memcached_array_clone(new_clone, source->prefix_key);
#ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
if (source->sasl.callbacks)
void *user_data;
uint64_t query_id;
uint32_t number_of_replicas;
- hashkit_st distribution_hashkit;
memcached_result_st result;
struct {
{
public:
- Memcache() :
- servers_list(),
- memc(),
- result()
+ Memcache()
{
- memcached_create(&memc);
+ memc= memcached("", 0);
}
- Memcache(const std::string &in_servers_list)
- :
- servers_list(in_servers_list),
- memc(),
- result()
+ Memcache(const std::string &config)
{
- memcached_create(&memc);
- init();
+ memc= memcached(config.c_str(), config.size());
}
- Memcache(const std::string &hostname,
- in_port_t port)
- :
- servers_list(),
- memc(),
- result()
+ Memcache(const std::string &hostname, in_port_t port)
{
- memcached_create(&memc);
-
- servers_list.append(hostname);
- servers_list.append(":");
- std::ostringstream strsmt;
- strsmt << port;
- servers_list.append(strsmt.str());
-
- init();
+ memc= memcached("", 0);
+ if (memc)
+ memcached_server_add(memc, hostname.c_str(), port);
}
Memcache(memcached_st *clone)
- :
- servers_list(),
- memc(),
- result()
{
- memcached_clone(&memc, clone);
+ memc= memcached_clone(NULL, clone);
}
Memcache(const Memcache &rhs)
- :
- servers_list(rhs.servers_list),
- memc(),
- result()
{
- memcached_clone(&memc, const_cast<memcached_st *>(&rhs.getImpl()));
- init();
+ memc= memcached_clone(NULL, rhs.getImpl());
}
Memcache &operator=(const Memcache &rhs)
{
if (this != &rhs)
{
- memcached_clone(&memc, const_cast<memcached_st *>(&rhs.getImpl()));
- init();
+ memcached_free(memc);
+ memc= memcached_clone(NULL, rhs.getImpl());
}
return *this;
~Memcache()
{
- memcached_free(&memc);
- }
-
- void init()
- {
- memcached_server_st *servers;
- servers= memcached_servers_parse(servers_list.c_str());
- memcached_server_push(&memc, servers);
- memcached_server_free(servers);
- }
-
- /**
- * Get the internal memcached_st *
- */
- memcached_st &getImpl()
- {
- return memc;
+ memcached_free(memc);
}
/**
* Get the internal memcached_st *
*/
- const memcached_st &getImpl() const
+ const memcached_st *getImpl() const
{
return memc;
}
bool setBehavior(memcached_behavior_t flag, uint64_t data)
{
- memcached_return_t rc;
- rc= memcached_behavior_set(&memc, flag, data);
- return (rc == MEMCACHED_SUCCESS);
- }
-
- uint64_t getBehavior(memcached_behavior_t flag) {
- return memcached_behavior_get(&memc, flag);
+ return (memcached_success(memcached_behavior_set(memc, flag, data)));
}
- /**
- * Return the string which contains the list of memcached servers being
- * used.
- *
- * @return a std::string containing the list of memcached servers
- */
- const std::string getServersList() const
+ uint64_t getBehavior(memcached_behavior_t flag)
{
- return servers_list;
+ return memcached_behavior_get(memc, flag);
}
/**
- * Set the list of memcached servers to use.
+ * Configure the memcache object
*
- * @param[in] in_servers_list list of servers
+ * @param[in] in_config configuration
* @return true on success; false otherwise
*/
- bool setServers(const std::string &in_servers_list)
+ bool configure(const std::string &configuration)
{
- servers_list.assign(in_servers_list);
- init();
-
- return (memcached_server_count(&memc));
+ return (memcached_success(memcached_parse_configuration(memc, configuration.c_str(), configuration.size())));
}
/**
{
memcached_return_t rc;
- rc= memcached_server_add(&memc, server_name.c_str(), port);
+ rc= memcached_server_add(memc, server_name.c_str(), port);
return (rc == MEMCACHED_SUCCESS);
}
size_t key_length= 0;
memcached_return_t rc;
uint32_t flags= 0;
- char *value= memcached_fetch(&memc, ret_key, &key_length,
+ char *value= memcached_fetch(memc, ret_key, &key_length,
&value_length, &flags, &rc);
if (value && ret_val.empty())
{
memcached_return_t rc;
size_t value_length= 0;
- char *value= memcached_get(&memc, key.c_str(), key.length(),
+ char *value= memcached_get(memc, key.c_str(), key.length(),
&value_length, &flags, &rc);
if (value != NULL && ret_val.empty())
{
memcached_return_t rc;
size_t value_length= 0;
- char *value= memcached_get_by_key(&memc,
+ char *value= memcached_get_by_key(memc,
master_key.c_str(), master_key.length(),
key.c_str(), key.length(),
&value_length, &flags, &rc);
*/
if (! real_keys.empty())
{
- memcached_return_t rc= memcached_mget(&memc, &real_keys[0], &key_len[0],
- real_keys.size());
+ memcached_return_t rc= memcached_mget(memc, &real_keys[0], &key_len[0], real_keys.size());
return (rc == MEMCACHED_SUCCESS);
}
time_t expiration,
uint32_t flags)
{
- memcached_return_t rc= memcached_set(&memc,
- key.c_str(), key.length(),
- &value[0], value.size(),
- expiration, flags);
+ memcached_return_t rc= memcached_set(memc,
+ key.c_str(), key.length(),
+ &value[0], value.size(),
+ expiration, flags);
return (rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
}
time_t expiration,
uint32_t flags)
{
- memcached_return_t rc= memcached_set_by_key(&memc, master_key.c_str(),
- master_key.length(),
- key.c_str(), key.length(),
- &value[0], value.size(),
- expiration,
- flags);
+ memcached_return_t rc= memcached_set_by_key(memc, master_key.c_str(),
+ master_key.length(),
+ key.c_str(), key.length(),
+ &value[0], value.size(),
+ expiration,
+ flags);
return (rc == MEMCACHED_SUCCESS);
}
*/
bool increment(const std::string &key, uint32_t offset, uint64_t *value)
{
- memcached_return_t rc= memcached_increment(&memc, key.c_str(), key.length(),
- offset, value);
+ memcached_return_t rc= memcached_increment(memc, key.c_str(), key.length(),
+ offset, value);
return (rc == MEMCACHED_SUCCESS);
}
*/
bool decrement(const std::string &key, uint32_t offset, uint64_t *value)
{
- memcached_return_t rc= memcached_decrement(&memc, key.c_str(),
- key.length(),
- offset, value);
+ memcached_return_t rc= memcached_decrement(memc, key.c_str(),
+ key.length(),
+ offset, value);
return (rc == MEMCACHED_SUCCESS);
}
*/
bool add(const std::string &key, const std::vector<char> &value)
{
- memcached_return_t rc= memcached_add(&memc, key.c_str(), key.length(),
- &value[0], value.size(), 0, 0);
+ memcached_return_t rc= memcached_add(memc, key.c_str(), key.length(),
+ &value[0], value.size(), 0, 0);
return (rc == MEMCACHED_SUCCESS);
}
const std::string &key,
const std::vector<char> &value)
{
- memcached_return_t rc= memcached_add_by_key(&memc,
- master_key.c_str(),
- master_key.length(),
- key.c_str(),
- key.length(),
- &value[0],
- value.size(),
- 0, 0);
+ memcached_return_t rc= memcached_add_by_key(memc,
+ master_key.c_str(),
+ master_key.length(),
+ key.c_str(),
+ key.length(),
+ &value[0],
+ value.size(),
+ 0, 0);
return (rc == MEMCACHED_SUCCESS);
}
*/
bool replace(const std::string &key, const std::vector<char> &value)
{
- memcached_return_t rc= memcached_replace(&memc, key.c_str(), key.length(),
- &value[0], value.size(),
- 0, 0);
+ memcached_return_t rc= memcached_replace(memc, key.c_str(), key.length(),
+ &value[0], value.size(),
+ 0, 0);
return (rc == MEMCACHED_SUCCESS);
}
const std::string &key,
const std::vector<char> &value)
{
- memcached_return_t rc= memcached_replace_by_key(&memc,
- master_key.c_str(),
- master_key.length(),
- key.c_str(),
- key.length(),
- &value[0],
- value.size(),
- 0, 0);
+ memcached_return_t rc= memcached_replace_by_key(memc,
+ master_key.c_str(),
+ master_key.length(),
+ key.c_str(),
+ key.length(),
+ &value[0],
+ value.size(),
+ 0, 0);
return (rc == MEMCACHED_SUCCESS);
}
*/
bool prepend(const std::string &key, const std::vector<char> &value)
{
- memcached_return_t rc= memcached_prepend(&memc, key.c_str(), key.length(),
- &value[0], value.size(), 0, 0);
+ memcached_return_t rc= memcached_prepend(memc, key.c_str(), key.length(),
+ &value[0], value.size(), 0, 0);
return (rc == MEMCACHED_SUCCESS);
}
const std::string &key,
const std::vector<char> &value)
{
- memcached_return_t rc= memcached_prepend_by_key(&memc,
- master_key.c_str(),
- master_key.length(),
- key.c_str(),
- key.length(),
- &value[0],
- value.size(),
- 0,
- 0);
+ memcached_return_t rc= memcached_prepend_by_key(memc,
+ master_key.c_str(),
+ master_key.length(),
+ key.c_str(),
+ key.length(),
+ &value[0],
+ value.size(),
+ 0,
+ 0);
return (rc == MEMCACHED_SUCCESS);
}
*/
bool append(const std::string &key, const std::vector<char> &value)
{
- memcached_return_t rc= memcached_append(&memc,
+ memcached_return_t rc= memcached_append(memc,
key.c_str(),
key.length(),
&value[0],
const std::string &key,
const std::vector<char> &value)
{
- memcached_return_t rc= memcached_append_by_key(&memc,
+ memcached_return_t rc= memcached_append_by_key(memc,
master_key.c_str(),
master_key.length(),
key.c_str(),
const std::vector<char> &value,
uint64_t cas_arg)
{
- memcached_return_t rc= memcached_cas(&memc, key.c_str(), key.length(),
- &value[0], value.size(),
- 0, 0, cas_arg);
+ memcached_return_t rc= memcached_cas(memc, key.c_str(), key.length(),
+ &value[0], value.size(),
+ 0, 0, cas_arg);
return (rc == MEMCACHED_SUCCESS);
}
const std::vector<char> &value,
uint64_t cas_arg)
{
- memcached_return_t rc= memcached_cas_by_key(&memc,
- master_key.c_str(),
- master_key.length(),
- key.c_str(),
- key.length(),
- &value[0],
- value.size(),
- 0, 0, cas_arg);
+ memcached_return_t rc= memcached_cas_by_key(memc,
+ master_key.c_str(),
+ master_key.length(),
+ key.c_str(),
+ key.length(),
+ &value[0],
+ value.size(),
+ 0, 0, cas_arg);
return (rc == MEMCACHED_SUCCESS);
}
*/
bool remove(const std::string &key)
{
- memcached_return_t rc= memcached_delete(&memc, key.c_str(), key.length(), 0);
+ memcached_return_t rc= memcached_delete(memc, key.c_str(), key.length(), 0);
return (rc == MEMCACHED_SUCCESS);
}
*/
bool remove(const std::string &key, time_t expiration)
{
- memcached_return_t rc= memcached_delete(&memc,
- key.c_str(),
- key.length(),
- expiration);
+ memcached_return_t rc= memcached_delete(memc,
+ key.c_str(),
+ key.length(),
+ expiration);
return (rc == MEMCACHED_SUCCESS);
}
bool removeByKey(const std::string &master_key,
const std::string &key)
{
- memcached_return_t rc= memcached_delete_by_key(&memc,
- master_key.c_str(),
- master_key.length(),
- key.c_str(),
- key.length(),
- 0);
+ memcached_return_t rc= memcached_delete_by_key(memc,
+ master_key.c_str(),
+ master_key.length(),
+ key.c_str(),
+ key.length(),
+ 0);
return (rc == MEMCACHED_SUCCESS);
}
const std::string &key,
time_t expiration)
{
- memcached_return_t rc= memcached_delete_by_key(&memc,
- master_key.c_str(),
- master_key.length(),
- key.c_str(),
- key.length(),
- expiration);
+ memcached_return_t rc= memcached_delete_by_key(memc,
+ master_key.c_str(),
+ master_key.length(),
+ key.c_str(),
+ key.length(),
+ expiration);
return (rc == MEMCACHED_SUCCESS);
}
*/
bool flush(time_t expiration)
{
- memcached_return_t rc= memcached_flush(&memc, expiration);
+ memcached_return_t rc= memcached_flush(memc, expiration);
return (rc == MEMCACHED_SUCCESS);
}
&stats_map)
{
memcached_return_t rc;
- memcached_stat_st *stats= memcached_stat(&memc, NULL, &rc);
+ memcached_stat_st *stats= memcached_stat(memc, NULL, &rc);
if (rc != MEMCACHED_SUCCESS &&
rc != MEMCACHED_SOME_ERRORS)
return false;
}
- uint32_t server_count= memcached_server_count(&memc);
+ uint32_t server_count= memcached_server_count(memc);
/*
* For each memcached server, construct a std::map for its stats and add
for (uint32_t x= 0; x < server_count; x++)
{
memcached_server_instance_st instance=
- memcached_server_instance_by_position(&memc, x);
+ memcached_server_instance_by_position(memc, x);
std::ostringstream strstm;
std::string server_name(memcached_server_name(instance));
server_name.append(":");
char **list= NULL;
char **ptr= NULL;
- list= memcached_stat_get_keys(&memc, &stats[x], &rc);
+ list= memcached_stat_get_keys(memc, &stats[x], &rc);
for (ptr= list; *ptr; ptr++)
{
- char *value= memcached_stat_get_value(&memc, &stats[x], *ptr, &rc);
+ char *value= memcached_stat_get_value(memc, &stats[x], *ptr, &rc);
server_stats[*ptr]= value;
free(value);
}
free(list);
}
- memcached_stat_free(&memc, stats);
+ memcached_stat_free(memc, stats);
return true;
}
private:
-
- std::string servers_list;
- memcached_st memc;
- memcached_result_st result;
+ memcached_st *memc;
};
}
--- /dev/null
+/* 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.
+ *
+ */
+
+#pragma once
+
+static inline void libmemcached_free(const memcached_st *self, void *mem)
+{
+ if (self)
+ {
+ self->allocators.free(self, mem, self->allocators.context);
+ }
+ else if (mem)
+ {
+ free(mem);
+ }
+}
+
+static inline void *libmemcached_malloc(const memcached_st *self, const size_t size)
+{
+ if (self)
+ {
+ return self->allocators.malloc(self, size, self->allocators.context);
+ }
+
+ return malloc(size);
+}
+
+static inline void *libmemcached_realloc(const memcached_st *self, void *mem, const size_t size)
+{
+ if (self)
+ {
+ return self->allocators.realloc(self, mem, size, self->allocators.context);
+ }
+
+ return realloc(mem, size);
+}
+
+static inline void *libmemcached_calloc(const memcached_st *self, size_t nelem, size_t size)
+{
+ if (self)
+ {
+ return self->allocators.calloc(self, nelem, size, self->allocators.context);
+ }
+
+ return calloc(nelem, size);
+}
*/
#include <libmemcached/common.h>
+#include <assert.h>
#include <libmemcached/options/context.h>
const char *memcached_parse_filename(memcached_st *memc)
{
+ assert(memc);
return memcached_array_string(memc->configure.filename);
}
return memcached_array_size(memc->configure.filename);
}
-static memcached_return_t _parse_file_options(memcached_st *self, memcached_string_t *filename)
+static memcached_return_t _parse_file_options(memcached_st *self, memcached_array_st *real_name)
{
- memcached_array_st *real_name= memcached_strcpy(self, filename->c_str, filename->size);
-
- if (not real_name)
- return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
-
FILE *fp= fopen(memcached_array_string(real_name), "r");
- if (! fp)
+ if (not fp)
{
memcached_string_t error_message= memcached_array_to_string(real_name);
- memcached_return_t rc= memcached_set_errno(self, errno, &error_message);
- memcached_array_free(real_name);
+ memcached_return_t rc= memcached_set_errno(*self, errno, MEMCACHED_AT, error_message);
return rc;
}
- memcached_array_free(real_name);
char buffer[BUFSIZ];
memcached_return_t rc= MEMCACHED_INVALID_ARGUMENTS;
if (length == 1 and buffer[0] == '\n')
continue;
- rc= memcached_parse_configuration(self, buffer, length);
- if (rc != MEMCACHED_SUCCESS)
+ if (memcached_failed(rc= memcached_parse_configuration(self, buffer, length)))
break;
}
fclose(fp);
if (error_buffer_size)
error_buffer[0]= 0;
- if (! (memc_ptr= memcached_create(&memc)))
+ if (not (memc_ptr= memcached_create(&memc)))
return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
memcached_return_t rc= memcached_parse_configuration(memc_ptr, option_string, length);
- if (rc != MEMCACHED_SUCCESS && error_buffer && error_buffer_size)
+ if (memcached_failed(rc) && error_buffer && error_buffer_size)
{
strncpy(error_buffer, memcached_last_error_message(memc_ptr), error_buffer_size);
}
- if (rc== MEMCACHED_SUCCESS && memcached_behavior_get(memc_ptr, MEMCACHED_BEHAVIOR_LOAD_FROM_FILE))
+ bool has_filename= memcached_behavior_get(memc_ptr, MEMCACHED_BEHAVIOR_LOAD_FROM_FILE);
+ if (memcached_success(rc) and has_filename)
{
+ assert(memcached_parse_filename(memc_ptr));
+ assert(memcached_parse_filename_length(memc_ptr));
memcached_string_t filename= memcached_array_to_string(memc_ptr->configure.filename);
- rc= _parse_file_options(memc_ptr, &filename);
+ rc= _parse_file_options(memc_ptr, memc_ptr->configure.filename);
- if (rc != MEMCACHED_SUCCESS && error_buffer && error_buffer_size)
+ if (memcached_failed(rc) and error_buffer && error_buffer_size)
{
strncpy(error_buffer, memcached_last_error_message(memc_ptr), error_buffer_size);
}
memcached_return_t memcached_parse_configuration(memcached_st *self, char const *option_string, size_t length)
{
WATCHPOINT_ASSERT(self);
- if (! self)
+ if (not self)
{
- return memcached_set_error(self, MEMCACHED_INVALID_ARGUMENTS, NULL);
+ return MEMCACHED_INVALID_ARGUMENTS;
}
memcached_return_t rc;
void memcached_set_configuration_file(memcached_st *self, const char *filename, size_t filename_length)
{
+ assert(filename);
+ assert(filename_length);
memcached_array_free(self->configure.filename);
self->configure.filename= memcached_strcpy(self, filename, filename_length);
}
-memcached_return_t memcached_parse_configure_file(memcached_st *self, const char *filename, size_t filename_length)
+memcached_return_t memcached_parse_configure_file(memcached_st *self, const char *filename, size_t length)
+{
+ WATCHPOINT_ASSERT(self);
+ if (not self)
+ {
+ return MEMCACHED_INVALID_ARGUMENTS;
+ }
+
+ WATCHPOINT_ASSERT(self);
+ if (not filename)
+ {
+ return memcached_set_error(*self, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT);
+ }
+
+ WATCHPOINT_ASSERT(self);
+ if (not length)
+ {
+ return memcached_set_error(*self, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT);
+ }
+
+ memcached_array_st *tmp_array= memcached_strcpy(self, filename, length);
+
+ memcached_return_t rc= memcached_parse_configure_file(self, tmp_array);
+ memcached_array_free(tmp_array);
+
+ return rc;
+}
+
+memcached_return_t memcached_parse_configure_file(memcached_st *self, memcached_array_st *filename)
{
- if (! self)
- return memcached_set_error(self, MEMCACHED_INVALID_ARGUMENTS, NULL);
+ WATCHPOINT_ASSERT(self);
+ if (not self)
+ {
+ return MEMCACHED_INVALID_ARGUMENTS;
+ }
- if (! filename || filename_length == 0)
- return memcached_set_error(self, MEMCACHED_INVALID_ARGUMENTS, NULL);
-
- memcached_string_t tmp;
- tmp.c_str= filename;
- tmp.size= filename_length;
+ WATCHPOINT_ASSERT(memcached_array_size(filename));
+ if (not memcached_array_size(filename))
+ {
+ return memcached_set_error(*self, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT);
+ }
- return _parse_file_options(self, &tmp);
+ return _parse_file_options(self, filename);
}
LIBMEMCACHED_LOCAL
memcached_return_t memcached_parse_configuration(memcached_st *ptr, const char *option_string, size_t length);
-LIBMEMCACHED_LOCAL
- memcached_return_t memcached_parse_configure_file(memcached_st *ptr, const char *filename, size_t filename_length);
-
LIBMEMCACHED_LOCAL
const char *memcached_parse_filename(memcached_st *memc);
#ifdef __cplusplus
}
#endif
+
+#ifdef __cplusplus
+
+LIBMEMCACHED_LOCAL
+ memcached_return_t memcached_parse_configure_file(memcached_st *self, const char *filename, size_t length);
+
+LIBMEMCACHED_LOCAL
+ memcached_return_t memcached_parse_configure_file(memcached_st *self, memcached_array_st *filename);
+
+#endif
rc= MEMCACHED_PARSE_ERROR;
memcached_string_st *error_string= memcached_string_create(memc, NULL, 1024);
- memcached_string_append(error_string, memcached_string_with_size("Error occured while parsing: "));
+ memcached_string_append(error_string, memcached_literal_param("Error occured while parsing: "));
memcached_string_append(error_string, memcached_string_make_from_cstr(begin));
- memcached_string_append(error_string, memcached_string_with_size(" ("));
+ memcached_string_append(error_string, memcached_literal_param(" ("));
if (rc == MEMCACHED_PARSE_ERROR and error)
{
{
memcached_string_append(error_string, memcached_string_make_from_cstr(memcached_strerror(NULL, rc)));
}
- memcached_string_append(error_string, memcached_string_with_size(")"));
+ memcached_string_append(error_string, memcached_literal_param(")"));
- memcached_set_error_string(memc, rc, memcached_string_value(error_string), memcached_string_length(error_string));
+ memcached_set_error(*memc, rc, MEMCACHED_AT, memcached_string_value(error_string), memcached_string_length(error_string));
memcached_string_free(error_string);
}
libmemcached/options/parser.h \
libmemcached/options/scanner.h \
libmemcached/options/server.h \
- libmemcached/options/string.h \
libmemcached/options/symbol.h
libmemcached_libmemcached_la_SOURCES+= \
+++ /dev/null
-#pragma once
-
-#include <stdlib.h>
-#include <iostream>
-
-struct string_t
-{
- const char *c_str;
- size_t length;
-};
-
-inline std::ostream& operator<<(std::ostream& output, const string_t& arg)
-{
- output << arg.c_str;
- return output;
-}
#include <libmemcached/common.h>
#include <libmemcached/options/context.h>
-#include <libmemcached/options/string.h>
#include <libmemcached/options/symbol.h>
#include <libmemcached/options/scanner.h>
/* Line 189 of yacc.c */
-#line 107 "libmemcached/options/parser.cc"
+#line 106 "libmemcached/options/parser.cc"
/* Enabling traces. */
#ifndef YYDEBUG
/* Line 264 of yacc.c */
-#line 218 "libmemcached/options/parser.cc"
+#line 217 "libmemcached/options/parser.cc"
#ifdef short
# undef short
/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
static const yytype_uint16 yyrline[] =
{
- 0, 156, 156, 157, 161, 163, 165, 167, 172, 177,
- 181, 185, 196, 204, 212, 216, 220, 224, 228, 235,
- 242, 253, 260, 267, 274, 280, 284, 288, 292, 296,
- 300, 304, 308, 312, 316, 320, 324, 331, 335, 339,
- 343, 347, 351, 355, 359, 363, 367, 371, 375, 382,
- 383, 388, 389, 394, 398, 402, 406, 410, 414, 418,
- 422, 426, 433, 437, 445, 449, 453
+ 0, 155, 155, 156, 160, 162, 164, 166, 171, 176,
+ 180, 184, 195, 203, 211, 215, 219, 223, 227, 234,
+ 241, 252, 259, 266, 273, 279, 283, 287, 291, 295,
+ 299, 303, 307, 311, 315, 319, 323, 330, 334, 338,
+ 342, 346, 350, 354, 358, 362, 366, 370, 374, 381,
+ 382, 387, 388, 393, 397, 401, 405, 409, 413, 417,
+ 421, 425, 432, 436, 444, 448, 452
};
#endif
case 4:
/* Line 1464 of yacc.c */
-#line 162 "libmemcached/options/parser.yy"
+#line 161 "libmemcached/options/parser.yy"
{ ;}
break;
case 5:
/* Line 1464 of yacc.c */
-#line 164 "libmemcached/options/parser.yy"
+#line 163 "libmemcached/options/parser.yy"
{ ;}
break;
case 6:
/* Line 1464 of yacc.c */
-#line 166 "libmemcached/options/parser.yy"
+#line 165 "libmemcached/options/parser.yy"
{ ;}
break;
case 7:
/* Line 1464 of yacc.c */
-#line 168 "libmemcached/options/parser.yy"
+#line 167 "libmemcached/options/parser.yy"
{
context->set_end();
YYACCEPT;
case 8:
/* Line 1464 of yacc.c */
-#line 173 "libmemcached/options/parser.yy"
+#line 172 "libmemcached/options/parser.yy"
{
context->rc= MEMCACHED_PARSE_USER_ERROR;
parser_abort(context, NULL);
case 9:
/* Line 1464 of yacc.c */
-#line 178 "libmemcached/options/parser.yy"
+#line 177 "libmemcached/options/parser.yy"
{
memcached_reset(context->memc);
;}
case 10:
/* Line 1464 of yacc.c */
-#line 182 "libmemcached/options/parser.yy"
+#line 181 "libmemcached/options/parser.yy"
{
yydebug= 1;
;}
case 11:
/* Line 1464 of yacc.c */
-#line 186 "libmemcached/options/parser.yy"
+#line 185 "libmemcached/options/parser.yy"
{
- if ((context->rc= memcached_parse_configure_file(context->memc, (yyvsp[(3) - (3)].string).c_str, (yyvsp[(3) - (3)].string).length)) != MEMCACHED_SUCCESS)
+ if ((context->rc= memcached_parse_configure_file(context->memc, (yyvsp[(3) - (3)].string).c_str, (yyvsp[(3) - (3)].string).size)) != MEMCACHED_SUCCESS)
{
parser_abort(context, NULL);
}
case 12:
/* Line 1464 of yacc.c */
-#line 197 "libmemcached/options/parser.yy"
+#line 196 "libmemcached/options/parser.yy"
{
if ((context->rc= memcached_server_add_with_weight(context->memc, (yyvsp[(2) - (4)].server).c_str, (yyvsp[(2) - (4)].server).port, (yyvsp[(2) - (4)].server).weight)) != MEMCACHED_SUCCESS)
{
case 13:
/* Line 1464 of yacc.c */
-#line 205 "libmemcached/options/parser.yy"
+#line 204 "libmemcached/options/parser.yy"
{
if ((context->rc= memcached_server_add_with_weight(context->memc, (yyvsp[(2) - (4)].server).c_str, (yyvsp[(2) - (4)].server).port, (yyvsp[(2) - (4)].server).weight)) != MEMCACHED_SUCCESS)
{
case 14:
/* Line 1464 of yacc.c */
-#line 213 "libmemcached/options/parser.yy"
+#line 212 "libmemcached/options/parser.yy"
{
- memcached_set_configuration_file(context->memc, (yyvsp[(2) - (2)].string).c_str, (yyvsp[(2) - (2)].string).length);
+ memcached_set_configuration_file(context->memc, (yyvsp[(2) - (2)].string).c_str, (yyvsp[(2) - (2)].string).size);
;}
break;
case 15:
/* Line 1464 of yacc.c */
-#line 217 "libmemcached/options/parser.yy"
+#line 216 "libmemcached/options/parser.yy"
{
context->memc->configure.initial_pool_size= (yyvsp[(2) - (2)].number);
;}
case 16:
/* Line 1464 of yacc.c */
-#line 221 "libmemcached/options/parser.yy"
+#line 220 "libmemcached/options/parser.yy"
{
context->memc->configure.max_pool_size= (yyvsp[(2) - (2)].number);
;}
case 18:
/* Line 1464 of yacc.c */
-#line 229 "libmemcached/options/parser.yy"
+#line 228 "libmemcached/options/parser.yy"
{
- if ((context->rc= memcached_set_prefix_key(context->memc, (yyvsp[(2) - (2)].string).c_str, (yyvsp[(2) - (2)].string).length)) != MEMCACHED_SUCCESS)
+ if ((context->rc= memcached_set_prefix_key(context->memc, (yyvsp[(2) - (2)].string).c_str, (yyvsp[(2) - (2)].string).size)) != MEMCACHED_SUCCESS)
{
parser_abort(context, NULL);;
}
case 19:
/* Line 1464 of yacc.c */
-#line 236 "libmemcached/options/parser.yy"
+#line 235 "libmemcached/options/parser.yy"
{
if ((context->rc= memcached_behavior_set(context->memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, (yyvsp[(2) - (2)].distribution))) != MEMCACHED_SUCCESS)
{
case 20:
/* Line 1464 of yacc.c */
-#line 243 "libmemcached/options/parser.yy"
+#line 242 "libmemcached/options/parser.yy"
{
if ((context->rc= memcached_behavior_set(context->memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, (yyvsp[(2) - (4)].distribution))) != MEMCACHED_SUCCESS)
{
case 21:
/* Line 1464 of yacc.c */
-#line 254 "libmemcached/options/parser.yy"
+#line 253 "libmemcached/options/parser.yy"
{
if ((context->rc= memcached_behavior_set(context->memc, MEMCACHED_BEHAVIOR_HASH, (yyvsp[(2) - (2)].hash))) != MEMCACHED_SUCCESS)
{
case 22:
/* Line 1464 of yacc.c */
-#line 261 "libmemcached/options/parser.yy"
+#line 260 "libmemcached/options/parser.yy"
{
if ((context->rc= memcached_behavior_set(context->memc, (yyvsp[(1) - (2)].behavior), (yyvsp[(2) - (2)].number))) != MEMCACHED_SUCCESS)
{
case 23:
/* Line 1464 of yacc.c */
-#line 268 "libmemcached/options/parser.yy"
+#line 267 "libmemcached/options/parser.yy"
{
if ((context->rc= memcached_behavior_set(context->memc, (yyvsp[(1) - (1)].behavior), true)) != MEMCACHED_SUCCESS)
{
case 24:
/* Line 1464 of yacc.c */
-#line 275 "libmemcached/options/parser.yy"
+#line 274 "libmemcached/options/parser.yy"
{
;}
break;
case 25:
/* Line 1464 of yacc.c */
-#line 281 "libmemcached/options/parser.yy"
+#line 280 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_REMOVE_FAILED_SERVERS;
;}
case 26:
/* Line 1464 of yacc.c */
-#line 285 "libmemcached/options/parser.yy"
+#line 284 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT;
;}
case 27:
/* Line 1464 of yacc.c */
-#line 289 "libmemcached/options/parser.yy"
+#line 288 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK;
;}
case 28:
/* Line 1464 of yacc.c */
-#line 293 "libmemcached/options/parser.yy"
+#line 292 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK;
;}
case 29:
/* Line 1464 of yacc.c */
-#line 297 "libmemcached/options/parser.yy"
+#line 296 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH;
;}
case 30:
/* Line 1464 of yacc.c */
-#line 301 "libmemcached/options/parser.yy"
+#line 300 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS;
;}
case 31:
/* Line 1464 of yacc.c */
-#line 305 "libmemcached/options/parser.yy"
+#line 304 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_POLL_TIMEOUT;
;}
case 32:
/* Line 1464 of yacc.c */
-#line 309 "libmemcached/options/parser.yy"
+#line 308 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_RCV_TIMEOUT;
;}
case 33:
/* Line 1464 of yacc.c */
-#line 313 "libmemcached/options/parser.yy"
+#line 312 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_RETRY_TIMEOUT;
;}
case 34:
/* Line 1464 of yacc.c */
-#line 317 "libmemcached/options/parser.yy"
+#line 316 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_SND_TIMEOUT;
;}
case 35:
/* Line 1464 of yacc.c */
-#line 321 "libmemcached/options/parser.yy"
+#line 320 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE;
;}
case 36:
/* Line 1464 of yacc.c */
-#line 325 "libmemcached/options/parser.yy"
+#line 324 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE;
;}
case 37:
/* Line 1464 of yacc.c */
-#line 332 "libmemcached/options/parser.yy"
+#line 331 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_BINARY_PROTOCOL;
;}
case 38:
/* Line 1464 of yacc.c */
-#line 336 "libmemcached/options/parser.yy"
+#line 335 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_BUFFER_REQUESTS;
;}
case 39:
/* Line 1464 of yacc.c */
-#line 340 "libmemcached/options/parser.yy"
+#line 339 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_HASH_WITH_PREFIX_KEY;
;}
case 40:
/* Line 1464 of yacc.c */
-#line 344 "libmemcached/options/parser.yy"
+#line 343 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_NOREPLY;
;}
case 41:
/* Line 1464 of yacc.c */
-#line 348 "libmemcached/options/parser.yy"
+#line 347 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ;
;}
case 42:
/* Line 1464 of yacc.c */
-#line 352 "libmemcached/options/parser.yy"
+#line 351 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_SORT_HOSTS;
;}
case 43:
/* Line 1464 of yacc.c */
-#line 356 "libmemcached/options/parser.yy"
+#line 355 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_SUPPORT_CAS;
;}
case 44:
/* Line 1464 of yacc.c */
-#line 360 "libmemcached/options/parser.yy"
+#line 359 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_TCP_NODELAY;
;}
case 45:
/* Line 1464 of yacc.c */
-#line 364 "libmemcached/options/parser.yy"
+#line 363 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_TCP_KEEPALIVE;
;}
case 46:
/* Line 1464 of yacc.c */
-#line 368 "libmemcached/options/parser.yy"
+#line 367 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_TCP_KEEPIDLE;
;}
case 47:
/* Line 1464 of yacc.c */
-#line 372 "libmemcached/options/parser.yy"
+#line 371 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_USE_UDP;
;}
case 48:
/* Line 1464 of yacc.c */
-#line 376 "libmemcached/options/parser.yy"
+#line 375 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_VERIFY_KEY;
;}
case 49:
/* Line 1464 of yacc.c */
-#line 382 "libmemcached/options/parser.yy"
+#line 381 "libmemcached/options/parser.yy"
{ ;}
break;
case 50:
/* Line 1464 of yacc.c */
-#line 384 "libmemcached/options/parser.yy"
+#line 383 "libmemcached/options/parser.yy"
{ ;}
break;
case 51:
/* Line 1464 of yacc.c */
-#line 388 "libmemcached/options/parser.yy"
+#line 387 "libmemcached/options/parser.yy"
{ ;}
break;
case 52:
/* Line 1464 of yacc.c */
-#line 390 "libmemcached/options/parser.yy"
+#line 389 "libmemcached/options/parser.yy"
{ ;}
break;
case 53:
/* Line 1464 of yacc.c */
-#line 395 "libmemcached/options/parser.yy"
+#line 394 "libmemcached/options/parser.yy"
{
(yyval.hash)= MEMCACHED_HASH_MD5;
;}
case 54:
/* Line 1464 of yacc.c */
-#line 399 "libmemcached/options/parser.yy"
+#line 398 "libmemcached/options/parser.yy"
{
(yyval.hash)= MEMCACHED_HASH_CRC;
;}
case 55:
/* Line 1464 of yacc.c */
-#line 403 "libmemcached/options/parser.yy"
+#line 402 "libmemcached/options/parser.yy"
{
(yyval.hash)= MEMCACHED_HASH_FNV1_64;
;}
case 56:
/* Line 1464 of yacc.c */
-#line 407 "libmemcached/options/parser.yy"
+#line 406 "libmemcached/options/parser.yy"
{
(yyval.hash)= MEMCACHED_HASH_FNV1A_64;
;}
case 57:
/* Line 1464 of yacc.c */
-#line 411 "libmemcached/options/parser.yy"
+#line 410 "libmemcached/options/parser.yy"
{
(yyval.hash)= MEMCACHED_HASH_FNV1_32;
;}
case 58:
/* Line 1464 of yacc.c */
-#line 415 "libmemcached/options/parser.yy"
+#line 414 "libmemcached/options/parser.yy"
{
(yyval.hash)= MEMCACHED_HASH_FNV1A_32;
;}
case 59:
/* Line 1464 of yacc.c */
-#line 419 "libmemcached/options/parser.yy"
+#line 418 "libmemcached/options/parser.yy"
{
(yyval.hash)= MEMCACHED_HASH_HSIEH;
;}
case 60:
/* Line 1464 of yacc.c */
-#line 423 "libmemcached/options/parser.yy"
+#line 422 "libmemcached/options/parser.yy"
{
(yyval.hash)= MEMCACHED_HASH_MURMUR;
;}
case 61:
/* Line 1464 of yacc.c */
-#line 427 "libmemcached/options/parser.yy"
+#line 426 "libmemcached/options/parser.yy"
{
(yyval.hash)= MEMCACHED_HASH_JENKINS;
;}
case 62:
/* Line 1464 of yacc.c */
-#line 434 "libmemcached/options/parser.yy"
+#line 433 "libmemcached/options/parser.yy"
{
(yyval.string)= (yyvsp[(1) - (1)].string);
;}
case 63:
/* Line 1464 of yacc.c */
-#line 438 "libmemcached/options/parser.yy"
+#line 437 "libmemcached/options/parser.yy"
{
(yyval.string).c_str= (yyvsp[(1) - (1)].string).c_str +1; // +1 to move use passed the initial quote
- (yyval.string).length= (yyvsp[(1) - (1)].string).length -1; // -1 removes the end quote
+ (yyval.string).size= (yyvsp[(1) - (1)].string).size -2; // -2 removes the begin and end quote
;}
break;
case 64:
/* Line 1464 of yacc.c */
-#line 446 "libmemcached/options/parser.yy"
+#line 445 "libmemcached/options/parser.yy"
{
(yyval.distribution)= MEMCACHED_DISTRIBUTION_CONSISTENT;
;}
case 65:
/* Line 1464 of yacc.c */
-#line 450 "libmemcached/options/parser.yy"
+#line 449 "libmemcached/options/parser.yy"
{
(yyval.distribution)= MEMCACHED_DISTRIBUTION_MODULA;
;}
case 66:
/* Line 1464 of yacc.c */
-#line 454 "libmemcached/options/parser.yy"
+#line 453 "libmemcached/options/parser.yy"
{
(yyval.distribution)= MEMCACHED_DISTRIBUTION_RANDOM;
;}
/* Line 1464 of yacc.c */
-#line 2104 "libmemcached/options/parser.cc"
+#line 2103 "libmemcached/options/parser.cc"
default: break;
}
YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
/* Line 1684 of yacc.c */
-#line 459 "libmemcached/options/parser.yy"
+#line 458 "libmemcached/options/parser.yy"
void Context::start()
#include <libmemcached/common.h>
#include <libmemcached/options/context.h>
#include <libmemcached/options/parser.h>
-#include <libmemcached/options/string.h>
#include <libmemcached/options/symbol.h>
#pragma GCC diagnostic ignored "-Wold-style-cast"
-#line 20 "libmemcached/options/scanner.cc"
+#line 19 "libmemcached/options/scanner.cc"
#define YY_INT_ALIGNED short int
static yyconst flex_int16_t yy_rule_linenum[64] =
{ 0,
- 78, 80, 82, 84, 86, 89, 93, 95, 96, 97,
- 98, 99, 100, 101, 102, 103, 104, 105, 106, 107,
- 108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
- 118, 119, 120, 121, 122, 124, 125, 127, 129, 130,
- 131, 132, 133, 134, 136, 137, 140, 145, 146, 147,
- 149, 150, 151, 152, 153, 154, 155, 156, 157, 159,
- 168, 186, 192
+ 77, 79, 81, 83, 85, 88, 92, 94, 95, 96,
+ 97, 98, 99, 100, 101, 102, 103, 104, 105, 106,
+ 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
+ 117, 118, 119, 120, 121, 123, 124, 126, 128, 129,
+ 130, 131, 132, 133, 135, 136, 139, 144, 145, 146,
+ 148, 149, 150, 151, 152, 153, 154, 155, 156, 158,
+ 167, 185, 191
} ;
/* The intent behind this definition is that it'll catch
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
-#line 39 "libmemcached/options/scanner.l"
+#line 38 "libmemcached/options/scanner.l"
#include <cstdlib>
#include <cstring>
#define YY_INPUT(buffer, result, max_size) get_lex_chars(buffer, result, max_size, PARAM)
-#line 1141 "libmemcached/options/scanner.cc"
+#line 1140 "libmemcached/options/scanner.cc"
#define INITIAL 0
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
/* %% [7.0] user's declarations go here */
-#line 75 "libmemcached/options/scanner.l"
+#line 74 "libmemcached/options/scanner.l"
-#line 1448 "libmemcached/options/scanner.cc"
+#line 1447 "libmemcached/options/scanner.cc"
yylval = yylval_param;
case 1:
YY_RULE_SETUP
-#line 78 "libmemcached/options/scanner.l"
+#line 77 "libmemcached/options/scanner.l"
{ return yytext[0];}
YY_BREAK
case 2:
YY_RULE_SETUP
-#line 80 "libmemcached/options/scanner.l"
+#line 79 "libmemcached/options/scanner.l"
{ yylval->number = atoi(yytext); return (NUMBER); }
YY_BREAK
case 3:
YY_RULE_SETUP
-#line 82 "libmemcached/options/scanner.l"
+#line 81 "libmemcached/options/scanner.l"
{ yylval->server.port = atoi(yytext +1); return PORT; }
YY_BREAK
case 4:
YY_RULE_SETUP
-#line 84 "libmemcached/options/scanner.l"
+#line 83 "libmemcached/options/scanner.l"
{ yylval->server.weight = atoi(yytext +2); return WEIGHT_START; }
YY_BREAK
case 5:
/* rule 5 can match eol */
YY_RULE_SETUP
-#line 86 "libmemcached/options/scanner.l"
+#line 85 "libmemcached/options/scanner.l"
; /* skip whitespace */
YY_BREAK
case 6:
yyg->yy_c_buf_p = yy_cp -= 1;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
-#line 89 "libmemcached/options/scanner.l"
+#line 88 "libmemcached/options/scanner.l"
{
return COMMENT;
}
YY_BREAK
case 7:
YY_RULE_SETUP
-#line 93 "libmemcached/options/scanner.l"
+#line 92 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; yyextra->set_server(); return SERVER; }
YY_BREAK
case 8:
YY_RULE_SETUP
-#line 95 "libmemcached/options/scanner.l"
+#line 94 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return BINARY_PROTOCOL; }
YY_BREAK
case 9:
YY_RULE_SETUP
-#line 96 "libmemcached/options/scanner.l"
+#line 95 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return BUFFER_REQUESTS; }
YY_BREAK
case 10:
YY_RULE_SETUP
-#line 97 "libmemcached/options/scanner.l"
+#line 96 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return CONFIGURE_FILE; }
YY_BREAK
case 11:
YY_RULE_SETUP
-#line 98 "libmemcached/options/scanner.l"
+#line 97 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return CONNECT_TIMEOUT; }
YY_BREAK
case 12:
YY_RULE_SETUP
-#line 99 "libmemcached/options/scanner.l"
+#line 98 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return DISTRIBUTION; }
YY_BREAK
case 13:
YY_RULE_SETUP
-#line 100 "libmemcached/options/scanner.l"
+#line 99 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return HASH_WITH_NAMESPACE; }
YY_BREAK
case 14:
YY_RULE_SETUP
-#line 101 "libmemcached/options/scanner.l"
+#line 100 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return HASH; }
YY_BREAK
case 15:
YY_RULE_SETUP
-#line 102 "libmemcached/options/scanner.l"
+#line 101 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return IO_BYTES_WATERMARK; }
YY_BREAK
case 16:
YY_RULE_SETUP
-#line 103 "libmemcached/options/scanner.l"
+#line 102 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return IO_KEY_PREFETCH; }
YY_BREAK
case 17:
YY_RULE_SETUP
-#line 104 "libmemcached/options/scanner.l"
+#line 103 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return IO_MSG_WATERMARK; }
YY_BREAK
case 18:
YY_RULE_SETUP
-#line 105 "libmemcached/options/scanner.l"
+#line 104 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return NOREPLY; }
YY_BREAK
case 19:
YY_RULE_SETUP
-#line 106 "libmemcached/options/scanner.l"
+#line 105 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return NUMBER_OF_REPLICAS; }
YY_BREAK
case 20:
YY_RULE_SETUP
-#line 107 "libmemcached/options/scanner.l"
+#line 106 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return POLL_TIMEOUT; }
YY_BREAK
case 21:
YY_RULE_SETUP
-#line 108 "libmemcached/options/scanner.l"
+#line 107 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return RANDOMIZE_REPLICA_READ; }
YY_BREAK
case 22:
YY_RULE_SETUP
-#line 109 "libmemcached/options/scanner.l"
+#line 108 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return RCV_TIMEOUT; }
YY_BREAK
case 23:
YY_RULE_SETUP
-#line 110 "libmemcached/options/scanner.l"
+#line 109 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return REMOVE_FAILED_SERVERS; }
YY_BREAK
case 24:
YY_RULE_SETUP
-#line 111 "libmemcached/options/scanner.l"
+#line 110 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return RETRY_TIMEOUT; }
YY_BREAK
case 25:
YY_RULE_SETUP
-#line 112 "libmemcached/options/scanner.l"
+#line 111 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return SND_TIMEOUT; }
YY_BREAK
case 26:
YY_RULE_SETUP
-#line 113 "libmemcached/options/scanner.l"
+#line 112 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return SOCKET_RECV_SIZE; }
YY_BREAK
case 27:
YY_RULE_SETUP
-#line 114 "libmemcached/options/scanner.l"
+#line 113 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return SOCKET_SEND_SIZE; }
YY_BREAK
case 28:
YY_RULE_SETUP
-#line 115 "libmemcached/options/scanner.l"
+#line 114 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return SORT_HOSTS; }
YY_BREAK
case 29:
YY_RULE_SETUP
-#line 116 "libmemcached/options/scanner.l"
+#line 115 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return SUPPORT_CAS; }
YY_BREAK
case 30:
YY_RULE_SETUP
-#line 117 "libmemcached/options/scanner.l"
+#line 116 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return _TCP_KEEPALIVE; }
YY_BREAK
case 31:
YY_RULE_SETUP
-#line 118 "libmemcached/options/scanner.l"
+#line 117 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return _TCP_KEEPIDLE; }
YY_BREAK
case 32:
YY_RULE_SETUP
-#line 119 "libmemcached/options/scanner.l"
+#line 118 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return _TCP_NODELAY; }
YY_BREAK
case 33:
YY_RULE_SETUP
-#line 120 "libmemcached/options/scanner.l"
+#line 119 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return USE_UDP; }
YY_BREAK
case 34:
YY_RULE_SETUP
-#line 121 "libmemcached/options/scanner.l"
+#line 120 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return USER_DATA; }
YY_BREAK
case 35:
YY_RULE_SETUP
-#line 122 "libmemcached/options/scanner.l"
+#line 121 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return VERIFY_KEY; }
YY_BREAK
case 36:
YY_RULE_SETUP
-#line 124 "libmemcached/options/scanner.l"
+#line 123 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return POOL_MIN; }
YY_BREAK
case 37:
YY_RULE_SETUP
-#line 125 "libmemcached/options/scanner.l"
+#line 124 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return POOL_MAX; }
YY_BREAK
case 38:
YY_RULE_SETUP
-#line 127 "libmemcached/options/scanner.l"
+#line 126 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return NAMESPACE; }
YY_BREAK
case 39:
YY_RULE_SETUP
-#line 129 "libmemcached/options/scanner.l"
+#line 128 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return INCLUDE; }
YY_BREAK
case 40:
YY_RULE_SETUP
-#line 130 "libmemcached/options/scanner.l"
+#line 129 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return RESET; }
YY_BREAK
case 41:
YY_RULE_SETUP
-#line 131 "libmemcached/options/scanner.l"
+#line 130 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return PARSER_DEBUG; }
YY_BREAK
case 42:
YY_RULE_SETUP
-#line 132 "libmemcached/options/scanner.l"
+#line 131 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return SERVERS; }
YY_BREAK
case 43:
YY_RULE_SETUP
-#line 133 "libmemcached/options/scanner.l"
+#line 132 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return END; }
YY_BREAK
case 44:
YY_RULE_SETUP
-#line 134 "libmemcached/options/scanner.l"
+#line 133 "libmemcached/options/scanner.l"
{ yyextra->begin= yytext; return ERROR; }
YY_BREAK
case 45:
YY_RULE_SETUP
-#line 136 "libmemcached/options/scanner.l"
+#line 135 "libmemcached/options/scanner.l"
{ return TRUE; }
YY_BREAK
case 46:
YY_RULE_SETUP
-#line 137 "libmemcached/options/scanner.l"
+#line 136 "libmemcached/options/scanner.l"
{ return FALSE; }
YY_BREAK
case 47:
YY_RULE_SETUP
-#line 140 "libmemcached/options/scanner.l"
+#line 139 "libmemcached/options/scanner.l"
{
yyextra->begin= yytext;
return UNKNOWN_OPTION;
YY_BREAK
case 48:
YY_RULE_SETUP
-#line 145 "libmemcached/options/scanner.l"
+#line 144 "libmemcached/options/scanner.l"
{ return CONSISTENT; }
YY_BREAK
case 49:
YY_RULE_SETUP
-#line 146 "libmemcached/options/scanner.l"
+#line 145 "libmemcached/options/scanner.l"
{ return MODULA; }
YY_BREAK
case 50:
YY_RULE_SETUP
-#line 147 "libmemcached/options/scanner.l"
+#line 146 "libmemcached/options/scanner.l"
{ return RANDOM; }
YY_BREAK
case 51:
YY_RULE_SETUP
-#line 149 "libmemcached/options/scanner.l"
+#line 148 "libmemcached/options/scanner.l"
{ return MD5; }
YY_BREAK
case 52:
YY_RULE_SETUP
-#line 150 "libmemcached/options/scanner.l"
+#line 149 "libmemcached/options/scanner.l"
{ return CRC; }
YY_BREAK
case 53:
YY_RULE_SETUP
-#line 151 "libmemcached/options/scanner.l"
+#line 150 "libmemcached/options/scanner.l"
{ return FNV1_64; }
YY_BREAK
case 54:
YY_RULE_SETUP
-#line 152 "libmemcached/options/scanner.l"
+#line 151 "libmemcached/options/scanner.l"
{ return FNV1A_64; }
YY_BREAK
case 55:
YY_RULE_SETUP
-#line 153 "libmemcached/options/scanner.l"
+#line 152 "libmemcached/options/scanner.l"
{ return FNV1_32; }
YY_BREAK
case 56:
YY_RULE_SETUP
-#line 154 "libmemcached/options/scanner.l"
+#line 153 "libmemcached/options/scanner.l"
{ return FNV1A_32; }
YY_BREAK
case 57:
YY_RULE_SETUP
-#line 155 "libmemcached/options/scanner.l"
+#line 154 "libmemcached/options/scanner.l"
{ return HSIEH; }
YY_BREAK
case 58:
YY_RULE_SETUP
-#line 156 "libmemcached/options/scanner.l"
+#line 155 "libmemcached/options/scanner.l"
{ return MURMUR; }
YY_BREAK
case 59:
YY_RULE_SETUP
-#line 157 "libmemcached/options/scanner.l"
+#line 156 "libmemcached/options/scanner.l"
{ return JENKINS; }
YY_BREAK
case 60:
YY_RULE_SETUP
-#line 159 "libmemcached/options/scanner.l"
+#line 158 "libmemcached/options/scanner.l"
{
yylval->server.port= MEMCACHED_DEFAULT_PORT;
yylval->server.weight= 1;
yylval->server.c_str= yyextra->set_hostname(yytext, yyleng);
if (yylval->server.c_str)
- yylval->server.length= yyleng;
+ yylval->server.size= yyleng;
return IPADDRESS;
}
YY_BREAK
case 61:
YY_RULE_SETUP
-#line 168 "libmemcached/options/scanner.l"
+#line 167 "libmemcached/options/scanner.l"
{
if (yyextra->is_server())
{
yylval->server.weight= 1;
yylval->server.c_str= yyextra->set_hostname(yytext, yyleng);
if (yylval->server.c_str)
- yylval->server.length= yyleng;
+ yylval->server.size= yyleng;
return HOSTNAME;
}
yylval->string.c_str = yytext;
- yylval->string.length = yyleng;
+ yylval->string.size = yyleng;
return STRING;
}
YY_BREAK
case 62:
YY_RULE_SETUP
-#line 186 "libmemcached/options/scanner.l"
+#line 185 "libmemcached/options/scanner.l"
{
yylval->string.c_str = yytext;
- yylval->string.length = yyleng;
+ yylval->string.size = yyleng;
return QUOTED_STRING;
}
YY_BREAK
case 63:
YY_RULE_SETUP
-#line 192 "libmemcached/options/scanner.l"
+#line 191 "libmemcached/options/scanner.l"
{
yyextra->begin= yytext;
return UNKNOWN;
YY_BREAK
case 64:
YY_RULE_SETUP
-#line 197 "libmemcached/options/scanner.l"
+#line 196 "libmemcached/options/scanner.l"
ECHO;
YY_BREAK
-#line 1924 "libmemcached/options/scanner.cc"
+#line 1923 "libmemcached/options/scanner.cc"
case YY_STATE_EOF(INITIAL):
yyterminate();
/* %ok-for-header */
-#line 197 "libmemcached/options/scanner.l"
+#line 196 "libmemcached/options/scanner.l"
#include <libmemcached/common.h>
#include <libmemcached/options/context.h>
#include <libmemcached/options/parser.h>
-#include <libmemcached/options/string.h>
#include <libmemcached/options/symbol.h>
#pragma GCC diagnostic ignored "-Wold-style-cast"
-#line 24 "libmemcached/options/scanner.h"
+#line 23 "libmemcached/options/scanner.h"
#define YY_INT_ALIGNED short int
#undef YY_DECL
#endif
-#line 197 "libmemcached/options/scanner.l"
+#line 196 "libmemcached/options/scanner.l"
-#line 479 "libmemcached/options/scanner.h"
+#line 478 "libmemcached/options/scanner.h"
#undef config_IN_HEADER
#endif /* config_HEADER_H */
#pragma once
#include <cstdlib>
-#include <iostream>
#include <arpa/inet.h>
struct server_t
{
in_port_t port;
uint32_t weight;
- size_t length;
const char *c_str;
+ size_t size;
};
+#if 0
+#include <iostream>
inline std::ostream& operator<<(std::ostream& output, const server_t& arg)
{
- output.write(arg.c_str, arg.length);
+ output.write(arg.c_str, arg.size);
output << ':' << arg.port;
output << '+' << arg.weight;
return output;
}
+#endif
+++ /dev/null
-/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
- *
- * Libmemcached library
- *
- * Copyright (C) 2011 Data Differential, http://datadifferential.com/
- * All rights reserved.
- *
- * 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.
- *
- */
-
-#pragma once
-
-#include <cstdlib>
-#include <iostream>
-
-struct string_t
-{
- const char *c_str;
- size_t length;
-};
-
-inline std::ostream& operator<<(std::ostream& output, const string_t& arg)
-{
- output.write(arg.c_str, arg.length);
- return output;
-}
#pragma once
+#include <libmemcached/basic_string.h>
#include <libmemcached/constants.h>
-#include <libmemcached/options/string.h>
#include <libmemcached/options/server.h>
union YYSTYPE
{
long long number;
- string_t string;
- string_t option;
+ memcached_string_t string;
+ memcached_string_t option;
double double_number;
memcached_server_distribution_t distribution;
memcached_hash_t hash;
memcached_return_t memcached_set_prefix_key(memcached_st *self, const char *key, size_t key_length)
{
- if (key && key_length)
+ WATCHPOINT_ASSERT(self);
+
+ if (key and key_length)
{
if (memcached_key_test((const char **)&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED)
- return memcached_set_error(self, MEMCACHED_BAD_KEY_PROVIDED, NULL);
+ return memcached_set_error(*self, MEMCACHED_BAD_KEY_PROVIDED, MEMCACHED_AT);
if ((key_length > MEMCACHED_PREFIX_KEY_MAX_SIZE -1))
- return memcached_set_error(self, MEMCACHED_KEY_TOO_BIG, NULL);
+ return memcached_set_error(*self, MEMCACHED_KEY_TOO_BIG, MEMCACHED_AT);
memcached_array_free(self->prefix_key);
self->prefix_key= memcached_strcpy(self, key, key_length);
- if (! self->prefix_key)
- return memcached_set_error(self, MEMCACHED_MEMORY_ALLOCATION_FAILURE, NULL);
+ if (not self->prefix_key)
+ return memcached_set_error(*self, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT);
}
else
{
char *buffer,
memcached_result_st *result)
{
- memcached_return_t rc= MEMCACHED_SUCCESS;
char *string_ptr;
char *end_ptr;
char *next_ptr;
size_t value_length;
size_t to_read;
- char *value_ptr;
ssize_t read_length= 0;
- memcached_return_t rrc;
if (ptr->root->flags.use_udp)
- return MEMCACHED_NOT_SUPPORTED;
+ return memcached_set_error(*ptr, MEMCACHED_NOT_SUPPORTED, MEMCACHED_AT);
WATCHPOINT_ASSERT(ptr->root);
end_ptr= buffer + MEMCACHED_DEFAULT_COMMAND_SIZE;
goto read_error;
/* We add two bytes so that we can walk the \r\n */
- rc= memcached_string_check(&result->value, value_length+2);
- if (rc != MEMCACHED_SUCCESS)
+ if (memcached_failed(memcached_string_check(&result->value, value_length +2)))
{
value_length= 0;
- return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
+ return memcached_set_error(*ptr, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT);
}
- value_ptr= memcached_string_value_mutable(&result->value);
- /*
- We read the \r\n into the string since not doing so is more
- cycles then the waster of memory to do so.
-
- We are null terminating through, which will most likely make
- some people lazy about using the return length.
- */
- to_read= (value_length) + 2;
- rrc= memcached_io_read(ptr, value_ptr, to_read, &read_length);
- if (rrc != MEMCACHED_SUCCESS)
- return rrc;
+ {
+ char *value_ptr= memcached_string_value_mutable(&result->value);
+ /*
+ We read the \r\n into the string since not doing so is more
+ cycles then the waster of memory to do so.
+
+ We are null terminating through, which will most likely make
+ some people lazy about using the return length.
+ */
+ to_read= (value_length) + 2;
+ memcached_return_t rrc= memcached_io_read(ptr, value_ptr, to_read, &read_length);
+ if (memcached_failed(rrc))
+ return rrc;
+ }
if (read_length != (ssize_t)(value_length + 2))
{
if ((rc= memcached_safe_read(ptr, hole, nr)) != MEMCACHED_SUCCESS)
{
WATCHPOINT_ERROR(rc);
- return MEMCACHED_UNKNOWN_READ_FAILURE;
+ return memcached_set_error(*ptr, MEMCACHED_UNKNOWN_READ_FAILURE, MEMCACHED_AT);
}
bodylen-= (uint32_t) nr;
}
_result_init(ptr, (memcached_st *)memc);
WATCHPOINT_SET(ptr->value.options.is_initialized= false);
- memcached_string_create(memc, &ptr->value, 0);
+ memcached_string_create((memcached_st*)memc, &ptr->value, 0);
WATCHPOINT_ASSERT_INITIALIZED(&ptr->value);
WATCHPOINT_ASSERT(ptr->value.string == NULL);
void memcached_result_free(memcached_result_st *ptr)
{
- if (ptr == NULL)
+ if (not ptr)
return;
memcached_string_free(&ptr->value);
const char *value,
size_t length)
{
- memcached_return_t rc= memcached_string_append(&ptr->value, value, length);
-
- if (rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE)
+ if (memcached_failed(memcached_string_append(&ptr->value, value, length)))
{
- memcached_set_errno(ptr->root, errno, NULL);
+ return memcached_set_errno(*ptr->root, errno, MEMCACHED_AT);
}
- return rc;
+ return MEMCACHED_SUCCESS;
}
const char *memcached_result_key_value(const memcached_result_st *self)
-/* LibMemcached
- * Copyright (C) 2006-2009 Brian Aker
- * All rights reserved.
+/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ * Libmemcached library
*
- * Use and distribution licensed under the BSD license. See
- * the COPYING file in the parent directory for full text.
+ * Copyright (C) 2011 Data Differential, http://datadifferential.com/
+ * Copyright (C) 2006-2009 Brian Aker All rights reserved.
*
- * Summary: Functions to manipulate the result structure.
+ * 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.
*
*/
+#pragma once
#ifndef __LIBMEMCACHED_RESULT_H__
#define __LIBMEMCACHED_RESULT_H__
enum memcached_return_t {
MEMCACHED_SUCCESS,
MEMCACHED_FAILURE,
- MEMCACHED_HOST_LOOKUP_FAILURE,
- MEMCACHED_CONNECTION_FAILURE,
- MEMCACHED_CONNECTION_BIND_FAILURE,
+ MEMCACHED_HOST_LOOKUP_FAILURE, // getaddrinfo() only
+ MEMCACHED_CONNECTION_FAILURE, // DEPRECATED
+ MEMCACHED_CONNECTION_BIND_FAILURE, // DEPRECATED
MEMCACHED_WRITE_FAILURE,
MEMCACHED_READ_FAILURE,
MEMCACHED_UNKNOWN_READ_FAILURE,
MEMCACHED_PROTOCOL_ERROR,
MEMCACHED_CLIENT_ERROR,
MEMCACHED_SERVER_ERROR,
- MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE,
+ MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE, // DEPRECATED
MEMCACHED_DATA_EXISTS,
MEMCACHED_DATA_DOES_NOT_EXIST,
MEMCACHED_NOTSTORED,
MEMCACHED_STAT,
MEMCACHED_ITEM,
MEMCACHED_ERRNO,
- MEMCACHED_FAIL_UNIX_SOCKET,
+ MEMCACHED_FAIL_UNIX_SOCKET, // DEPRECATED
MEMCACHED_NOT_SUPPORTED,
MEMCACHED_NO_KEY_PROVIDED, /* Deprecated. Use MEMCACHED_BAD_KEY_PROVIDED! */
MEMCACHED_FETCH_NOTFINISHED,
typedef enum memcached_return_t memcached_return_t;
#endif
-#define memcached_failed(A) (A) != MEMCACHED_SUCCESS ? true : false
+
+#define memcached_success(X) ((X) == MEMCACHED_SUCCESS)
+#define memcached_failed(A) ((A) != MEMCACHED_SUCCESS)
-/* LibMemcached
- * Copyright (C) 2006-2010 Brian Aker
- * All rights reserved.
+/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ * Libmemcached library
*
- * Use and distribution licensed under the BSD license. See
- * the COPYING file in the parent directory for full text.
+ * Copyright (C) 2011 Data Differential, http://datadifferential.com/
+ * Copyright (C) 2006-2009 Brian Aker All rights reserved.
*
- * Summary: interface for memcached server
- * Description: main include file for libmemcached
+ * 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 "common.h"
+
+#include <libmemcached/common.h>
void memcached_set_sasl_callbacks(memcached_st *ptr,
const sasl_callback_t *callbacks)
memcached_return_t rc;
/* SANITY CHECK: SASL can only be used with the binary protocol */
- unlikely (!server->root->flags.binary_protocol)
+ if (!server->root->flags.binary_protocol)
return MEMCACHED_FAILURE;
/* Try to get the supported mech from the server. Servers without SASL
-/* LibMemcached
- * Copyright (C) 2006-2009 Brian Aker
- * All rights reserved.
+/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ * Libmemcached library
*
- * Use and distribution licensed under the BSD license. See
- * the COPYING file in the parent directory for full text.
+ * Copyright (C) 2011 Data Differential, http://datadifferential.com/
+ * Copyright (C) 2006-2009 Brian Aker All rights reserved.
*
- * Summary: String structure used for libmemcached.
+ * 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.
*
*/
This is a partial implementation for fetching/creating memcached_server_st objects.
*/
#include <libmemcached/common.h>
+#include <cassert>
-static inline void _server_init(memcached_server_st *self, const memcached_st *root,
+static inline void _server_init(memcached_server_st *self, memcached_st *root,
const char *hostname, in_port_t port,
uint32_t weight, memcached_connection_t type)
{
self->next_retry= 0;
}
- if (self->weight > 1 && root)
- {
- ((memcached_st *)root)->ketama.weighted= true;
- }
-
self->root= root;
self->limit_maxbytes= 0;
if (hostname == NULL)
static memcached_server_st *_server_create(memcached_server_st *self, const memcached_st *memc)
{
- if (self == NULL)
+ if (not self)
{
self= (memcached_server_st *)libmemcached_malloc(memc, sizeof(memcached_server_st));
- if (! self)
+ if (not self)
return NULL; /* MEMCACHED_MEMORY_ALLOCATION_FAILURE */
self->options.is_allocated= true;
{
self= _server_create(self, memc);
- if (self == NULL)
+ if (not self)
return NULL;
- _server_init(self, memc, hostname, port, weight, type);
+ _server_init(self, const_cast<memcached_st *>(memc), hostname, port, weight, type);
if (type == MEMCACHED_CONNECTION_UDP)
void memcached_server_free(memcached_server_st *self)
{
+ assert(self);
memcached_quit_server(self, false);
if (self->cached_server_error)
if (memcached_is_allocated(self))
{
- if (self->root)
- {
- libmemcached_free(self->root, self);
- }
- else
- {
- free(self);
- }
+ libmemcached_free(self->root, self);
}
else
{
const memcached_server_st *source)
{
/* We just do a normal create if source is missing */
- if (source == NULL)
+ if (not source)
return NULL;
destination= memcached_server_create_with(source->root, destination,
uint32_t number_of_callbacks)
{
memcached_return_t rc;
- if ((rc= initialize_const_query(ptr)) != MEMCACHED_SUCCESS)
+ if (memcached_failed(rc= initialize_const_query(ptr)))
{
return rc;
}
{
for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
{
- memcached_server_write_instance_st instance=
- memcached_server_instance_fetch(ptr, x);
-
- unsigned int iferror;
+ memcached_server_write_instance_st instance= memcached_server_instance_fetch(ptr, x);
- iferror= (*callback)(ptr, instance, context);
+ unsigned int iferror= (*callback)(ptr, instance, context);
if (iferror)
continue;
memcached_return_t *error)
{
memcached_return_t rc;
+ memcached_return_t unused;
+
+ if (not error)
+ error= &unused;
+
if (memcached_failed(rc= initialize_const_query(ptr)))
{
- if (error)
- *error= rc;
-
+ *error= rc;
return NULL;
}
if (memcached_failed(rc= memcached_validate_key_length(key_length, ptr->flags.binary_protocol)))
{
- if (error)
- *error= rc;
-
+ *error= rc;
return NULL;
}
if (ptr->flags.verify_key && (memcached_key_test((const char **)&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED))
{
- if (error)
- *error= MEMCACHED_BAD_KEY_PROVIDED;
+ *error= MEMCACHED_BAD_KEY_PROVIDED;
return NULL;
}
}
}
- const memcached_st *root= self->root;
- if (root)
- {
- libmemcached_free(root, self);
- }
- else
- {
- free(self);
- }
+ memcached_st *root= self->root;
+ libmemcached_free(root, self);
}
uint32_t memcached_servers_set_count(memcached_server_st *servers, uint32_t count)
-/* LibMemcached
- * Copyright (C) 2006-2009 Brian Aker
- * All rights reserved.
+/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ * Libmemcached library
*
- * Use and distribution licensed under the BSD license. See
- * the COPYING file in the parent directory for full text.
+ * Copyright (C) 2011 Data Differential, http://datadifferential.com/
+ * Copyright (C) 2006-2009 Brian Aker All rights reserved.
*
- * Summary: String structure used for libmemcached.
+ * 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.
*
*/
-#ifndef __LIBMEMCACHED_SERVER_H__
-#define __LIBMEMCACHED_SERVER_H__
+#pragma once
struct memcached_server_st {
struct {
struct addrinfo *address_info;
struct addrinfo *address_info_next;
time_t next_retry;
- const memcached_st *root;
+ memcached_st *root;
uint64_t limit_maxbytes;
char read_buffer[MEMCACHED_MAX_BUFFER];
char write_buffer[MEMCACHED_MAX_BUFFER];
#ifdef __cplusplus
} // extern "C"
#endif
-
-#endif /* __LIBMEMCACHED_SERVER_H__ */
*/
-#include "common.h"
+#include <libmemcached/common.h>
memcached_server_list_st
memcached_server_list_append_with_weight(memcached_server_list_st ptr,
if (memc_stat->root)
{
libmemcached_free(memc_stat->root, memc_stat);
+ return;
}
- else if (ptr)
- {
- libmemcached_free(ptr, memc_stat);
- }
- else
- {
- free(memc_stat);
- }
+
+ libmemcached_free(ptr, memc_stat);
}
static memcached_return_t call_stat_fn(memcached_st *ptr,
-#include "common.h"
+/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ * Libmemcached library
+ *
+ * Copyright (C) 2011 Data Differential, http://datadifferential.com/
+ * Copyright (C) 2006-2009 Brian Aker All rights reserved.
+ *
+ * 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.
+ *
+ */
-const char *memcached_strerror(memcached_st *ptr, memcached_return_t rc)
+#include <libmemcached/common.h>
+
+const char *memcached_strerror(memcached_st *, memcached_return_t rc)
{
- (void)ptr;
switch (rc)
{
case MEMCACHED_SUCCESS:
return "SUCCESS";
case MEMCACHED_FAILURE:
return "FAILURE";
- case MEMCACHED_HOST_LOOKUP_FAILURE:
- return "HOSTNAME LOOKUP FAILURE";
- case MEMCACHED_CONNECTION_FAILURE:
+ case MEMCACHED_HOST_LOOKUP_FAILURE: // getaddrinfo only
+ return "getaddrinfo() HOSTNAME LOOKUP FAILURE";
+ case MEMCACHED_CONNECTION_FAILURE: // DEPRECATED
return "CONNECTION FAILURE";
case MEMCACHED_CONNECTION_BIND_FAILURE:
return "CONNECTION BIND FAILURE";
return "SERVER ERROR";
case MEMCACHED_WRITE_FAILURE:
return "WRITE FAILURE";
- case MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE:
+ case MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE: // DEPRECATED
return "CONNECTION SOCKET CREATE FAILURE";
case MEMCACHED_DATA_EXISTS:
return "CONNECTION DATA EXISTS";
-/* LibMemcached
- * Copyright (C) 2010 Brian Aker
- * All rights reserved.
+/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ * Libmemcached library
*
- * Use and distribution licensed under the BSD license. See
- * the COPYING file in the parent directory for full text.
+ * Copyright (C) 2011 Data Differential, http://datadifferential.com/
+ * Copyright (C) 2010 Brian Aker All rights reserved.
*
- * Summary: returns a human readable string for the error message
+ * 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.
*
*/
-#ifndef __LIBMEMCACHED_STRERROR_H__
-#define __LIBMEMCACHED_STRERROR_H__
+
+#pragma once
#ifdef __cplusplus
extern "C" {
#ifdef __cplusplus
}
#endif
-
-#endif /* __LIBMEMCACHED_STRERROR_H__ */
new_size= sizeof(char) * (size_t)((adjust * MEMCACHED_BLOCK_SIZE) + string->current_size);
/* Test for overflow */
if (new_size < need)
- return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
+ return memcached_set_error(*string->root, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT);
new_value= static_cast<char *>(libmemcached_realloc(string->root, string->string, new_size));
- if (new_value == NULL)
+ if (not new_value)
{
- return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
+ return memcached_set_error(*string->root, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT);
}
string->string= new_value;
self->end= self->string= NULL;
}
-memcached_string_st *memcached_string_create(const memcached_st *memc, memcached_string_st *self, size_t initial_size)
+memcached_string_st *memcached_string_create(memcached_st *memc, memcached_string_st *self, size_t initial_size)
{
- memcached_return_t rc;
-
WATCHPOINT_ASSERT(memc);
/* Saving malloc calls :) */
self->options.is_allocated= true;
}
- self->root= const_cast<memcached_st *>(memc);
+ self->root= memc;
_init_string(self);
- rc= _string_check(self, initial_size);
- if (rc != MEMCACHED_SUCCESS)
+ if (memcached_failed(_string_check(self, initial_size)))
{
- if (rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE)
- {
- memcached_set_errno(self->root, errno, NULL);
- }
libmemcached_free(memc, self);
return NULL;
memcached_return_t memcached_string_append_character(memcached_string_st *string,
char character)
{
- memcached_return_t rc;
-
- rc= _string_check(string, 1);
-
- if (rc != MEMCACHED_SUCCESS)
+ if (memcached_failed(_string_check(string, 1)))
{
- return rc;
+ return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
}
*string->end= character;
memcached_return_t memcached_string_append(memcached_string_st *string,
const char *value, size_t length)
{
- memcached_return_t rc;
-
- rc= _string_check(string, length);
-
- if (rc != MEMCACHED_SUCCESS)
+ if (memcached_failed(_string_check(string, length)))
{
- return rc;
+ return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
}
WATCHPOINT_ASSERT(length <= string->current_size);
char *memcached_string_c_copy(memcached_string_st *string)
{
- char *c_ptr;
-
- if (memcached_string_length(string) == 0)
+ if (not memcached_string_length(string))
return NULL;
- c_ptr= static_cast<char *>(libmemcached_malloc(string->root, (memcached_string_length(string)+1) * sizeof(char)));
+ char *c_ptr= static_cast<char *>(libmemcached_malloc(string->root, (memcached_string_length(string)+1) * sizeof(char)));
- if (c_ptr == NULL)
+ if (not c_ptr)
return NULL;
memcpy(c_ptr, memcached_string_value(string), memcached_string_length(string));
void memcached_string_free(memcached_string_st *ptr)
{
- if (ptr == NULL)
+ if (not ptr)
return;
if (ptr->string)
#pragma once
+#include <libmemcached/basic_string.h>
+
/**
Strings are always under our control so we make some assumptions
about them.
} options;
};
-struct memcached_string_t {
- size_t size;
- const char *c_str;
-};
+#ifdef BUILDING_LIBMEMCACHED
#ifdef __cplusplus
extern "C" {
#endif
LIBMEMCACHED_LOCAL
-memcached_string_st *memcached_string_create(const memcached_st *ptr,
+memcached_string_st *memcached_string_create(memcached_st *ptr,
memcached_string_st *string,
size_t initial_size);
LIBMEMCACHED_LOCAL
}
#endif
-#ifdef BUILDING_LIBMEMCACHED
-
#ifdef __cplusplus
-#define memcached_string_with_size(X) (X), (static_cast<size_t>((sizeof(X) - 1)))
-#define memcached_string_make(X) (static_cast<size_t>((sizeof(X) - 1))), (X)
+#define memcached_literal_param(X) (X), (static_cast<size_t>((sizeof(X) - 1)))
#else
-#define memcached_string_with_size(X) (X), ((size_t)((sizeof(X) - 1)))
-#define memcached_string_make(X) (((size_t)((sizeof(X) - 1))), (X)
+#define memcached_literal_param(X) (X), ((size_t)((sizeof(X) - 1)))
#endif
#define memcached_string_make_from_cstr(X) (X), ((X) ? strlen(X) : 0)
-/* LibMemcached
- * Copyright (C) 2006-2009 Brian Aker
- * All rights reserved.
+/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ * Libmemcached library
*
- * Use and distribution licensed under the BSD license. See
- * the COPYING file in the parent directory for full text.
+ * Copyright (C) 2011 Data Differential, http://datadifferential.com/
+ * Copyright (C) 2006-2009 Brian Aker All rights reserved.
*
- * Summary: Types for libmemcached
+ * 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.
*
*/
+
#pragma once
#ifndef __LIBMEMCACHED_TYPES_H__
#define __LIBMEMCACHED_TYPES_H__
*
*/
-#include <libmemcached/common.h>
+#include <config.h>
+#include <libmemcached/memcached.h>
#include <libmemcached/virtual_bucket.h>
struct bucket_t {
{ \
if ((A) != (B)) \
{ \
- fprintf(stderr, "\n%s:%d: Expected %lu == %lu\n", __FILE__, __LINE__, (unsigned long)(A), (unsigned long)(B)); \
+ fprintf(stderr, "\n%s:%d: Expected %s, got %lu\n", __FILE__, __LINE__, #A, (unsigned long)(B)); \
+ create_core(); \
+ return TEST_FAILURE; \
+ } \
+} while (0)
+
+#define test_compare_got(A,B,C) \
+do \
+{ \
+ if ((A) != (B)) \
+ { \
+ fprintf(stderr, "\n%s:%d: Expected %s, got %s\n", __FILE__, __LINE__, #A, (C)); \
create_core(); \
return TEST_FAILURE; \
} \
#include <libtest/test.h>
#include <tests/error_conditions.h>
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-test_return_t memcached_increment_MEMCACHED_NO_SERVERS(memcached_st *junk)
+test_return_t memcached_increment_MEMCACHED_NO_SERVERS(memcached_st *)
{
- (void)junk;
memcached_st *memc_ptr;
memc_ptr= memcached_create(NULL);
test_true(memc_ptr);
- memcached_increment(memc_ptr, memcached_string_with_size("dead key"), 1, NULL);
+ memcached_increment(memc_ptr, memcached_literal_param("dead key"), 1, NULL);
test_true(memcached_last_error(memc_ptr) == MEMCACHED_NO_SERVERS);
- memcached_increment(memc_ptr, memcached_string_with_size("dead key"), 1, NULL);
+ memcached_increment(memc_ptr, memcached_literal_param("dead key"), 1, NULL);
test_true(memcached_last_error(memc_ptr) == MEMCACHED_NO_SERVERS);
memcached_free(memc_ptr);
return TEST_SUCCESS;
}
-
-#ifdef __cplusplus
-}
-#endif
tests/basic.cc \
tests/deprecated.cc \
tests/error_conditions.cc \
- tests/mem_functions.c \
+ tests/mem_functions.cc \
tests/parser.cc \
tests/pool.cc \
tests/print.cc \
+++ /dev/null
-/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
- *
- * Libmemcached library
- *
- * Copyright (C) 2011 Data Differential, http://datadifferential.com/
- * Copyright (C) 2006-2009 Brian Aker All rights reserved.
- *
- * 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.
- *
- */
-
-
-/*
- Sample test application.
-*/
-
-#include "config.h"
-
-#include <assert.h>
-#include <stdio.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <signal.h>
-#include <unistd.h>
-#include <time.h>
-
-#include "libmemcached/common.h"
-
-#include <libtest/server.h>
-
-#include "clients/generator.h"
-#include "clients/execute.h"
-
-#define SMALL_STRING_LEN 1024
-
-#include <libtest/test.h>
-#include "tests/deprecated.h"
-#include "tests/parser.h"
-#include "tests/pool.h"
-#include "tests/string.h"
-#include "tests/replication.h"
-#include "tests/basic.h"
-#include "tests/error_conditions.h"
-#include "tests/print.h"
-#include "tests/virtual_buckets.h"
-
-
-#ifdef HAVE_LIBMEMCACHEDUTIL
-#include <pthread.h>
-#include "libmemcached/memcached_util.h"
-#endif
-
-#include "hash_results.h"
-
-#define GLOBAL_COUNT 10000
-#define GLOBAL2_COUNT 100
-#define SERVERS_TO_CREATE 5
-static uint32_t global_count;
-
-static pairs_st *global_pairs;
-static const char *global_keys[GLOBAL_COUNT];
-static size_t global_keys_length[GLOBAL_COUNT];
-
-// Prototype
-static test_return_t pre_binary(memcached_st *memc);
-
-
-static test_return_t init_test(memcached_st *not_used)
-{
- memcached_st memc;
- (void)not_used;
-
- (void)memcached_create(&memc);
- memcached_free(&memc);
-
- return TEST_SUCCESS;
-}
-
-#define TEST_PORT_COUNT 7
-in_port_t test_ports[TEST_PORT_COUNT];
-
-static memcached_return_t server_display_function(const memcached_st *ptr,
- const memcached_server_st *server,
- void *context)
-{
- /* Do Nothing */
- size_t bigger= *((size_t *)(context));
- (void)ptr;
- assert(bigger <= memcached_server_port(server));
- *((size_t *)(context))= memcached_server_port(server);
-
- return MEMCACHED_SUCCESS;
-}
-
-static memcached_return_t dump_server_information(const memcached_st *ptr,
- const memcached_server_st *instance,
- void *context)
-{
- /* Do Nothing */
- FILE *stream= (FILE *)context;
- (void)ptr;
-
- fprintf(stream, "Memcached Server: %s %u Version %u.%u.%u\n",
- memcached_server_name(instance),
- memcached_server_port(instance),
- instance->major_version,
- instance->minor_version,
- instance->micro_version);
-
- return MEMCACHED_SUCCESS;
-}
-
-static test_return_t server_sort_test(memcached_st *ptr)
-{
- size_t bigger= 0; /* Prime the value for the test_true in server_display_function */
-
- memcached_return_t rc;
- memcached_server_fn callbacks[1];
- memcached_st *local_memc;
- (void)ptr;
-
- local_memc= memcached_create(NULL);
- test_true(local_memc);
- memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SORT_HOSTS, 1);
-
- for (size_t x= 0; x < TEST_PORT_COUNT; x++)
- {
- test_ports[x]= (in_port_t)random() % 64000;
- rc= memcached_server_add_with_weight(local_memc, "localhost", test_ports[x], 0);
- test_true(memcached_server_count(local_memc) == x + 1);
-#if 0 // Rewrite
- test_true(memcached_server_list_count(memcached_server_list(local_memc)) == x+1);
-#endif
- test_true(rc == MEMCACHED_SUCCESS);
- }
-
- callbacks[0]= server_display_function;
- memcached_server_cursor(local_memc, callbacks, (void *)&bigger, 1);
-
-
- memcached_free(local_memc);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t server_sort2_test(memcached_st *ptr)
-{
- size_t bigger= 0; /* Prime the value for the test_true in server_display_function */
- memcached_return_t rc;
- memcached_server_fn callbacks[1];
- memcached_st *local_memc;
- memcached_server_instance_st instance;
- (void)ptr;
-
- local_memc= memcached_create(NULL);
- test_true(local_memc);
- rc= memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SORT_HOSTS, 1);
- test_true(rc == MEMCACHED_SUCCESS);
-
- rc= memcached_server_add_with_weight(local_memc, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0);
- test_true(rc == MEMCACHED_SUCCESS);
- instance= memcached_server_instance_by_position(local_memc, 0);
- test_true(memcached_server_port(instance) == 43043);
-
- rc= memcached_server_add_with_weight(local_memc, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0);
- test_true(rc == MEMCACHED_SUCCESS);
-
- instance= memcached_server_instance_by_position(local_memc, 0);
- test_true(memcached_server_port(instance) == 43042);
-
- instance= memcached_server_instance_by_position(local_memc, 1);
- test_true(memcached_server_port(instance) == 43043);
-
- callbacks[0]= server_display_function;
- memcached_server_cursor(local_memc, callbacks, (void *)&bigger, 1);
-
-
- memcached_free(local_memc);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t memcached_server_remove_test(memcached_st *ptr)
-{
- const char *server_string= "--server=localhost:4444 --server=localhost:4445 --server=localhost:4446 --server=localhost:4447 --server=localhost --server=memcache1.memcache.bk.sapo.pt:11211 --server=memcache1.memcache.bk.sapo.pt:11212 --server=memcache1.memcache.bk.sapo.pt:11213 --server=memcache1.memcache.bk.sapo.pt:11214 --server=memcache2.memcache.bk.sapo.pt:11211 --server=memcache2.memcache.bk.sapo.pt:11212 --server=memcache2.memcache.bk.sapo.pt:11213 --server=memcache2.memcache.bk.sapo.pt:11214";
- (void)ptr;
-
- memcached_st *memc= memcached(server_string, strlen(server_string));
- test_true(memc);
-
- memcached_server_fn callbacks[1];
- callbacks[0]= server_print_callback;
- memcached_server_cursor(memc, callbacks, NULL, 1);
-
- memcached_free(memc);
-
- return TEST_SUCCESS;
-}
-
-static memcached_return_t server_display_unsort_function(const memcached_st *ptr,
- const memcached_server_st *server,
- void *context)
-{
- /* Do Nothing */
- uint32_t x= *((uint32_t *)(context));
- (void)ptr;
-
- if (! (test_ports[x] == server->port))
- {
- fprintf(stderr, "%lu -> %lu\n", (unsigned long)test_ports[x], (unsigned long)server->port);
- return MEMCACHED_FAILURE;
- }
-
- *((uint32_t *)(context))= ++x;
-
- return MEMCACHED_SUCCESS;
-}
-
-static test_return_t server_unsort_test(memcached_st *ptr)
-{
- size_t counter= 0; /* Prime the value for the test_true in server_display_function */
- size_t bigger= 0; /* Prime the value for the test_true in server_display_function */
- memcached_return_t rc;
- memcached_server_fn callbacks[1];
- memcached_st *local_memc;
- (void)ptr;
-
- local_memc= memcached_create(NULL);
- test_true(local_memc);
-
- for (size_t x= 0; x < TEST_PORT_COUNT; x++)
- {
- test_ports[x]= (in_port_t)(random() % 64000);
- rc= memcached_server_add_with_weight(local_memc, "localhost", test_ports[x], 0);
- test_true(memcached_server_count(local_memc) == x+1);
-#if 0 // Rewrite
- test_true(memcached_server_list_count(memcached_server_list(local_memc)) == x+1);
-#endif
- test_true(rc == MEMCACHED_SUCCESS);
- }
-
- callbacks[0]= server_display_unsort_function;
- memcached_server_cursor(local_memc, callbacks, (void *)&counter, 1);
-
- /* Now we sort old data! */
- memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SORT_HOSTS, 1);
- callbacks[0]= server_display_function;
- memcached_server_cursor(local_memc, callbacks, (void *)&bigger, 1);
-
-
- memcached_free(local_memc);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t allocation_test(memcached_st *not_used)
-{
- (void)not_used;
- memcached_st *memc;
- memc= memcached_create(NULL);
- test_true(memc);
- memcached_free(memc);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t clone_test(memcached_st *memc)
-{
- /* All null? */
- {
- memcached_st *memc_clone;
- memc_clone= memcached_clone(NULL, NULL);
- test_true(memc_clone);
- memcached_free(memc_clone);
- }
-
- /* Can we init from null? */
- {
- memcached_st *memc_clone;
- memc_clone= memcached_clone(NULL, memc);
- test_true(memc_clone);
-
- { // Test allocators
- test_true(memc_clone->allocators.free == memc->allocators.free);
- test_true(memc_clone->allocators.malloc == memc->allocators.malloc);
- test_true(memc_clone->allocators.realloc == memc->allocators.realloc);
- test_true(memc_clone->allocators.calloc == memc->allocators.calloc);
- }
-
- test_true(memc_clone->connect_timeout == memc->connect_timeout);
- test_true(memc_clone->delete_trigger == memc->delete_trigger);
- test_true(memc_clone->distribution == memc->distribution);
- { // Test all of the flags
- test_true(memc_clone->flags.no_block == memc->flags.no_block);
- test_true(memc_clone->flags.tcp_nodelay == memc->flags.tcp_nodelay);
- test_true(memc_clone->flags.support_cas == memc->flags.support_cas);
- test_true(memc_clone->flags.buffer_requests == memc->flags.buffer_requests);
- test_true(memc_clone->flags.use_sort_hosts == memc->flags.use_sort_hosts);
- test_true(memc_clone->flags.verify_key == memc->flags.verify_key);
- test_true(memc_clone->ketama.weighted == memc->ketama.weighted);
- test_true(memc_clone->flags.binary_protocol == memc->flags.binary_protocol);
- test_true(memc_clone->flags.hash_with_prefix_key == memc->flags.hash_with_prefix_key);
- test_true(memc_clone->flags.no_reply == memc->flags.no_reply);
- test_true(memc_clone->flags.use_udp == memc->flags.use_udp);
- test_true(memc_clone->flags.auto_eject_hosts == memc->flags.auto_eject_hosts);
- test_true(memc_clone->flags.randomize_replica_read == memc->flags.randomize_replica_read);
- }
- test_true(memc_clone->get_key_failure == memc->get_key_failure);
- test_true(hashkit_compare(&memc_clone->hashkit, &memc->hashkit));
- test_true(hashkit_compare(&memc_clone->distribution_hashkit, &memc->distribution_hashkit));
- test_true(memc_clone->io_bytes_watermark == memc->io_bytes_watermark);
- test_true(memc_clone->io_msg_watermark == memc->io_msg_watermark);
- test_true(memc_clone->io_key_prefetch == memc->io_key_prefetch);
- test_true(memc_clone->on_cleanup == memc->on_cleanup);
- test_true(memc_clone->on_clone == memc->on_clone);
- test_true(memc_clone->poll_timeout == memc->poll_timeout);
- test_true(memc_clone->rcv_timeout == memc->rcv_timeout);
- test_true(memc_clone->recv_size == memc->recv_size);
- test_true(memc_clone->retry_timeout == memc->retry_timeout);
- test_true(memc_clone->send_size == memc->send_size);
- test_true(memc_clone->server_failure_limit == memc->server_failure_limit);
- test_true(memc_clone->snd_timeout == memc->snd_timeout);
- test_true(memc_clone->user_data == memc->user_data);
-
- memcached_free(memc_clone);
- }
-
- /* Can we init from struct? */
- {
- memcached_st declared_clone;
- memcached_st *memc_clone;
- memset(&declared_clone, 0 , sizeof(memcached_st));
- memc_clone= memcached_clone(&declared_clone, NULL);
- test_true(memc_clone);
- memcached_free(memc_clone);
- }
-
- /* Can we init from struct? */
- {
- memcached_st declared_clone;
- memcached_st *memc_clone;
- memset(&declared_clone, 0 , sizeof(memcached_st));
- memc_clone= memcached_clone(&declared_clone, memc);
- test_true(memc_clone);
- memcached_free(memc_clone);
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t userdata_test(memcached_st *memc)
-{
- void* foo= NULL;
- test_true(memcached_set_user_data(memc, foo) == NULL);
- test_true(memcached_get_user_data(memc) == foo);
- test_true(memcached_set_user_data(memc, NULL) == foo);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t connection_test(memcached_st *memc)
-{
- memcached_return_t rc;
-
- rc= memcached_server_add_with_weight(memc, "localhost", 0, 0);
- test_true(rc == MEMCACHED_SUCCESS);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t error_test(memcached_st *memc)
-{
- memcached_return_t rc;
- uint32_t values[] = { 851992627U, 2337886783U, 3196981036U, 4001849190U,
- 982370485U, 1263635348U, 4242906218U, 3829656100U,
- 1891735253U, 334139633U, 2257084983U, 3088286104U,
- 13199785U, 2542027183U, 1097051614U, 199566778U,
- 2748246961U, 2465192557U, 1664094137U, 2405439045U,
- 1842224848U, 692413798U, 3479807801U, 919913813U,
- 4269430871U, 610793021U, 527273862U, 1437122909U,
- 2300930706U, 2943759320U, 674306647U, 2400528935U,
- 54481931U, 4186304426U, 1741088401U, 2979625118U,
- 4159057246U, 3425930182U, 2593724503U, 1868899624U,
- 1769812374U, 2302537950U, 1110330676U, 3365377466U,
- 1336171666U, 3021258493U, 3365377466U };
-
- // You have updated the memcache_error messages but not updated docs/tests.
- for (rc= MEMCACHED_SUCCESS; rc < MEMCACHED_MAXIMUM_RETURN; rc++)
- {
- uint32_t hash_val;
- const char *msg= memcached_strerror(memc, rc);
- hash_val= memcached_generate_hash_value(msg, strlen(msg),
- MEMCACHED_HASH_JENKINS);
- if (values[rc] != hash_val)
- {
- fprintf(stderr, "\n\nYou have updated memcached_return_t without updating the error_test\n");
- fprintf(stderr, "%u, %s, (%u)\n\n", (uint32_t)rc, memcached_strerror(memc, rc), hash_val);
- }
- test_true(values[rc] == hash_val);
- }
- test_true(MEMCACHED_MAXIMUM_RETURN == 46);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t set_test(memcached_st *memc)
-{
- memcached_return_t rc;
- const char *key= "foo";
- const char *value= "when we sanitize";
-
- rc= memcached_set(memc, key, strlen(key),
- value, strlen(value),
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t append_test(memcached_st *memc)
-{
- memcached_return_t rc;
- const char *key= "fig";
- const char *in_value= "we";
- char *out_value= NULL;
- size_t value_length;
- uint32_t flags;
-
- rc= memcached_flush(memc, 0);
- test_true(rc == MEMCACHED_SUCCESS);
-
- rc= memcached_set(memc, key, strlen(key),
- in_value, strlen(in_value),
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS);
-
- rc= memcached_append(memc, key, strlen(key),
- " the", strlen(" the"),
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS);
-
- rc= memcached_append(memc, key, strlen(key),
- " people", strlen(" people"),
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS);
-
- out_value= memcached_get(memc, key, strlen(key),
- &value_length, &flags, &rc);
- test_true(!memcmp(out_value, "we the people", strlen("we the people")));
- test_true(strlen("we the people") == value_length);
- test_true(rc == MEMCACHED_SUCCESS);
- free(out_value);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t append_binary_test(memcached_st *memc)
-{
- memcached_return_t rc;
- const char *key= "numbers";
- uint32_t store_list[] = { 23, 56, 499, 98, 32847, 0 };
- uint32_t *value;
- size_t value_length;
- uint32_t flags;
- uint32_t x;
-
- rc= memcached_flush(memc, 0);
- test_true(rc == MEMCACHED_SUCCESS);
-
- rc= memcached_set(memc,
- key, strlen(key),
- NULL, 0,
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS);
-
- for (x= 0; store_list[x] ; x++)
- {
- rc= memcached_append(memc,
- key, strlen(key),
- (char *)&store_list[x], sizeof(uint32_t),
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS);
- }
-
- value= (uint32_t *)memcached_get(memc, key, strlen(key),
- &value_length, &flags, &rc);
- test_true((value_length == (sizeof(uint32_t) * x)));
- test_true(rc == MEMCACHED_SUCCESS);
-
- for (uint32_t counter= x, *ptr= value; counter; counter--)
- {
- test_true(*ptr == store_list[x - counter]);
- ptr++;
- }
- free(value);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t cas2_test(memcached_st *memc)
-{
- memcached_return_t rc;
- const char *keys[]= {"fudge", "son", "food"};
- size_t key_length[]= {5, 3, 4};
- const char *value= "we the people";
- size_t value_length= strlen("we the people");
- unsigned int x;
- memcached_result_st results_obj;
- memcached_result_st *results;
- unsigned int set= 1;
-
- rc= memcached_flush(memc, 0);
- test_true(rc == MEMCACHED_SUCCESS);
-
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
-
- for (x= 0; x < 3; x++)
- {
- rc= memcached_set(memc, keys[x], key_length[x],
- keys[x], key_length[x],
- (time_t)50, (uint32_t)9);
- test_true(rc == MEMCACHED_SUCCESS);
- }
-
- rc= memcached_mget(memc, keys, key_length, 3);
-
- results= memcached_result_create(memc, &results_obj);
-
- results= memcached_fetch_result(memc, &results_obj, &rc);
- test_true(results);
- test_true(results->item_cas);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(memcached_result_cas(results));
-
- test_true(!memcmp(value, "we the people", strlen("we the people")));
- test_true(strlen("we the people") == value_length);
- test_true(rc == MEMCACHED_SUCCESS);
-
- memcached_result_free(&results_obj);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t cas_test(memcached_st *memc)
-{
- memcached_return_t rc;
- const char *key= "fun";
- size_t key_length= strlen(key);
- const char *value= "we the people";
- const char* keys[2] = { key, NULL };
- size_t keylengths[2] = { strlen(key), 0 };
- size_t value_length= strlen(value);
- const char *value2= "change the value";
- size_t value2_length= strlen(value2);
-
- memcached_result_st results_obj;
- memcached_result_st *results;
- unsigned int set= 1;
-
- rc= memcached_flush(memc, 0);
- test_true(rc == MEMCACHED_SUCCESS);
-
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
-
- rc= memcached_set(memc, key, strlen(key),
- value, strlen(value),
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS);
-
- rc= memcached_mget(memc, keys, keylengths, 1);
-
- results= memcached_result_create(memc, &results_obj);
-
- results= memcached_fetch_result(memc, &results_obj, &rc);
- test_true(results);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(memcached_result_cas(results));
- test_true(!memcmp(value, memcached_result_value(results), value_length));
- test_true(strlen(memcached_result_value(results)) == value_length);
- test_true(rc == MEMCACHED_SUCCESS);
- uint64_t cas = memcached_result_cas(results);
-
-#if 0
- results= memcached_fetch_result(memc, &results_obj, &rc);
- test_true(rc == MEMCACHED_END);
- test_true(results == NULL);
-#endif
-
- rc= memcached_cas(memc, key, key_length, value2, value2_length, 0, 0, cas);
- test_true(rc == MEMCACHED_SUCCESS);
-
- /*
- * The item will have a new cas value, so try to set it again with the old
- * value. This should fail!
- */
- rc= memcached_cas(memc, key, key_length, value2, value2_length, 0, 0, cas);
- test_true(rc == MEMCACHED_DATA_EXISTS);
-
- memcached_result_free(&results_obj);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t prepend_test(memcached_st *memc)
-{
- memcached_return_t rc;
- const char *key= "fig";
- const char *value= "people";
- char *out_value= NULL;
- size_t value_length;
- uint32_t flags;
-
- rc= memcached_flush(memc, 0);
- test_true(rc == MEMCACHED_SUCCESS);
-
- rc= memcached_set(memc, key, strlen(key),
- value, strlen(value),
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS);
-
- rc= memcached_prepend(memc, key, strlen(key),
- "the ", strlen("the "),
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS);
-
- rc= memcached_prepend(memc, key, strlen(key),
- "we ", strlen("we "),
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS);
-
- out_value= memcached_get(memc, key, strlen(key),
- &value_length, &flags, &rc);
- test_true(!memcmp(out_value, "we the people", strlen("we the people")));
- test_true(strlen("we the people") == value_length);
- test_true(rc == MEMCACHED_SUCCESS);
- free(out_value);
-
- return TEST_SUCCESS;
-}
-
-/*
- Set the value, then quit to make sure it is flushed.
- Come back in and test that add fails.
-*/
-static test_return_t add_test(memcached_st *memc)
-{
- memcached_return_t rc;
- const char *key= "foo";
- const char *value= "when we sanitize";
- unsigned long long setting_value;
-
- setting_value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
-
- rc= memcached_set(memc, key, strlen(key),
- value, strlen(value),
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
- memcached_quit(memc);
- rc= memcached_add(memc, key, strlen(key),
- value, strlen(value),
- (time_t)0, (uint32_t)0);
-
- /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
- if (setting_value)
- {
- test_true(rc == MEMCACHED_NOTSTORED || rc == MEMCACHED_STORED);
- }
- else
- {
- test_true(rc == MEMCACHED_NOTSTORED || rc == MEMCACHED_DATA_EXISTS);
- }
-
- return TEST_SUCCESS;
-}
-
-/*
-** There was a problem of leaking filedescriptors in the initial release
-** of MacOSX 10.5. This test case triggers the problem. On some Solaris
-** systems it seems that the kernel is slow on reclaiming the resources
-** because the connects starts to time out (the test doesn't do much
-** anyway, so just loop 10 iterations)
-*/
-static test_return_t add_wrapper(memcached_st *memc)
-{
- unsigned int max= 10000;
-#ifdef __sun
- max= 10;
-#endif
-#ifdef __APPLE__
- max= 10;
-#endif
-
- for (uint32_t x= 0; x < max; x++)
- add_test(memc);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t replace_test(memcached_st *memc)
-{
- memcached_return_t rc;
- const char *key= "foo";
- const char *value= "when we sanitize";
- const char *original= "first we insert some data";
-
- rc= memcached_set(memc, key, strlen(key),
- original, strlen(original),
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
-
- rc= memcached_replace(memc, key, strlen(key),
- value, strlen(value),
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t delete_test(memcached_st *memc)
-{
- memcached_return_t rc;
- const char *key= "foo";
- const char *value= "when we sanitize";
-
- rc= memcached_set(memc, key, strlen(key),
- value, strlen(value),
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
-
- rc= memcached_delete(memc, key, strlen(key), (time_t)0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t flush_test(memcached_st *memc)
-{
- memcached_return_t rc;
-
- uint64_t query_id= memcached_query_id(memc);
- rc= memcached_flush(memc, 0);
- test_compare(rc, MEMCACHED_SUCCESS);
- test_compare(query_id +1, memcached_query_id(memc));
-
- return TEST_SUCCESS;
-}
-
-static memcached_return_t server_function(const memcached_st *ptr,
- const memcached_server_st *server,
- void *context)
-{
- (void)ptr; (void)server; (void)context;
- /* Do Nothing */
-
- return MEMCACHED_SUCCESS;
-}
-
-static test_return_t memcached_server_cursor_test(memcached_st *memc)
-{
- char context[10];
- strncpy(context, "foo bad", sizeof(context));
- memcached_server_fn callbacks[1];
-
- callbacks[0]= server_function;
- memcached_server_cursor(memc, callbacks, context, 1);
- return TEST_SUCCESS;
-}
-
-static test_return_t bad_key_test(memcached_st *memc)
-{
- memcached_return_t rc;
- const char *key= "foo bad";
- char *string;
- size_t string_length;
- uint32_t flags;
- memcached_st *memc_clone;
- unsigned int set= 1;
- size_t max_keylen= 0xffff;
-
- // Just skip if we are in binary mode.
- uint64_t query_id= memcached_query_id(memc);
- if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL))
- return TEST_SKIPPED;
- test_compare(query_id, memcached_query_id(memc)); // We should not increase the query_id for memcached_behavior_get()
-
- memc_clone= memcached_clone(NULL, memc);
- test_true(memc_clone);
-
- query_id= memcached_query_id(memc_clone);
- rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
- test_true(rc == MEMCACHED_SUCCESS);
- test_compare(query_id, memcached_query_id(memc_clone)); // We should not increase the query_id for memcached_behavior_set()
-
- /* All keys are valid in the binary protocol (except for length) */
- if (memcached_behavior_get(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 0)
- {
- query_id= memcached_query_id(memc_clone);
- string= memcached_get(memc_clone, key, strlen(key),
- &string_length, &flags, &rc);
- test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
- test_true(string_length == 0);
- test_true(!string);
-
- set= 0;
- query_id= memcached_query_id(memc_clone);
- rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
- test_compare(query_id, memcached_query_id(memc_clone)); // We should not increase the query_id for memcached_behavior_set()
- test_true(rc == MEMCACHED_SUCCESS);
- string= memcached_get(memc_clone, key, strlen(key),
- &string_length, &flags, &rc);
- test_true(rc == MEMCACHED_NOTFOUND);
- test_true(string_length == 0);
- test_true(!string);
-
- /* Test multi key for bad keys */
- const char *keys[] = { "GoodKey", "Bad Key", "NotMine" };
- size_t key_lengths[] = { 7, 7, 7 };
- set= 1;
- query_id= memcached_query_id(memc_clone);
- rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
- test_true(rc == MEMCACHED_SUCCESS);
- test_compare(query_id, memcached_query_id(memc_clone));
-
- query_id= memcached_query_id(memc_clone);
- rc= memcached_mget(memc_clone, keys, key_lengths, 3);
- test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
- test_compare(query_id +1, memcached_query_id(memc_clone));
-
- query_id= memcached_query_id(memc_clone);
- rc= memcached_mget_by_key(memc_clone, "foo daddy", 9, keys, key_lengths, 1);
- test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
- test_compare(query_id +1, memcached_query_id(memc_clone));
-
- max_keylen= 250;
-
- /* The following test should be moved to the end of this function when the
- memcached server is updated to allow max size length of the keys in the
- binary protocol
- */
- rc= memcached_callback_set(memc_clone, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
- test_true(rc == MEMCACHED_SUCCESS);
-
- char *longkey= (char *)malloc(max_keylen + 1);
- if (longkey != NULL)
- {
- memset(longkey, 'a', max_keylen + 1);
- string= memcached_get(memc_clone, longkey, max_keylen,
- &string_length, &flags, &rc);
- test_true(rc == MEMCACHED_NOTFOUND);
- test_true(string_length == 0);
- test_true(!string);
-
- string= memcached_get(memc_clone, longkey, max_keylen + 1,
- &string_length, &flags, &rc);
- test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
- test_true(string_length == 0);
- test_true(!string);
-
- free(longkey);
- }
- }
-
- /* Make sure zero length keys are marked as bad */
- set= 1;
- rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
- test_true(rc == MEMCACHED_SUCCESS);
- string= memcached_get(memc_clone, key, 0,
- &string_length, &flags, &rc);
- test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
- test_true(string_length == 0);
- test_true(!string);
-
- memcached_free(memc_clone);
-
- return TEST_SUCCESS;
-}
-
-#define READ_THROUGH_VALUE "set for me"
-static memcached_return_t read_through_trigger(memcached_st *memc,
- char *key,
- size_t key_length,
- memcached_result_st *result)
-{
- (void)memc;(void)key;(void)key_length;
- return memcached_result_set_value(result, READ_THROUGH_VALUE, strlen(READ_THROUGH_VALUE));
-}
-
-static test_return_t read_through(memcached_st *memc)
-{
- memcached_return_t rc;
- const char *key= "foo";
- char *string;
- size_t string_length;
- uint32_t flags;
- memcached_trigger_key_fn cb= (memcached_trigger_key_fn)read_through_trigger;
-
- string= memcached_get(memc, key, strlen(key),
- &string_length, &flags, &rc);
-
- test_true(rc == MEMCACHED_NOTFOUND);
- test_false(string_length);
- test_false(string);
-
- rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_GET_FAILURE,
- *(void **)&cb);
- test_true(rc == MEMCACHED_SUCCESS);
-
- string= memcached_get(memc, key, strlen(key),
- &string_length, &flags, &rc);
-
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(string_length == strlen(READ_THROUGH_VALUE));
- test_strcmp(READ_THROUGH_VALUE, string);
- free(string);
-
- string= memcached_get(memc, key, strlen(key),
- &string_length, &flags, &rc);
-
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(string_length == strlen(READ_THROUGH_VALUE));
- test_true(!strcmp(READ_THROUGH_VALUE, string));
- free(string);
-
- return TEST_SUCCESS;
-}
-
-static memcached_return_t delete_trigger(memcached_st *ptr,
- const char *key,
- size_t key_length)
-{
- (void)ptr;(void)key_length;
- assert(key);
-
- return MEMCACHED_SUCCESS;
-}
-
-static test_return_t delete_through(memcached_st *memc)
-{
- memcached_trigger_delete_key_fn callback;
- memcached_return_t rc;
-
- callback= (memcached_trigger_delete_key_fn)delete_trigger;
-
- rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_DELETE_TRIGGER, *(void**)&callback);
- test_true(rc == MEMCACHED_SUCCESS);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t get_test(memcached_st *memc)
-{
- memcached_return_t rc;
- const char *key= "foo";
- char *string;
- size_t string_length;
- uint32_t flags;
-
- uint64_t query_id= memcached_query_id(memc);
- rc= memcached_delete(memc, key, strlen(key), (time_t)0);
- test_true(rc == MEMCACHED_BUFFERED || rc == MEMCACHED_NOTFOUND);
- test_compare(query_id +1, memcached_query_id(memc));
-
- string= memcached_get(memc, key, strlen(key),
- &string_length, &flags, &rc);
-
- test_true(rc == MEMCACHED_NOTFOUND);
- test_false(string_length);
- test_false(string);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t get_test2(memcached_st *memc)
-{
- memcached_return_t rc;
- const char *key= "foo";
- const char *value= "when we sanitize";
- char *string;
- size_t string_length;
- uint32_t flags;
-
- uint64_t query_id= memcached_query_id(memc);
- rc= memcached_set(memc, key, strlen(key),
- value, strlen(value),
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
- test_compare(query_id +1, memcached_query_id(memc));
-
- query_id= memcached_query_id(memc);
- string= memcached_get(memc, key, strlen(key),
- &string_length, &flags, &rc);
- test_compare(query_id +1, memcached_query_id(memc));
-
- test_true(string);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(string_length == strlen(value));
- test_memcmp(string, value, string_length);
-
- free(string);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t set_test2(memcached_st *memc)
-{
- memcached_return_t rc;
- const char *key= "foo";
- const char *value= "train in the brain";
- size_t value_length= strlen(value);
- unsigned int x;
-
- for (x= 0; x < 10; x++)
- {
- rc= memcached_set(memc, key, strlen(key),
- value, value_length,
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t set_test3(memcached_st *memc)
-{
- memcached_return_t rc;
- char *value;
- size_t value_length= 8191;
-
- value = (char*)malloc(value_length);
- test_true(value);
-
- for (uint32_t x= 0; x < value_length; x++)
- value[x] = (char) (x % 127);
-
- /* The dump test relies on there being at least 32 items in memcached */
- for (uint32_t x= 0; x < 32; x++)
- {
- char key[16];
-
- snprintf(key, sizeof(key), "foo%u", x);
-
- uint64_t query_id= memcached_query_id(memc);
- rc= memcached_set(memc, key, strlen(key),
- value, value_length,
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
- test_compare(query_id +1, memcached_query_id(memc));
- }
-
- free(value);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t get_test3(memcached_st *memc)
-{
- memcached_return_t rc;
- const char *key= "foo";
- char *value;
- size_t value_length= 8191;
- char *string;
- size_t string_length;
- uint32_t flags;
- uint32_t x;
-
- value = (char*)malloc(value_length);
- test_true(value);
-
- for (x= 0; x < value_length; x++)
- value[x] = (char) (x % 127);
-
- rc= memcached_set(memc, key, strlen(key),
- value, value_length,
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
-
- string= memcached_get(memc, key, strlen(key),
- &string_length, &flags, &rc);
-
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(string);
- test_true(string_length == value_length);
- test_true(!memcmp(string, value, string_length));
-
- free(string);
- free(value);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t get_test4(memcached_st *memc)
-{
- memcached_return_t rc;
- const char *key= "foo";
- char *value;
- size_t value_length= 8191;
- char *string;
- size_t string_length;
- uint32_t flags;
- uint32_t x;
-
- value = (char*)malloc(value_length);
- test_true(value);
-
- for (x= 0; x < value_length; x++)
- value[x] = (char) (x % 127);
-
- rc= memcached_set(memc, key, strlen(key),
- value, value_length,
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
-
- for (x= 0; x < 10; x++)
- {
- string= memcached_get(memc, key, strlen(key),
- &string_length, &flags, &rc);
-
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(string);
- test_true(string_length == value_length);
- test_true(!memcmp(string, value, string_length));
- free(string);
- }
-
- free(value);
-
- return TEST_SUCCESS;
-}
-
-/*
- * This test verifies that memcached_read_one_response doesn't try to
- * dereference a NIL-pointer if you issue a multi-get and don't read out all
- * responses before you execute a storage command.
- */
-static test_return_t get_test5(memcached_st *memc)
-{
- /*
- ** Request the same key twice, to ensure that we hash to the same server
- ** (so that we have multiple response values queued up) ;-)
- */
- const char *keys[]= { "key", "key" };
- size_t lengths[]= { 3, 3 };
- uint32_t flags;
- size_t rlen;
-
- memcached_return_t rc= memcached_set(memc, keys[0], lengths[0],
- keys[0], lengths[0], 0, 0);
- test_true(rc == MEMCACHED_SUCCESS);
- rc= memcached_mget(memc, keys, lengths, 2);
-
- memcached_result_st results_obj;
- memcached_result_st *results;
- results=memcached_result_create(memc, &results_obj);
- test_true(results);
- results=memcached_fetch_result(memc, &results_obj, &rc);
- test_true(results);
- memcached_result_free(&results_obj);
-
- /* Don't read out the second result, but issue a set instead.. */
- rc= memcached_set(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0);
- test_true(rc == MEMCACHED_SUCCESS);
-
- char *val= memcached_get_by_key(memc, keys[0], lengths[0], "yek", 3,
- &rlen, &flags, &rc);
- test_true(val == NULL);
- test_true(rc == MEMCACHED_NOTFOUND);
- val= memcached_get(memc, keys[0], lengths[0], &rlen, &flags, &rc);
- test_true(val != NULL);
- test_true(rc == MEMCACHED_SUCCESS);
- free(val);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t mget_end(memcached_st *memc)
-{
- const char *keys[]= { "foo", "foo2" };
- size_t lengths[]= { 3, 4 };
- const char *values[]= { "fjord", "41" };
-
- memcached_return_t rc;
-
- // Set foo and foo2
- for (int i= 0; i < 2; i++)
- {
- rc= memcached_set(memc, keys[i], lengths[i], values[i], strlen(values[i]),
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS);
- }
-
- char *string;
- size_t string_length;
- uint32_t flags;
-
- // retrieve both via mget
- rc= memcached_mget(memc, keys, lengths, 2);
- test_true(rc == MEMCACHED_SUCCESS);
-
- char key[MEMCACHED_MAX_KEY];
- size_t key_length;
-
- // this should get both
- for (int i = 0; i < 2; i++)
- {
- string= memcached_fetch(memc, key, &key_length, &string_length,
- &flags, &rc);
- test_true(rc == MEMCACHED_SUCCESS);
- int val = 0;
- if (key_length == 4)
- val= 1;
- test_true(string_length == strlen(values[val]));
- test_true(strncmp(values[val], string, string_length) == 0);
- free(string);
- }
-
- // this should indicate end
- string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);
- test_true(rc == MEMCACHED_END);
-
- // now get just one
- rc= memcached_mget(memc, keys, lengths, 1);
- test_true(rc == MEMCACHED_SUCCESS);
-
- string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);
- test_true(key_length == lengths[0]);
- test_true(strncmp(keys[0], key, key_length) == 0);
- test_true(string_length == strlen(values[0]));
- test_true(strncmp(values[0], string, string_length) == 0);
- test_true(rc == MEMCACHED_SUCCESS);
- free(string);
-
- // this should indicate end
- string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);
- test_true(rc == MEMCACHED_END);
-
- return TEST_SUCCESS;
-}
-
-/* Do not copy the style of this code, I just access hosts to testthis function */
-static test_return_t stats_servername_test(memcached_st *memc)
-{
- memcached_return_t rc;
- memcached_stat_st memc_stat;
- memcached_server_instance_st instance=
- memcached_server_instance_by_position(memc, 0);
-
-#ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
- if (memcached_get_sasl_callbacks(memc) != NULL)
- return TEST_SKIPPED;
-#endif
- rc= memcached_stat_servername(&memc_stat, NULL,
- memcached_server_name(instance),
- memcached_server_port(instance));
-
- return TEST_SUCCESS;
-}
-
-static test_return_t increment_test(memcached_st *memc)
-{
- uint64_t new_number;
- memcached_return_t rc;
- const char *key= "number";
- const char *value= "0";
-
- rc= memcached_set(memc, key, strlen(key),
- value, strlen(value),
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
-
- rc= memcached_increment(memc, key, strlen(key),
- 1, &new_number);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(new_number == 1);
-
- rc= memcached_increment(memc, key, strlen(key),
- 1, &new_number);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(new_number == 2);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t increment_with_initial_test(memcached_st *memc)
-{
- if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0)
- {
- uint64_t new_number;
- memcached_return_t rc;
- const char *key= "number";
- uint64_t initial= 0;
-
- rc= memcached_increment_with_initial(memc, key, strlen(key),
- 1, initial, 0, &new_number);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(new_number == initial);
-
- rc= memcached_increment_with_initial(memc, key, strlen(key),
- 1, initial, 0, &new_number);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(new_number == (initial + 1));
- }
- return TEST_SUCCESS;
-}
-
-static test_return_t decrement_test(memcached_st *memc)
-{
- uint64_t new_number;
- memcached_return_t rc;
- const char *key= "number";
- const char *value= "3";
-
- rc= memcached_set(memc, key, strlen(key),
- value, strlen(value),
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
-
- rc= memcached_decrement(memc, key, strlen(key),
- 1, &new_number);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(new_number == 2);
-
- rc= memcached_decrement(memc, key, strlen(key),
- 1, &new_number);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(new_number == 1);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t decrement_with_initial_test(memcached_st *memc)
-{
- if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0)
- {
- uint64_t new_number;
- memcached_return_t rc;
- const char *key= "number";
- uint64_t initial= 3;
-
- rc= memcached_decrement_with_initial(memc, key, strlen(key),
- 1, initial, 0, &new_number);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(new_number == initial);
-
- rc= memcached_decrement_with_initial(memc, key, strlen(key),
- 1, initial, 0, &new_number);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(new_number == (initial - 1));
- }
- return TEST_SUCCESS;
-}
-
-static test_return_t increment_by_key_test(memcached_st *memc)
-{
- uint64_t new_number;
- memcached_return_t rc;
- const char *master_key= "foo";
- const char *key= "number";
- const char *value= "0";
-
- rc= memcached_set_by_key(memc, master_key, strlen(master_key),
- key, strlen(key),
- value, strlen(value),
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
-
- rc= memcached_increment_by_key(memc, master_key, strlen(master_key), key, strlen(key),
- 1, &new_number);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(new_number == 1);
-
- rc= memcached_increment_by_key(memc, master_key, strlen(master_key), key, strlen(key),
- 1, &new_number);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(new_number == 2);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t increment_with_initial_by_key_test(memcached_st *memc)
-{
- if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0)
- {
- uint64_t new_number;
- memcached_return_t rc;
- const char *master_key= "foo";
- const char *key= "number";
- uint64_t initial= 0;
-
- rc= memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
- key, strlen(key),
- 1, initial, 0, &new_number);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(new_number == initial);
-
- rc= memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
- key, strlen(key),
- 1, initial, 0, &new_number);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(new_number == (initial + 1));
- }
- return TEST_SUCCESS;
-}
-
-static test_return_t decrement_by_key_test(memcached_st *memc)
-{
- uint64_t new_number;
- memcached_return_t rc;
- const char *master_key= "foo";
- const char *key= "number";
- const char *value= "3";
-
- rc= memcached_set_by_key(memc, master_key, strlen(master_key),
- key, strlen(key),
- value, strlen(value),
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
-
- rc= memcached_decrement_by_key(memc, master_key, strlen(master_key),
- key, strlen(key),
- 1, &new_number);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(new_number == 2);
-
- rc= memcached_decrement_by_key(memc, master_key, strlen(master_key),
- key, strlen(key),
- 1, &new_number);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(new_number == 1);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t decrement_with_initial_by_key_test(memcached_st *memc)
-{
- if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0)
- {
- uint64_t new_number;
- memcached_return_t rc;
- const char *master_key= "foo";
- const char *key= "number";
- uint64_t initial= 3;
-
- rc= memcached_decrement_with_initial_by_key(memc, master_key, strlen(master_key),
- key, strlen(key),
- 1, initial, 0, &new_number);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(new_number == initial);
-
- rc= memcached_decrement_with_initial_by_key(memc, master_key, strlen(master_key),
- key, strlen(key),
- 1, initial, 0, &new_number);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(new_number == (initial - 1));
- }
- return TEST_SUCCESS;
-}
-
-static test_return_t quit_test(memcached_st *memc)
-{
- memcached_return_t rc;
- const char *key= "fudge";
- const char *value= "sanford and sun";
-
- rc= memcached_set(memc, key, strlen(key),
- value, strlen(value),
- (time_t)10, (uint32_t)3);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
- memcached_quit(memc);
-
- rc= memcached_set(memc, key, strlen(key),
- value, strlen(value),
- (time_t)50, (uint32_t)9);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t mget_result_test(memcached_st *memc)
-{
- memcached_return_t rc;
- const char *keys[]= {"fudge", "son", "food"};
- size_t key_length[]= {5, 3, 4};
- unsigned int x;
-
- memcached_result_st results_obj;
- memcached_result_st *results;
-
- results= memcached_result_create(memc, &results_obj);
- test_true(results);
- test_true(&results_obj == results);
-
- /* We need to empty the server before continueing test */
- rc= memcached_flush(memc, 0);
- test_true(rc == MEMCACHED_SUCCESS);
-
- rc= memcached_mget(memc, keys, key_length, 3);
- test_true(rc == MEMCACHED_SUCCESS);
-
- while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
- {
- test_true(results);
- }
-
- while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
- test_true(!results);
- test_true(rc == MEMCACHED_END);
-
- for (x= 0; x < 3; x++)
- {
- rc= memcached_set(memc, keys[x], key_length[x],
- keys[x], key_length[x],
- (time_t)50, (uint32_t)9);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
- }
-
- rc= memcached_mget(memc, keys, key_length, 3);
- test_true(rc == MEMCACHED_SUCCESS);
-
- while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
- {
- test_true(results);
- test_true(&results_obj == results);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(memcached_result_key_length(results) == memcached_result_length(results));
- test_true(!memcmp(memcached_result_key_value(results),
- memcached_result_value(results),
- memcached_result_length(results)));
- }
-
- memcached_result_free(&results_obj);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t mget_result_alloc_test(memcached_st *memc)
-{
- memcached_return_t rc;
- const char *keys[]= {"fudge", "son", "food"};
- size_t key_length[]= {5, 3, 4};
- unsigned int x;
-
- memcached_result_st *results;
-
- /* We need to empty the server before continueing test */
- rc= memcached_flush(memc, 0);
- test_true(rc == MEMCACHED_SUCCESS);
-
- rc= memcached_mget(memc, keys, key_length, 3);
- test_true(rc == MEMCACHED_SUCCESS);
-
- while ((results= memcached_fetch_result(memc, NULL, &rc)) != NULL)
- {
- test_true(results);
- }
- test_true(!results);
- test_true(rc == MEMCACHED_END);
-
- for (x= 0; x < 3; x++)
- {
- rc= memcached_set(memc, keys[x], key_length[x],
- keys[x], key_length[x],
- (time_t)50, (uint32_t)9);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
- }
-
- rc= memcached_mget(memc, keys, key_length, 3);
- test_true(rc == MEMCACHED_SUCCESS);
-
- x= 0;
- while ((results= memcached_fetch_result(memc, NULL, &rc)))
- {
- test_true(results);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(memcached_result_key_length(results) == memcached_result_length(results));
- test_true(!memcmp(memcached_result_key_value(results),
- memcached_result_value(results),
- memcached_result_length(results)));
- memcached_result_free(results);
- x++;
- }
-
- return TEST_SUCCESS;
-}
-
-/* Count the results */
-static memcached_return_t callback_counter(const memcached_st *ptr,
- memcached_result_st *result,
- void *context)
-{
- (void)ptr; (void)result;
- size_t *counter= (size_t *)context;
-
- *counter= *counter + 1;
-
- return MEMCACHED_SUCCESS;
-}
-
-static test_return_t mget_result_function(memcached_st *memc)
-{
- memcached_return_t rc;
- const char *keys[]= {"fudge", "son", "food"};
- size_t key_length[]= {5, 3, 4};
- unsigned int x;
- size_t counter;
- memcached_execute_fn callbacks[1];
-
- /* We need to empty the server before continueing test */
- rc= memcached_flush(memc, 0);
- for (x= 0; x < 3; x++)
- {
- rc= memcached_set(memc, keys[x], key_length[x],
- keys[x], key_length[x],
- (time_t)50, (uint32_t)9);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
- }
-
- rc= memcached_mget(memc, keys, key_length, 3);
- test_true(rc == MEMCACHED_SUCCESS);
-
- callbacks[0]= &callback_counter;
- counter= 0;
- rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
-
- test_true(counter == 3);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t mget_test(memcached_st *memc)
-{
- memcached_return_t rc;
- const char *keys[]= {"fudge", "son", "food"};
- size_t key_length[]= {5, 3, 4};
- unsigned int x;
- uint32_t flags;
-
- char return_key[MEMCACHED_MAX_KEY];
- size_t return_key_length;
- char *return_value;
- size_t return_value_length;
-
- /* We need to empty the server before continueing test */
- rc= memcached_flush(memc, 0);
- test_true(rc == MEMCACHED_SUCCESS);
-
- rc= memcached_mget(memc, keys, key_length, 3);
- test_true(rc == MEMCACHED_SUCCESS);
-
- while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
- &return_value_length, &flags, &rc)) != NULL)
- {
- test_true(return_value);
- }
- test_true(!return_value);
- test_true(return_value_length == 0);
- test_true(rc == MEMCACHED_END);
-
- for (x= 0; x < 3; x++)
- {
- rc= memcached_set(memc, keys[x], key_length[x],
- keys[x], key_length[x],
- (time_t)50, (uint32_t)9);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
- }
-
- rc= memcached_mget(memc, keys, key_length, 3);
- test_true(rc == MEMCACHED_SUCCESS);
-
- x= 0;
- while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
- &return_value_length, &flags, &rc)))
- {
- test_true(return_value);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(return_key_length == return_value_length);
- test_true(!memcmp(return_value, return_key, return_value_length));
- free(return_value);
- x++;
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t mget_execute(memcached_st *memc)
-{
- bool binary= false;
-
- if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0)
- binary= true;
-
- /*
- * I only want to hit _one_ server so I know the number of requests I'm
- * sending in the pipeline.
- */
- uint32_t number_of_hosts= memc->number_of_hosts;
- memc->number_of_hosts= 1;
-
- size_t max_keys= 20480;
-
-
- char **keys= calloc(max_keys, sizeof(char*));
- size_t *key_length=calloc(max_keys, sizeof(size_t));
-
- /* First add all of the items.. */
- char blob[1024] = {0};
- memcached_return_t rc;
-
- for (size_t x= 0; x < max_keys; ++x)
- {
- char k[251];
-
- key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
- keys[x]= strdup(k);
- test_true(keys[x] != NULL);
- uint64_t query_id= memcached_query_id(memc);
- rc= memcached_add(memc, keys[x], key_length[x], blob, sizeof(blob), 0, 0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
- test_compare(query_id +1, memcached_query_id(memc));
- }
-
- /* Try to get all of them with a large multiget */
- size_t counter= 0;
- memcached_execute_fn callbacks[1]= { [0]= &callback_counter };
- rc= memcached_mget_execute(memc, (const char**)keys, key_length,
- max_keys, callbacks, &counter, 1);
-
- if (rc == MEMCACHED_SUCCESS)
- {
- test_true(binary);
- uint64_t query_id= memcached_query_id(memc);
- rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
- test_true(rc == MEMCACHED_END);
- test_compare(query_id, memcached_query_id(memc));
-
- /* Verify that we got all of the items */
- test_true(counter == max_keys);
- }
- else if (rc == MEMCACHED_NOT_SUPPORTED)
- {
- test_true(counter == 0);
- }
- else
- {
- test_fail("note: this test functions differently when in binary mode");
- }
-
- /* Release all allocated resources */
- for (size_t x= 0; x < max_keys; ++x)
- {
- free(keys[x]);
- }
- free(keys);
- free(key_length);
-
- memc->number_of_hosts= number_of_hosts;
- return TEST_SUCCESS;
-}
-
-#define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
-
-static test_return_t key_setup(memcached_st *memc)
-{
- (void)memc;
-
- if (pre_binary(memc) != TEST_SUCCESS)
- return TEST_SKIPPED;
-
- global_pairs= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT, 0);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t key_teardown(memcached_st *memc)
-{
- (void)memc;
- pairs_free(global_pairs);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t block_add_regression(memcached_st *memc)
-{
- /* First add all of the items.. */
- for (size_t x= 0; x < REGRESSION_BINARY_VS_BLOCK_COUNT; ++x)
- {
- memcached_return_t rc;
- char blob[1024] = {0};
-
- rc= memcached_add_by_key(memc, "bob", 3, global_pairs[x].key, global_pairs[x].key_length, blob, sizeof(blob), 0, 0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t binary_add_regression(memcached_st *memc)
-{
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
- test_return_t rc= block_add_regression(memc);
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 0);
- return rc;
-}
-
-static test_return_t get_stats_keys(memcached_st *memc)
-{
- char **stat_list;
- char **ptr;
- memcached_stat_st memc_stat;
- memcached_return_t rc;
-
- stat_list= memcached_stat_get_keys(memc, &memc_stat, &rc);
- test_true(rc == MEMCACHED_SUCCESS);
- for (ptr= stat_list; *ptr; ptr++)
- test_true(*ptr);
-
- free(stat_list);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t version_string_test(memcached_st *memc)
-{
- const char *version_string;
- (void)memc;
-
- version_string= memcached_lib_version();
-
- test_true(!strcmp(version_string, LIBMEMCACHED_VERSION_STRING));
-
- return TEST_SUCCESS;
-}
-
-static test_return_t get_stats(memcached_st *memc)
-{
- char **stat_list;
- char **ptr;
- memcached_return_t rc;
- memcached_stat_st *memc_stat;
-
- memc_stat= memcached_stat(memc, NULL, &rc);
- test_true(rc == MEMCACHED_SUCCESS);
-
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(memc_stat);
-
- for (uint32_t x= 0; x < memcached_server_count(memc); x++)
- {
- stat_list= memcached_stat_get_keys(memc, memc_stat+x, &rc);
- test_true(rc == MEMCACHED_SUCCESS);
- for (ptr= stat_list; *ptr; ptr++);
-
- free(stat_list);
- }
-
- memcached_stat_free(NULL, memc_stat);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t add_host_test(memcached_st *memc)
-{
- unsigned int x;
- memcached_server_st *servers;
- memcached_return_t rc;
- char servername[]= "0.example.com";
-
- servers= memcached_server_list_append_with_weight(NULL, servername, 400, 0, &rc);
- test_true(servers);
- test_true(1 == memcached_server_list_count(servers));
-
- for (x= 2; x < 20; x++)
- {
- char buffer[SMALL_STRING_LEN];
-
- snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
- servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0,
- &rc);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(x == memcached_server_list_count(servers));
- }
-
- rc= memcached_server_push(memc, servers);
- test_true(rc == MEMCACHED_SUCCESS);
- rc= memcached_server_push(memc, servers);
- test_true(rc == MEMCACHED_SUCCESS);
-
- memcached_server_list_free(servers);
-
- return TEST_SUCCESS;
-}
-
-static memcached_return_t clone_test_callback(memcached_st *parent, memcached_st *memc_clone)
-{
- (void)parent;(void)memc_clone;
- return MEMCACHED_SUCCESS;
-}
-
-static memcached_return_t cleanup_test_callback(memcached_st *ptr)
-{
- (void)ptr;
- return MEMCACHED_SUCCESS;
-}
-
-static test_return_t callback_test(memcached_st *memc)
-{
- /* Test User Data */
- {
- int x= 5;
- int *test_ptr;
- memcached_return_t rc;
-
- rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_USER_DATA, &x);
- test_true(rc == MEMCACHED_SUCCESS);
- test_ptr= (int *)memcached_callback_get(memc, MEMCACHED_CALLBACK_USER_DATA, &rc);
- test_true(*test_ptr == x);
- }
-
- /* Test Clone Callback */
- {
- memcached_clone_fn clone_cb= (memcached_clone_fn)clone_test_callback;
- void *clone_cb_ptr= *(void **)&clone_cb;
- void *temp_function= NULL;
- memcached_return_t rc;
-
- rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION,
- clone_cb_ptr);
- test_true(rc == MEMCACHED_SUCCESS);
- temp_function= memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc);
- test_true(temp_function == clone_cb_ptr);
- }
-
- /* Test Cleanup Callback */
- {
- memcached_cleanup_fn cleanup_cb=
- (memcached_cleanup_fn)cleanup_test_callback;
- void *cleanup_cb_ptr= *(void **)&cleanup_cb;
- void *temp_function= NULL;
- memcached_return_t rc;
-
- rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION,
- cleanup_cb_ptr);
- test_true(rc == MEMCACHED_SUCCESS);
- temp_function= memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc);
- test_true(temp_function == cleanup_cb_ptr);
- }
-
- return TEST_SUCCESS;
-}
-
-/* We don't test the behavior itself, we test the switches */
-static test_return_t behavior_test(memcached_st *memc)
-{
- uint64_t value;
- uint32_t set= 1;
-
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
- value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
- test_true(value == 1);
-
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
- value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
- test_true(value == 1);
-
- set= MEMCACHED_HASH_MD5;
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
- value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
- test_true(value == MEMCACHED_HASH_MD5);
-
- set= 0;
-
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
- value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
- test_true(value == 0);
-
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
- value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
- test_true(value == 0);
-
- set= MEMCACHED_HASH_DEFAULT;
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
- value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
- test_true(value == MEMCACHED_HASH_DEFAULT);
-
- set= MEMCACHED_HASH_CRC;
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
- value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
- test_true(value == MEMCACHED_HASH_CRC);
-
- value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
- test_true(value > 0);
-
- value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
- test_true(value > 0);
-
- value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS);
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, value + 1);
- test_true((value + 1) == memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS));
-
- return TEST_SUCCESS;
-}
-
-static test_return_t MEMCACHED_BEHAVIOR_CORK_test(memcached_st *memc)
-{
- memcached_return_t rc;
- bool set= true;
-
- rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CORK, set);
- test_true(rc == MEMCACHED_DEPRECATED);
-
- // Platform dependent
-#if 0
- bool value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_CORK);
- test_false(value);
-#endif
-
- return TEST_SUCCESS;
-}
-
-
-static test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st *memc)
-{
- memcached_return_t rc;
- bool set= true;
- bool value;
-
- rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE, set);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOT_SUPPORTED);
-
- value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE);
-
- if (rc == MEMCACHED_SUCCESS)
- {
- test_true((bool)value == set);
- }
- else
- {
- test_false((bool)value == set);
- }
-
- return TEST_SUCCESS;
-}
-
-
-static test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st *memc)
-{
- memcached_return_t rc;
- bool set= true;
- bool value;
-
- rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE, set);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOT_SUPPORTED);
-
- value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE);
-
- if (rc == MEMCACHED_SUCCESS)
- {
- test_true((bool)value == set);
- }
- else
- {
- test_false((bool)value == set);
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t fetch_all_results(memcached_st *memc, size_t *keys_returned)
-{
- memcached_return_t rc= MEMCACHED_SUCCESS;
- char return_key[MEMCACHED_MAX_KEY];
- size_t return_key_length;
- char *return_value;
- size_t return_value_length;
- uint32_t flags;
-
- *keys_returned= 0;
-
- while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
- &return_value_length, &flags, &rc)))
- {
- test_true(return_value);
- test_true(rc == MEMCACHED_SUCCESS);
- free(return_value);
- *keys_returned= *keys_returned +1;
- }
-
- test_true_got(rc == MEMCACHED_END || rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
-
- return TEST_SUCCESS;
-}
-
-/* Test case provided by Cal Haldenbrand */
-static test_return_t user_supplied_bug1(memcached_st *memc)
-{
- unsigned int setter= 1;
-
- unsigned long long total= 0;
- uint32_t size= 0;
- char key[10];
- char randomstuff[6 * 1024];
- memcached_return_t rc;
-
- memset(randomstuff, 0, 6 * 1024);
-
- /* We just keep looking at the same values over and over */
- srandom(10);
-
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter);
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
-
-
- /* add key */
- for (uint32_t x= 0 ; total < 20 * 1024576 ; x++ )
- {
- unsigned int j= 0;
-
- size= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
- memset(randomstuff, 0, 6 * 1024);
- test_true(size < 6 * 1024); /* Being safe here */
-
- for (j= 0 ; j < size ;j++)
- randomstuff[j] = (signed char) ((rand() % 26) + 97);
-
- total += size;
- snprintf(key, sizeof(key), "%u", x);
- rc = memcached_set(memc, key, strlen(key),
- randomstuff, strlen(randomstuff), 10, 0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
- /* If we fail, lets try again */
- if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_BUFFERED)
- rc = memcached_set(memc, key, strlen(key),
- randomstuff, strlen(randomstuff), 10, 0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
- }
-
- return TEST_SUCCESS;
-}
-
-/* Test case provided by Cal Haldenbrand */
-static test_return_t user_supplied_bug2(memcached_st *memc)
-{
- unsigned int setter;
- size_t total= 0;
-
- setter= 1;
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter);
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
-#ifdef NOT_YET
- setter = 20 * 1024576;
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, setter);
- setter = 20 * 1024576;
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, setter);
- getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
- getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
-
- for (x= 0, errors= 0; total < 20 * 1024576 ; x++)
-#endif
-
- for (uint32_t x= 0, errors= 0; total < 24576 ; x++)
- {
- memcached_return_t rc= MEMCACHED_SUCCESS;
- char buffer[SMALL_STRING_LEN];
- uint32_t flags= 0;
- size_t val_len= 0;
- char *getval;
-
- memset(buffer, 0, SMALL_STRING_LEN);
-
- snprintf(buffer, sizeof(buffer), "%u", x);
- getval= memcached_get(memc, buffer, strlen(buffer),
- &val_len, &flags, &rc);
- if (rc != MEMCACHED_SUCCESS)
- {
- if (rc == MEMCACHED_NOTFOUND)
- errors++;
- else
- {
- test_true(rc);
- }
-
- continue;
- }
- total+= val_len;
- errors= 0;
- free(getval);
- }
-
- return TEST_SUCCESS;
-}
-
-/* Do a large mget() over all the keys we think exist */
-#define KEY_COUNT 3000 // * 1024576
-static test_return_t user_supplied_bug3(memcached_st *memc)
-{
- memcached_return_t rc;
- unsigned int setter;
- unsigned int x;
- char **keys;
- size_t key_lengths[KEY_COUNT];
-
- setter= 1;
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter);
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
-#ifdef NOT_YET
- setter = 20 * 1024576;
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, setter);
- setter = 20 * 1024576;
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, setter);
- getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
- getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
-#endif
-
- keys= calloc(KEY_COUNT, sizeof(char *));
- test_true(keys);
- for (x= 0; x < KEY_COUNT; x++)
- {
- char buffer[30];
-
- snprintf(buffer, 30, "%u", x);
- keys[x]= strdup(buffer);
- key_lengths[x]= strlen(keys[x]);
- }
-
- rc= memcached_mget(memc, (const char **)keys, key_lengths, KEY_COUNT);
- test_true(rc == MEMCACHED_SUCCESS);
-
- size_t keys_returned;
- test_true(fetch_all_results(memc, &keys_returned) == TEST_SUCCESS);
-
- for (x= 0; x < KEY_COUNT; x++)
- free(keys[x]);
- free(keys);
-
- return TEST_SUCCESS;
-}
-
-/* Make sure we behave properly if server list has no values */
-static test_return_t user_supplied_bug4(memcached_st *memc)
-{
- memcached_return_t rc;
- const char *keys[]= {"fudge", "son", "food"};
- size_t key_length[]= {5, 3, 4};
- unsigned int x;
- uint32_t flags;
- char return_key[MEMCACHED_MAX_KEY];
- size_t return_key_length;
- char *return_value;
- size_t return_value_length;
-
- /* Here we free everything before running a bunch of mget tests */
- memcached_servers_reset(memc);
-
-
- /* We need to empty the server before continueing test */
- rc= memcached_flush(memc, 0);
- test_compare(rc, MEMCACHED_NO_SERVERS);
-
- rc= memcached_mget(memc, keys, key_length, 3);
- test_true(rc == MEMCACHED_NO_SERVERS);
-
- while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
- &return_value_length, &flags, &rc)) != NULL)
- {
- test_true(return_value);
- }
- test_false(return_value);
- test_true(return_value_length == 0);
- test_true(rc == MEMCACHED_NO_SERVERS);
-
- for (x= 0; x < 3; x++)
- {
- rc= memcached_set(memc, keys[x], key_length[x],
- keys[x], key_length[x],
- (time_t)50, (uint32_t)9);
- test_true(rc == MEMCACHED_NO_SERVERS);
- }
-
- rc= memcached_mget(memc, keys, key_length, 3);
- test_true(rc == MEMCACHED_NO_SERVERS);
-
- x= 0;
- while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
- &return_value_length, &flags, &rc)))
- {
- test_true(return_value);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(return_key_length == return_value_length);
- test_memcmp(return_value, return_key, return_value_length);
- free(return_value);
- x++;
- }
-
- return TEST_SUCCESS;
-}
-
-#define VALUE_SIZE_BUG5 1048064
-static test_return_t user_supplied_bug5(memcached_st *memc)
-{
- memcached_return_t rc;
- const char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
- size_t key_length[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
- char return_key[MEMCACHED_MAX_KEY];
- size_t return_key_length;
- char *value;
- size_t value_length;
- uint32_t flags;
- unsigned int count;
- unsigned int x;
- char insert_data[VALUE_SIZE_BUG5];
-
- for (x= 0; x < VALUE_SIZE_BUG5; x++)
- insert_data[x]= (signed char)rand();
-
- memcached_flush(memc, 0);
- value= memcached_get(memc, keys[0], key_length[0],
- &value_length, &flags, &rc);
- test_true(value == NULL);
- rc= memcached_mget(memc, keys, key_length, 4);
-
- count= 0;
- while ((value= memcached_fetch(memc, return_key, &return_key_length,
- &value_length, &flags, &rc)))
- count++;
- test_true(count == 0);
-
- for (x= 0; x < 4; x++)
- {
- rc= memcached_set(memc, keys[x], key_length[x],
- insert_data, VALUE_SIZE_BUG5,
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS);
- }
-
- for (x= 0; x < 10; x++)
- {
- value= memcached_get(memc, keys[0], key_length[0],
- &value_length, &flags, &rc);
- test_true(value);
- free(value);
-
- rc= memcached_mget(memc, keys, key_length, 4);
- count= 0;
- while ((value= memcached_fetch(memc, return_key, &return_key_length,
- &value_length, &flags, &rc)))
- {
- count++;
- free(value);
- }
- test_true(count == 4);
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t user_supplied_bug6(memcached_st *memc)
-{
- memcached_return_t rc;
- const char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
- size_t key_length[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
- char return_key[MEMCACHED_MAX_KEY];
- size_t return_key_length;
- char *value;
- size_t value_length;
- uint32_t flags;
- unsigned int count;
- unsigned int x;
- char insert_data[VALUE_SIZE_BUG5];
-
- for (x= 0; x < VALUE_SIZE_BUG5; x++)
- insert_data[x]= (signed char)rand();
-
- memcached_flush(memc, 0);
- value= memcached_get(memc, keys[0], key_length[0],
- &value_length, &flags, &rc);
- test_true(value == NULL);
- test_true(rc == MEMCACHED_NOTFOUND);
- rc= memcached_mget(memc, keys, key_length, 4);
- test_true(rc == MEMCACHED_SUCCESS);
-
- count= 0;
- while ((value= memcached_fetch(memc, return_key, &return_key_length,
- &value_length, &flags, &rc)))
- count++;
- test_true(count == 0);
- test_true(rc == MEMCACHED_END);
-
- for (x= 0; x < 4; x++)
- {
- rc= memcached_set(memc, keys[x], key_length[x],
- insert_data, VALUE_SIZE_BUG5,
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS);
- }
-
- for (x= 0; x < 2; x++)
- {
- value= memcached_get(memc, keys[0], key_length[0],
- &value_length, &flags, &rc);
- test_true(value);
- free(value);
-
- rc= memcached_mget(memc, keys, key_length, 4);
- test_true(rc == MEMCACHED_SUCCESS);
- count= 3;
- /* We test for purge of partial complete fetches */
- for (count= 3; count; count--)
- {
- value= memcached_fetch(memc, return_key, &return_key_length,
- &value_length, &flags, &rc);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(!(memcmp(value, insert_data, value_length)));
- test_true(value_length);
- free(value);
- }
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t user_supplied_bug8(memcached_st *memc)
-{
- memcached_return_t rc;
- memcached_st *mine;
- memcached_st *memc_clone;
-
- memcached_server_st *servers;
- const char *server_list= "memcache1.memcache.bk.sapo.pt:11211, memcache1.memcache.bk.sapo.pt:11212, memcache1.memcache.bk.sapo.pt:11213, memcache1.memcache.bk.sapo.pt:11214, memcache2.memcache.bk.sapo.pt:11211, memcache2.memcache.bk.sapo.pt:11212, memcache2.memcache.bk.sapo.pt:11213, memcache2.memcache.bk.sapo.pt:11214";
-
- (void)memc;
- servers= memcached_servers_parse(server_list);
- test_true(servers);
-
- mine= memcached_create(NULL);
- rc= memcached_server_push(mine, servers);
- test_true(rc == MEMCACHED_SUCCESS);
- memcached_server_list_free(servers);
-
- test_true(mine);
- memc_clone= memcached_clone(NULL, mine);
-
- memcached_quit(mine);
- memcached_quit(memc_clone);
-
-
- memcached_free(mine);
- memcached_free(memc_clone);
-
- return TEST_SUCCESS;
-}
-
-/* Test flag store/retrieve */
-static test_return_t user_supplied_bug7(memcached_st *memc)
-{
- memcached_return_t rc;
- const char *keys= "036790384900";
- size_t key_length= strlen(keys);
- char return_key[MEMCACHED_MAX_KEY];
- size_t return_key_length;
- char *value;
- size_t value_length;
- uint32_t flags;
- unsigned int x;
- char insert_data[VALUE_SIZE_BUG5];
-
- for (x= 0; x < VALUE_SIZE_BUG5; x++)
- insert_data[x]= (signed char)rand();
-
- memcached_flush(memc, 0);
-
- flags= 245;
- rc= memcached_set(memc, keys, key_length,
- insert_data, VALUE_SIZE_BUG5,
- (time_t)0, flags);
- test_true(rc == MEMCACHED_SUCCESS);
-
- flags= 0;
- value= memcached_get(memc, keys, key_length,
- &value_length, &flags, &rc);
- test_true(flags == 245);
- test_true(value);
- free(value);
-
- rc= memcached_mget(memc, &keys, &key_length, 1);
-
- flags= 0;
- value= memcached_fetch(memc, return_key, &return_key_length,
- &value_length, &flags, &rc);
- test_true(flags == 245);
- test_true(value);
- free(value);
-
-
- return TEST_SUCCESS;
-}
-
-static test_return_t user_supplied_bug9(memcached_st *memc)
-{
- memcached_return_t rc;
- const char *keys[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
- size_t key_length[3];
- unsigned int x;
- uint32_t flags;
- unsigned count= 0;
-
- char return_key[MEMCACHED_MAX_KEY];
- size_t return_key_length;
- char *return_value;
- size_t return_value_length;
-
-
- key_length[0]= strlen("UDATA:edevil@sapo.pt");
- key_length[1]= strlen("fudge&*@#");
- key_length[2]= strlen("for^#@&$not");
-
-
- for (x= 0; x < 3; x++)
- {
- rc= memcached_set(memc, keys[x], key_length[x],
- keys[x], key_length[x],
- (time_t)50, (uint32_t)9);
- test_true(rc == MEMCACHED_SUCCESS);
- }
-
- rc= memcached_mget(memc, keys, key_length, 3);
- test_true(rc == MEMCACHED_SUCCESS);
-
- /* We need to empty the server before continueing test */
- while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
- &return_value_length, &flags, &rc)) != NULL)
- {
- test_true(return_value);
- free(return_value);
- count++;
- }
- test_true(count == 3);
-
- return TEST_SUCCESS;
-}
-
-/* We are testing with aggressive timeout to get failures */
-static test_return_t user_supplied_bug10(memcached_st *memc)
-{
- const char *key= "foo";
- char *value;
- size_t value_length= 512;
- unsigned int x;
- size_t key_len= 3;
- memcached_return_t rc;
- unsigned int set= 1;
- memcached_st *mclone= memcached_clone(NULL, memc);
- int32_t timeout;
-
- memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
- memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
- timeout= 2;
- memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT,
- (uint64_t)timeout);
-
- value = (char*)malloc(value_length * sizeof(char));
-
- for (x= 0; x < value_length; x++)
- value[x]= (char) (x % 127);
-
- for (x= 1; x <= 100000; ++x)
- {
- rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
-
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_WRITE_FAILURE ||
- rc == MEMCACHED_BUFFERED || rc == MEMCACHED_TIMEOUT);
-
- if (rc == MEMCACHED_WRITE_FAILURE || rc == MEMCACHED_TIMEOUT)
- x--;
- }
-
- free(value);
- memcached_free(mclone);
-
- return TEST_SUCCESS;
-}
-
-/*
- We are looking failures in the async protocol
-*/
-static test_return_t user_supplied_bug11(memcached_st *memc)
-{
- const char *key= "foo";
- char *value;
- size_t value_length= 512;
- unsigned int x;
- size_t key_len= 3;
- memcached_return_t rc;
- unsigned int set= 1;
- int32_t timeout;
- memcached_st *mclone= memcached_clone(NULL, memc);
-
- memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
- memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
- timeout= -1;
- memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT,
- (size_t)timeout);
-
- timeout= (int32_t)memcached_behavior_get(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
-
- test_true(timeout == -1);
-
- value = (char*)malloc(value_length * sizeof(char));
-
- for (x= 0; x < value_length; x++)
- value[x]= (char) (x % 127);
-
- for (x= 1; x <= 100000; ++x)
- {
- rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
- }
-
- free(value);
- memcached_free(mclone);
-
- return TEST_SUCCESS;
-}
-
-/*
- Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
-*/
-static test_return_t user_supplied_bug12(memcached_st *memc)
-{
- memcached_return_t rc;
- uint32_t flags;
- size_t value_length;
- char *value;
- uint64_t number_value;
-
- value= memcached_get(memc, "autoincrement", strlen("autoincrement"),
- &value_length, &flags, &rc);
- test_true(value == NULL);
- test_true(rc == MEMCACHED_NOTFOUND);
-
- rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"),
- 1, &number_value);
-
- test_true(value == NULL);
- /* The binary protocol will set the key if it doesn't exist */
- if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1)
- {
- test_true(rc == MEMCACHED_SUCCESS);
- }
- else
- {
- test_true(rc == MEMCACHED_NOTFOUND);
- }
-
- rc= memcached_set(memc, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
-
- value= memcached_get(memc, "autoincrement", strlen("autoincrement"),
- &value_length, &flags, &rc);
- test_true(value);
- test_true(rc == MEMCACHED_SUCCESS);
- free(value);
-
- rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"),
- 1, &number_value);
- test_true(number_value == 2);
- test_true(rc == MEMCACHED_SUCCESS);
-
- return TEST_SUCCESS;
-}
-
-/*
- Bug found where command total one more than MEMCACHED_MAX_BUFFER
- set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
- */
-static test_return_t user_supplied_bug13(memcached_st *memc)
-{
- char key[] = "key34567890";
- char *overflow;
- memcached_return_t rc;
- size_t overflowSize;
-
- char commandFirst[]= "set key34567890 0 0 ";
- char commandLast[] = " \r\n"; /* first line of command sent to server */
- size_t commandLength;
- size_t testSize;
-
- commandLength = strlen(commandFirst) + strlen(commandLast) + 4; /* 4 is number of characters in size, probably 8196 */
-
- overflowSize = MEMCACHED_MAX_BUFFER - commandLength;
-
- for (testSize= overflowSize - 1; testSize < overflowSize + 1; testSize++)
- {
- overflow= malloc(testSize);
- test_true(overflow != NULL);
-
- memset(overflow, 'x', testSize);
- rc= memcached_set(memc, key, strlen(key),
- overflow, testSize, 0, 0);
- test_true(rc == MEMCACHED_SUCCESS);
- free(overflow);
- }
-
- return TEST_SUCCESS;
-}
-
-
-/*
- Test values of many different sizes
- Bug found where command total one more than MEMCACHED_MAX_BUFFER
- set key34567890 0 0 8169 \r\n
- is sent followed by buffer of size 8169, followed by 8169
- */
-static test_return_t user_supplied_bug14(memcached_st *memc)
-{
- size_t setter= 1;
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
- memcached_return_t rc;
- const char *key= "foo";
- char *value;
- size_t value_length= 18000;
- char *string;
- size_t string_length;
- uint32_t flags;
- unsigned int x;
- size_t current_length;
-
- value = (char*)malloc(value_length);
- test_true(value);
-
- for (x= 0; x < value_length; x++)
- value[x] = (char) (x % 127);
-
- for (current_length= 0; current_length < value_length; current_length++)
- {
- rc= memcached_set(memc, key, strlen(key),
- value, current_length,
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
-
- string= memcached_get(memc, key, strlen(key),
- &string_length, &flags, &rc);
-
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(string_length == current_length);
- test_true(!memcmp(string, value, string_length));
-
- free(string);
- }
-
- free(value);
-
- return TEST_SUCCESS;
-}
-
-/*
- Look for zero length value problems
- */
-static test_return_t user_supplied_bug15(memcached_st *memc)
-{
- uint32_t x;
- memcached_return_t rc;
- const char *key= "mykey";
- char *value;
- size_t length;
- uint32_t flags;
-
- for (x= 0; x < 2; x++)
- {
- rc= memcached_set(memc, key, strlen(key),
- NULL, 0,
- (time_t)0, (uint32_t)0);
-
- test_true(rc == MEMCACHED_SUCCESS);
-
- value= memcached_get(memc, key, strlen(key),
- &length, &flags, &rc);
-
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(value == NULL);
- test_true(length == 0);
- test_true(flags == 0);
-
- value= memcached_get(memc, key, strlen(key),
- &length, &flags, &rc);
-
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(value == NULL);
- test_true(length == 0);
- test_true(flags == 0);
- }
-
- return TEST_SUCCESS;
-}
-
-/* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
-static test_return_t user_supplied_bug16(memcached_st *memc)
-{
- memcached_return_t rc;
- const char *key= "mykey";
- char *value;
- size_t length;
- uint32_t flags;
-
- rc= memcached_set(memc, key, strlen(key),
- NULL, 0,
- (time_t)0, UINT32_MAX);
-
- test_true(rc == MEMCACHED_SUCCESS);
-
- value= memcached_get(memc, key, strlen(key),
- &length, &flags, &rc);
-
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(value == NULL);
- test_true(length == 0);
- test_true(flags == UINT32_MAX);
-
- return TEST_SUCCESS;
-}
-
-#if !defined(__sun) && !defined(__OpenBSD__)
-/* Check the validity of chinese key*/
-static test_return_t user_supplied_bug17(memcached_st *memc)
-{
- memcached_return_t rc;
- const char *key= "豆瓣";
- const char *value="我们在炎热抑郁的夏天无法停止豆瓣";
- char *value2;
- size_t length;
- uint32_t flags;
-
- rc= memcached_set(memc, key, strlen(key),
- value, strlen(value),
- (time_t)0, 0);
-
- test_true(rc == MEMCACHED_SUCCESS);
-
- value2= memcached_get(memc, key, strlen(key),
- &length, &flags, &rc);
-
- test_true(length==strlen(value));
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(memcmp(value, value2, length)==0);
- free(value2);
-
- return TEST_SUCCESS;
-}
-#endif
-
-/*
- From Andrei on IRC
-*/
-
-static test_return_t user_supplied_bug19(memcached_st *not_used)
-{
- memcached_st *memc;
- const memcached_server_st *server;
- memcached_return_t res;
-
- (void)not_used;
-
- memc= memcached_create(NULL);
- memcached_server_add_with_weight(memc, "localhost", 11311, 100);
- memcached_server_add_with_weight(memc, "localhost", 11312, 100);
-
- server= memcached_server_by_key(memc, "a", 1, &res);
-
- memcached_free(memc);
-
- return TEST_SUCCESS;
-}
-
-/* CAS test from Andei */
-static test_return_t user_supplied_bug20(memcached_st *memc)
-{
- memcached_return_t status;
- memcached_result_st *result, result_obj;
- const char *key = "abc";
- size_t key_len = strlen("abc");
- const char *value = "foobar";
- size_t value_len = strlen(value);
-
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1);
-
- status = memcached_set(memc, key, key_len, value, value_len, (time_t)0, (uint32_t)0);
- test_true(status == MEMCACHED_SUCCESS);
-
- status = memcached_mget(memc, &key, &key_len, 1);
- test_true(status == MEMCACHED_SUCCESS);
-
- result= memcached_result_create(memc, &result_obj);
- test_true(result);
-
- memcached_result_create(memc, &result_obj);
- result= memcached_fetch_result(memc, &result_obj, &status);
-
- test_true(result);
- test_true(status == MEMCACHED_SUCCESS);
-
- memcached_result_free(result);
-
- return TEST_SUCCESS;
-}
-
-#include "ketama_test_cases.h"
-static test_return_t user_supplied_bug18(memcached_st *trash)
-{
- memcached_return_t rc;
- uint64_t value;
- int x;
- memcached_server_st *server_pool;
- memcached_st *memc;
-
- (void)trash;
-
- memc= memcached_create(NULL);
- test_true(memc);
-
- rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
- test_true(rc == MEMCACHED_SUCCESS);
-
- value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
- test_true(value == 1);
-
- rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
- test_true(rc == MEMCACHED_SUCCESS);
-
- value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
- test_true(value == MEMCACHED_HASH_MD5);
-
- server_pool = memcached_servers_parse("10.0.1.1:11211 600,10.0.1.2:11211 300,10.0.1.3:11211 200,10.0.1.4:11211 350,10.0.1.5:11211 1000,10.0.1.6:11211 800,10.0.1.7:11211 950,10.0.1.8:11211 100");
- memcached_server_push(memc, server_pool);
-
- /* verify that the server list was parsed okay. */
- test_true(memcached_server_count(memc) == 8);
- test_true(strcmp(server_pool[0].hostname, "10.0.1.1") == 0);
- test_true(server_pool[0].port == 11211);
- test_true(server_pool[0].weight == 600);
- test_true(strcmp(server_pool[2].hostname, "10.0.1.3") == 0);
- test_true(server_pool[2].port == 11211);
- test_true(server_pool[2].weight == 200);
- test_true(strcmp(server_pool[7].hostname, "10.0.1.8") == 0);
- test_true(server_pool[7].port == 11211);
- test_true(server_pool[7].weight == 100);
-
- /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
- * us test the boundary wraparound.
- */
- test_true(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->ketama.continuum[0].index);
-
- /* verify the standard ketama set. */
- for (x= 0; x < 99; x++)
- {
- uint32_t server_idx = memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key));
-
- memcached_server_instance_st instance=
- memcached_server_instance_by_position(memc, server_idx);
-
- const char *hostname = memcached_server_name(instance);
- test_strcmp(hostname, ketama_test_cases[x].server);
- }
-
- memcached_server_list_free(server_pool);
- memcached_free(memc);
-
- return TEST_SUCCESS;
-}
-
-/* Large mget() of missing keys with binary proto
- *
- * If many binary quiet commands (such as getq's in an mget) fill the output
- * buffer and the server chooses not to respond, memcached_flush hangs. See
- * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
- */
-
-/* sighandler_t function that always asserts false */
-static void fail(int unused)
-{
- (void)unused;
- assert(0);
-}
-
-
-static test_return_t _user_supplied_bug21(memcached_st* memc, size_t key_count)
-{
-#ifdef WIN32
- (void)memc;
- (void)key_count;
- return TEST_SKIPPED;
-#else
- memcached_return_t rc;
- unsigned int x;
- char **keys;
- size_t* key_lengths;
- void (*oldalarm)(int);
- memcached_st *memc_clone;
-
- memc_clone= memcached_clone(NULL, memc);
- test_true(memc_clone);
-
- /* only binproto uses getq for mget */
- memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
-
- /* empty the cache to ensure misses (hence non-responses) */
- rc= memcached_flush(memc_clone, 0);
- test_true(rc == MEMCACHED_SUCCESS);
-
- key_lengths= calloc(key_count, sizeof(size_t));
- keys= calloc(key_count, sizeof(char *));
- test_true(keys);
- for (x= 0; x < key_count; x++)
- {
- char buffer[30];
-
- snprintf(buffer, 30, "%u", x);
- keys[x]= strdup(buffer);
- key_lengths[x]= strlen(keys[x]);
- }
-
- oldalarm= signal(SIGALRM, fail);
- alarm(5);
-
- rc= memcached_mget(memc_clone, (const char **)keys, key_lengths, key_count);
- test_true(rc == MEMCACHED_SUCCESS);
-
- alarm(0);
- signal(SIGALRM, oldalarm);
-
- size_t keys_returned;
- test_true(fetch_all_results(memc, &keys_returned) == TEST_SUCCESS);
-
- for (x= 0; x < key_count; x++)
- free(keys[x]);
- free(keys);
- free(key_lengths);
-
- memcached_free(memc_clone);
-
- return TEST_SUCCESS;
-#endif
-}
-
-static test_return_t user_supplied_bug21(memcached_st *memc)
-{
- test_return_t test_rc;
- test_rc= pre_binary(memc);
-
- if (test_rc != TEST_SUCCESS)
- return test_rc;
-
- test_return_t rc;
-
- /* should work as of r580 */
- rc= _user_supplied_bug21(memc, 10);
- test_true(rc == TEST_SUCCESS);
-
- /* should fail as of r580 */
- rc= _user_supplied_bug21(memc, 1000);
- test_true(rc == TEST_SUCCESS);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t auto_eject_hosts(memcached_st *trash)
-{
- (void) trash;
- memcached_server_instance_st instance;
-
- memcached_return_t rc;
- memcached_st *memc= memcached_create(NULL);
- test_true(memc);
-
- rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
- test_true(rc == MEMCACHED_SUCCESS);
-
- uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
- test_true(value == 1);
-
- rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
- test_true(rc == MEMCACHED_SUCCESS);
-
- value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
- test_true(value == MEMCACHED_HASH_MD5);
-
- /* server should be removed when in delay */
- rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS, 1);
- test_true(rc == MEMCACHED_SUCCESS);
-
- value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS);
- test_true(value == 1);
-
- memcached_server_st *server_pool;
- server_pool = memcached_servers_parse("10.0.1.1:11211 600,10.0.1.2:11211 300,10.0.1.3:11211 200,10.0.1.4:11211 350,10.0.1.5:11211 1000,10.0.1.6:11211 800,10.0.1.7:11211 950,10.0.1.8:11211 100");
- memcached_server_push(memc, server_pool);
-
- /* verify that the server list was parsed okay. */
- test_true(memcached_server_count(memc) == 8);
- test_true(strcmp(server_pool[0].hostname, "10.0.1.1") == 0);
- test_true(server_pool[0].port == 11211);
- test_true(server_pool[0].weight == 600);
- test_true(strcmp(server_pool[2].hostname, "10.0.1.3") == 0);
- test_true(server_pool[2].port == 11211);
- test_true(server_pool[2].weight == 200);
- test_true(strcmp(server_pool[7].hostname, "10.0.1.8") == 0);
- test_true(server_pool[7].port == 11211);
- test_true(server_pool[7].weight == 100);
-
- instance= memcached_server_instance_by_position(memc, 2);
- ((memcached_server_write_instance_st)instance)->next_retry = time(NULL) + 15;
- memc->ketama.next_distribution_rebuild= time(NULL) - 1;
-
- /*
- This would not work if there were only two hosts.
- */
- for (size_t x= 0; x < 99; x++)
- {
- memcached_autoeject(memc);
- uint32_t server_idx= memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key));
- test_true(server_idx != 2);
- }
-
- /* and re-added when it's back. */
- ((memcached_server_write_instance_st)instance)->next_retry = time(NULL) - 1;
- memc->ketama.next_distribution_rebuild= time(NULL) - 1;
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION,
- memc->distribution);
- for (size_t x= 0; x < 99; x++)
- {
- uint32_t server_idx = memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key));
- // We re-use instance from above.
- instance=
- memcached_server_instance_by_position(memc, server_idx);
- const char *hostname = memcached_server_name(instance);
- test_true(strcmp(hostname, ketama_test_cases[x].server) == 0);
- }
-
- memcached_server_list_free(server_pool);
- memcached_free(memc);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t output_ketama_weighted_keys(memcached_st *trash)
-{
- (void) trash;
-
- memcached_return_t rc;
- memcached_st *memc= memcached_create(NULL);
- test_true(memc);
-
-
- rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
- test_true(rc == MEMCACHED_SUCCESS);
-
- uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
- test_true(value == 1);
-
- rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
- test_true(rc == MEMCACHED_SUCCESS);
-
- value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
- test_true(value == MEMCACHED_HASH_MD5);
-
-
- test_true(memcached_behavior_set_distribution(memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY) == MEMCACHED_SUCCESS);
-
- memcached_server_st *server_pool;
- server_pool = memcached_servers_parse("10.0.1.1:11211,10.0.1.2:11211,10.0.1.3:11211,10.0.1.4:11211,10.0.1.5:11211,10.0.1.6:11211,10.0.1.7:11211,10.0.1.8:11211,192.168.1.1:11211,192.168.100.1:11211");
- memcached_server_push(memc, server_pool);
-
- // @todo this needs to be refactored to actually test something.
-#if 0
- FILE *fp;
- if ((fp = fopen("ketama_keys.txt", "w")))
- {
- // noop
- } else {
- printf("cannot write to file ketama_keys.txt");
- return TEST_FAILURE;
- }
-
- for (int x= 0; x < 10000; x++)
- {
- char key[10];
- snprintf(key, sizeof(key), "%d", x);
-
- uint32_t server_idx = memcached_generate_hash(memc, key, strlen(key));
- char *hostname = memc->hosts[server_idx].hostname;
- in_port_t port = memc->hosts[server_idx].port;
- fprintf(fp, "key %s is on host /%s:%u\n", key, hostname, port);
- memcached_server_instance_st instance=
- memcached_server_instance_by_position(memc, host_index);
- }
- fclose(fp);
-#endif
- memcached_server_list_free(server_pool);
- memcached_free(memc);
-
- return TEST_SUCCESS;
-}
-
-
-static test_return_t result_static(memcached_st *memc)
-{
- memcached_result_st result;
- memcached_result_st *result_ptr;
-
- result_ptr= memcached_result_create(memc, &result);
- test_true(result.options.is_allocated == false);
- test_true(memcached_is_initialized(&result) == true);
- test_true(result_ptr);
- test_true(result_ptr == &result);
-
- memcached_result_free(&result);
-
- test_true(result.options.is_allocated == false);
- test_true(memcached_is_initialized(&result) == false);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t result_alloc(memcached_st *memc)
-{
- memcached_result_st *result_ptr;
-
- result_ptr= memcached_result_create(memc, NULL);
- test_true(result_ptr);
- test_true(result_ptr->options.is_allocated == true);
- test_true(memcached_is_initialized(result_ptr) == true);
- memcached_result_free(result_ptr);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t cleanup_pairs(memcached_st *memc)
-{
- (void)memc;
- pairs_free(global_pairs);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t generate_pairs(memcached_st *memc)
-{
- (void)memc;
- global_pairs= pairs_generate(GLOBAL_COUNT, 400);
- global_count= GLOBAL_COUNT;
-
- for (size_t x= 0; x < global_count; x++)
- {
- global_keys[x]= global_pairs[x].key;
- global_keys_length[x]= global_pairs[x].key_length;
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t generate_large_pairs(memcached_st *memc)
-{
- (void)memc;
- global_pairs= pairs_generate(GLOBAL2_COUNT, MEMCACHED_MAX_BUFFER+10);
- global_count= GLOBAL2_COUNT;
-
- for (size_t x= 0; x < global_count; x++)
- {
- global_keys[x]= global_pairs[x].key;
- global_keys_length[x]= global_pairs[x].key_length;
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t generate_data(memcached_st *memc)
-{
- unsigned int check_execute= execute_set(memc, global_pairs, global_count);
-
- test_true(check_execute == global_count);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t generate_data_with_stats(memcached_st *memc)
-{
- memcached_stat_st *stat_p;
- memcached_return_t rc;
- uint32_t host_index= 0;
- unsigned int check_execute= execute_set(memc, global_pairs, global_count);
-
- test_true(check_execute == global_count);
-
- //TODO: hosts used size stats
- stat_p= memcached_stat(memc, NULL, &rc);
- test_true(stat_p);
-
- for (host_index= 0; host_index < SERVERS_TO_CREATE; host_index++)
- {
- /* This test was changes so that "make test" would work properlly */
-#ifdef DEBUG
- memcached_server_instance_st instance=
- memcached_server_instance_by_position(memc, host_index);
-
- printf("\nserver %u|%s|%u bytes: %llu\n", host_index, instance->hostname, instance->port, (unsigned long long)(stat_p + host_index)->bytes);
-#endif
- test_true((unsigned long long)(stat_p + host_index)->bytes);
- }
-
- memcached_stat_free(NULL, stat_p);
-
- return TEST_SUCCESS;
-}
-static test_return_t generate_buffer_data(memcached_st *memc)
-{
- size_t latch= 0;
-
- latch= 1;
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch);
- generate_data(memc);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t get_read_count(memcached_st *memc)
-{
- memcached_return_t rc;
- memcached_st *memc_clone;
-
- memc_clone= memcached_clone(NULL, memc);
- test_true(memc_clone);
-
- memcached_server_add_with_weight(memc_clone, "localhost", 6666, 0);
-
- {
- char *return_value;
- size_t return_value_length;
- uint32_t flags;
- uint32_t count;
-
- for (size_t x= count= 0; x < global_count; x++)
- {
- return_value= memcached_get(memc_clone, global_keys[x], global_keys_length[x],
- &return_value_length, &flags, &rc);
- if (rc == MEMCACHED_SUCCESS)
- {
- count++;
- if (return_value)
- free(return_value);
- }
- }
- }
-
- memcached_free(memc_clone);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t get_read(memcached_st *memc)
-{
- memcached_return_t rc;
-
- {
- char *return_value;
- size_t return_value_length;
- uint32_t flags;
-
- for (size_t x= 0; x < global_count; x++)
- {
- return_value= memcached_get(memc, global_keys[x], global_keys_length[x],
- &return_value_length, &flags, &rc);
- /*
- test_true(return_value);
- test_true(rc == MEMCACHED_SUCCESS);
- */
- if (rc == MEMCACHED_SUCCESS && return_value)
- free(return_value);
- }
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t mget_read(memcached_st *memc)
-{
- memcached_return_t rc;
-
- if (! libmemcached_util_version_check(memc, 1, 4, 4))
- return TEST_SKIPPED;
-
- rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
-
- test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
-
- // Go fetch the keys and test to see if all of them were returned
- {
- size_t keys_returned;
- test_true(fetch_all_results(memc, &keys_returned) == TEST_SUCCESS);
- char buffer[30];
- snprintf(buffer, sizeof(buffer), "%lu", (unsigned long)keys_returned);
- test_true_got(global_count == keys_returned, buffer);
- }
-
-
- return TEST_SUCCESS;
-}
-
-static test_return_t mget_read_result(memcached_st *memc)
-{
- memcached_return_t rc;
-
- if (! libmemcached_util_version_check(memc, 1, 4, 4))
- return TEST_SKIPPED;
-
- rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
-
- test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
-
- /* Turn this into a help function */
- {
- memcached_result_st results_obj;
- memcached_result_st *results;
-
- results= memcached_result_create(memc, &results_obj);
-
- while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
- {
- test_true(results);
- test_true(rc == MEMCACHED_SUCCESS);
- }
-
- memcached_result_free(&results_obj);
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t mget_read_function(memcached_st *memc)
-{
- memcached_return_t rc;
- size_t counter;
- memcached_execute_fn callbacks[1];
-
- if (! libmemcached_util_version_check(memc, 1, 4, 4))
- return TEST_SKIPPED;
-
- rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
-
- test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
-
- callbacks[0]= &callback_counter;
- counter= 0;
- rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t delete_generate(memcached_st *memc)
-{
- for (size_t x= 0; x < global_count; x++)
- {
- (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t delete_buffer_generate(memcached_st *memc)
-{
- uint64_t latch= 0;
-
- latch= 1;
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch);
-
- for (size_t x= 0; x < global_count; x++)
- {
- (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t add_host_test1(memcached_st *memc)
-{
- memcached_return_t rc;
- char servername[]= "0.example.com";
- memcached_server_st *servers;
-
- servers= memcached_server_list_append_with_weight(NULL, servername, 400, 0, &rc);
- test_true(servers);
- test_true(1 == memcached_server_list_count(servers));
-
- for (size_t x= 2; x < 20; x++)
- {
- char buffer[SMALL_STRING_LEN];
-
- snprintf(buffer, SMALL_STRING_LEN, "%lu.example.com", (unsigned long)(400 +x));
- servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0,
- &rc);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(x == memcached_server_list_count(servers));
- }
-
- rc= memcached_server_push(memc, servers);
- test_true(rc == MEMCACHED_SUCCESS);
- rc= memcached_server_push(memc, servers);
- test_true(rc == MEMCACHED_SUCCESS);
-
- memcached_server_list_free(servers);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t pre_nonblock(memcached_st *memc)
-{
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t pre_cork(memcached_st *memc)
-{
- memcached_return_t rc;
- bool set= true;
-
- rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CORK, set);
-
-#ifdef __APPLE__
- return TEST_SKIPPED;
-#endif
-
- if (rc == MEMCACHED_SUCCESS)
- return TEST_SUCCESS;
-
- return TEST_SKIPPED;
-}
-
-static test_return_t pre_cork_and_nonblock(memcached_st *memc)
-{
- test_return_t rc;
-
- rc= pre_cork(memc);
-
-#ifdef __APPLE__
- return TEST_SKIPPED;
-#endif
-
- if (rc != TEST_SUCCESS)
- return rc;
-
- return pre_nonblock(memc);
-}
-
-static test_return_t pre_nonblock_binary(memcached_st *memc)
-{
- memcached_return_t rc= MEMCACHED_FAILURE;
- memcached_st *memc_clone;
-
- memc_clone= memcached_clone(NULL, memc);
- test_true(memc_clone);
- // The memcached_version needs to be done on a clone, because the server
- // will not toggle protocol on an connection.
- memcached_version(memc_clone);
-
- if (libmemcached_util_version_check(memc_clone, 1, 4, 4))
- {
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
- rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1);
- }
- else
- {
- return TEST_SKIPPED;
- }
-
- memcached_free(memc_clone);
-
- return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
-}
-
-static test_return_t pre_murmur(memcached_st *memc)
-{
-#ifdef HAVE_MURMUR_HASH
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR);
- return TEST_SUCCESS;
-#else
- (void) memc;
- return TEST_SKIPPED;
-#endif
-}
-
-static test_return_t pre_jenkins(memcached_st *memc)
-{
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_JENKINS);
-
- return TEST_SUCCESS;
-}
-
-
-static test_return_t pre_md5(memcached_st *memc)
-{
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MD5);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t pre_crc(memcached_st *memc)
-{
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_CRC);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t pre_hsieh(memcached_st *memc)
-{
-#ifdef HAVE_HSIEH_HASH
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_HSIEH);
- return TEST_SUCCESS;
-#else
- (void) memc;
- return TEST_SKIPPED;
-#endif
-}
-
-static test_return_t pre_hash_fnv1_64(memcached_st *memc)
-{
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t pre_hash_fnv1a_64(memcached_st *memc)
-{
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1A_64);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t pre_hash_fnv1_32(memcached_st *memc)
-{
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1_32);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t pre_hash_fnv1a_32(memcached_st *memc)
-{
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1A_32);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t pre_behavior_ketama(memcached_st *memc)
-{
- memcached_return_t rc;
- uint64_t value;
-
- rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA, 1);
- test_true(rc == MEMCACHED_SUCCESS);
-
- value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA);
- test_true(value == 1);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t pre_behavior_ketama_weighted(memcached_st *memc)
-{
- memcached_return_t rc;
- uint64_t value;
-
- rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
- test_true(rc == MEMCACHED_SUCCESS);
-
- value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
- test_true(value == 1);
-
- rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
- test_true(rc == MEMCACHED_SUCCESS);
-
- value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
- test_true(value == MEMCACHED_HASH_MD5);
-
- return TEST_SUCCESS;
-}
-
-/**
- @note This should be testing to see if the server really supports the binary protocol.
-*/
-static test_return_t pre_binary(memcached_st *memc)
-{
- memcached_return_t rc= MEMCACHED_FAILURE;
-
- if (libmemcached_util_version_check(memc, 1, 4, 4))
- {
- rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1);
- }
-
- return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
-}
-
-static test_return_t pre_sasl(memcached_st *memc)
-{
- memcached_return_t rc= MEMCACHED_FAILURE;
-
-#ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
- const char *server= getenv("LIBMEMCACHED_TEST_SASL_SERVER");
- const char *user= getenv("LIBMEMCACHED_TEST_SASL_USERNAME");
- const char *pass= getenv("LIBMEMCACHED_TEST_SASL_PASSWORD");
-
- if (server != NULL && user != NULL && pass != NULL)
- {
- memcached_server_st *servers= memcached_servers_parse(server);
- test_true(servers != NULL);
- memcached_servers_reset(memc);
- test_true(memcached_server_push(memc, servers) == MEMCACHED_SUCCESS);
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
- rc= memcached_set_sasl_auth_data(memc, user, pass);
- test_true(rc == MEMCACHED_SUCCESS);
- }
-#else
- (void)memc;
-#endif
-
- return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
-}
-
-static test_return_t pre_replication(memcached_st *memc)
-{
- test_return_t test_rc;
- test_rc= pre_binary(memc);
-
- if (test_rc != TEST_SUCCESS)
- return test_rc;
-
- /*
- * Make sure that we store the item on all servers
- * (master + replicas == number of servers)
- */
- memcached_return_t rc;
- rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS,
- memcached_server_count(memc) - 1);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS) == memcached_server_count(memc) - 1);
-
- return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
-}
-
-
-static test_return_t pre_replication_noblock(memcached_st *memc)
-{
- test_return_t rc;
-
- rc= pre_replication(memc);
- if (rc != TEST_SUCCESS)
- return rc;
-
- rc= pre_nonblock(memc);
-
- return rc;
-}
-
-
-static void my_free(const memcached_st *ptr, void *mem, void *context)
-{
- (void)context;
- (void)ptr;
-#ifdef HARD_MALLOC_TESTS
- void *real_ptr= (mem == NULL) ? mem : (void*)((caddr_t)mem - 8);
- free(real_ptr);
-#else
- free(mem);
-#endif
-}
-
-
-static void *my_malloc(const memcached_st *ptr, const size_t size, void *context)
-{
- (void)context;
- (void)ptr;
-#ifdef HARD_MALLOC_TESTS
- void *ret= malloc(size + 8);
- if (ret != NULL)
- {
- ret= (void*)((caddr_t)ret + 8);
- }
-#else
- void *ret= malloc(size);
-#endif
-
- if (ret != NULL)
- {
- memset(ret, 0xff, size);
- }
-
- return ret;
-}
-
-
-static void *my_realloc(const memcached_st *ptr, void *mem, const size_t size, void *context)
-{
- (void)context;
-#ifdef HARD_MALLOC_TESTS
- void *real_ptr= (mem == NULL) ? NULL : (void*)((caddr_t)mem - 8);
- void *nmem= realloc(real_ptr, size + 8);
-
- void *ret= NULL;
- if (nmem != NULL)
- {
- ret= (void*)((caddr_t)nmem + 8);
- }
-
- return ret;
-#else
- (void)ptr;
- return realloc(mem, size);
-#endif
-}
-
-
-static void *my_calloc(const memcached_st *ptr, size_t nelem, const size_t size, void *context)
-{
- (void)context;
-#ifdef HARD_MALLOC_TESTS
- void *mem= my_malloc(ptr, nelem * size);
- if (mem)
- {
- memset(mem, 0, nelem * size);
- }
-
- return mem;
-#else
- (void)ptr;
- return calloc(nelem, size);
-#endif
-}
-
-
-static test_return_t set_prefix(memcached_st *memc)
-{
- memcached_return_t rc;
- const char *key= "mine";
- char *value;
-
- /* Make sure be default none exists */
- value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
- test_true(rc == MEMCACHED_FAILURE);
-
- /* Test a clean set */
- rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, (void *)key);
- test_true_got(rc == MEMCACHED_SUCCESS, memcached_last_error_message(memc));
-
- value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
- test_true(value);
- test_true(memcmp(value, key, 4) == 0);
- test_true(rc == MEMCACHED_SUCCESS);
-
- /* Test that we can turn it off */
- rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
- test_true(rc == MEMCACHED_SUCCESS);
-
- value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
- test_false(value);
- test_true(rc == MEMCACHED_FAILURE);
-
- /* Now setup for main test */
- rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, (void *)key);
- test_true(rc == MEMCACHED_SUCCESS);
-
- value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
- test_true(value);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(memcmp(value, key, 4) == 0);
-
- /* Set to Zero, and then Set to something too large */
- {
- char long_key[255];
- memset(long_key, 0, 255);
-
- rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
- test_true(rc == MEMCACHED_SUCCESS);
-
- value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
- test_false(value);
- test_true(rc == MEMCACHED_FAILURE);
- test_true(value == NULL);
-
- /* Test a long key for failure */
- /* TODO, extend test to determine based on setting, what result should be */
- strncpy(long_key, "Thisismorethentheallottednumberofcharacters", sizeof(long_key));
- rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
- //test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
- test_true(rc == MEMCACHED_SUCCESS);
-
- /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
- strncpy(long_key, "This is more then the allotted number of characters", sizeof(long_key));
- rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
- test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
-
- /* Test for a bad prefix, but with a short key */
- rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_VERIFY_KEY, 1);
- test_true(rc == MEMCACHED_SUCCESS);
-
- strncpy(long_key, "dog cat", sizeof(long_key));
- rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
- test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
- }
-
- return TEST_SUCCESS;
-}
-
-
-#ifdef MEMCACHED_ENABLE_DEPRECATED
-static test_return_t deprecated_set_memory_alloc(memcached_st *memc)
-{
- void *test_ptr= NULL;
- void *cb_ptr= NULL;
- {
- memcached_malloc_fn malloc_cb=
- (memcached_malloc_fn)my_malloc;
- cb_ptr= *(void **)&malloc_cb;
- memcached_return_t rc;
-
- rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, cb_ptr);
- test_true(rc == MEMCACHED_SUCCESS);
- test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, &rc);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(test_ptr == cb_ptr);
- }
-
- {
- memcached_realloc_fn realloc_cb=
- (memcached_realloc_fn)my_realloc;
- cb_ptr= *(void **)&realloc_cb;
- memcached_return_t rc;
-
- rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, cb_ptr);
- test_true(rc == MEMCACHED_SUCCESS);
- test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, &rc);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(test_ptr == cb_ptr);
- }
-
- {
- memcached_free_fn free_cb=
- (memcached_free_fn)my_free;
- cb_ptr= *(void **)&free_cb;
- memcached_return_t rc;
-
- rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, cb_ptr);
- test_true(rc == MEMCACHED_SUCCESS);
- test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, &rc);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(test_ptr == cb_ptr);
- }
-
- return TEST_SUCCESS;
-}
-#endif
-
-
-static test_return_t set_memory_alloc(memcached_st *memc)
-{
- memcached_return_t rc;
- rc= memcached_set_memory_allocators(memc, NULL, my_free,
- my_realloc, my_calloc, NULL);
- test_true(rc == MEMCACHED_FAILURE);
-
- rc= memcached_set_memory_allocators(memc, my_malloc, my_free,
- my_realloc, my_calloc, NULL);
-
- memcached_malloc_fn mem_malloc;
- memcached_free_fn mem_free;
- memcached_realloc_fn mem_realloc;
- memcached_calloc_fn mem_calloc;
- memcached_get_memory_allocators(memc, &mem_malloc, &mem_free,
- &mem_realloc, &mem_calloc);
-
- test_true(mem_malloc == my_malloc);
- test_true(mem_realloc == my_realloc);
- test_true(mem_calloc == my_calloc);
- test_true(mem_free == my_free);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t enable_consistent_crc(memcached_st *memc)
-{
- test_return_t rc;
- memcached_server_distribution_t value= MEMCACHED_DISTRIBUTION_CONSISTENT;
- memcached_hash_t hash;
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, value);
- if ((rc= pre_crc(memc)) != TEST_SUCCESS)
- return rc;
-
- value= (memcached_server_distribution_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION);
- test_true(value == MEMCACHED_DISTRIBUTION_CONSISTENT);
-
- hash= (memcached_hash_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
-
- if (hash != MEMCACHED_HASH_CRC)
- return TEST_SKIPPED;
-
- return TEST_SUCCESS;
-}
-
-static test_return_t enable_consistent_hsieh(memcached_st *memc)
-{
- test_return_t rc;
- memcached_server_distribution_t value= MEMCACHED_DISTRIBUTION_CONSISTENT;
- memcached_hash_t hash;
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, value);
- if ((rc= pre_hsieh(memc)) != TEST_SUCCESS)
- return rc;
-
- value= (memcached_server_distribution_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION);
- test_true(value == MEMCACHED_DISTRIBUTION_CONSISTENT);
-
- hash= (memcached_hash_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
-
- if (hash != MEMCACHED_HASH_HSIEH)
- return TEST_SKIPPED;
-
-
- return TEST_SUCCESS;
-}
-
-static test_return_t enable_cas(memcached_st *memc)
-{
- unsigned int set= 1;
-
- if (libmemcached_util_version_check(memc, 1, 2, 4))
- {
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
-
- return TEST_SUCCESS;
- }
-
- return TEST_SKIPPED;
-}
-
-static test_return_t check_for_1_2_3(memcached_st *memc)
-{
- memcached_version(memc);
-
- memcached_server_instance_st instance=
- memcached_server_instance_by_position(memc, 0);
-
- if ((instance->major_version >= 1 && (instance->minor_version == 2 && instance->micro_version >= 4))
- || instance->minor_version > 2)
- {
- return TEST_SUCCESS;
- }
-
- return TEST_SKIPPED;
-}
-
-static test_return_t pre_unix_socket(memcached_st *memc)
-{
- memcached_return_t rc;
- struct stat buf;
-
- memcached_servers_reset(memc);
-
- if (stat("/tmp/memcached.socket", &buf))
- return TEST_SKIPPED;
-
- rc= memcached_server_add_unix_socket_with_weight(memc, "/tmp/memcached.socket", 0);
-
- return ( rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_FAILURE );
-}
-
-static test_return_t pre_nodelay(memcached_st *memc)
-{
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 0);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t pre_settimer(memcached_st *memc)
-{
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 1000);
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 1000);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t poll_timeout(memcached_st *memc)
-{
- size_t timeout;
-
- timeout= 100;
-
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
-
- timeout= (size_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
-
- test_true(timeout == 100);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t noreply_test(memcached_st *memc)
-{
- memcached_return_t ret;
- ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1);
- test_true(ret == MEMCACHED_SUCCESS);
- ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
- test_true(ret == MEMCACHED_SUCCESS);
- ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1);
- test_true(ret == MEMCACHED_SUCCESS);
- test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NOREPLY) == 1);
- test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS) == 1);
- test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS) == 1);
-
- for (int count=0; count < 5; ++count)
- {
- for (size_t x= 0; x < 100; ++x)
- {
- char key[10];
- int check_length= (size_t)snprintf(key, sizeof(key), "%lu", (unsigned long)x);
- test_false((size_t)check_length >= sizeof(key) || check_length < 0);
-
- size_t len= (size_t)check_length;
-
- switch (count)
- {
- case 0:
- ret= memcached_add(memc, key, len, key, len, 0, 0);
- break;
- case 1:
- ret= memcached_replace(memc, key, len, key, len, 0, 0);
- break;
- case 2:
- ret= memcached_set(memc, key, len, key, len, 0, 0);
- break;
- case 3:
- ret= memcached_append(memc, key, len, key, len, 0, 0);
- break;
- case 4:
- ret= memcached_prepend(memc, key, len, key, len, 0, 0);
- break;
- default:
- test_true(count);
- break;
- }
- test_true(ret == MEMCACHED_SUCCESS || ret == MEMCACHED_BUFFERED);
- }
-
- /*
- ** NOTE: Don't ever do this in your code! this is not a supported use of the
- ** API and is _ONLY_ done this way to verify that the library works the
- ** way it is supposed to do!!!!
- */
- int no_msg=0;
- for (uint32_t x= 0; x < memcached_server_count(memc); ++x)
- {
- memcached_server_instance_st instance=
- memcached_server_instance_by_position(memc, x);
- no_msg+=(int)(instance->cursor_active);
- }
-
- test_true(no_msg == 0);
- test_true(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
-
- /*
- ** Now validate that all items was set properly!
- */
- for (size_t x= 0; x < 100; ++x)
- {
- char key[10];
-
- int check_length= (size_t)snprintf(key, sizeof(key), "%lu", (unsigned long)x);
-
- test_false((size_t)check_length >= sizeof(key) || check_length < 0);
-
- size_t len= (size_t)check_length;
- size_t length;
- uint32_t flags;
- char* value=memcached_get(memc, key, strlen(key),
- &length, &flags, &ret);
- test_true(ret == MEMCACHED_SUCCESS && value != NULL);
- switch (count)
- {
- case 0: /* FALLTHROUGH */
- case 1: /* FALLTHROUGH */
- case 2:
- test_true(strncmp(value, key, len) == 0);
- test_true(len == length);
- break;
- case 3:
- test_true(length == len * 2);
- break;
- case 4:
- test_true(length == len * 3);
- break;
- default:
- test_true(count);
- break;
- }
- free(value);
- }
- }
-
- /* Try setting an illegal cas value (should not return an error to
- * the caller (because we don't expect a return message from the server)
- */
- const char* keys[]= {"0"};
- size_t lengths[]= {1};
- size_t length;
- uint32_t flags;
- memcached_result_st results_obj;
- memcached_result_st *results;
- ret= memcached_mget(memc, keys, lengths, 1);
- test_true(ret == MEMCACHED_SUCCESS);
-
- results= memcached_result_create(memc, &results_obj);
- test_true(results);
- results= memcached_fetch_result(memc, &results_obj, &ret);
- test_true(results);
- test_true(ret == MEMCACHED_SUCCESS);
- uint64_t cas= memcached_result_cas(results);
- memcached_result_free(&results_obj);
-
- ret= memcached_cas(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0, cas);
- test_true(ret == MEMCACHED_SUCCESS);
-
- /*
- * The item will have a new cas value, so try to set it again with the old
- * value. This should fail!
- */
- ret= memcached_cas(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0, cas);
- test_true(ret == MEMCACHED_SUCCESS);
- test_true(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
- char* value=memcached_get(memc, keys[0], lengths[0], &length, &flags, &ret);
- test_true(ret == MEMCACHED_SUCCESS && value != NULL);
- free(value);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t analyzer_test(memcached_st *memc)
-{
- memcached_return_t rc;
- memcached_stat_st *memc_stat;
- memcached_analysis_st *report;
-
- memc_stat= memcached_stat(memc, NULL, &rc);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(memc_stat);
-
- report= memcached_analyze(memc, memc_stat, &rc);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(report);
-
- free(report);
- memcached_stat_free(NULL, memc_stat);
-
- return TEST_SUCCESS;
-}
-
-/* Count the objects */
-static memcached_return_t callback_dump_counter(const memcached_st *ptr,
- const char *key,
- size_t key_length,
- void *context)
-{
- (void)ptr; (void)key; (void)key_length;
- size_t *counter= (size_t *)context;
-
- *counter= *counter + 1;
-
- return MEMCACHED_SUCCESS;
-}
-
-static test_return_t dump_test(memcached_st *memc)
-{
- memcached_return_t rc;
- size_t counter= 0;
- memcached_dump_fn callbacks[1];
- test_return_t main_rc;
-
- callbacks[0]= &callback_dump_counter;
-
- /* No support for Binary protocol yet */
- if (memc->flags.binary_protocol)
- return TEST_SUCCESS;
-
- main_rc= set_test3(memc);
-
- test_true (main_rc == TEST_SUCCESS);
-
- rc= memcached_dump(memc, callbacks, (void *)&counter, 1);
- test_true(rc == MEMCACHED_SUCCESS);
-
- /* We may have more then 32 if our previous flush has not completed */
- test_true(counter >= 32);
-
- return TEST_SUCCESS;
-}
-
-#ifdef HAVE_LIBMEMCACHEDUTIL
-static void* connection_release(void *arg)
-{
- struct {
- memcached_pool_st* pool;
- memcached_st* mmc;
- } *resource= arg;
-
- usleep(250);
- // Release all of the memc we are holding
- assert(memcached_pool_push(resource->pool, resource->mmc) == MEMCACHED_SUCCESS);
- return arg;
-}
-
-#define POOL_SIZE 10
-static test_return_t connection_pool_test(memcached_st *memc)
-{
- memcached_pool_st* pool= memcached_pool_create(memc, 5, POOL_SIZE);
- test_true(pool != NULL);
- memcached_st *mmc[POOL_SIZE];
- memcached_return_t rc;
-
- // Fill up our array that we will store the memc that are in the pool
- for (size_t x= 0; x < POOL_SIZE; ++x)
- {
- mmc[x]= memcached_pool_pop(pool, false, &rc);
- test_true(mmc[x] != NULL);
- test_true(rc == MEMCACHED_SUCCESS);
- }
-
- // All memc should be gone
- test_true(memcached_pool_pop(pool, false, &rc) == NULL);
- test_true(rc == MEMCACHED_SUCCESS);
-
- pthread_t tid;
- struct {
- memcached_pool_st* pool;
- memcached_st* mmc;
- } item= { .pool = pool, .mmc = mmc[9] };
-
- pthread_create(&tid, NULL, connection_release, &item);
- mmc[9]= memcached_pool_pop(pool, true, &rc);
- test_true(rc == MEMCACHED_SUCCESS);
- pthread_join(tid, NULL);
- test_true(mmc[9]);
- const char *key= "key";
- size_t keylen= strlen(key);
-
- // verify that I can do ops with all connections
- rc= memcached_set(mmc[0], key, keylen, "0", 1, 0, 0);
- test_true(rc == MEMCACHED_SUCCESS);
-
- for (size_t x= 0; x < POOL_SIZE; ++x)
- {
- uint64_t number_value;
- rc= memcached_increment(mmc[x], key, keylen, 1, &number_value);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(number_value == (x+1));
- }
-
- // Release them..
- for (size_t x= 0; x < POOL_SIZE; ++x)
- {
- test_true(memcached_pool_push(pool, mmc[x]) == MEMCACHED_SUCCESS);
- }
-
-
- /* verify that I can set behaviors on the pool when I don't have all
- * of the connections in the pool. It should however be enabled
- * when I push the item into the pool
- */
- mmc[0]= memcached_pool_pop(pool, false, &rc);
- test_true(mmc[0] != NULL);
-
- rc= memcached_pool_behavior_set(pool, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK, 9999);
- test_true(rc == MEMCACHED_SUCCESS);
-
- mmc[1]= memcached_pool_pop(pool, false, &rc);
- test_true(mmc[1] != NULL);
-
- test_true(memcached_behavior_get(mmc[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK) == 9999);
- test_true(memcached_pool_push(pool, mmc[1]) == MEMCACHED_SUCCESS);
- test_true(memcached_pool_push(pool, mmc[0]) == MEMCACHED_SUCCESS);
-
- mmc[0]= memcached_pool_pop(pool, false, &rc);
- test_true(memcached_behavior_get(mmc[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK) == 9999);
- test_true(memcached_pool_push(pool, mmc[0]) == MEMCACHED_SUCCESS);
-
- test_true(memcached_pool_destroy(pool) == memc);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t util_version_test(memcached_st *memc)
-{
- bool if_successful;
-
- if_successful= libmemcached_util_version_check(memc, 0, 0, 0);
- test_true(if_successful == true);
-
- if_successful= libmemcached_util_version_check(memc, 9, 9, 9);
-
- // We expect failure
- if (if_successful)
- {
- fprintf(stderr, "\n----------------------------------------------------------------------\n");
- fprintf(stderr, "\nDumping Server Information\n\n");
- memcached_server_fn callbacks[1];
-
- callbacks[0]= dump_server_information;
- memcached_server_cursor(memc, callbacks, (void *)stderr, 1);
- fprintf(stderr, "\n----------------------------------------------------------------------\n");
- }
- test_true(if_successful == false);
-
- memcached_server_instance_st instance=
- memcached_server_instance_by_position(memc, 0);
-
- memcached_version(memc);
-
- // We only use one binary when we test, so this should be just fine.
- if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, instance->micro_version);
- test_true(if_successful == true);
-
- if (instance->micro_version > 0)
- if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, (uint8_t)(instance->micro_version -1));
- else if (instance->minor_version > 0)
- if_successful= libmemcached_util_version_check(memc, instance->major_version, (uint8_t)(instance->minor_version - 1), instance->micro_version);
- else if (instance->major_version > 0)
- if_successful= libmemcached_util_version_check(memc, (uint8_t)(instance->major_version -1), instance->minor_version, instance->micro_version);
-
- test_true(if_successful == true);
-
- if (instance->micro_version > 0)
- if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, (uint8_t)(instance->micro_version +1));
- else if (instance->minor_version > 0)
- if_successful= libmemcached_util_version_check(memc, instance->major_version, (uint8_t)(instance->minor_version +1), instance->micro_version);
- else if (instance->major_version > 0)
- if_successful= libmemcached_util_version_check(memc, (uint8_t)(instance->major_version +1), instance->minor_version, instance->micro_version);
-
- test_true(if_successful == false);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t ping_test(memcached_st *memc)
-{
- memcached_return_t rc;
- memcached_server_instance_st instance=
- memcached_server_instance_by_position(memc, 0);
-
- // Test both the version that returns a code, and the one that does not.
- test_true(libmemcached_util_ping(memcached_server_name(instance),
- memcached_server_port(instance), NULL));
-
- test_true(libmemcached_util_ping(memcached_server_name(instance),
- memcached_server_port(instance), &rc));
-
- test_true(rc == MEMCACHED_SUCCESS);
-
- return TEST_SUCCESS;
-}
-#endif
-
-
-#if 0
-static test_return_t hash_sanity_test (memcached_st *memc)
-{
- (void)memc;
-
- assert(MEMCACHED_HASH_DEFAULT == MEMCACHED_HASH_DEFAULT);
- assert(MEMCACHED_HASH_MD5 == MEMCACHED_HASH_MD5);
- assert(MEMCACHED_HASH_CRC == MEMCACHED_HASH_CRC);
- assert(MEMCACHED_HASH_FNV1_64 == MEMCACHED_HASH_FNV1_64);
- assert(MEMCACHED_HASH_FNV1A_64 == MEMCACHED_HASH_FNV1A_64);
- assert(MEMCACHED_HASH_FNV1_32 == MEMCACHED_HASH_FNV1_32);
- assert(MEMCACHED_HASH_FNV1A_32 == MEMCACHED_HASH_FNV1A_32);
-#ifdef HAVE_HSIEH_HASH
- assert(MEMCACHED_HASH_HSIEH == MEMCACHED_HASH_HSIEH);
-#endif
- assert(MEMCACHED_HASH_MURMUR == MEMCACHED_HASH_MURMUR);
- assert(MEMCACHED_HASH_JENKINS == MEMCACHED_HASH_JENKINS);
- assert(MEMCACHED_HASH_MAX == MEMCACHED_HASH_MAX);
-
- return TEST_SUCCESS;
-}
-#endif
-
-static test_return_t hsieh_avaibility_test (memcached_st *memc)
-{
- memcached_return_t expected_rc= MEMCACHED_INVALID_ARGUMENTS;
-#ifdef HAVE_HSIEH_HASH
- expected_rc= MEMCACHED_SUCCESS;
-#endif
- memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH,
- (uint64_t)MEMCACHED_HASH_HSIEH);
- test_true(rc == expected_rc);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t murmur_avaibility_test (memcached_st *memc)
-{
- memcached_return_t expected_rc= MEMCACHED_INVALID_ARGUMENTS;
-#ifdef HAVE_MURMUR_HASH
- expected_rc= MEMCACHED_SUCCESS;
-#endif
- memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH,
- (uint64_t)MEMCACHED_HASH_MURMUR);
- test_true(rc == expected_rc);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t one_at_a_time_run (memcached_st *memc)
-{
- uint32_t x;
- const char **ptr;
- (void)memc;
-
- for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
- {
- uint32_t hash_val;
-
- hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_DEFAULT);
- test_true(one_at_a_time_values[x] == hash_val);
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t md5_run (memcached_st *memc)
-{
- uint32_t x;
- const char **ptr;
- (void)memc;
-
- for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
- {
- uint32_t hash_val;
-
- hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_MD5);
- test_true(md5_values[x] == hash_val);
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t crc_run (memcached_st *memc)
-{
- uint32_t x;
- const char **ptr;
- (void)memc;
-
- for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
- {
- uint32_t hash_val;
-
- hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_CRC);
- test_true(crc_values[x] == hash_val);
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t fnv1_64_run (memcached_st *memc)
-{
- uint32_t x;
- const char **ptr;
- (void)memc;
-
- for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
- {
- uint32_t hash_val;
-
- hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_64);
- test_true(fnv1_64_values[x] == hash_val);
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t fnv1a_64_run (memcached_st *memc)
-{
- uint32_t x;
- const char **ptr;
- (void)memc;
-
- for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
- {
- uint32_t hash_val;
-
- hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_64);
- test_true(fnv1a_64_values[x] == hash_val);
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t fnv1_32_run (memcached_st *memc)
-{
- uint32_t x;
- const char **ptr;
- (void)memc;
-
- for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
- {
- uint32_t hash_val;
-
- hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_32);
- test_true(fnv1_32_values[x] == hash_val);
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t fnv1a_32_run (memcached_st *memc)
-{
- uint32_t x;
- const char **ptr;
- (void)memc;
-
- for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
- {
- uint32_t hash_val;
-
- hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_32);
- test_true(fnv1a_32_values[x] == hash_val);
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t hsieh_run (memcached_st *memc)
-{
- uint32_t x;
- const char **ptr;
- (void)memc;
-
- for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
- {
- uint32_t hash_val;
-
- hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_HSIEH);
- test_true(hsieh_values[x] == hash_val);
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t murmur_run (memcached_st *memc)
-{
-#ifdef WORDS_BIGENDIAN
- (void)murmur_values;
- return TEST_SKIPPED;
-#else
- uint32_t x;
- const char **ptr;
- (void)memc;
-
- for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
- {
- uint32_t hash_val;
-
- hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_MURMUR);
- test_true(murmur_values[x] == hash_val);
- }
-
- return TEST_SUCCESS;
-#endif
-}
-
-static test_return_t jenkins_run (memcached_st *memc)
-{
- uint32_t x;
- const char **ptr;
- (void)memc;
-
- for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
- {
- uint32_t hash_val;
-
- hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_JENKINS);
- test_true(jenkins_values[x] == hash_val);
- }
-
- return TEST_SUCCESS;
-}
-
-static uint32_t hash_md5_test_function(const char *string, size_t string_length, void *context)
-{
- (void)context;
- return libhashkit_md5(string, string_length);
-}
-
-static uint32_t hash_crc_test_function(const char *string, size_t string_length, void *context)
-{
- (void)context;
- return libhashkit_crc32(string, string_length);
-}
-
-static test_return_t memcached_get_hashkit_test (memcached_st *memc)
-{
- uint32_t x;
- const char **ptr;
- const hashkit_st *kit;
- hashkit_st new_kit;
- hashkit_return_t hash_rc;
-
- uint32_t md5_hosts[]= {4U, 1U, 0U, 1U, 4U, 2U, 0U, 3U, 0U, 0U, 3U, 1U, 0U, 0U, 1U, 3U, 0U, 0U, 0U, 3U, 1U, 0U, 4U, 4U, 3U};
- uint32_t crc_hosts[]= {2U, 4U, 1U, 0U, 2U, 4U, 4U, 4U, 1U, 2U, 3U, 4U, 3U, 4U, 1U, 3U, 3U, 2U, 0U, 0U, 0U, 1U, 2U, 4U, 0U};
-
- kit= memcached_get_hashkit(memc);
-
- hashkit_clone(&new_kit, kit);
- hash_rc= hashkit_set_custom_function(&new_kit, hash_md5_test_function, NULL);
- test_true(hash_rc == HASHKIT_SUCCESS);
-
- memcached_set_hashkit(memc, &new_kit);
-
- /*
- Verify Setting the hash.
- */
- for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
- {
- uint32_t hash_val;
-
- hash_val= hashkit_digest(kit, *ptr, strlen(*ptr));
- test_true(md5_values[x] == hash_val);
- }
-
-
- /*
- Now check memcached_st.
- */
- for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
- {
- uint32_t hash_val;
-
- hash_val= memcached_generate_hash(memc, *ptr, strlen(*ptr));
- test_true(md5_hosts[x] == hash_val);
- }
-
- hash_rc= hashkit_set_custom_function(&new_kit, hash_crc_test_function, NULL);
- test_true(hash_rc == HASHKIT_SUCCESS);
-
- memcached_set_hashkit(memc, &new_kit);
-
- /*
- Verify Setting the hash.
- */
- for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
- {
- uint32_t hash_val;
-
- hash_val= hashkit_digest(kit, *ptr, strlen(*ptr));
- test_true(crc_values[x] == hash_val);
- }
-
- for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
- {
- uint32_t hash_val;
-
- hash_val= memcached_generate_hash(memc, *ptr, strlen(*ptr));
- test_true(crc_hosts[x] == hash_val);
- }
-
- return TEST_SUCCESS;
-}
-
-/*
- Test case adapted from John Gorman <johngorman2@gmail.com>
-
- We are testing the error condition when we connect to a server via memcached_get()
- but find that the server is not available.
-*/
-static test_return_t memcached_get_MEMCACHED_ERRNO(memcached_st *memc)
-{
- (void)memc;
- memcached_st *tl_memc_h;
- memcached_server_st *servers;
-
- const char *key= "MemcachedLives";
- size_t len;
- uint32_t flags;
- memcached_return rc;
- char *value;
-
- // Create a handle.
- tl_memc_h= memcached_create(NULL);
- servers= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
- memcached_server_push(tl_memc_h, servers);
- memcached_server_list_free(servers);
-
- // See if memcached is reachable.
- value= memcached_get(tl_memc_h, key, strlen(key), &len, &flags, &rc);
-
- test_false(value);
- test_true(len == 0);
- test_false(rc == MEMCACHED_SUCCESS);
-
- memcached_free(tl_memc_h);
-
- return TEST_SUCCESS;
-}
-
-/*
- We connect to a server which exists, but search for a key that does not exist.
-*/
-static test_return_t memcached_get_MEMCACHED_NOTFOUND(memcached_st *memc)
-{
- const char *key= "MemcachedKeyNotEXIST";
- size_t len;
- uint32_t flags;
- memcached_return rc;
- char *value;
-
- // See if memcached is reachable.
- value= memcached_get(memc, key, strlen(key), &len, &flags, &rc);
-
- test_false(value);
- test_true(len == 0);
- test_true(rc == MEMCACHED_NOTFOUND);
-
- return TEST_SUCCESS;
-}
-
-/*
- Test case adapted from John Gorman <johngorman2@gmail.com>
-
- We are testing the error condition when we connect to a server via memcached_get_by_key()
- but find that the server is not available.
-*/
-static test_return_t memcached_get_by_key_MEMCACHED_ERRNO(memcached_st *memc)
-{
- (void)memc;
- memcached_st *tl_memc_h;
- memcached_server_st *servers;
-
- const char *key= "MemcachedLives";
- size_t len;
- uint32_t flags;
- memcached_return rc;
- char *value;
-
- // Create a handle.
- tl_memc_h= memcached_create(NULL);
- servers= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
- memcached_server_push(tl_memc_h, servers);
- memcached_server_list_free(servers);
-
- // See if memcached is reachable.
- value= memcached_get_by_key(tl_memc_h, key, strlen(key), key, strlen(key), &len, &flags, &rc);
-
- test_false(value);
- test_true(len == 0);
- test_false(rc == MEMCACHED_SUCCESS);
-
- memcached_free(tl_memc_h);
-
- return TEST_SUCCESS;
-}
-
-/*
- We connect to a server which exists, but search for a key that does not exist.
-*/
-static test_return_t memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st *memc)
-{
- const char *key= "MemcachedKeyNotEXIST";
- size_t len;
- uint32_t flags;
- memcached_return rc;
- char *value;
-
- // See if memcached is reachable.
- value= memcached_get_by_key(memc, key, strlen(key), key, strlen(key), &len, &flags, &rc);
-
- test_false(value);
- test_true(len == 0);
- test_true(rc == MEMCACHED_NOTFOUND);
-
- return TEST_SUCCESS;
-}
-
-
-static test_return_t ketama_compatibility_libmemcached(memcached_st *trash)
-{
- memcached_return_t rc;
- uint64_t value;
- int x;
- memcached_server_st *server_pool;
- memcached_st *memc;
-
- (void)trash;
-
- memc= memcached_create(NULL);
- test_true(memc);
-
- rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
- test_true(rc == MEMCACHED_SUCCESS);
-
- value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
- test_true(value == 1);
-
- test_true(memcached_behavior_set_distribution(memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA) == MEMCACHED_SUCCESS);
- test_true(memcached_behavior_get_distribution(memc) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA);
-
-
- server_pool = memcached_servers_parse("10.0.1.1:11211 600,10.0.1.2:11211 300,10.0.1.3:11211 200,10.0.1.4:11211 350,10.0.1.5:11211 1000,10.0.1.6:11211 800,10.0.1.7:11211 950,10.0.1.8:11211 100");
- memcached_server_push(memc, server_pool);
-
- /* verify that the server list was parsed okay. */
- test_true(memcached_server_count(memc) == 8);
- test_strcmp(server_pool[0].hostname, "10.0.1.1");
- test_true(server_pool[0].port == 11211);
- test_true(server_pool[0].weight == 600);
- test_strcmp(server_pool[2].hostname, "10.0.1.3");
- test_true(server_pool[2].port == 11211);
- test_true(server_pool[2].weight == 200);
- test_strcmp(server_pool[7].hostname, "10.0.1.8");
- test_true(server_pool[7].port == 11211);
- test_true(server_pool[7].weight == 100);
-
- /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
- * us test the boundary wraparound.
- */
- test_true(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->ketama.continuum[0].index);
-
- /* verify the standard ketama set. */
- for (x= 0; x < 99; x++)
- {
- uint32_t server_idx = memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key));
- memcached_server_instance_st instance=
- memcached_server_instance_by_position(memc, server_idx);
- const char *hostname = memcached_server_name(instance);
-
- test_strcmp(hostname, ketama_test_cases[x].server);
- }
-
- memcached_server_list_free(server_pool);
- memcached_free(memc);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t ketama_compatibility_spymemcached(memcached_st *trash)
-{
- memcached_return_t rc;
- uint64_t value;
- memcached_server_st *server_pool;
- memcached_st *memc;
-
- (void)trash;
-
- memc= memcached_create(NULL);
- test_true(memc);
-
- rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
- test_true(rc == MEMCACHED_SUCCESS);
-
- value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
- test_true(value == 1);
-
- test_true(memcached_behavior_set_distribution(memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY) == MEMCACHED_SUCCESS);
- test_true(memcached_behavior_get_distribution(memc) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY);
-
- server_pool = memcached_servers_parse("10.0.1.1:11211 600,10.0.1.2:11211 300,10.0.1.3:11211 200,10.0.1.4:11211 350,10.0.1.5:11211 1000,10.0.1.6:11211 800,10.0.1.7:11211 950,10.0.1.8:11211 100");
- assert(server_pool);
- memcached_server_push(memc, server_pool);
-
- /* verify that the server list was parsed okay. */
- test_true(memcached_server_count(memc) == 8);
- test_strcmp(server_pool[0].hostname, "10.0.1.1");
- test_true(server_pool[0].port == 11211);
- test_true(server_pool[0].weight == 600);
- test_strcmp(server_pool[2].hostname, "10.0.1.3");
- test_true(server_pool[2].port == 11211);
- test_true(server_pool[2].weight == 200);
- test_strcmp(server_pool[7].hostname, "10.0.1.8");
- test_true(server_pool[7].port == 11211);
- test_true(server_pool[7].weight == 100);
-
- /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
- * us test the boundary wraparound.
- */
- test_true(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->ketama.continuum[0].index);
-
- /* verify the standard ketama set. */
- for (uint32_t x= 0; x < 99; x++)
- {
- uint32_t server_idx= memcached_generate_hash(memc, ketama_test_cases_spy[x].key, strlen(ketama_test_cases_spy[x].key));
-
- memcached_server_instance_st instance=
- memcached_server_instance_by_position(memc, server_idx);
-
- const char *hostname= memcached_server_name(instance);
-
- test_strcmp(hostname, ketama_test_cases_spy[x].server);
- }
-
- memcached_server_list_free(server_pool);
- memcached_free(memc);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t regression_bug_434484(memcached_st *memc)
-{
- test_return_t test_rc;
- test_rc= pre_binary(memc);
-
- if (test_rc != TEST_SUCCESS)
- return test_rc;
-
- memcached_return_t ret;
- const char *key= "regression_bug_434484";
- size_t keylen= strlen(key);
-
- ret= memcached_append(memc, key, keylen, key, keylen, 0, 0);
- test_true(ret == MEMCACHED_NOTSTORED);
-
- size_t size= 2048 * 1024;
- void *data= calloc(1, size);
- test_true(data != NULL);
- ret= memcached_set(memc, key, keylen, data, size, 0, 0);
- test_true(ret == MEMCACHED_E2BIG);
- free(data);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t regression_bug_434843(memcached_st *memc)
-{
- test_return_t test_rc;
- test_rc= pre_binary(memc);
-
- if (test_rc != TEST_SUCCESS)
- return test_rc;
-
- memcached_return_t rc;
- size_t counter= 0;
- memcached_execute_fn callbacks[1]= { [0]= &callback_counter };
-
- /*
- * I only want to hit only _one_ server so I know the number of requests I'm
- * sending in the pipleine to the server. Let's try to do a multiget of
- * 1024 (that should satisfy most users don't you think?). Future versions
- * will include a mget_execute function call if you need a higher number.
- */
- uint32_t number_of_hosts= memcached_server_count(memc);
- memc->number_of_hosts= 1;
- const size_t max_keys= 1024;
- char **keys= calloc(max_keys, sizeof(char*));
- size_t *key_length=calloc(max_keys, sizeof(size_t));
-
- for (size_t x= 0; x < max_keys; ++x)
- {
- char k[251];
-
- key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
- keys[x]= strdup(k);
- test_true(keys[x] != NULL);
- }
-
- /*
- * Run two times.. the first time we should have 100% cache miss,
- * and the second time we should have 100% cache hits
- */
- for (size_t y= 0; y < 2; y++)
- {
- rc= memcached_mget(memc, (const char**)keys, key_length, max_keys);
- test_true(rc == MEMCACHED_SUCCESS);
- rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
-
- if (y == 0)
- {
- /* The first iteration should give me a 100% cache miss. verify that*/
- char blob[1024]= { 0 };
-
- test_true(counter == 0);
-
- for (size_t x= 0; x < max_keys; ++x)
- {
- rc= memcached_add(memc, keys[x], key_length[x],
- blob, sizeof(blob), 0, 0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
- }
- }
- else
- {
- /* Verify that we received all of the key/value pairs */
- test_true(counter == max_keys);
- }
- }
-
- /* Release allocated resources */
- for (size_t x= 0; x < max_keys; ++x)
- {
- free(keys[x]);
- }
- free(keys);
- free(key_length);
-
- memc->number_of_hosts= number_of_hosts;
-
- return TEST_SUCCESS;
-}
-
-static test_return_t regression_bug_434843_buffered(memcached_st *memc)
-{
- memcached_return_t rc;
- rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
- test_true(rc == MEMCACHED_SUCCESS);
-
- return regression_bug_434843(memc);
-}
-
-static test_return_t regression_bug_421108(memcached_st *memc)
-{
- memcached_return_t rc;
- memcached_stat_st *memc_stat= memcached_stat(memc, NULL, &rc);
- test_true(rc == MEMCACHED_SUCCESS);
-
- char *bytes= memcached_stat_get_value(memc, memc_stat, "bytes", &rc);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(bytes != NULL);
- char *bytes_read= memcached_stat_get_value(memc, memc_stat,
- "bytes_read", &rc);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(bytes_read != NULL);
-
- char *bytes_written= memcached_stat_get_value(memc, memc_stat,
- "bytes_written", &rc);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(bytes_written != NULL);
-
- test_true(strcmp(bytes, bytes_read) != 0);
- test_true(strcmp(bytes, bytes_written) != 0);
-
- /* Release allocated resources */
- free(bytes);
- free(bytes_read);
- free(bytes_written);
- memcached_stat_free(NULL, memc_stat);
-
- return TEST_SUCCESS;
-}
-
-/*
- * The test case isn't obvious so I should probably document why
- * it works the way it does. Bug 442914 was caused by a bug
- * in the logic in memcached_purge (it did not handle the case
- * where the number of bytes sent was equal to the watermark).
- * In this test case, create messages so that we hit that case
- * and then disable noreply mode and issue a new command to
- * verify that it isn't stuck. If we change the format for the
- * delete command or the watermarks, we need to update this
- * test....
- */
-static test_return_t regression_bug_442914(memcached_st *memc)
-{
- memcached_return_t rc;
- rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1);
- test_true(rc == MEMCACHED_SUCCESS);
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1);
-
- uint32_t number_of_hosts= memcached_server_count(memc);
- memc->number_of_hosts= 1;
-
- char k[250];
- size_t len;
-
- for (uint32_t x= 0; x < 250; ++x)
- {
- len= (size_t)snprintf(k, sizeof(k), "%0250u", x);
- rc= memcached_delete(memc, k, len, 0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
- }
-
- (void)snprintf(k, sizeof(k), "%037u", 251U);
- len= strlen(k);
-
- rc= memcached_delete(memc, k, len, 0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
-
- rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 0);
- test_true(rc == MEMCACHED_SUCCESS);
- rc= memcached_delete(memc, k, len, 0);
- test_true(rc == MEMCACHED_NOTFOUND);
-
- memc->number_of_hosts= number_of_hosts;
-
- return TEST_SUCCESS;
-}
-
-static test_return_t regression_bug_447342(memcached_st *memc)
-{
- memcached_server_instance_st instance_one;
- memcached_server_instance_st instance_two;
-
- if (memcached_server_count(memc) < 3 || pre_replication(memc) != TEST_SUCCESS)
- return TEST_SKIPPED;
-
- memcached_return_t rc;
-
- rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 2);
- test_true(rc == MEMCACHED_SUCCESS);
-
- const size_t max_keys= 100;
- char **keys= calloc(max_keys, sizeof(char*));
- size_t *key_length= calloc(max_keys, sizeof(size_t));
-
- for (size_t x= 0; x < max_keys; ++x)
- {
- char k[251];
-
- key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
- keys[x]= strdup(k);
- test_true(keys[x] != NULL);
- rc= memcached_set(memc, k, key_length[x], k, key_length[x], 0, 0);
- test_true(rc == MEMCACHED_SUCCESS);
- }
-
- /*
- ** We are using the quiet commands to store the replicas, so we need
- ** to ensure that all of them are processed before we can continue.
- ** In the test we go directly from storing the object to trying to
- ** receive the object from all of the different servers, so we
- ** could end up in a race condition (the memcached server hasn't yet
- ** processed the quiet command from the replication set when it process
- ** the request from the other client (created by the clone)). As a
- ** workaround for that we call memcached_quit to send the quit command
- ** to the server and wait for the response ;-) If you use the test code
- ** as an example for your own code, please note that you shouldn't need
- ** to do this ;-)
- */
- memcached_quit(memc);
-
- /* Verify that all messages are stored, and we didn't stuff too much
- * into the servers
- */
- rc= memcached_mget(memc, (const char* const *)keys, key_length, max_keys);
- test_true(rc == MEMCACHED_SUCCESS);
-
- size_t counter= 0;
- memcached_execute_fn callbacks[1]= { [0]= &callback_counter };
- rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
- /* Verify that we received all of the key/value pairs */
- test_true(counter == max_keys);
-
- memcached_quit(memc);
- /*
- * Don't do the following in your code. I am abusing the internal details
- * within the library, and this is not a supported interface.
- * This is to verify correct behavior in the library. Fake that two servers
- * are dead..
- */
- instance_one= memcached_server_instance_by_position(memc, 0);
- instance_two= memcached_server_instance_by_position(memc, 2);
- in_port_t port0= instance_one->port;
- in_port_t port2= instance_two->port;
-
- ((memcached_server_write_instance_st)instance_one)->port= 0;
- ((memcached_server_write_instance_st)instance_two)->port= 0;
-
- rc= memcached_mget(memc, (const char* const *)keys, key_length, max_keys);
- test_true(rc == MEMCACHED_SUCCESS);
-
- counter= 0;
- rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
- test_true(counter == (unsigned int)max_keys);
-
- /* restore the memc handle */
- ((memcached_server_write_instance_st)instance_one)->port= port0;
- ((memcached_server_write_instance_st)instance_two)->port= port2;
-
- memcached_quit(memc);
-
- /* Remove half of the objects */
- for (size_t x= 0; x < max_keys; ++x)
- {
- if (x & 1)
- {
- rc= memcached_delete(memc, keys[x], key_length[x], 0);
- test_true(rc == MEMCACHED_SUCCESS);
- }
- }
-
- memcached_quit(memc);
- ((memcached_server_write_instance_st)instance_one)->port= 0;
- ((memcached_server_write_instance_st)instance_two)->port= 0;
-
- /* now retry the command, this time we should have cache misses */
- rc= memcached_mget(memc, (const char* const *)keys, key_length, max_keys);
- test_true(rc == MEMCACHED_SUCCESS);
-
- counter= 0;
- rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
- test_true(counter == (unsigned int)(max_keys >> 1));
-
- /* Release allocated resources */
- for (size_t x= 0; x < max_keys; ++x)
- {
- free(keys[x]);
- }
- free(keys);
- free(key_length);
-
- /* restore the memc handle */
- ((memcached_server_write_instance_st)instance_one)->port= port0;
- ((memcached_server_write_instance_st)instance_two)->port= port2;
-
- return TEST_SUCCESS;
-}
-
-static test_return_t regression_bug_463297(memcached_st *memc)
-{
- memcached_st *memc_clone= memcached_clone(NULL, memc);
- test_true(memc_clone != NULL);
- test_true(memcached_version(memc_clone) == MEMCACHED_SUCCESS);
-
- memcached_server_instance_st instance=
- memcached_server_instance_by_position(memc_clone, 0);
-
- if (instance->major_version > 1 ||
- (instance->major_version == 1 &&
- instance->minor_version > 2))
- {
- /* Binary protocol doesn't support deferred delete */
- memcached_st *bin_clone= memcached_clone(NULL, memc);
- test_true(bin_clone != NULL);
- test_true(memcached_behavior_set(bin_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1) == MEMCACHED_SUCCESS);
- test_true(memcached_delete(bin_clone, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS);
- memcached_free(bin_clone);
-
- memcached_quit(memc_clone);
-
- /* If we know the server version, deferred delete should fail
- * with invalid arguments */
- test_true(memcached_delete(memc_clone, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS);
-
- /* If we don't know the server version, we should get a protocol error */
- memcached_return_t rc= memcached_delete(memc, "foo", 3, 1);
-
- /* but there is a bug in some of the memcached servers (1.4) that treats
- * the counter as noreply so it doesn't send the proper error message
- */
- test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc));
-
- /* And buffered mode should be disabled and we should get protocol error */
- test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1) == MEMCACHED_SUCCESS);
- rc= memcached_delete(memc, "foo", 3, 1);
- test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc));
-
- /* Same goes for noreply... */
- test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1) == MEMCACHED_SUCCESS);
- rc= memcached_delete(memc, "foo", 3, 1);
- test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc));
-
- /* but a normal request should go through (and be buffered) */
- test_true((rc= memcached_delete(memc, "foo", 3, 0)) == MEMCACHED_BUFFERED);
- test_true(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
-
- test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 0) == MEMCACHED_SUCCESS);
- /* unbuffered noreply should be success */
- test_true(memcached_delete(memc, "foo", 3, 0) == MEMCACHED_SUCCESS);
- /* unbuffered with reply should be not found... */
- test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 0) == MEMCACHED_SUCCESS);
- test_true(memcached_delete(memc, "foo", 3, 0) == MEMCACHED_NOTFOUND);
- }
-
- memcached_free(memc_clone);
- return TEST_SUCCESS;
-}
-
-
-/* Test memcached_server_get_last_disconnect
- * For a working server set, shall be NULL
- * For a set of non existing server, shall not be NULL
- */
-static test_return_t test_get_last_disconnect(memcached_st *memc)
-{
- memcached_return_t rc;
- memcached_server_instance_st disconnected_server;
-
- /* With the working set of server */
- const char *key= "marmotte";
- const char *value= "milka";
-
- memcached_reset_last_disconnected_server(memc);
- rc= memcached_set(memc, key, strlen(key),
- value, strlen(value),
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
-
- disconnected_server = memcached_server_get_last_disconnect(memc);
- test_true(disconnected_server == NULL);
-
- /* With a non existing server */
- memcached_st *mine;
- memcached_server_st *servers;
-
- const char *server_list= "localhost:9";
-
- servers= memcached_servers_parse(server_list);
- test_true(servers);
- mine= memcached_create(NULL);
- rc= memcached_server_push(mine, servers);
- test_true(rc == MEMCACHED_SUCCESS);
- memcached_server_list_free(servers);
- test_true(mine);
-
- rc= memcached_set(mine, key, strlen(key),
- value, strlen(value),
- (time_t)0, (uint32_t)0);
- test_true(rc != MEMCACHED_SUCCESS);
-
- disconnected_server= memcached_server_get_last_disconnect(mine);
- if (disconnected_server == NULL)
- {
- fprintf(stderr, "RC %s\n", memcached_strerror(mine, rc));
- abort();
- }
- test_true(disconnected_server != NULL);
- test_true(memcached_server_port(disconnected_server)== 9);
- test_true(strncmp(memcached_server_name(disconnected_server),"localhost",9) == 0);
-
- memcached_quit(mine);
- memcached_free(mine);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t test_verbosity(memcached_st *memc)
-{
- memcached_verbosity(memc, 3);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t test_server_failure(memcached_st *memc)
-{
- memcached_st *local_memc;
- memcached_server_instance_st instance= memcached_server_instance_by_position(memc, 0);
-
- local_memc= memcached_create(NULL);
-
- memcached_server_add(local_memc, memcached_server_name(instance), memcached_server_port(instance));
- memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 2);
-
- uint32_t server_count= memcached_server_count(local_memc);
-
- test_true(server_count == 1);
-
- // Disable the server
- instance= memcached_server_instance_by_position(local_memc, 0);
- ((memcached_server_write_instance_st)instance)->server_failure_counter= 2;
-
- memcached_return_t rc;
- rc= memcached_set(local_memc, "foo", strlen("foo"),
- NULL, 0,
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SERVER_MARKED_DEAD);
-
- ((memcached_server_write_instance_st)instance)->server_failure_counter= 0;
- rc= memcached_set(local_memc, "foo", strlen("foo"),
- NULL, 0,
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS);
-
-
- memcached_free(local_memc);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t test_cull_servers(memcached_st *memc)
-{
- uint32_t count = memcached_server_count(memc);
-
- // Do not do this in your code, it is not supported.
- memc->servers[1].options.is_dead= true;
- memc->state.is_time_for_rebuild= true;
-
- uint32_t new_count= memcached_server_count(memc);
- test_true(count == new_count);
-
-#if 0
- test_true(count == new_count + 1 );
-#endif
-
- return TEST_SUCCESS;
-}
-
-
-static memcached_return_t stat_printer(memcached_server_instance_st server,
- const char *key, size_t key_length,
- const char *value, size_t value_length,
- void *context)
-{
- (void)server;
- (void)context;
- (void)key;
- (void)key_length;
- (void)value;
- (void)value_length;
-
- return MEMCACHED_SUCCESS;
-}
-
-static test_return_t memcached_stat_execute_test(memcached_st *memc)
-{
- memcached_return_t rc= memcached_stat_execute(memc, NULL, stat_printer, NULL);
- test_true(rc == MEMCACHED_SUCCESS);
-
- rc= memcached_stat_execute(memc, "slabs", stat_printer, NULL);
- test_true(rc == MEMCACHED_SUCCESS);
-
- rc= memcached_stat_execute(memc, "items", stat_printer, NULL);
- test_true(rc == MEMCACHED_SUCCESS);
-
- rc= memcached_stat_execute(memc, "sizes", stat_printer, NULL);
- test_true(rc == MEMCACHED_SUCCESS);
-
- return TEST_SUCCESS;
-}
-
-/*
- * This test ensures that the failure counter isn't incremented during
- * normal termination of the memcached instance.
- */
-static test_return_t wrong_failure_counter_test(memcached_st *memc)
-{
- memcached_return_t rc;
- memcached_server_instance_st instance;
-
- /* Set value to force connection to the server */
- const char *key= "marmotte";
- const char *value= "milka";
-
- /*
- * Please note that I'm abusing the internal structures in libmemcached
- * in a non-portable way and you shouldn't be doing this. I'm only
- * doing this in order to verify that the library works the way it should
- */
- uint32_t number_of_hosts= memcached_server_count(memc);
- memc->number_of_hosts= 1;
-
- /* Ensure that we are connected to the server by setting a value */
- rc= memcached_set(memc, key, strlen(key),
- value, strlen(value),
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
-
-
- instance= memcached_server_instance_by_position(memc, 0);
- /* The test is to see that the memcached_quit doesn't increase the
- * the server failure conter, so let's ensure that it is zero
- * before sending quit
- */
- ((memcached_server_write_instance_st)instance)->server_failure_counter= 0;
-
- memcached_quit(memc);
-
- /* Verify that it memcached_quit didn't increment the failure counter
- * Please note that this isn't bullet proof, because an error could
- * occur...
- */
- test_true(instance->server_failure_counter == 0);
-
- /* restore the instance */
- memc->number_of_hosts= number_of_hosts;
-
- return TEST_SUCCESS;
-}
-
-/*
- * This tests ensures expected disconnections (for some behavior changes
- * for instance) do not wrongly increase failure counter
- */
-static test_return_t wrong_failure_counter_two_test(memcached_st *memc)
-{
- memcached_return rc;
-
- memcached_st *memc_clone;
- memc_clone= memcached_clone(NULL, memc);
- test_true(memc_clone);
-
- /* Set value to force connection to the server */
- const char *key= "marmotte";
- const char *value= "milka";
- char *string = NULL;
- size_t string_length;
- uint32_t flags;
-
- rc= memcached_set(memc_clone, key, strlen(key),
- value, strlen(value),
- (time_t)0, (uint32_t)0);
- test_true_got(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc));
-
-
- /* put failure limit to 1 */
- rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 1);
- assert(rc == MEMCACHED_SUCCESS);
-
- /* Put a retry timeout to effectively activate failure_limit effect */
- rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 1);
- assert(rc == MEMCACHED_SUCCESS);
-
- /* change behavior that triggers memcached_quit()*/
- rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1);
- assert(rc == MEMCACHED_SUCCESS);
-
-
- /* Check if we still are connected */
- string= memcached_get(memc_clone, key, strlen(key),
- &string_length, &flags, &rc);
-
- test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
- test_true(string);
- free(string);
- memcached_free(memc_clone);
-
- return TEST_SUCCESS;
-}
-
-
-
-
-/*
- * Test that ensures mget_execute does not end into recursive calls that finally fails
- */
-static test_return_t regression_bug_490486(memcached_st *memc)
-{
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 1);
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, 1000);
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 1);
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 3600);
-
-#ifdef __APPLE__
- return TEST_SKIPPED; // My MAC can't handle this test
-#endif
-
- /*
- * I only want to hit _one_ server so I know the number of requests I'm
- * sending in the pipeline.
- */
- uint32_t number_of_hosts= memc->number_of_hosts;
- memc->number_of_hosts= 1;
- size_t max_keys= 20480;
-
-
- char **keys= calloc(max_keys, sizeof(char*));
- size_t *key_length=calloc(max_keys, sizeof(size_t));
-
- /* First add all of the items.. */
- bool slept= false;
- char blob[1024]= { 0 };
- memcached_return rc;
- for (size_t x= 0; x < max_keys; ++x)
- {
- char k[251];
- key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
- keys[x]= strdup(k);
- assert(keys[x] != NULL);
- rc= memcached_set(memc, keys[x], key_length[x], blob, sizeof(blob), 0, 0);
-#ifdef __APPLE__
- if (rc == MEMCACHED_SERVER_MARKED_DEAD)
- {
- break; // We are out of business
- }
-#endif
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED || rc == MEMCACHED_TIMEOUT); // MEMCACHED_TIMEOUT <-- only observed on OSX
-
- if (rc == MEMCACHED_TIMEOUT && slept == false)
- {
- x++;
- sleep(1);// We will try to sleep
- slept= true;
- }
- else if (rc == MEMCACHED_TIMEOUT && slept == true)
- {
- // We failed to send everything.
- break;
- }
- }
-
- if (rc != MEMCACHED_SERVER_MARKED_DEAD)
- {
-
- /* Try to get all of them with a large multiget */
- size_t counter= 0;
- memcached_execute_function callbacks[1]= { [0]= &callback_counter };
- rc= memcached_mget_execute(memc, (const char**)keys, key_length,
- (size_t)max_keys, callbacks, &counter, 1);
-
- assert(rc == MEMCACHED_SUCCESS);
- char* the_value= NULL;
- char the_key[MEMCACHED_MAX_KEY];
- size_t the_key_length;
- size_t the_value_length;
- uint32_t the_flags;
-
- do {
- the_value= memcached_fetch(memc, the_key, &the_key_length, &the_value_length, &the_flags, &rc);
-
- if ((the_value!= NULL) && (rc == MEMCACHED_SUCCESS))
- {
- ++counter;
- free(the_value);
- }
-
- } while ( (the_value!= NULL) && (rc == MEMCACHED_SUCCESS));
-
-
- assert(rc == MEMCACHED_END);
-
- /* Verify that we got all of the items */
- assert(counter == max_keys);
- }
-
- /* Release all allocated resources */
- for (size_t x= 0; x < max_keys; ++x)
- {
- free(keys[x]);
- }
- free(keys);
- free(key_length);
-
- memc->number_of_hosts= number_of_hosts;
-
- return TEST_SUCCESS;
-}
-
-static test_return_t regression_bug_583031(memcached_st *unused)
-{
- (void)unused;
-
- memcached_st *memc= memcached_create(NULL);
- assert(memc);
- memcached_server_add(memc, "10.2.3.4", 11211);
-
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, 1000);
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 1000);
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 1000);
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 1000);
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, 1000);
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 3);
-
- memcached_return_t rc;
- size_t length;
- uint32_t flags;
-
- (void)memcached_get(memc, "dsf", 3, &length, &flags, &rc);
-
- test_true_got(rc == MEMCACHED_TIMEOUT || rc == MEMCACHED_ERRNO || rc == MEMCACHED_FAILURE, memcached_strerror(memc, rc));
-
- memcached_free(memc);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t regression_bug_581030(memcached_st *unused)
-{
- (void)unused;
-
-#ifndef DEBUG
- memcached_stat_st *local_stat= memcached_stat(NULL, NULL, NULL);
- test_false(local_stat);
-
- memcached_stat_free(NULL, NULL);
-#endif
-
- return TEST_SUCCESS;
-}
-
-static void memcached_die(memcached_st* mc, memcached_return error, const char* what, uint32_t it)
-{
- fprintf(stderr, "Iteration #%u: ", it);
-
- if(error == MEMCACHED_ERRNO)
- {
- fprintf(stderr, "system error %d from %s: %s\n",
- errno, what, strerror(errno));
- }
- else
- {
- fprintf(stderr, "error %d from %s: %s\n", error, what,
- memcached_strerror(mc, error));
- }
-}
-
-#define TEST_CONSTANT_CREATION 200
-
-static test_return_t regression_bug_(memcached_st *memc)
-{
- const char *remote_server;
- (void)memc;
-
- if (! (remote_server= getenv("LIBMEMCACHED_REMOTE_SERVER")))
- {
- return TEST_SKIPPED;
- }
-
- for (uint32_t x= 0; x < TEST_CONSTANT_CREATION; x++)
- {
- memcached_st* mc= memcached_create(NULL);
- memcached_return rc;
-
- rc= memcached_behavior_set(mc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
- if (rc != MEMCACHED_SUCCESS)
- {
- memcached_die(mc, rc, "memcached_behavior_set", x);
- }
-
- rc= memcached_behavior_set(mc, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS, 1);
- if (rc != MEMCACHED_SUCCESS)
- {
- memcached_die(mc, rc, "memcached_behavior_set", x);
- }
-
- rc= memcached_server_add(mc, remote_server, 0);
- if (rc != MEMCACHED_SUCCESS)
- {
- memcached_die(mc, rc, "memcached_server_add", x);
- }
-
- const char *set_key= "akey";
- const size_t set_key_len= strlen(set_key);
- const char *set_value= "a value";
- const size_t set_value_len= strlen(set_value);
-
- if (rc == MEMCACHED_SUCCESS)
- {
- if (x > 0)
- {
- size_t get_value_len;
- char *get_value;
- uint32_t get_value_flags;
-
- get_value= memcached_get(mc, set_key, set_key_len, &get_value_len,
- &get_value_flags, &rc);
- if (rc != MEMCACHED_SUCCESS)
- {
- memcached_die(mc, rc, "memcached_get", x);
- }
- else
- {
-
- if (x != 0 &&
- (get_value_len != set_value_len
- || 0!=strncmp(get_value, set_value, get_value_len)))
- {
- fprintf(stderr, "Values don't match?\n");
- rc= MEMCACHED_FAILURE;
- }
- free(get_value);
- }
- }
-
- rc= memcached_set(mc,
- set_key, set_key_len,
- set_value, set_value_len,
- 0, /* time */
- 0 /* flags */
- );
- if (rc != MEMCACHED_SUCCESS)
- {
- memcached_die(mc, rc, "memcached_set", x);
- }
- }
-
- memcached_quit(mc);
- memcached_free(mc);
-
- if (rc != MEMCACHED_SUCCESS)
- {
- break;
- }
- }
-
- return TEST_SUCCESS;
-}
-
-/*
- * Test that the sasl authentication works. We cannot use the default
- * pool of servers, because that would require that all servers we want
- * to test supports SASL authentication, and that they use the default
- * creds.
- */
-static test_return_t sasl_auth_test(memcached_st *memc)
-{
-#ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
- memcached_return_t rc;
-
- rc= memcached_set(memc, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true((rc= memcached_delete(memc, "foo", 3, 0)) == MEMCACHED_SUCCESS);
- test_true((rc= memcached_destroy_sasl_auth_data(memc)) == MEMCACHED_SUCCESS);
- test_true((rc= memcached_destroy_sasl_auth_data(memc)) == MEMCACHED_FAILURE);
- test_true((rc= memcached_destroy_sasl_auth_data(NULL)) == MEMCACHED_FAILURE);
- memcached_quit(memc);
-
- rc= memcached_set_sasl_auth_data(memc,
- getenv("LIBMEMCACHED_TEST_SASL_USERNAME"),
- getenv("LIBMEMCACHED_TEST_SASL_SERVER"));
- test_true(rc == MEMCACHED_SUCCESS);
-
- rc= memcached_set(memc, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_AUTH_FAILURE);
- test_true(memcached_destroy_sasl_auth_data(memc) == MEMCACHED_SUCCESS);
-
- memcached_quit(memc);
- return TEST_SUCCESS;
-#else
- (void)memc;
- return TEST_FAILURE;
-#endif
-}
-
-/* Clean the server before beginning testing */
-test_st tests[] ={
- {"util_version", 1, (test_callback_fn)util_version_test },
- {"flush", 0, (test_callback_fn)flush_test },
- {"init", 0, (test_callback_fn)init_test },
- {"allocation", 0, (test_callback_fn)allocation_test },
- {"server_list_null_test", 0, (test_callback_fn)server_list_null_test},
- {"server_unsort", 0, (test_callback_fn)server_unsort_test},
- {"server_sort", 0, (test_callback_fn)server_sort_test},
- {"server_sort2", 0, (test_callback_fn)server_sort2_test},
- {"memcached_server_remove", 0, (test_callback_fn)memcached_server_remove_test},
- {"clone_test", 0, (test_callback_fn)clone_test },
- {"connection_test", 0, (test_callback_fn)connection_test},
- {"callback_test", 0, (test_callback_fn)callback_test},
- {"userdata_test", 0, (test_callback_fn)userdata_test},
- {"error", 0, (test_callback_fn)error_test },
- {"set", 0, (test_callback_fn)set_test },
- {"set2", 0, (test_callback_fn)set_test2 },
- {"set3", 0, (test_callback_fn)set_test3 },
- {"dump", 1, (test_callback_fn)dump_test},
- {"add", 1, (test_callback_fn)add_test },
- {"replace", 1, (test_callback_fn)replace_test },
- {"delete", 1, (test_callback_fn)delete_test },
- {"get", 1, (test_callback_fn)get_test },
- {"get2", 0, (test_callback_fn)get_test2 },
- {"get3", 0, (test_callback_fn)get_test3 },
- {"get4", 0, (test_callback_fn)get_test4 },
- {"partial mget", 0, (test_callback_fn)get_test5 },
- {"stats_servername", 0, (test_callback_fn)stats_servername_test },
- {"increment", 0, (test_callback_fn)increment_test },
- {"increment_with_initial", 1, (test_callback_fn)increment_with_initial_test },
- {"decrement", 0, (test_callback_fn)decrement_test },
- {"decrement_with_initial", 1, (test_callback_fn)decrement_with_initial_test },
- {"increment_by_key", 0, (test_callback_fn)increment_by_key_test },
- {"increment_with_initial_by_key", 1, (test_callback_fn)increment_with_initial_by_key_test },
- {"decrement_by_key", 0, (test_callback_fn)decrement_by_key_test },
- {"decrement_with_initial_by_key", 1, (test_callback_fn)decrement_with_initial_by_key_test },
- {"quit", 0, (test_callback_fn)quit_test },
- {"mget", 1, (test_callback_fn)mget_test },
- {"mget_result", 1, (test_callback_fn)mget_result_test },
- {"mget_result_alloc", 1, (test_callback_fn)mget_result_alloc_test },
- {"mget_result_function", 1, (test_callback_fn)mget_result_function },
- {"mget_execute", 1, (test_callback_fn)mget_execute },
- {"mget_end", 0, (test_callback_fn)mget_end },
- {"get_stats", 0, (test_callback_fn)get_stats },
- {"add_host_test", 0, (test_callback_fn)add_host_test },
- {"add_host_test_1", 0, (test_callback_fn)add_host_test1 },
- {"get_stats_keys", 0, (test_callback_fn)get_stats_keys },
- {"version_string_test", 0, (test_callback_fn)version_string_test},
- {"bad_key", 1, (test_callback_fn)bad_key_test },
- {"memcached_server_cursor", 1, (test_callback_fn)memcached_server_cursor_test },
- {"read_through", 1, (test_callback_fn)read_through },
- {"delete_through", 1, (test_callback_fn)delete_through },
- {"noreply", 1, (test_callback_fn)noreply_test},
- {"analyzer", 1, (test_callback_fn)analyzer_test},
- {"connectionpool", 1, (test_callback_fn)connection_pool_test },
- {"memcached_pool_test", 1, (test_callback_fn)memcached_pool_test },
- {"ping", 1, (test_callback_fn)ping_test },
- {"test_get_last_disconnect", 1, (test_callback_fn)test_get_last_disconnect},
- {"verbosity", 1, (test_callback_fn)test_verbosity},
- {"test_server_failure", 1, (test_callback_fn)test_server_failure},
- {"cull_servers", 1, (test_callback_fn)test_cull_servers},
- {"memcached_stat_execute", 1, (test_callback_fn)memcached_stat_execute_test},
- {0, 0, 0}
-};
-
-test_st behavior_tests[] ={
- {"behavior_test", 0, (test_callback_fn)behavior_test},
- {"MEMCACHED_BEHAVIOR_CORK", 0, (test_callback_fn)MEMCACHED_BEHAVIOR_CORK_test},
- {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", 0, (test_callback_fn)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test},
- {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", 0, (test_callback_fn)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test},
- {0, 0, 0}
-};
-
-test_st basic_tests[] ={
- {"init", 1, (test_callback_fn)basic_init_test},
- {"clone", 1, (test_callback_fn)basic_clone_test},
- {"reset", 1, (test_callback_fn)basic_reset_stack_test},
- {"reset heap", 1, (test_callback_fn)basic_reset_heap_test},
- {"reset stack clone", 1, (test_callback_fn)basic_reset_stack_clone_test},
- {"reset heap clone", 1, (test_callback_fn)basic_reset_heap_clone_test},
- {0, 0, 0}
-};
-
-test_st regression_binary_vs_block[] ={
- {"block add", 1, (test_callback_fn)block_add_regression},
- {"binary add", 1, (test_callback_fn)binary_add_regression},
- {0, 0, 0}
-};
-
-test_st async_tests[] ={
- {"add", 1, (test_callback_fn)add_wrapper },
- {0, 0, 0}
-};
-
-test_st string_tests[] ={
- {"string static with null", 0, (test_callback_fn)string_static_null },
- {"string alloc with null", 0, (test_callback_fn)string_alloc_null },
- {"string alloc with 1K", 0, (test_callback_fn)string_alloc_with_size },
- {"string alloc with malloc failure", 0, (test_callback_fn)string_alloc_with_size_toobig },
- {"string append", 0, (test_callback_fn)string_alloc_append },
- {"string append failure (too big)", 0, (test_callback_fn)string_alloc_append_toobig },
- {"string_alloc_append_multiple", 0, (test_callback_fn)string_alloc_append_multiple },
- {0, 0, (test_callback_fn)0}
-};
-
-test_st result_tests[] ={
- {"result static", 0, (test_callback_fn)result_static},
- {"result alloc", 0, (test_callback_fn)result_alloc},
- {0, 0, (test_callback_fn)0}
-};
-
-test_st version_1_2_3[] ={
- {"append", 0, (test_callback_fn)append_test },
- {"prepend", 0, (test_callback_fn)prepend_test },
- {"cas", 0, (test_callback_fn)cas_test },
- {"cas2", 0, (test_callback_fn)cas2_test },
- {"append_binary", 0, (test_callback_fn)append_binary_test },
- {0, 0, (test_callback_fn)0}
-};
-
-test_st user_tests[] ={
- {"user_supplied_bug1", 0, (test_callback_fn)user_supplied_bug1 },
- {"user_supplied_bug2", 0, (test_callback_fn)user_supplied_bug2 },
- {"user_supplied_bug3", 0, (test_callback_fn)user_supplied_bug3 },
- {"user_supplied_bug4", 0, (test_callback_fn)user_supplied_bug4 },
- {"user_supplied_bug5", 1, (test_callback_fn)user_supplied_bug5 },
- {"user_supplied_bug6", 1, (test_callback_fn)user_supplied_bug6 },
- {"user_supplied_bug7", 1, (test_callback_fn)user_supplied_bug7 },
- {"user_supplied_bug8", 1, (test_callback_fn)user_supplied_bug8 },
- {"user_supplied_bug9", 1, (test_callback_fn)user_supplied_bug9 },
- {"user_supplied_bug10", 1, (test_callback_fn)user_supplied_bug10 },
- {"user_supplied_bug11", 1, (test_callback_fn)user_supplied_bug11 },
- {"user_supplied_bug12", 1, (test_callback_fn)user_supplied_bug12 },
- {"user_supplied_bug13", 1, (test_callback_fn)user_supplied_bug13 },
- {"user_supplied_bug14", 1, (test_callback_fn)user_supplied_bug14 },
- {"user_supplied_bug15", 1, (test_callback_fn)user_supplied_bug15 },
- {"user_supplied_bug16", 1, (test_callback_fn)user_supplied_bug16 },
-#if !defined(__sun) && !defined(__OpenBSD__)
- /*
- ** It seems to be something weird with the character sets..
- ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
- ** guess I need to find out how this is supposed to work.. Perhaps I need
- ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
- ** so just disable the code for now...).
- */
- {"user_supplied_bug17", 1, (test_callback_fn)user_supplied_bug17 },
-#endif
- {"user_supplied_bug18", 1, (test_callback_fn)user_supplied_bug18 },
- {"user_supplied_bug19", 1, (test_callback_fn)user_supplied_bug19 },
- {"user_supplied_bug20", 1, (test_callback_fn)user_supplied_bug20 },
- {"user_supplied_bug21", 1, (test_callback_fn)user_supplied_bug21 },
- {"wrong_failure_counter_test", 1, (test_callback_fn)wrong_failure_counter_test},
- {"wrong_failure_counter_two_test", 1, (test_callback_fn)wrong_failure_counter_two_test},
- {0, 0, (test_callback_fn)0}
-};
-
-test_st replication_tests[]= {
- {"set", 1, (test_callback_fn)replication_set_test },
- {"get", 0, (test_callback_fn)replication_get_test },
- {"mget", 0, (test_callback_fn)replication_mget_test },
- {"delete", 0, (test_callback_fn)replication_delete_test },
- {"rand_mget", 0, (test_callback_fn)replication_randomize_mget_test },
- {0, 0, (test_callback_fn)0}
-};
-
-/*
- * The following test suite is used to verify that we don't introduce
- * regression bugs. If you want more information about the bug / test,
- * you should look in the bug report at
- * http://bugs.launchpad.net/libmemcached
- */
-test_st regression_tests[]= {
- {"lp:434484", 1, (test_callback_fn)regression_bug_434484 },
- {"lp:434843", 1, (test_callback_fn)regression_bug_434843 },
- {"lp:434843-buffered", 1, (test_callback_fn)regression_bug_434843_buffered },
- {"lp:421108", 1, (test_callback_fn)regression_bug_421108 },
- {"lp:442914", 1, (test_callback_fn)regression_bug_442914 },
- {"lp:447342", 1, (test_callback_fn)regression_bug_447342 },
- {"lp:463297", 1, (test_callback_fn)regression_bug_463297 },
- {"lp:490486", 1, (test_callback_fn)regression_bug_490486 },
- {"lp:583031", 1, (test_callback_fn)regression_bug_583031 },
- {"lp:?", 1, (test_callback_fn)regression_bug_ },
- {"lp:728286", 1, (test_callback_fn)regression_bug_728286 },
- {"lp:581030", 1, (test_callback_fn)regression_bug_581030 },
- {0, 0, (test_callback_fn)0}
-};
-
-test_st sasl_auth_tests[]= {
- {"sasl_auth", 1, (test_callback_fn)sasl_auth_test },
- {0, 0, (test_callback_fn)0}
-};
-
-test_st ketama_compatibility[]= {
- {"libmemcached", 1, (test_callback_fn)ketama_compatibility_libmemcached },
- {"spymemcached", 1, (test_callback_fn)ketama_compatibility_spymemcached },
- {0, 0, (test_callback_fn)0}
-};
-
-test_st generate_tests[] ={
- {"generate_pairs", 1, (test_callback_fn)generate_pairs },
- {"generate_data", 1, (test_callback_fn)generate_data },
- {"get_read", 0, (test_callback_fn)get_read },
- {"delete_generate", 0, (test_callback_fn)delete_generate },
- {"generate_buffer_data", 1, (test_callback_fn)generate_buffer_data },
- {"delete_buffer", 0, (test_callback_fn)delete_buffer_generate},
- {"generate_data", 1, (test_callback_fn)generate_data },
- {"mget_read", 0, (test_callback_fn)mget_read },
- {"mget_read_result", 0, (test_callback_fn)mget_read_result },
- {"mget_read_function", 0, (test_callback_fn)mget_read_function },
- {"cleanup", 1, (test_callback_fn)cleanup_pairs },
- {"generate_large_pairs", 1, (test_callback_fn)generate_large_pairs },
- {"generate_data", 1, (test_callback_fn)generate_data },
- {"generate_buffer_data", 1, (test_callback_fn)generate_buffer_data },
- {"cleanup", 1, (test_callback_fn)cleanup_pairs },
- {0, 0, (test_callback_fn)0}
-};
-
-test_st consistent_tests[] ={
- {"generate_pairs", 1, (test_callback_fn)generate_pairs },
- {"generate_data", 1, (test_callback_fn)generate_data },
- {"get_read", 0, (test_callback_fn)get_read_count },
- {"cleanup", 1, (test_callback_fn)cleanup_pairs },
- {0, 0, (test_callback_fn)0}
-};
-
-test_st consistent_weighted_tests[] ={
- {"generate_pairs", 1, (test_callback_fn)generate_pairs },
- {"generate_data", 1, (test_callback_fn)generate_data_with_stats },
- {"get_read", 0, (test_callback_fn)get_read_count },
- {"cleanup", 1, (test_callback_fn)cleanup_pairs },
- {0, 0, (test_callback_fn)0}
-};
-
-test_st hsieh_availability[] ={
- {"hsieh_avaibility_test", 0, (test_callback_fn)hsieh_avaibility_test},
- {0, 0, (test_callback_fn)0}
-};
-
-test_st murmur_availability[] ={
- {"murmur_avaibility_test", 0, (test_callback_fn)murmur_avaibility_test},
- {0, 0, (test_callback_fn)0}
-};
-
-#if 0
-test_st hash_sanity[] ={
- {"hash sanity", 0, (test_callback_fn)hash_sanity_test},
- {0, 0, (test_callback_fn)0}
-};
-#endif
-
-test_st ketama_auto_eject_hosts[] ={
- {"auto_eject_hosts", 1, (test_callback_fn)auto_eject_hosts },
- {"output_ketama_weighted_keys", 1, (test_callback_fn)output_ketama_weighted_keys },
- {0, 0, (test_callback_fn)0}
-};
-
-test_st hash_tests[] ={
- {"one_at_a_time_run", 0, (test_callback_fn)one_at_a_time_run },
- {"md5", 0, (test_callback_fn)md5_run },
- {"crc", 0, (test_callback_fn)crc_run },
- {"fnv1_64", 0, (test_callback_fn)fnv1_64_run },
- {"fnv1a_64", 0, (test_callback_fn)fnv1a_64_run },
- {"fnv1_32", 0, (test_callback_fn)fnv1_32_run },
- {"fnv1a_32", 0, (test_callback_fn)fnv1a_32_run },
- {"hsieh", 0, (test_callback_fn)hsieh_run },
- {"murmur", 0, (test_callback_fn)murmur_run },
- {"jenkis", 0, (test_callback_fn)jenkins_run },
- {"memcached_get_hashkit", 0, (test_callback_fn)memcached_get_hashkit_test },
- {0, 0, (test_callback_fn)0}
-};
-
-test_st error_conditions[] ={
- {"memcached_get(MEMCACHED_ERRNO)", 0, (test_callback_fn)memcached_get_MEMCACHED_ERRNO },
- {"memcached_get(MEMCACHED_NOTFOUND)", 0, (test_callback_fn)memcached_get_MEMCACHED_NOTFOUND },
- {"memcached_get_by_key(MEMCACHED_ERRNO)", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_ERRNO },
- {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_NOTFOUND },
- {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_NOTFOUND },
- {"memcached_increment(MEMCACHED_NO_SERVERS)", 0, (test_callback_fn)memcached_increment_MEMCACHED_NO_SERVERS },
- {0, 0, (test_callback_fn)0}
-};
-
-
-test_st parser_tests[] ={
- {"behavior", 0, (test_callback_fn)behavior_parser_test },
- {"boolean_options", 0, (test_callback_fn)parser_boolean_options_test },
- {"configure_file", 0, (test_callback_fn)memcached_create_with_options_with_filename },
- {"distribtions", 0, (test_callback_fn)parser_distribution_test },
- {"hash", 0, (test_callback_fn)parser_hash_test },
- {"libmemcached_check_configuration", 0, (test_callback_fn)libmemcached_check_configuration_test },
- {"libmemcached_check_configuration_with_filename", 0, (test_callback_fn)libmemcached_check_configuration_with_filename_test },
- {"number_options", 0, (test_callback_fn)parser_number_options_test },
- {"randomly generated options", 0, (test_callback_fn)random_statement_build_test },
- {"prefix_key", 0, (test_callback_fn)parser_key_prefix_test },
- {"server", 0, (test_callback_fn)server_test },
- {"bad server strings", 0, (test_callback_fn)servers_bad_test },
- {"server with weights", 0, (test_callback_fn)server_with_weight_test },
- {0, 0, (test_callback_fn)0}
-};
-
-test_st virtual_bucket_tests[] ={
- {"basic", 0, (test_callback_fn)virtual_back_map },
- {0, 0, (test_callback_fn)0}
-};
-
-collection_st collection[] ={
-#if 0
- {"hash_sanity", 0, 0, hash_sanity},
-#endif
- {"basic", 0, 0, basic_tests},
- {"hsieh_availability", 0, 0, hsieh_availability},
- {"murmur_availability", 0, 0, murmur_availability},
- {"block", 0, 0, tests},
- {"binary", (test_callback_fn)pre_binary, 0, tests},
- {"nonblock", (test_callback_fn)pre_nonblock, 0, tests},
- {"nodelay", (test_callback_fn)pre_nodelay, 0, tests},
- {"settimer", (test_callback_fn)pre_settimer, 0, tests},
- {"md5", (test_callback_fn)pre_md5, 0, tests},
- {"crc", (test_callback_fn)pre_crc, 0, tests},
- {"hsieh", (test_callback_fn)pre_hsieh, 0, tests},
- {"jenkins", (test_callback_fn)pre_jenkins, 0, tests},
- {"fnv1_64", (test_callback_fn)pre_hash_fnv1_64, 0, tests},
- {"fnv1a_64", (test_callback_fn)pre_hash_fnv1a_64, 0, tests},
- {"fnv1_32", (test_callback_fn)pre_hash_fnv1_32, 0, tests},
- {"fnv1a_32", (test_callback_fn)pre_hash_fnv1a_32, 0, tests},
- {"ketama", (test_callback_fn)pre_behavior_ketama, 0, tests},
- {"ketama_auto_eject_hosts", (test_callback_fn)pre_behavior_ketama, 0, ketama_auto_eject_hosts},
- {"unix_socket", (test_callback_fn)pre_unix_socket, 0, tests},
- {"unix_socket_nodelay", (test_callback_fn)pre_nodelay, 0, tests},
- {"poll_timeout", (test_callback_fn)poll_timeout, 0, tests},
- {"gets", (test_callback_fn)enable_cas, 0, tests},
- {"consistent_crc", (test_callback_fn)enable_consistent_crc, 0, tests},
- {"consistent_hsieh", (test_callback_fn)enable_consistent_hsieh, 0, tests},
-#ifdef MEMCACHED_ENABLE_DEPRECATED
- {"deprecated_memory_allocators", (test_callback_fn)deprecated_set_memory_alloc, 0, tests},
-#endif
- {"memory_allocators", (test_callback_fn)set_memory_alloc, 0, tests},
- {"prefix", (test_callback_fn)set_prefix, 0, tests},
- {"sasl_auth", (test_callback_fn)pre_sasl, 0, sasl_auth_tests },
- {"sasl", (test_callback_fn)pre_sasl, 0, tests },
- {"version_1_2_3", (test_callback_fn)check_for_1_2_3, 0, version_1_2_3},
- {"string", 0, 0, string_tests},
- {"result", 0, 0, result_tests},
- {"async", (test_callback_fn)pre_nonblock, 0, async_tests},
- {"async_binary", (test_callback_fn)pre_nonblock_binary, 0, async_tests},
- {"user", 0, 0, user_tests},
- {"generate", 0, 0, generate_tests},
- {"generate_hsieh", (test_callback_fn)pre_hsieh, 0, generate_tests},
- {"generate_ketama", (test_callback_fn)pre_behavior_ketama, 0, generate_tests},
- {"generate_hsieh_consistent", (test_callback_fn)enable_consistent_hsieh, 0, generate_tests},
- {"generate_md5", (test_callback_fn)pre_md5, 0, generate_tests},
- {"generate_murmur", (test_callback_fn)pre_murmur, 0, generate_tests},
- {"generate_jenkins", (test_callback_fn)pre_jenkins, 0, generate_tests},
- {"generate_nonblock", (test_callback_fn)pre_nonblock, 0, generate_tests},
- // Too slow
- {"generate_corked", (test_callback_fn)pre_cork, 0, generate_tests},
- {"generate_corked_and_nonblock", (test_callback_fn)pre_cork_and_nonblock, 0, generate_tests},
- {"consistent_not", 0, 0, consistent_tests},
- {"consistent_ketama", (test_callback_fn)pre_behavior_ketama, 0, consistent_tests},
- {"consistent_ketama_weighted", (test_callback_fn)pre_behavior_ketama_weighted, 0, consistent_weighted_tests},
- {"ketama_compat", 0, 0, ketama_compatibility},
- {"test_hashes", 0, 0, hash_tests},
- {"replication", (test_callback_fn)pre_replication, 0, replication_tests},
- {"replication_noblock", (test_callback_fn)pre_replication_noblock, 0, replication_tests},
- {"regression", 0, 0, regression_tests},
- {"behaviors", 0, 0, behavior_tests},
- {"regression_binary_vs_block", (test_callback_fn)key_setup, (test_callback_fn)key_teardown, regression_binary_vs_block},
- {"error_conditions", 0, 0, error_conditions},
- {"parser", 0, 0, parser_tests},
- {"virtual buckets", 0, 0, virtual_bucket_tests},
- {0, 0, 0, 0}
-};
-
-#include "tests/libmemcached_world.h"
-
-void get_world(world_st *world)
-{
- world->collections= collection;
-
- world->create= (test_callback_create_fn)world_create;
- world->destroy= (test_callback_fn)world_destroy;
-
- world->test.startup= (test_callback_fn)world_test_startup;
- world->test.flush= (test_callback_fn)world_flush;
- world->test.pre_run= (test_callback_fn)world_pre_run;
- world->test.post_run= (test_callback_fn)world_post_run;
- world->test.on_error= (test_callback_error_fn)world_on_error;
-
- world->collection.startup= (test_callback_fn)world_container_startup;
- world->collection.shutdown= (test_callback_fn)world_container_shutdown;
-
- world->runner= &defualt_libmemcached_runner;
-}
--- /dev/null
+/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ * Libmemcached library
+ *
+ * Copyright (C) 2011 Data Differential, http://datadifferential.com/
+ * Copyright (C) 2006-2009 Brian Aker All rights reserved.
+ *
+ * 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.
+ *
+ */
+
+
+/*
+ Test cases
+*/
+
+#define BUILDING_LIBMEMCACHED
+// !NEVER use common.h, always use memcached.h in your own apps
+#include <libmemcached/common.h>
+
+#include <stdint.h>
+
+#include <cassert>
+#include <memory>
+#include <signal.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <libtest/server.h>
+
+#include "clients/generator.h"
+#include "clients/execute.h"
+
+#define SMALL_STRING_LEN 1024
+
+#include <libtest/test.h>
+#include "tests/deprecated.h"
+#include "tests/parser.h"
+#include "tests/pool.h"
+#include "tests/string.h"
+#include "tests/replication.h"
+#include "tests/basic.h"
+#include "tests/error_conditions.h"
+#include "tests/print.h"
+#include "tests/virtual_buckets.h"
+
+
+#ifdef HAVE_LIBMEMCACHEDUTIL
+#include <pthread.h>
+#include "libmemcached/memcached_util.h"
+#endif
+
+#include "hash_results.h"
+
+#define GLOBAL_COUNT 10000
+#define GLOBAL2_COUNT 100
+#define SERVERS_TO_CREATE 5
+static uint32_t global_count;
+
+static pairs_st *global_pairs;
+static const char *global_keys[GLOBAL_COUNT];
+static size_t global_keys_length[GLOBAL_COUNT];
+
+// Prototype
+static test_return_t pre_binary(memcached_st *memc);
+
+
+static test_return_t init_test(memcached_st *not_used)
+{
+ memcached_st memc;
+ (void)not_used;
+
+ (void)memcached_create(&memc);
+ memcached_free(&memc);
+
+ return TEST_SUCCESS;
+}
+
+#define TEST_PORT_COUNT 7
+in_port_t test_ports[TEST_PORT_COUNT];
+
+static memcached_return_t server_display_function(const memcached_st *ptr,
+ const memcached_server_st *server,
+ void *context)
+{
+ /* Do Nothing */
+ size_t bigger= *((size_t *)(context));
+ (void)ptr;
+ assert(bigger <= memcached_server_port(server));
+ *((size_t *)(context))= memcached_server_port(server);
+
+ return MEMCACHED_SUCCESS;
+}
+
+static memcached_return_t dump_server_information(const memcached_st *ptr,
+ const memcached_server_st *instance,
+ void *context)
+{
+ /* Do Nothing */
+ FILE *stream= (FILE *)context;
+ (void)ptr;
+
+ fprintf(stream, "Memcached Server: %s %u Version %u.%u.%u\n",
+ memcached_server_name(instance),
+ memcached_server_port(instance),
+ instance->major_version,
+ instance->minor_version,
+ instance->micro_version);
+
+ return MEMCACHED_SUCCESS;
+}
+
+static test_return_t server_sort_test(memcached_st *ptr)
+{
+ size_t bigger= 0; /* Prime the value for the test_true in server_display_function */
+
+ memcached_return_t rc;
+ memcached_server_fn callbacks[1];
+ memcached_st *local_memc;
+ (void)ptr;
+
+ local_memc= memcached_create(NULL);
+ test_true(local_memc);
+ memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SORT_HOSTS, 1);
+
+ for (size_t x= 0; x < TEST_PORT_COUNT; x++)
+ {
+ test_ports[x]= (in_port_t)random() % 64000;
+ rc= memcached_server_add_with_weight(local_memc, "localhost", test_ports[x], 0);
+ test_true(memcached_server_count(local_memc) == x + 1);
+#if 0 // Rewrite
+ test_true(memcached_server_list_count(memcached_server_list(local_memc)) == x+1);
+#endif
+ test_true(rc == MEMCACHED_SUCCESS);
+ }
+
+ callbacks[0]= server_display_function;
+ memcached_server_cursor(local_memc, callbacks, (void *)&bigger, 1);
+
+
+ memcached_free(local_memc);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t server_sort2_test(memcached_st *ptr)
+{
+ size_t bigger= 0; /* Prime the value for the test_true in server_display_function */
+ memcached_return_t rc;
+ memcached_server_fn callbacks[1];
+ memcached_st *local_memc;
+ memcached_server_instance_st instance;
+ (void)ptr;
+
+ local_memc= memcached_create(NULL);
+ test_true(local_memc);
+ rc= memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SORT_HOSTS, 1);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ rc= memcached_server_add_with_weight(local_memc, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0);
+ test_true(rc == MEMCACHED_SUCCESS);
+ instance= memcached_server_instance_by_position(local_memc, 0);
+ test_true(memcached_server_port(instance) == 43043);
+
+ rc= memcached_server_add_with_weight(local_memc, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ instance= memcached_server_instance_by_position(local_memc, 0);
+ test_true(memcached_server_port(instance) == 43042);
+
+ instance= memcached_server_instance_by_position(local_memc, 1);
+ test_true(memcached_server_port(instance) == 43043);
+
+ callbacks[0]= server_display_function;
+ memcached_server_cursor(local_memc, callbacks, (void *)&bigger, 1);
+
+
+ memcached_free(local_memc);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t memcached_server_remove_test(memcached_st*)
+{
+ const char *server_string= "--server=localhost:4444 --server=localhost:4445 --server=localhost:4446 --server=localhost:4447 --server=localhost --server=memcache1.memcache.bk.sapo.pt:11211 --server=memcache1.memcache.bk.sapo.pt:11212 --server=memcache1.memcache.bk.sapo.pt:11213 --server=memcache1.memcache.bk.sapo.pt:11214 --server=memcache2.memcache.bk.sapo.pt:11211 --server=memcache2.memcache.bk.sapo.pt:11212 --server=memcache2.memcache.bk.sapo.pt:11213 --server=memcache2.memcache.bk.sapo.pt:11214";
+ char buffer[BUFSIZ];
+
+ memcached_return_t rc;
+ test_compare_got(MEMCACHED_SUCCESS,
+ rc= libmemcached_check_configuration(server_string, strlen(server_string), buffer, sizeof(buffer)),
+ memcached_strerror(NULL, rc));
+ memcached_st *memc= memcached(server_string, strlen(server_string));
+ test_true(memc);
+
+ memcached_server_fn callbacks[1];
+ callbacks[0]= server_print_callback;
+ memcached_server_cursor(memc, callbacks, NULL, 1);
+
+ memcached_free(memc);
+
+ return TEST_SUCCESS;
+}
+
+static memcached_return_t server_display_unsort_function(const memcached_st*,
+ const memcached_server_st *server,
+ void *context)
+{
+ /* Do Nothing */
+ uint32_t x= *((uint32_t *)(context));
+
+ if (! (test_ports[x] == server->port))
+ {
+ fprintf(stderr, "%lu -> %lu\n", (unsigned long)test_ports[x], (unsigned long)server->port);
+ return MEMCACHED_FAILURE;
+ }
+
+ *((uint32_t *)(context))= ++x;
+
+ return MEMCACHED_SUCCESS;
+}
+
+static test_return_t server_unsort_test(memcached_st *ptr)
+{
+ size_t counter= 0; /* Prime the value for the test_true in server_display_function */
+ size_t bigger= 0; /* Prime the value for the test_true in server_display_function */
+ memcached_return_t rc;
+ memcached_server_fn callbacks[1];
+ memcached_st *local_memc;
+ (void)ptr;
+
+ local_memc= memcached_create(NULL);
+ test_true(local_memc);
+
+ for (size_t x= 0; x < TEST_PORT_COUNT; x++)
+ {
+ test_ports[x]= (in_port_t)(random() % 64000);
+ rc= memcached_server_add_with_weight(local_memc, "localhost", test_ports[x], 0);
+ test_true(memcached_server_count(local_memc) == x+1);
+#if 0 // Rewrite
+ test_true(memcached_server_list_count(memcached_server_list(local_memc)) == x+1);
+#endif
+ test_true(rc == MEMCACHED_SUCCESS);
+ }
+
+ callbacks[0]= server_display_unsort_function;
+ memcached_server_cursor(local_memc, callbacks, (void *)&counter, 1);
+
+ /* Now we sort old data! */
+ memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SORT_HOSTS, 1);
+ callbacks[0]= server_display_function;
+ memcached_server_cursor(local_memc, callbacks, (void *)&bigger, 1);
+
+
+ memcached_free(local_memc);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t allocation_test(memcached_st *not_used)
+{
+ (void)not_used;
+ memcached_st *memc;
+ memc= memcached_create(NULL);
+ test_true(memc);
+ memcached_free(memc);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t clone_test(memcached_st *memc)
+{
+ /* All null? */
+ {
+ memcached_st *memc_clone;
+ memc_clone= memcached_clone(NULL, NULL);
+ test_true(memc_clone);
+ memcached_free(memc_clone);
+ }
+
+ /* Can we init from null? */
+ {
+ memcached_st *memc_clone;
+ memc_clone= memcached_clone(NULL, memc);
+ test_true(memc_clone);
+
+ { // Test allocators
+ test_true(memc_clone->allocators.free == memc->allocators.free);
+ test_true(memc_clone->allocators.malloc == memc->allocators.malloc);
+ test_true(memc_clone->allocators.realloc == memc->allocators.realloc);
+ test_true(memc_clone->allocators.calloc == memc->allocators.calloc);
+ }
+
+ test_true(memc_clone->connect_timeout == memc->connect_timeout);
+ test_true(memc_clone->delete_trigger == memc->delete_trigger);
+ test_true(memc_clone->distribution == memc->distribution);
+ { // Test all of the flags
+ test_true(memc_clone->flags.no_block == memc->flags.no_block);
+ test_true(memc_clone->flags.tcp_nodelay == memc->flags.tcp_nodelay);
+ test_true(memc_clone->flags.support_cas == memc->flags.support_cas);
+ test_true(memc_clone->flags.buffer_requests == memc->flags.buffer_requests);
+ test_true(memc_clone->flags.use_sort_hosts == memc->flags.use_sort_hosts);
+ test_true(memc_clone->flags.verify_key == memc->flags.verify_key);
+ test_true(memc_clone->ketama.weighted == memc->ketama.weighted);
+ test_true(memc_clone->flags.binary_protocol == memc->flags.binary_protocol);
+ test_true(memc_clone->flags.hash_with_prefix_key == memc->flags.hash_with_prefix_key);
+ test_true(memc_clone->flags.no_reply == memc->flags.no_reply);
+ test_true(memc_clone->flags.use_udp == memc->flags.use_udp);
+ test_true(memc_clone->flags.auto_eject_hosts == memc->flags.auto_eject_hosts);
+ test_true(memc_clone->flags.randomize_replica_read == memc->flags.randomize_replica_read);
+ }
+ test_true(memc_clone->get_key_failure == memc->get_key_failure);
+ test_true(hashkit_compare(&memc_clone->hashkit, &memc->hashkit));
+ test_true(memc_clone->io_bytes_watermark == memc->io_bytes_watermark);
+ test_true(memc_clone->io_msg_watermark == memc->io_msg_watermark);
+ test_true(memc_clone->io_key_prefetch == memc->io_key_prefetch);
+ test_true(memc_clone->on_cleanup == memc->on_cleanup);
+ test_true(memc_clone->on_clone == memc->on_clone);
+ test_true(memc_clone->poll_timeout == memc->poll_timeout);
+ test_true(memc_clone->rcv_timeout == memc->rcv_timeout);
+ test_true(memc_clone->recv_size == memc->recv_size);
+ test_true(memc_clone->retry_timeout == memc->retry_timeout);
+ test_true(memc_clone->send_size == memc->send_size);
+ test_true(memc_clone->server_failure_limit == memc->server_failure_limit);
+ test_true(memc_clone->snd_timeout == memc->snd_timeout);
+ test_true(memc_clone->user_data == memc->user_data);
+
+ memcached_free(memc_clone);
+ }
+
+ /* Can we init from struct? */
+ {
+ memcached_st declared_clone;
+ memcached_st *memc_clone;
+ memset(&declared_clone, 0 , sizeof(memcached_st));
+ memc_clone= memcached_clone(&declared_clone, NULL);
+ test_true(memc_clone);
+ memcached_free(memc_clone);
+ }
+
+ /* Can we init from struct? */
+ {
+ memcached_st declared_clone;
+ memcached_st *memc_clone;
+ memset(&declared_clone, 0 , sizeof(memcached_st));
+ memc_clone= memcached_clone(&declared_clone, memc);
+ test_true(memc_clone);
+ memcached_free(memc_clone);
+ }
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t userdata_test(memcached_st *memc)
+{
+ void* foo= NULL;
+ test_true(memcached_set_user_data(memc, foo) == NULL);
+ test_true(memcached_get_user_data(memc) == foo);
+ test_true(memcached_set_user_data(memc, NULL) == foo);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t connection_test(memcached_st *memc)
+{
+ memcached_return_t rc;
+
+ rc= memcached_server_add_with_weight(memc, "localhost", 0, 0);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t error_test(memcached_st *memc)
+{
+ uint32_t values[] = { 851992627U, 2337886783U, 646418395U, 4001849190U,
+ 982370485U, 1263635348U, 4242906218U, 3829656100U,
+ 1891735253U, 334139633U, 2257084983U, 3088286104U,
+ 13199785U, 2542027183U, 1097051614U, 199566778U,
+ 2748246961U, 2465192557U, 1664094137U, 2405439045U,
+ 1842224848U, 692413798U, 3479807801U, 919913813U,
+ 4269430871U, 610793021U, 527273862U, 1437122909U,
+ 2300930706U, 2943759320U, 674306647U, 2400528935U,
+ 54481931U, 4186304426U, 1741088401U, 2979625118U,
+ 4159057246U, 3425930182U, 2593724503U, 1868899624U,
+ 1769812374U, 2302537950U, 1110330676U, 3365377466U,
+ 1336171666U, 3021258493U, 3365377466U };
+
+ // You have updated the memcache_error messages but not updated docs/tests.
+ for (int rc= int(MEMCACHED_SUCCESS); rc < int(MEMCACHED_MAXIMUM_RETURN); ++rc)
+ {
+ uint32_t hash_val;
+ const char *msg= memcached_strerror(memc, memcached_return_t(rc));
+ hash_val= memcached_generate_hash_value(msg, strlen(msg),
+ MEMCACHED_HASH_JENKINS);
+ if (values[rc] != hash_val)
+ {
+ fprintf(stderr, "\n\nYou have updated memcached_return_t without updating the error_test\n");
+ fprintf(stderr, "%u, %s, (%u)\n\n", (uint32_t)rc, memcached_strerror(memc, memcached_return_t(rc)), hash_val);
+ }
+ test_true(values[rc] == hash_val);
+ }
+ test_true(MEMCACHED_MAXIMUM_RETURN == 46);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t set_test(memcached_st *memc)
+{
+ memcached_return_t rc= memcached_set(memc,
+ memcached_literal_param("foo"),
+ memcached_literal_param("when we sanitize"),
+ time_t(0), (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t append_test(memcached_st *memc)
+{
+ memcached_return_t rc;
+ const char *key= "fig";
+ const char *in_value= "we";
+ char *out_value= NULL;
+ size_t value_length;
+ uint32_t flags;
+
+ rc= memcached_flush(memc, 0);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ rc= memcached_set(memc, key, strlen(key),
+ in_value, strlen(in_value),
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ rc= memcached_append(memc, key, strlen(key),
+ " the", strlen(" the"),
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ rc= memcached_append(memc, key, strlen(key),
+ " people", strlen(" people"),
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ out_value= memcached_get(memc, key, strlen(key),
+ &value_length, &flags, &rc);
+ test_true(!memcmp(out_value, "we the people", strlen("we the people")));
+ test_true(strlen("we the people") == value_length);
+ test_true(rc == MEMCACHED_SUCCESS);
+ free(out_value);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t append_binary_test(memcached_st *memc)
+{
+ memcached_return_t rc;
+ const char *key= "numbers";
+ uint32_t store_list[] = { 23, 56, 499, 98, 32847, 0 };
+ uint32_t *value;
+ size_t value_length;
+ uint32_t flags;
+ uint32_t x;
+
+ rc= memcached_flush(memc, 0);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ rc= memcached_set(memc,
+ key, strlen(key),
+ NULL, 0,
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ for (x= 0; store_list[x] ; x++)
+ {
+ rc= memcached_append(memc,
+ key, strlen(key),
+ (char *)&store_list[x], sizeof(uint32_t),
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS);
+ }
+
+ value= (uint32_t *)memcached_get(memc, key, strlen(key),
+ &value_length, &flags, &rc);
+ test_true((value_length == (sizeof(uint32_t) * x)));
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ for (uint32_t counter= x, *ptr= value; counter; counter--)
+ {
+ test_true(*ptr == store_list[x - counter]);
+ ptr++;
+ }
+ free(value);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t cas2_test(memcached_st *memc)
+{
+ memcached_return_t rc;
+ const char *keys[]= {"fudge", "son", "food"};
+ size_t key_length[]= {5, 3, 4};
+ const char *value= "we the people";
+ size_t value_length= strlen("we the people");
+ unsigned int x;
+ memcached_result_st results_obj;
+ memcached_result_st *results;
+ unsigned int set= 1;
+
+ rc= memcached_flush(memc, 0);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
+
+ for (x= 0; x < 3; x++)
+ {
+ rc= memcached_set(memc, keys[x], key_length[x],
+ keys[x], key_length[x],
+ (time_t)50, (uint32_t)9);
+ test_true(rc == MEMCACHED_SUCCESS);
+ }
+
+ rc= memcached_mget(memc, keys, key_length, 3);
+
+ results= memcached_result_create(memc, &results_obj);
+
+ results= memcached_fetch_result(memc, &results_obj, &rc);
+ test_true(results);
+ test_true(results->item_cas);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(memcached_result_cas(results));
+
+ test_true(!memcmp(value, "we the people", strlen("we the people")));
+ test_true(strlen("we the people") == value_length);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ memcached_result_free(&results_obj);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t cas_test(memcached_st *memc)
+{
+ memcached_return_t rc;
+ const char *key= "fun";
+ size_t key_length= strlen(key);
+ const char *value= "we the people";
+ const char* keys[2] = { key, NULL };
+ size_t keylengths[2] = { strlen(key), 0 };
+ size_t value_length= strlen(value);
+ const char *value2= "change the value";
+ size_t value2_length= strlen(value2);
+
+ memcached_result_st results_obj;
+ memcached_result_st *results;
+ unsigned int set= 1;
+
+ rc= memcached_flush(memc, 0);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
+
+ rc= memcached_set(memc, key, strlen(key),
+ value, strlen(value),
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ rc= memcached_mget(memc, keys, keylengths, 1);
+
+ results= memcached_result_create(memc, &results_obj);
+
+ results= memcached_fetch_result(memc, &results_obj, &rc);
+ test_true(results);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(memcached_result_cas(results));
+ test_true(!memcmp(value, memcached_result_value(results), value_length));
+ test_true(strlen(memcached_result_value(results)) == value_length);
+ test_true(rc == MEMCACHED_SUCCESS);
+ uint64_t cas = memcached_result_cas(results);
+
+#if 0
+ results= memcached_fetch_result(memc, &results_obj, &rc);
+ test_true(rc == MEMCACHED_END);
+ test_true(results == NULL);
+#endif
+
+ rc= memcached_cas(memc, key, key_length, value2, value2_length, 0, 0, cas);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ /*
+ * The item will have a new cas value, so try to set it again with the old
+ * value. This should fail!
+ */
+ rc= memcached_cas(memc, key, key_length, value2, value2_length, 0, 0, cas);
+ test_true(rc == MEMCACHED_DATA_EXISTS);
+
+ memcached_result_free(&results_obj);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t prepend_test(memcached_st *memc)
+{
+ memcached_return_t rc;
+ const char *key= "fig";
+ const char *value= "people";
+ char *out_value= NULL;
+ size_t value_length;
+ uint32_t flags;
+
+ rc= memcached_flush(memc, 0);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ rc= memcached_set(memc, key, strlen(key),
+ value, strlen(value),
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ rc= memcached_prepend(memc, key, strlen(key),
+ "the ", strlen("the "),
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ rc= memcached_prepend(memc, key, strlen(key),
+ "we ", strlen("we "),
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ out_value= memcached_get(memc, key, strlen(key),
+ &value_length, &flags, &rc);
+ test_true(!memcmp(out_value, "we the people", strlen("we the people")));
+ test_true(strlen("we the people") == value_length);
+ test_true(rc == MEMCACHED_SUCCESS);
+ free(out_value);
+
+ return TEST_SUCCESS;
+}
+
+/*
+ Set the value, then quit to make sure it is flushed.
+ Come back in and test that add fails.
+*/
+static test_return_t add_test(memcached_st *memc)
+{
+ memcached_return_t rc;
+ const char *key= "foo";
+ const char *value= "when we sanitize";
+ unsigned long long setting_value;
+
+ setting_value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
+
+ rc= memcached_set(memc, key, strlen(key),
+ value, strlen(value),
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ memcached_quit(memc);
+ rc= memcached_add(memc, key, strlen(key),
+ value, strlen(value),
+ (time_t)0, (uint32_t)0);
+
+ /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
+ if (setting_value)
+ {
+ test_true(rc == MEMCACHED_NOTSTORED || rc == MEMCACHED_STORED);
+ }
+ else
+ {
+ test_true(rc == MEMCACHED_NOTSTORED || rc == MEMCACHED_DATA_EXISTS);
+ }
+
+ return TEST_SUCCESS;
+}
+
+/*
+** There was a problem of leaking filedescriptors in the initial release
+** of MacOSX 10.5. This test case triggers the problem. On some Solaris
+** systems it seems that the kernel is slow on reclaiming the resources
+** because the connects starts to time out (the test doesn't do much
+** anyway, so just loop 10 iterations)
+*/
+static test_return_t add_wrapper(memcached_st *memc)
+{
+ unsigned int max= 10000;
+#ifdef __sun
+ max= 10;
+#endif
+#ifdef __APPLE__
+ max= 10;
+#endif
+
+ for (uint32_t x= 0; x < max; x++)
+ add_test(memc);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t replace_test(memcached_st *memc)
+{
+ memcached_return_t rc;
+ const char *key= "foo";
+ const char *value= "when we sanitize";
+ const char *original= "first we insert some data";
+
+ rc= memcached_set(memc, key, strlen(key),
+ original, strlen(original),
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+
+ rc= memcached_replace(memc, key, strlen(key),
+ value, strlen(value),
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t delete_test(memcached_st *memc)
+{
+ memcached_return_t rc;
+ const char *key= "foo";
+ const char *value= "when we sanitize";
+
+ rc= memcached_set(memc, key, strlen(key),
+ value, strlen(value),
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+
+ rc= memcached_delete(memc, key, strlen(key), (time_t)0);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t flush_test(memcached_st *memc)
+{
+ memcached_return_t rc;
+
+ uint64_t query_id= memcached_query_id(memc);
+ rc= memcached_flush(memc, 0);
+ test_compare(rc, MEMCACHED_SUCCESS);
+ test_compare(query_id +1, memcached_query_id(memc));
+
+ return TEST_SUCCESS;
+}
+
+static memcached_return_t server_function(const memcached_st *ptr,
+ const memcached_server_st *server,
+ void *context)
+{
+ (void)ptr; (void)server; (void)context;
+ /* Do Nothing */
+
+ return MEMCACHED_SUCCESS;
+}
+
+static test_return_t memcached_server_cursor_test(memcached_st *memc)
+{
+ char context[10];
+ strncpy(context, "foo bad", sizeof(context));
+ memcached_server_fn callbacks[1];
+
+ callbacks[0]= server_function;
+ memcached_server_cursor(memc, callbacks, context, 1);
+ return TEST_SUCCESS;
+}
+
+static test_return_t bad_key_test(memcached_st *memc)
+{
+ memcached_return_t rc;
+ const char *key= "foo bad";
+ char *string;
+ size_t string_length;
+ uint32_t flags;
+ memcached_st *memc_clone;
+ unsigned int set= 1;
+ size_t max_keylen= 0xffff;
+
+ // Just skip if we are in binary mode.
+ uint64_t query_id= memcached_query_id(memc);
+ if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL))
+ return TEST_SKIPPED;
+ test_compare(query_id, memcached_query_id(memc)); // We should not increase the query_id for memcached_behavior_get()
+
+ memc_clone= memcached_clone(NULL, memc);
+ test_true(memc_clone);
+
+ query_id= memcached_query_id(memc_clone);
+ rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_compare(query_id, memcached_query_id(memc_clone)); // We should not increase the query_id for memcached_behavior_set()
+
+ /* All keys are valid in the binary protocol (except for length) */
+ if (memcached_behavior_get(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 0)
+ {
+ query_id= memcached_query_id(memc_clone);
+ string= memcached_get(memc_clone, key, strlen(key),
+ &string_length, &flags, &rc);
+ test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
+ test_true(string_length == 0);
+ test_true(!string);
+
+ set= 0;
+ query_id= memcached_query_id(memc_clone);
+ rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
+ test_compare(query_id, memcached_query_id(memc_clone)); // We should not increase the query_id for memcached_behavior_set()
+ test_true(rc == MEMCACHED_SUCCESS);
+ string= memcached_get(memc_clone, key, strlen(key),
+ &string_length, &flags, &rc);
+ test_true(rc == MEMCACHED_NOTFOUND);
+ test_true(string_length == 0);
+ test_true(!string);
+
+ /* Test multi key for bad keys */
+ const char *keys[] = { "GoodKey", "Bad Key", "NotMine" };
+ size_t key_lengths[] = { 7, 7, 7 };
+ set= 1;
+ query_id= memcached_query_id(memc_clone);
+ rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_compare(query_id, memcached_query_id(memc_clone));
+
+ query_id= memcached_query_id(memc_clone);
+ rc= memcached_mget(memc_clone, keys, key_lengths, 3);
+ test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
+ test_compare(query_id +1, memcached_query_id(memc_clone));
+
+ query_id= memcached_query_id(memc_clone);
+ rc= memcached_mget_by_key(memc_clone, "foo daddy", 9, keys, key_lengths, 1);
+ test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
+ test_compare(query_id +1, memcached_query_id(memc_clone));
+
+ max_keylen= 250;
+
+ /* The following test should be moved to the end of this function when the
+ memcached server is updated to allow max size length of the keys in the
+ binary protocol
+ */
+ rc= memcached_callback_set(memc_clone, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ char *longkey= (char *)malloc(max_keylen + 1);
+ if (longkey != NULL)
+ {
+ memset(longkey, 'a', max_keylen + 1);
+ string= memcached_get(memc_clone, longkey, max_keylen,
+ &string_length, &flags, &rc);
+ test_true(rc == MEMCACHED_NOTFOUND);
+ test_true(string_length == 0);
+ test_true(!string);
+
+ string= memcached_get(memc_clone, longkey, max_keylen + 1,
+ &string_length, &flags, &rc);
+ test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
+ test_true(string_length == 0);
+ test_true(!string);
+
+ free(longkey);
+ }
+ }
+
+ /* Make sure zero length keys are marked as bad */
+ set= 1;
+ rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
+ test_true(rc == MEMCACHED_SUCCESS);
+ string= memcached_get(memc_clone, key, 0,
+ &string_length, &flags, &rc);
+ test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
+ test_true(string_length == 0);
+ test_true(!string);
+
+ memcached_free(memc_clone);
+
+ return TEST_SUCCESS;
+}
+
+#define READ_THROUGH_VALUE "set for me"
+static memcached_return_t read_through_trigger(memcached_st *memc,
+ char *key,
+ size_t key_length,
+ memcached_result_st *result)
+{
+ (void)memc;(void)key;(void)key_length;
+ return memcached_result_set_value(result, READ_THROUGH_VALUE, strlen(READ_THROUGH_VALUE));
+}
+
+#ifndef __INTEL_COMPILER
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif
+
+static test_return_t read_through(memcached_st *memc)
+{
+ memcached_return_t rc;
+ const char *key= "foo";
+ char *string;
+ size_t string_length;
+ uint32_t flags;
+ memcached_trigger_key_fn cb= (memcached_trigger_key_fn)read_through_trigger;
+
+ string= memcached_get(memc, key, strlen(key),
+ &string_length, &flags, &rc);
+
+ test_true(rc == MEMCACHED_NOTFOUND);
+ test_false(string_length);
+ test_false(string);
+
+ rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_GET_FAILURE, *(void **)&cb);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ string= memcached_get(memc, key, strlen(key),
+ &string_length, &flags, &rc);
+
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(string_length == strlen(READ_THROUGH_VALUE));
+ test_strcmp(READ_THROUGH_VALUE, string);
+ free(string);
+
+ string= memcached_get(memc, key, strlen(key),
+ &string_length, &flags, &rc);
+
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(string_length == strlen(READ_THROUGH_VALUE));
+ test_true(!strcmp(READ_THROUGH_VALUE, string));
+ free(string);
+
+ return TEST_SUCCESS;
+}
+
+static memcached_return_t delete_trigger(memcached_st *ptr,
+ const char *key,
+ size_t key_length)
+{
+ (void)ptr;(void)key_length;
+ assert(key);
+
+ return MEMCACHED_SUCCESS;
+}
+
+static test_return_t delete_through(memcached_st *memc)
+{
+ memcached_trigger_delete_key_fn callback;
+ memcached_return_t rc;
+
+ callback= (memcached_trigger_delete_key_fn)delete_trigger;
+
+ rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_DELETE_TRIGGER, *(void**)&callback);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t get_test(memcached_st *memc)
+{
+ memcached_return_t rc;
+ const char *key= "foo";
+ char *string;
+ size_t string_length;
+ uint32_t flags;
+
+ uint64_t query_id= memcached_query_id(memc);
+ rc= memcached_delete(memc, key, strlen(key), (time_t)0);
+ test_true(rc == MEMCACHED_BUFFERED || rc == MEMCACHED_NOTFOUND);
+ test_compare(query_id +1, memcached_query_id(memc));
+
+ string= memcached_get(memc, key, strlen(key),
+ &string_length, &flags, &rc);
+
+ test_true(rc == MEMCACHED_NOTFOUND);
+ test_false(string_length);
+ test_false(string);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t get_test2(memcached_st *memc)
+{
+ memcached_return_t rc;
+ const char *key= "foo";
+ const char *value= "when we sanitize";
+ char *string;
+ size_t string_length;
+ uint32_t flags;
+
+ uint64_t query_id= memcached_query_id(memc);
+ rc= memcached_set(memc, key, strlen(key),
+ value, strlen(value),
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ test_compare(query_id +1, memcached_query_id(memc));
+
+ query_id= memcached_query_id(memc);
+ string= memcached_get(memc, key, strlen(key),
+ &string_length, &flags, &rc);
+ test_compare(query_id +1, memcached_query_id(memc));
+
+ test_true(string);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(string_length == strlen(value));
+ test_memcmp(string, value, string_length);
+
+ free(string);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t set_test2(memcached_st *memc)
+{
+ memcached_return_t rc;
+ const char *key= "foo";
+ const char *value= "train in the brain";
+ size_t value_length= strlen(value);
+ unsigned int x;
+
+ for (x= 0; x < 10; x++)
+ {
+ rc= memcached_set(memc, key, strlen(key),
+ value, value_length,
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ }
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t set_test3(memcached_st *memc)
+{
+ memcached_return_t rc;
+ char *value;
+ size_t value_length= 8191;
+
+ value = (char*)malloc(value_length);
+ test_true(value);
+
+ for (uint32_t x= 0; x < value_length; x++)
+ value[x] = (char) (x % 127);
+
+ /* The dump test relies on there being at least 32 items in memcached */
+ for (uint32_t x= 0; x < 32; x++)
+ {
+ char key[16];
+
+ snprintf(key, sizeof(key), "foo%u", x);
+
+ uint64_t query_id= memcached_query_id(memc);
+ rc= memcached_set(memc, key, strlen(key),
+ value, value_length,
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ test_compare(query_id +1, memcached_query_id(memc));
+ }
+
+ free(value);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t get_test3(memcached_st *memc)
+{
+ memcached_return_t rc;
+ const char *key= "foo";
+ char *value;
+ size_t value_length= 8191;
+ char *string;
+ size_t string_length;
+ uint32_t flags;
+ uint32_t x;
+
+ value = (char*)malloc(value_length);
+ test_true(value);
+
+ for (x= 0; x < value_length; x++)
+ value[x] = (char) (x % 127);
+
+ rc= memcached_set(memc, key, strlen(key),
+ value, value_length,
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+
+ string= memcached_get(memc, key, strlen(key),
+ &string_length, &flags, &rc);
+
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(string);
+ test_true(string_length == value_length);
+ test_true(!memcmp(string, value, string_length));
+
+ free(string);
+ free(value);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t get_test4(memcached_st *memc)
+{
+ memcached_return_t rc;
+ const char *key= "foo";
+ char *value;
+ size_t value_length= 8191;
+ char *string;
+ size_t string_length;
+ uint32_t flags;
+ uint32_t x;
+
+ value = (char*)malloc(value_length);
+ test_true(value);
+
+ for (x= 0; x < value_length; x++)
+ value[x] = (char) (x % 127);
+
+ rc= memcached_set(memc, key, strlen(key),
+ value, value_length,
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+
+ for (x= 0; x < 10; x++)
+ {
+ string= memcached_get(memc, key, strlen(key),
+ &string_length, &flags, &rc);
+
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(string);
+ test_true(string_length == value_length);
+ test_true(!memcmp(string, value, string_length));
+ free(string);
+ }
+
+ free(value);
+
+ return TEST_SUCCESS;
+}
+
+/*
+ * This test verifies that memcached_read_one_response doesn't try to
+ * dereference a NIL-pointer if you issue a multi-get and don't read out all
+ * responses before you execute a storage command.
+ */
+static test_return_t get_test5(memcached_st *memc)
+{
+ /*
+ ** Request the same key twice, to ensure that we hash to the same server
+ ** (so that we have multiple response values queued up) ;-)
+ */
+ const char *keys[]= { "key", "key" };
+ size_t lengths[]= { 3, 3 };
+ uint32_t flags;
+ size_t rlen;
+
+ memcached_return_t rc= memcached_set(memc, keys[0], lengths[0],
+ keys[0], lengths[0], 0, 0);
+ test_true(rc == MEMCACHED_SUCCESS);
+ rc= memcached_mget(memc, keys, lengths, 2);
+
+ memcached_result_st results_obj;
+ memcached_result_st *results;
+ results=memcached_result_create(memc, &results_obj);
+ test_true(results);
+ results=memcached_fetch_result(memc, &results_obj, &rc);
+ test_true(results);
+ memcached_result_free(&results_obj);
+
+ /* Don't read out the second result, but issue a set instead.. */
+ rc= memcached_set(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ char *val= memcached_get_by_key(memc, keys[0], lengths[0], "yek", 3,
+ &rlen, &flags, &rc);
+ test_true(val == NULL);
+ test_true(rc == MEMCACHED_NOTFOUND);
+ val= memcached_get(memc, keys[0], lengths[0], &rlen, &flags, &rc);
+ test_true(val != NULL);
+ test_true(rc == MEMCACHED_SUCCESS);
+ free(val);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t mget_end(memcached_st *memc)
+{
+ const char *keys[]= { "foo", "foo2" };
+ size_t lengths[]= { 3, 4 };
+ const char *values[]= { "fjord", "41" };
+
+ memcached_return_t rc;
+
+ // Set foo and foo2
+ for (int i= 0; i < 2; i++)
+ {
+ rc= memcached_set(memc, keys[i], lengths[i], values[i], strlen(values[i]),
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS);
+ }
+
+ char *string;
+ size_t string_length;
+ uint32_t flags;
+
+ // retrieve both via mget
+ rc= memcached_mget(memc, keys, lengths, 2);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ char key[MEMCACHED_MAX_KEY];
+ size_t key_length;
+
+ // this should get both
+ for (int i = 0; i < 2; i++)
+ {
+ string= memcached_fetch(memc, key, &key_length, &string_length,
+ &flags, &rc);
+ test_true(rc == MEMCACHED_SUCCESS);
+ int val = 0;
+ if (key_length == 4)
+ val= 1;
+ test_true(string_length == strlen(values[val]));
+ test_true(strncmp(values[val], string, string_length) == 0);
+ free(string);
+ }
+
+ // this should indicate end
+ string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);
+ test_true(rc == MEMCACHED_END);
+
+ // now get just one
+ rc= memcached_mget(memc, keys, lengths, 1);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);
+ test_true(key_length == lengths[0]);
+ test_true(strncmp(keys[0], key, key_length) == 0);
+ test_true(string_length == strlen(values[0]));
+ test_true(strncmp(values[0], string, string_length) == 0);
+ test_true(rc == MEMCACHED_SUCCESS);
+ free(string);
+
+ // this should indicate end
+ string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);
+ test_true(rc == MEMCACHED_END);
+
+ return TEST_SUCCESS;
+}
+
+/* Do not copy the style of this code, I just access hosts to testthis function */
+static test_return_t stats_servername_test(memcached_st *memc)
+{
+ memcached_return_t rc;
+ memcached_stat_st memc_stat;
+ memcached_server_instance_st instance=
+ memcached_server_instance_by_position(memc, 0);
+
+#ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
+ if (memcached_get_sasl_callbacks(memc) != NULL)
+ return TEST_SKIPPED;
+#endif
+ rc= memcached_stat_servername(&memc_stat, NULL,
+ memcached_server_name(instance),
+ memcached_server_port(instance));
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t increment_test(memcached_st *memc)
+{
+ uint64_t new_number;
+ memcached_return_t rc;
+ const char *key= "number";
+ const char *value= "0";
+
+ rc= memcached_set(memc, key, strlen(key),
+ value, strlen(value),
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+
+ rc= memcached_increment(memc, key, strlen(key),
+ 1, &new_number);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(new_number == 1);
+
+ rc= memcached_increment(memc, key, strlen(key),
+ 1, &new_number);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(new_number == 2);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t increment_with_initial_test(memcached_st *memc)
+{
+ if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0)
+ {
+ uint64_t new_number;
+ memcached_return_t rc;
+ const char *key= "number";
+ uint64_t initial= 0;
+
+ rc= memcached_increment_with_initial(memc, key, strlen(key),
+ 1, initial, 0, &new_number);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(new_number == initial);
+
+ rc= memcached_increment_with_initial(memc, key, strlen(key),
+ 1, initial, 0, &new_number);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(new_number == (initial + 1));
+ }
+ return TEST_SUCCESS;
+}
+
+static test_return_t decrement_test(memcached_st *memc)
+{
+ uint64_t new_number;
+ memcached_return_t rc;
+ const char *key= "number";
+ const char *value= "3";
+
+ rc= memcached_set(memc, key, strlen(key),
+ value, strlen(value),
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+
+ rc= memcached_decrement(memc, key, strlen(key),
+ 1, &new_number);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(new_number == 2);
+
+ rc= memcached_decrement(memc, key, strlen(key),
+ 1, &new_number);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(new_number == 1);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t decrement_with_initial_test(memcached_st *memc)
+{
+ if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0)
+ {
+ uint64_t new_number;
+ memcached_return_t rc;
+ const char *key= "number";
+ uint64_t initial= 3;
+
+ rc= memcached_decrement_with_initial(memc, key, strlen(key),
+ 1, initial, 0, &new_number);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(new_number == initial);
+
+ rc= memcached_decrement_with_initial(memc, key, strlen(key),
+ 1, initial, 0, &new_number);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(new_number == (initial - 1));
+ }
+ return TEST_SUCCESS;
+}
+
+static test_return_t increment_by_key_test(memcached_st *memc)
+{
+ uint64_t new_number;
+ memcached_return_t rc;
+ const char *master_key= "foo";
+ const char *key= "number";
+ const char *value= "0";
+
+ rc= memcached_set_by_key(memc, master_key, strlen(master_key),
+ key, strlen(key),
+ value, strlen(value),
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+
+ rc= memcached_increment_by_key(memc, master_key, strlen(master_key), key, strlen(key),
+ 1, &new_number);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(new_number == 1);
+
+ rc= memcached_increment_by_key(memc, master_key, strlen(master_key), key, strlen(key),
+ 1, &new_number);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(new_number == 2);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t increment_with_initial_by_key_test(memcached_st *memc)
+{
+ if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0)
+ {
+ uint64_t new_number;
+ memcached_return_t rc;
+ const char *master_key= "foo";
+ const char *key= "number";
+ uint64_t initial= 0;
+
+ rc= memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
+ key, strlen(key),
+ 1, initial, 0, &new_number);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(new_number == initial);
+
+ rc= memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
+ key, strlen(key),
+ 1, initial, 0, &new_number);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(new_number == (initial + 1));
+ }
+ return TEST_SUCCESS;
+}
+
+static test_return_t decrement_by_key_test(memcached_st *memc)
+{
+ uint64_t new_number;
+ memcached_return_t rc;
+ const char *master_key= "foo";
+ const char *key= "number";
+ const char *value= "3";
+
+ rc= memcached_set_by_key(memc, master_key, strlen(master_key),
+ key, strlen(key),
+ value, strlen(value),
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+
+ rc= memcached_decrement_by_key(memc, master_key, strlen(master_key),
+ key, strlen(key),
+ 1, &new_number);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(new_number == 2);
+
+ rc= memcached_decrement_by_key(memc, master_key, strlen(master_key),
+ key, strlen(key),
+ 1, &new_number);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(new_number == 1);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t decrement_with_initial_by_key_test(memcached_st *memc)
+{
+ if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0)
+ {
+ uint64_t new_number;
+ memcached_return_t rc;
+ const char *master_key= "foo";
+ const char *key= "number";
+ uint64_t initial= 3;
+
+ rc= memcached_decrement_with_initial_by_key(memc, master_key, strlen(master_key),
+ key, strlen(key),
+ 1, initial, 0, &new_number);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(new_number == initial);
+
+ rc= memcached_decrement_with_initial_by_key(memc, master_key, strlen(master_key),
+ key, strlen(key),
+ 1, initial, 0, &new_number);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(new_number == (initial - 1));
+ }
+ return TEST_SUCCESS;
+}
+
+static test_return_t quit_test(memcached_st *memc)
+{
+ memcached_return_t rc;
+ const char *key= "fudge";
+ const char *value= "sanford and sun";
+
+ rc= memcached_set(memc, key, strlen(key),
+ value, strlen(value),
+ (time_t)10, (uint32_t)3);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ memcached_quit(memc);
+
+ rc= memcached_set(memc, key, strlen(key),
+ value, strlen(value),
+ (time_t)50, (uint32_t)9);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t mget_result_test(memcached_st *memc)
+{
+ memcached_return_t rc;
+ const char *keys[]= {"fudge", "son", "food"};
+ size_t key_length[]= {5, 3, 4};
+ unsigned int x;
+
+ memcached_result_st results_obj;
+ memcached_result_st *results;
+
+ results= memcached_result_create(memc, &results_obj);
+ test_true(results);
+ test_true(&results_obj == results);
+
+ /* We need to empty the server before continueing test */
+ rc= memcached_flush(memc, 0);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ rc= memcached_mget(memc, keys, key_length, 3);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
+ {
+ test_true(results);
+ }
+
+ while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
+ test_true(!results);
+ test_true(rc == MEMCACHED_END);
+
+ for (x= 0; x < 3; x++)
+ {
+ rc= memcached_set(memc, keys[x], key_length[x],
+ keys[x], key_length[x],
+ (time_t)50, (uint32_t)9);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ }
+
+ rc= memcached_mget(memc, keys, key_length, 3);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
+ {
+ test_true(results);
+ test_true(&results_obj == results);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(memcached_result_key_length(results) == memcached_result_length(results));
+ test_true(!memcmp(memcached_result_key_value(results),
+ memcached_result_value(results),
+ memcached_result_length(results)));
+ }
+
+ memcached_result_free(&results_obj);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t mget_result_alloc_test(memcached_st *memc)
+{
+ memcached_return_t rc;
+ const char *keys[]= {"fudge", "son", "food"};
+ size_t key_length[]= {5, 3, 4};
+ unsigned int x;
+
+ memcached_result_st *results;
+
+ /* We need to empty the server before continueing test */
+ rc= memcached_flush(memc, 0);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ rc= memcached_mget(memc, keys, key_length, 3);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ while ((results= memcached_fetch_result(memc, NULL, &rc)) != NULL)
+ {
+ test_true(results);
+ }
+ test_true(!results);
+ test_true(rc == MEMCACHED_END);
+
+ for (x= 0; x < 3; x++)
+ {
+ rc= memcached_set(memc, keys[x], key_length[x],
+ keys[x], key_length[x],
+ (time_t)50, (uint32_t)9);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ }
+
+ rc= memcached_mget(memc, keys, key_length, 3);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ x= 0;
+ while ((results= memcached_fetch_result(memc, NULL, &rc)))
+ {
+ test_true(results);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(memcached_result_key_length(results) == memcached_result_length(results));
+ test_true(!memcmp(memcached_result_key_value(results),
+ memcached_result_value(results),
+ memcached_result_length(results)));
+ memcached_result_free(results);
+ x++;
+ }
+
+ return TEST_SUCCESS;
+}
+
+/* Count the results */
+static memcached_return_t callback_counter(const memcached_st *ptr,
+ memcached_result_st *result,
+ void *context)
+{
+ (void)ptr; (void)result;
+ size_t *counter= (size_t *)context;
+
+ *counter= *counter + 1;
+
+ return MEMCACHED_SUCCESS;
+}
+
+static test_return_t mget_result_function(memcached_st *memc)
+{
+ memcached_return_t rc;
+ const char *keys[]= {"fudge", "son", "food"};
+ size_t key_length[]= {5, 3, 4};
+ unsigned int x;
+ size_t counter;
+ memcached_execute_fn callbacks[1];
+
+ /* We need to empty the server before continueing test */
+ rc= memcached_flush(memc, 0);
+ for (x= 0; x < 3; x++)
+ {
+ rc= memcached_set(memc, keys[x], key_length[x],
+ keys[x], key_length[x],
+ (time_t)50, (uint32_t)9);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ }
+
+ rc= memcached_mget(memc, keys, key_length, 3);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ callbacks[0]= &callback_counter;
+ counter= 0;
+ rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
+
+ test_true(counter == 3);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t mget_test(memcached_st *memc)
+{
+ memcached_return_t rc;
+ const char *keys[]= {"fudge", "son", "food"};
+ size_t key_length[]= {5, 3, 4};
+ unsigned int x;
+ uint32_t flags;
+
+ char return_key[MEMCACHED_MAX_KEY];
+ size_t return_key_length;
+ char *return_value;
+ size_t return_value_length;
+
+ /* We need to empty the server before continueing test */
+ rc= memcached_flush(memc, 0);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ rc= memcached_mget(memc, keys, key_length, 3);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
+ &return_value_length, &flags, &rc)) != NULL)
+ {
+ test_true(return_value);
+ }
+ test_true(!return_value);
+ test_true(return_value_length == 0);
+ test_true(rc == MEMCACHED_END);
+
+ for (x= 0; x < 3; x++)
+ {
+ rc= memcached_set(memc, keys[x], key_length[x],
+ keys[x], key_length[x],
+ (time_t)50, (uint32_t)9);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ }
+
+ rc= memcached_mget(memc, keys, key_length, 3);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ x= 0;
+ while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
+ &return_value_length, &flags, &rc)))
+ {
+ test_true(return_value);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(return_key_length == return_value_length);
+ test_true(!memcmp(return_value, return_key, return_value_length));
+ free(return_value);
+ x++;
+ }
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t mget_execute(memcached_st *memc)
+{
+ bool binary= false;
+
+ if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0)
+ binary= true;
+
+ /*
+ * I only want to hit _one_ server so I know the number of requests I'm
+ * sending in the pipeline.
+ */
+ uint32_t number_of_hosts= memc->number_of_hosts;
+ memc->number_of_hosts= 1;
+
+ size_t max_keys= 20480;
+
+
+ char **keys= static_cast<char **>(calloc(max_keys, sizeof(char*)));
+ size_t *key_length=static_cast<size_t *>(calloc(max_keys, sizeof(size_t)));
+
+ /* First add all of the items.. */
+ char blob[1024] = {0};
+ memcached_return_t rc;
+
+ for (size_t x= 0; x < max_keys; ++x)
+ {
+ char k[251];
+
+ key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
+ keys[x]= strdup(k);
+ test_true(keys[x] != NULL);
+ uint64_t query_id= memcached_query_id(memc);
+ rc= memcached_add(memc, keys[x], key_length[x], blob, sizeof(blob), 0, 0);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ test_compare(query_id +1, memcached_query_id(memc));
+ }
+
+ /* Try to get all of them with a large multiget */
+ size_t counter= 0;
+ memcached_execute_fn callbacks[]= { &callback_counter };
+ rc= memcached_mget_execute(memc, (const char**)keys, key_length,
+ max_keys, callbacks, &counter, 1);
+
+ if (rc == MEMCACHED_SUCCESS)
+ {
+ test_true(binary);
+ uint64_t query_id= memcached_query_id(memc);
+ rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
+ test_true(rc == MEMCACHED_END);
+ test_compare(query_id, memcached_query_id(memc));
+
+ /* Verify that we got all of the items */
+ test_true(counter == max_keys);
+ }
+ else if (rc == MEMCACHED_NOT_SUPPORTED)
+ {
+ test_true(counter == 0);
+ }
+ else
+ {
+ test_fail("note: this test functions differently when in binary mode");
+ }
+
+ /* Release all allocated resources */
+ for (size_t x= 0; x < max_keys; ++x)
+ {
+ free(keys[x]);
+ }
+ free(keys);
+ free(key_length);
+
+ memc->number_of_hosts= number_of_hosts;
+ return TEST_SUCCESS;
+}
+
+#define REGRESSION_BINARY_VS_BLOCK_COUNT 20480
+
+static test_return_t key_setup(memcached_st *memc)
+{
+ (void)memc;
+
+ if (pre_binary(memc) != TEST_SUCCESS)
+ return TEST_SKIPPED;
+
+ global_pairs= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT, 0);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t key_teardown(memcached_st *memc)
+{
+ (void)memc;
+ pairs_free(global_pairs);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t block_add_regression(memcached_st *memc)
+{
+ /* First add all of the items.. */
+ for (size_t x= 0; x < REGRESSION_BINARY_VS_BLOCK_COUNT; ++x)
+ {
+ memcached_return_t rc;
+ char blob[1024] = {0};
+
+ rc= memcached_add_by_key(memc, "bob", 3, global_pairs[x].key, global_pairs[x].key_length, blob, sizeof(blob), 0, 0);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ }
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t binary_add_regression(memcached_st *memc)
+{
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
+ test_return_t rc= block_add_regression(memc);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 0);
+ return rc;
+}
+
+static test_return_t get_stats_keys(memcached_st *memc)
+{
+ char **stat_list;
+ char **ptr;
+ memcached_stat_st memc_stat;
+ memcached_return_t rc;
+
+ stat_list= memcached_stat_get_keys(memc, &memc_stat, &rc);
+ test_true(rc == MEMCACHED_SUCCESS);
+ for (ptr= stat_list; *ptr; ptr++)
+ test_true(*ptr);
+
+ free(stat_list);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t version_string_test(memcached_st *memc)
+{
+ const char *version_string;
+ (void)memc;
+
+ version_string= memcached_lib_version();
+
+ test_true(!strcmp(version_string, LIBMEMCACHED_VERSION_STRING));
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t get_stats(memcached_st *memc)
+{
+ char **stat_list;
+ char **ptr;
+ memcached_return_t rc;
+ memcached_stat_st *memc_stat;
+
+ memc_stat= memcached_stat(memc, NULL, &rc);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(memc_stat);
+
+ for (uint32_t x= 0; x < memcached_server_count(memc); x++)
+ {
+ stat_list= memcached_stat_get_keys(memc, memc_stat+x, &rc);
+ test_true(rc == MEMCACHED_SUCCESS);
+ for (ptr= stat_list; *ptr; ptr++);
+
+ free(stat_list);
+ }
+
+ memcached_stat_free(NULL, memc_stat);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t add_host_test(memcached_st *memc)
+{
+ unsigned int x;
+ memcached_server_st *servers;
+ memcached_return_t rc;
+ char servername[]= "0.example.com";
+
+ servers= memcached_server_list_append_with_weight(NULL, servername, 400, 0, &rc);
+ test_true(servers);
+ test_true(1 == memcached_server_list_count(servers));
+
+ for (x= 2; x < 20; x++)
+ {
+ char buffer[SMALL_STRING_LEN];
+
+ snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
+ servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0,
+ &rc);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(x == memcached_server_list_count(servers));
+ }
+
+ rc= memcached_server_push(memc, servers);
+ test_true(rc == MEMCACHED_SUCCESS);
+ rc= memcached_server_push(memc, servers);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ memcached_server_list_free(servers);
+
+ return TEST_SUCCESS;
+}
+
+static memcached_return_t clone_test_callback(memcached_st *parent, memcached_st *memc_clone)
+{
+ (void)parent;(void)memc_clone;
+ return MEMCACHED_SUCCESS;
+}
+
+static memcached_return_t cleanup_test_callback(memcached_st *ptr)
+{
+ (void)ptr;
+ return MEMCACHED_SUCCESS;
+}
+
+static test_return_t callback_test(memcached_st *memc)
+{
+ /* Test User Data */
+ {
+ int x= 5;
+ int *test_ptr;
+ memcached_return_t rc;
+
+ rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_USER_DATA, &x);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_ptr= (int *)memcached_callback_get(memc, MEMCACHED_CALLBACK_USER_DATA, &rc);
+ test_true(*test_ptr == x);
+ }
+
+ /* Test Clone Callback */
+ {
+ memcached_clone_fn clone_cb= (memcached_clone_fn)clone_test_callback;
+ void *clone_cb_ptr= *(void **)&clone_cb;
+ void *temp_function= NULL;
+ memcached_return_t rc;
+
+ rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION,
+ clone_cb_ptr);
+ test_true(rc == MEMCACHED_SUCCESS);
+ temp_function= memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc);
+ test_true(temp_function == clone_cb_ptr);
+ }
+
+ /* Test Cleanup Callback */
+ {
+ memcached_cleanup_fn cleanup_cb=
+ (memcached_cleanup_fn)cleanup_test_callback;
+ void *cleanup_cb_ptr= *(void **)&cleanup_cb;
+ void *temp_function= NULL;
+ memcached_return_t rc;
+
+ rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION,
+ cleanup_cb_ptr);
+ test_true(rc == MEMCACHED_SUCCESS);
+ temp_function= memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc);
+ test_true(temp_function == cleanup_cb_ptr);
+ }
+
+ return TEST_SUCCESS;
+}
+
+/* We don't test the behavior itself, we test the switches */
+static test_return_t behavior_test(memcached_st *memc)
+{
+ uint64_t value;
+ uint32_t set= 1;
+
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
+ value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
+ test_true(value == 1);
+
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
+ value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
+ test_true(value == 1);
+
+ set= MEMCACHED_HASH_MD5;
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
+ value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
+ test_true(value == MEMCACHED_HASH_MD5);
+
+ set= 0;
+
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
+ value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
+ test_true(value == 0);
+
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
+ value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
+ test_true(value == 0);
+
+ set= MEMCACHED_HASH_DEFAULT;
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
+ value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
+ test_true(value == MEMCACHED_HASH_DEFAULT);
+
+ set= MEMCACHED_HASH_CRC;
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
+ value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
+ test_true(value == MEMCACHED_HASH_CRC);
+
+ value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
+ test_true(value > 0);
+
+ value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
+ test_true(value > 0);
+
+ value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, value + 1);
+ test_true((value + 1) == memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS));
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t MEMCACHED_BEHAVIOR_CORK_test(memcached_st *memc)
+{
+ memcached_return_t rc;
+ bool set= true;
+
+ rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CORK, set);
+ test_true(rc == MEMCACHED_DEPRECATED);
+
+ // Platform dependent
+#if 0
+ bool value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_CORK);
+ test_false(value);
+#endif
+
+ return TEST_SUCCESS;
+}
+
+
+static test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st *memc)
+{
+ memcached_return_t rc;
+ bool set= true;
+ bool value;
+
+ rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE, set);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOT_SUPPORTED);
+
+ value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE);
+
+ if (rc == MEMCACHED_SUCCESS)
+ {
+ test_true((bool)value == set);
+ }
+ else
+ {
+ test_false((bool)value == set);
+ }
+
+ return TEST_SUCCESS;
+}
+
+
+static test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st *memc)
+{
+ memcached_return_t rc;
+ bool set= true;
+ bool value;
+
+ rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE, set);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOT_SUPPORTED);
+
+ value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE);
+
+ if (rc == MEMCACHED_SUCCESS)
+ {
+ test_true((bool)value == set);
+ }
+ else
+ {
+ test_false((bool)value == set);
+ }
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t fetch_all_results(memcached_st *memc, size_t *keys_returned)
+{
+ memcached_return_t rc= MEMCACHED_SUCCESS;
+ char return_key[MEMCACHED_MAX_KEY];
+ size_t return_key_length;
+ char *return_value;
+ size_t return_value_length;
+ uint32_t flags;
+
+ *keys_returned= 0;
+
+ while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
+ &return_value_length, &flags, &rc)))
+ {
+ test_true(return_value);
+ test_true(rc == MEMCACHED_SUCCESS);
+ free(return_value);
+ *keys_returned= *keys_returned +1;
+ }
+
+ test_true_got(rc == MEMCACHED_END || rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
+
+ return TEST_SUCCESS;
+}
+
+/* Test case provided by Cal Haldenbrand */
+static test_return_t user_supplied_bug1(memcached_st *memc)
+{
+ unsigned int setter= 1;
+
+ unsigned long long total= 0;
+ uint32_t size= 0;
+ char key[10];
+ char randomstuff[6 * 1024];
+ memcached_return_t rc;
+
+ memset(randomstuff, 0, 6 * 1024);
+
+ /* We just keep looking at the same values over and over */
+ srandom(10);
+
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
+
+
+ /* add key */
+ for (uint32_t x= 0 ; total < 20 * 1024576 ; x++ )
+ {
+ unsigned int j= 0;
+
+ size= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
+ memset(randomstuff, 0, 6 * 1024);
+ test_true(size < 6 * 1024); /* Being safe here */
+
+ for (j= 0 ; j < size ;j++)
+ randomstuff[j] = (signed char) ((rand() % 26) + 97);
+
+ total += size;
+ snprintf(key, sizeof(key), "%u", x);
+ rc = memcached_set(memc, key, strlen(key),
+ randomstuff, strlen(randomstuff), 10, 0);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ /* If we fail, lets try again */
+ if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_BUFFERED)
+ rc = memcached_set(memc, key, strlen(key),
+ randomstuff, strlen(randomstuff), 10, 0);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ }
+
+ return TEST_SUCCESS;
+}
+
+/* Test case provided by Cal Haldenbrand */
+static test_return_t user_supplied_bug2(memcached_st *memc)
+{
+ unsigned int setter;
+ size_t total= 0;
+
+ setter= 1;
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
+#ifdef NOT_YET
+ setter = 20 * 1024576;
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, setter);
+ setter = 20 * 1024576;
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, setter);
+ getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
+ getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
+
+ for (x= 0, errors= 0; total < 20 * 1024576 ; x++)
+#endif
+
+ for (uint32_t x= 0, errors= 0; total < 24576 ; x++)
+ {
+ memcached_return_t rc= MEMCACHED_SUCCESS;
+ char buffer[SMALL_STRING_LEN];
+ uint32_t flags= 0;
+ size_t val_len= 0;
+ char *getval;
+
+ memset(buffer, 0, SMALL_STRING_LEN);
+
+ snprintf(buffer, sizeof(buffer), "%u", x);
+ getval= memcached_get(memc, buffer, strlen(buffer),
+ &val_len, &flags, &rc);
+ if (rc != MEMCACHED_SUCCESS)
+ {
+ if (rc == MEMCACHED_NOTFOUND)
+ errors++;
+ else
+ {
+ test_true(rc);
+ }
+
+ continue;
+ }
+ total+= val_len;
+ errors= 0;
+ free(getval);
+ }
+
+ return TEST_SUCCESS;
+}
+
+/* Do a large mget() over all the keys we think exist */
+#define KEY_COUNT 3000 // * 1024576
+static test_return_t user_supplied_bug3(memcached_st *memc)
+{
+ memcached_return_t rc;
+ unsigned int setter;
+ unsigned int x;
+ char **keys;
+ size_t key_lengths[KEY_COUNT];
+
+ setter= 1;
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
+#ifdef NOT_YET
+ setter = 20 * 1024576;
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, setter);
+ setter = 20 * 1024576;
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, setter);
+ getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
+ getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
+#endif
+
+ keys= static_cast<char **>(calloc(KEY_COUNT, sizeof(char *)));
+ test_true(keys);
+ for (x= 0; x < KEY_COUNT; x++)
+ {
+ char buffer[30];
+
+ snprintf(buffer, 30, "%u", x);
+ keys[x]= strdup(buffer);
+ key_lengths[x]= strlen(keys[x]);
+ }
+
+ rc= memcached_mget(memc, (const char **)keys, key_lengths, KEY_COUNT);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ size_t keys_returned;
+ test_true(fetch_all_results(memc, &keys_returned) == TEST_SUCCESS);
+
+ for (x= 0; x < KEY_COUNT; x++)
+ free(keys[x]);
+ free(keys);
+
+ return TEST_SUCCESS;
+}
+
+/* Make sure we behave properly if server list has no values */
+static test_return_t user_supplied_bug4(memcached_st *memc)
+{
+ memcached_return_t rc;
+ const char *keys[]= {"fudge", "son", "food"};
+ size_t key_length[]= {5, 3, 4};
+ unsigned int x;
+ uint32_t flags;
+ char return_key[MEMCACHED_MAX_KEY];
+ size_t return_key_length;
+ char *return_value;
+ size_t return_value_length;
+
+ /* Here we free everything before running a bunch of mget tests */
+ memcached_servers_reset(memc);
+
+
+ /* We need to empty the server before continueing test */
+ rc= memcached_flush(memc, 0);
+ test_compare(rc, MEMCACHED_NO_SERVERS);
+
+ rc= memcached_mget(memc, keys, key_length, 3);
+ test_true(rc == MEMCACHED_NO_SERVERS);
+
+ while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
+ &return_value_length, &flags, &rc)) != NULL)
+ {
+ test_true(return_value);
+ }
+ test_false(return_value);
+ test_true(return_value_length == 0);
+ test_true(rc == MEMCACHED_NO_SERVERS);
+
+ for (x= 0; x < 3; x++)
+ {
+ rc= memcached_set(memc, keys[x], key_length[x],
+ keys[x], key_length[x],
+ (time_t)50, (uint32_t)9);
+ test_true(rc == MEMCACHED_NO_SERVERS);
+ }
+
+ rc= memcached_mget(memc, keys, key_length, 3);
+ test_true(rc == MEMCACHED_NO_SERVERS);
+
+ x= 0;
+ while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
+ &return_value_length, &flags, &rc)))
+ {
+ test_true(return_value);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(return_key_length == return_value_length);
+ test_memcmp(return_value, return_key, return_value_length);
+ free(return_value);
+ x++;
+ }
+
+ return TEST_SUCCESS;
+}
+
+#define VALUE_SIZE_BUG5 1048064
+static test_return_t user_supplied_bug5(memcached_st *memc)
+{
+ memcached_return_t rc;
+ const char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
+ size_t key_length[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
+ char return_key[MEMCACHED_MAX_KEY];
+ size_t return_key_length;
+ char *value;
+ size_t value_length;
+ uint32_t flags;
+ unsigned int count;
+ unsigned int x;
+ char *insert_data= new (std::nothrow) char[VALUE_SIZE_BUG5];
+
+ for (x= 0; x < VALUE_SIZE_BUG5; x++)
+ insert_data[x]= (signed char)rand();
+
+ memcached_flush(memc, 0);
+ value= memcached_get(memc, keys[0], key_length[0],
+ &value_length, &flags, &rc);
+ test_true(value == NULL);
+ rc= memcached_mget(memc, keys, key_length, 4);
+
+ count= 0;
+ while ((value= memcached_fetch(memc, return_key, &return_key_length,
+ &value_length, &flags, &rc)))
+ count++;
+ test_true(count == 0);
+
+ for (x= 0; x < 4; x++)
+ {
+ rc= memcached_set(memc, keys[x], key_length[x],
+ insert_data, VALUE_SIZE_BUG5,
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS);
+ }
+
+ for (x= 0; x < 10; x++)
+ {
+ value= memcached_get(memc, keys[0], key_length[0],
+ &value_length, &flags, &rc);
+ test_true(value);
+ free(value);
+
+ rc= memcached_mget(memc, keys, key_length, 4);
+ count= 0;
+ while ((value= memcached_fetch(memc, return_key, &return_key_length,
+ &value_length, &flags, &rc)))
+ {
+ count++;
+ free(value);
+ }
+ test_true(count == 4);
+ }
+ delete [] insert_data;
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t user_supplied_bug6(memcached_st *memc)
+{
+ memcached_return_t rc;
+ const char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
+ size_t key_length[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
+ char return_key[MEMCACHED_MAX_KEY];
+ size_t return_key_length;
+ char *value;
+ size_t value_length;
+ uint32_t flags;
+ unsigned int count;
+ unsigned int x;
+ char *insert_data= new (std::nothrow) char[VALUE_SIZE_BUG5];
+
+ for (x= 0; x < VALUE_SIZE_BUG5; x++)
+ insert_data[x]= (signed char)rand();
+
+ memcached_flush(memc, 0);
+ value= memcached_get(memc, keys[0], key_length[0],
+ &value_length, &flags, &rc);
+ test_true(value == NULL);
+ test_true(rc == MEMCACHED_NOTFOUND);
+ rc= memcached_mget(memc, keys, key_length, 4);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ count= 0;
+ while ((value= memcached_fetch(memc, return_key, &return_key_length,
+ &value_length, &flags, &rc)))
+ count++;
+ test_true(count == 0);
+ test_true(rc == MEMCACHED_END);
+
+ for (x= 0; x < 4; x++)
+ {
+ rc= memcached_set(memc, keys[x], key_length[x],
+ insert_data, VALUE_SIZE_BUG5,
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS);
+ }
+
+ for (x= 0; x < 2; x++)
+ {
+ value= memcached_get(memc, keys[0], key_length[0],
+ &value_length, &flags, &rc);
+ test_true(value);
+ free(value);
+
+ rc= memcached_mget(memc, keys, key_length, 4);
+ test_true(rc == MEMCACHED_SUCCESS);
+ count= 3;
+ /* We test for purge of partial complete fetches */
+ for (count= 3; count; count--)
+ {
+ value= memcached_fetch(memc, return_key, &return_key_length,
+ &value_length, &flags, &rc);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(!(memcmp(value, insert_data, value_length)));
+ test_true(value_length);
+ free(value);
+ }
+ }
+ delete [] insert_data;
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t user_supplied_bug8(memcached_st *memc)
+{
+ memcached_return_t rc;
+ memcached_st *mine;
+ memcached_st *memc_clone;
+
+ memcached_server_st *servers;
+ const char *server_list= "memcache1.memcache.bk.sapo.pt:11211, memcache1.memcache.bk.sapo.pt:11212, memcache1.memcache.bk.sapo.pt:11213, memcache1.memcache.bk.sapo.pt:11214, memcache2.memcache.bk.sapo.pt:11211, memcache2.memcache.bk.sapo.pt:11212, memcache2.memcache.bk.sapo.pt:11213, memcache2.memcache.bk.sapo.pt:11214";
+
+ (void)memc;
+ servers= memcached_servers_parse(server_list);
+ test_true(servers);
+
+ mine= memcached_create(NULL);
+ rc= memcached_server_push(mine, servers);
+ test_true(rc == MEMCACHED_SUCCESS);
+ memcached_server_list_free(servers);
+
+ test_true(mine);
+ memc_clone= memcached_clone(NULL, mine);
+
+ memcached_quit(mine);
+ memcached_quit(memc_clone);
+
+
+ memcached_free(mine);
+ memcached_free(memc_clone);
+
+ return TEST_SUCCESS;
+}
+
+/* Test flag store/retrieve */
+static test_return_t user_supplied_bug7(memcached_st *memc)
+{
+ const char *keys= "036790384900";
+ size_t key_length= strlen(keys);
+ char return_key[MEMCACHED_MAX_KEY];
+ size_t return_key_length;
+ char *value;
+ size_t value_length;
+ uint32_t flags;
+ char *insert_data= new (std::nothrow) char[VALUE_SIZE_BUG5];
+
+ for (unsigned int x= 0; x < VALUE_SIZE_BUG5; x++)
+ insert_data[x]= (signed char)rand();
+
+ memcached_flush(memc, 0);
+
+ flags= 245;
+ memcached_return_t rc= memcached_set(memc, keys, key_length,
+ insert_data, VALUE_SIZE_BUG5,
+ (time_t)0, flags);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ flags= 0;
+ value= memcached_get(memc, keys, key_length,
+ &value_length, &flags, &rc);
+ test_true(flags == 245);
+ test_true(value);
+ free(value);
+
+ rc= memcached_mget(memc, &keys, &key_length, 1);
+
+ flags= 0;
+ value= memcached_fetch(memc, return_key, &return_key_length,
+ &value_length, &flags, &rc);
+ test_compare(245, flags);
+ test_true(value);
+ free(value);
+ delete [] insert_data;
+
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t user_supplied_bug9(memcached_st *memc)
+{
+ const char *keys[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
+ size_t key_length[3];
+ uint32_t flags;
+ unsigned count= 0;
+
+ char return_key[MEMCACHED_MAX_KEY];
+ size_t return_key_length;
+ char *return_value;
+ size_t return_value_length;
+
+
+ key_length[0]= strlen("UDATA:edevil@sapo.pt");
+ key_length[1]= strlen("fudge&*@#");
+ key_length[2]= strlen("for^#@&$not");
+
+
+ for (unsigned int x= 0; x < 3; x++)
+ {
+ memcached_return_t rc= memcached_set(memc, keys[x], key_length[x],
+ keys[x], key_length[x],
+ (time_t)50, (uint32_t)9);
+ test_true(rc == MEMCACHED_SUCCESS);
+ }
+
+ memcached_return_t rc= memcached_mget(memc, keys, key_length, 3);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ /* We need to empty the server before continueing test */
+ while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
+ &return_value_length, &flags, &rc)) != NULL)
+ {
+ test_true(return_value);
+ free(return_value);
+ count++;
+ }
+ test_compare(3, count);
+
+ return TEST_SUCCESS;
+}
+
+/* We are testing with aggressive timeout to get failures */
+static test_return_t user_supplied_bug10(memcached_st *memc)
+{
+ const char *key= "foo";
+ char *value;
+ size_t value_length= 512;
+ unsigned int x;
+ size_t key_len= 3;
+ unsigned int set= 1;
+ memcached_st *mclone= memcached_clone(NULL, memc);
+ int32_t timeout;
+
+ memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
+ memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
+ timeout= 2;
+ memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT,
+ (uint64_t)timeout);
+
+ value = (char*)malloc(value_length * sizeof(char));
+
+ for (x= 0; x < value_length; x++)
+ value[x]= (char) (x % 127);
+
+ for (x= 1; x <= 100000; ++x)
+ {
+ memcached_return_t rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
+
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_WRITE_FAILURE ||
+ rc == MEMCACHED_BUFFERED || rc == MEMCACHED_TIMEOUT);
+
+ if (rc == MEMCACHED_WRITE_FAILURE || rc == MEMCACHED_TIMEOUT)
+ x--;
+ }
+
+ free(value);
+ memcached_free(mclone);
+
+ return TEST_SUCCESS;
+}
+
+/*
+ We are looking failures in the async protocol
+*/
+static test_return_t user_supplied_bug11(memcached_st *memc)
+{
+ const char *key= "foo";
+ char *value;
+ size_t value_length= 512;
+ unsigned int x;
+ size_t key_len= 3;
+ memcached_return_t rc;
+ unsigned int set= 1;
+ int32_t timeout;
+ memcached_st *mclone= memcached_clone(NULL, memc);
+
+ memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
+ memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
+ timeout= -1;
+ memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT,
+ (size_t)timeout);
+
+ timeout= (int32_t)memcached_behavior_get(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
+
+ test_true(timeout == -1);
+
+ value = (char*)malloc(value_length * sizeof(char));
+
+ for (x= 0; x < value_length; x++)
+ value[x]= (char) (x % 127);
+
+ for (x= 1; x <= 100000; ++x)
+ {
+ rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
+ }
+
+ free(value);
+ memcached_free(mclone);
+
+ return TEST_SUCCESS;
+}
+
+/*
+ Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
+*/
+static test_return_t user_supplied_bug12(memcached_st *memc)
+{
+ memcached_return_t rc;
+ uint32_t flags;
+ size_t value_length;
+ char *value;
+ uint64_t number_value;
+
+ value= memcached_get(memc, "autoincrement", strlen("autoincrement"),
+ &value_length, &flags, &rc);
+ test_true(value == NULL);
+ test_true(rc == MEMCACHED_NOTFOUND);
+
+ rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"),
+ 1, &number_value);
+
+ test_true(value == NULL);
+ /* The binary protocol will set the key if it doesn't exist */
+ if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1)
+ {
+ test_true(rc == MEMCACHED_SUCCESS);
+ }
+ else
+ {
+ test_true(rc == MEMCACHED_NOTFOUND);
+ }
+
+ rc= memcached_set(memc, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
+
+ value= memcached_get(memc, "autoincrement", strlen("autoincrement"),
+ &value_length, &flags, &rc);
+ test_true(value);
+ test_true(rc == MEMCACHED_SUCCESS);
+ free(value);
+
+ rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"),
+ 1, &number_value);
+ test_true(number_value == 2);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ return TEST_SUCCESS;
+}
+
+/*
+ Bug found where command total one more than MEMCACHED_MAX_BUFFER
+ set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
+ */
+static test_return_t user_supplied_bug13(memcached_st *memc)
+{
+ char key[] = "key34567890";
+ memcached_return_t rc;
+ size_t overflowSize;
+
+ char commandFirst[]= "set key34567890 0 0 ";
+ char commandLast[] = " \r\n"; /* first line of command sent to server */
+ size_t commandLength;
+ size_t testSize;
+
+ commandLength = strlen(commandFirst) + strlen(commandLast) + 4; /* 4 is number of characters in size, probably 8196 */
+
+ overflowSize = MEMCACHED_MAX_BUFFER - commandLength;
+
+ for (testSize= overflowSize - 1; testSize < overflowSize + 1; testSize++)
+ {
+ char *overflow= new (std::nothrow) char[testSize];
+ test_true(overflow);
+
+ memset(overflow, 'x', testSize);
+ rc= memcached_set(memc, key, strlen(key),
+ overflow, testSize, 0, 0);
+ test_true(rc == MEMCACHED_SUCCESS);
+ delete [] overflow;
+ }
+
+ return TEST_SUCCESS;
+}
+
+
+/*
+ Test values of many different sizes
+ Bug found where command total one more than MEMCACHED_MAX_BUFFER
+ set key34567890 0 0 8169 \r\n
+ is sent followed by buffer of size 8169, followed by 8169
+ */
+static test_return_t user_supplied_bug14(memcached_st *memc)
+{
+ size_t setter= 1;
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
+ memcached_return_t rc;
+ const char *key= "foo";
+ char *value;
+ size_t value_length= 18000;
+ char *string;
+ size_t string_length;
+ uint32_t flags;
+ unsigned int x;
+ size_t current_length;
+
+ value = (char*)malloc(value_length);
+ test_true(value);
+
+ for (x= 0; x < value_length; x++)
+ value[x] = (char) (x % 127);
+
+ for (current_length= 0; current_length < value_length; current_length++)
+ {
+ rc= memcached_set(memc, key, strlen(key),
+ value, current_length,
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+
+ string= memcached_get(memc, key, strlen(key),
+ &string_length, &flags, &rc);
+
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(string_length == current_length);
+ test_true(!memcmp(string, value, string_length));
+
+ free(string);
+ }
+
+ free(value);
+
+ return TEST_SUCCESS;
+}
+
+/*
+ Look for zero length value problems
+ */
+static test_return_t user_supplied_bug15(memcached_st *memc)
+{
+ uint32_t x;
+ memcached_return_t rc;
+ const char *key= "mykey";
+ char *value;
+ size_t length;
+ uint32_t flags;
+
+ for (x= 0; x < 2; x++)
+ {
+ rc= memcached_set(memc, key, strlen(key),
+ NULL, 0,
+ (time_t)0, (uint32_t)0);
+
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ value= memcached_get(memc, key, strlen(key),
+ &length, &flags, &rc);
+
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(value == NULL);
+ test_true(length == 0);
+ test_true(flags == 0);
+
+ value= memcached_get(memc, key, strlen(key),
+ &length, &flags, &rc);
+
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(value == NULL);
+ test_true(length == 0);
+ test_true(flags == 0);
+ }
+
+ return TEST_SUCCESS;
+}
+
+/* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
+static test_return_t user_supplied_bug16(memcached_st *memc)
+{
+ memcached_return_t rc;
+ const char *key= "mykey";
+ char *value;
+ size_t length;
+ uint32_t flags;
+
+ rc= memcached_set(memc, key, strlen(key),
+ NULL, 0,
+ (time_t)0, UINT32_MAX);
+
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ value= memcached_get(memc, key, strlen(key),
+ &length, &flags, &rc);
+
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(value == NULL);
+ test_true(length == 0);
+ test_true(flags == UINT32_MAX);
+
+ return TEST_SUCCESS;
+}
+
+#if !defined(__sun) && !defined(__OpenBSD__)
+/* Check the validity of chinese key*/
+static test_return_t user_supplied_bug17(memcached_st *memc)
+{
+ memcached_return_t rc;
+ const char *key= "豆瓣";
+ const char *value="我们在炎热抑郁的夏天无法停止豆瓣";
+ char *value2;
+ size_t length;
+ uint32_t flags;
+
+ rc= memcached_set(memc, key, strlen(key),
+ value, strlen(value),
+ (time_t)0, 0);
+
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ value2= memcached_get(memc, key, strlen(key),
+ &length, &flags, &rc);
+
+ test_true(length==strlen(value));
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(memcmp(value, value2, length)==0);
+ free(value2);
+
+ return TEST_SUCCESS;
+}
+#endif
+
+/*
+ From Andrei on IRC
+*/
+
+static test_return_t user_supplied_bug19(memcached_st *not_used)
+{
+ memcached_st *memc;
+ const memcached_server_st *server;
+ memcached_return_t res;
+
+ (void)not_used;
+
+ memc= memcached_create(NULL);
+ memcached_server_add_with_weight(memc, "localhost", 11311, 100);
+ memcached_server_add_with_weight(memc, "localhost", 11312, 100);
+
+ server= memcached_server_by_key(memc, "a", 1, &res);
+
+ memcached_free(memc);
+
+ return TEST_SUCCESS;
+}
+
+/* CAS test from Andei */
+static test_return_t user_supplied_bug20(memcached_st *memc)
+{
+ memcached_return_t status;
+ memcached_result_st *result, result_obj;
+ const char *key = "abc";
+ size_t key_len = strlen("abc");
+ const char *value = "foobar";
+ size_t value_len = strlen(value);
+
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1);
+
+ status = memcached_set(memc, key, key_len, value, value_len, (time_t)0, (uint32_t)0);
+ test_true(status == MEMCACHED_SUCCESS);
+
+ status = memcached_mget(memc, &key, &key_len, 1);
+ test_true(status == MEMCACHED_SUCCESS);
+
+ result= memcached_result_create(memc, &result_obj);
+ test_true(result);
+
+ memcached_result_create(memc, &result_obj);
+ result= memcached_fetch_result(memc, &result_obj, &status);
+
+ test_true(result);
+ test_true(status == MEMCACHED_SUCCESS);
+
+ memcached_result_free(result);
+
+ return TEST_SUCCESS;
+}
+
+#include "ketama_test_cases.h"
+static test_return_t user_supplied_bug18(memcached_st *trash)
+{
+ memcached_return_t rc;
+ uint64_t value;
+ int x;
+ memcached_server_st *server_pool;
+ memcached_st *memc;
+
+ (void)trash;
+
+ memc= memcached_create(NULL);
+ test_true(memc);
+
+ rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
+ test_true(value == 1);
+
+ rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
+ test_true(value == MEMCACHED_HASH_MD5);
+
+ server_pool = memcached_servers_parse("10.0.1.1:11211 600,10.0.1.2:11211 300,10.0.1.3:11211 200,10.0.1.4:11211 350,10.0.1.5:11211 1000,10.0.1.6:11211 800,10.0.1.7:11211 950,10.0.1.8:11211 100");
+ memcached_server_push(memc, server_pool);
+
+ /* verify that the server list was parsed okay. */
+ test_true(memcached_server_count(memc) == 8);
+ test_true(strcmp(server_pool[0].hostname, "10.0.1.1") == 0);
+ test_true(server_pool[0].port == 11211);
+ test_true(server_pool[0].weight == 600);
+ test_true(strcmp(server_pool[2].hostname, "10.0.1.3") == 0);
+ test_true(server_pool[2].port == 11211);
+ test_true(server_pool[2].weight == 200);
+ test_true(strcmp(server_pool[7].hostname, "10.0.1.8") == 0);
+ test_true(server_pool[7].port == 11211);
+ test_true(server_pool[7].weight == 100);
+
+ /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
+ * us test the boundary wraparound.
+ */
+ test_true(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->ketama.continuum[0].index);
+
+ /* verify the standard ketama set. */
+ for (x= 0; x < 99; x++)
+ {
+ uint32_t server_idx = memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key));
+
+ memcached_server_instance_st instance=
+ memcached_server_instance_by_position(memc, server_idx);
+
+ const char *hostname = memcached_server_name(instance);
+ test_strcmp(hostname, ketama_test_cases[x].server);
+ }
+
+ memcached_server_list_free(server_pool);
+ memcached_free(memc);
+
+ return TEST_SUCCESS;
+}
+
+/* Large mget() of missing keys with binary proto
+ *
+ * If many binary quiet commands (such as getq's in an mget) fill the output
+ * buffer and the server chooses not to respond, memcached_flush hangs. See
+ * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
+ */
+
+/* sighandler_t function that always asserts false */
+static void fail(int unused)
+{
+ (void)unused;
+ assert(0);
+}
+
+
+static test_return_t _user_supplied_bug21(memcached_st* memc, size_t key_count)
+{
+#ifdef WIN32
+ (void)memc;
+ (void)key_count;
+ return TEST_SKIPPED;
+#else
+ void (*oldalarm)(int);
+
+ memcached_st *memc_clone= memcached_clone(NULL, memc);
+ test_true(memc_clone);
+
+ /* only binproto uses getq for mget */
+ memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
+
+ /* empty the cache to ensure misses (hence non-responses) */
+ memcached_return_t rc= memcached_flush(memc_clone, 0);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ size_t* key_lengths= new (std::nothrow) size_t[key_count];
+ test_true(key_lengths);
+ char **keys= static_cast<char **>(calloc(key_count, sizeof(char *)));
+ test_true(keys);
+ for (unsigned int x= 0; x < key_count; x++)
+ {
+ char buffer[30];
+
+ snprintf(buffer, 30, "%u", x);
+ keys[x]= strdup(buffer);
+ key_lengths[x]= strlen(keys[x]);
+ }
+
+ oldalarm= signal(SIGALRM, fail);
+ alarm(5);
+
+ test_true_got(memcached_success(memcached_mget(memc_clone, (const char **)keys, key_lengths, key_count)), memcached_last_error_message(memc_clone));
+
+ alarm(0);
+ signal(SIGALRM, oldalarm);
+
+ size_t keys_returned;
+ test_true(fetch_all_results(memc, &keys_returned) == TEST_SUCCESS);
+
+ for (unsigned int x= 0; x < key_count; x++)
+ {
+ free(keys[x]);
+ }
+ free(keys);
+ delete [] key_lengths;
+
+ memcached_free(memc_clone);
+
+ return TEST_SUCCESS;
+#endif
+}
+
+static test_return_t user_supplied_bug21(memcached_st *memc)
+{
+ test_return_t test_rc;
+ test_rc= pre_binary(memc);
+
+ if (test_rc != TEST_SUCCESS)
+ return test_rc;
+
+ test_return_t rc;
+
+ /* should work as of r580 */
+ rc= _user_supplied_bug21(memc, 10);
+ test_true(rc == TEST_SUCCESS);
+
+ /* should fail as of r580 */
+ rc= _user_supplied_bug21(memc, 1000);
+ test_true(rc == TEST_SUCCESS);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t auto_eject_hosts(memcached_st *trash)
+{
+ (void) trash;
+ memcached_server_instance_st instance;
+
+ memcached_return_t rc;
+ memcached_st *memc= memcached_create(NULL);
+ test_true(memc);
+
+ rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
+ test_true(value == 1);
+
+ rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
+ test_true(value == MEMCACHED_HASH_MD5);
+
+ /* server should be removed when in delay */
+ rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS, 1);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS);
+ test_true(value == 1);
+
+ memcached_server_st *server_pool;
+ server_pool = memcached_servers_parse("10.0.1.1:11211 600,10.0.1.2:11211 300,10.0.1.3:11211 200,10.0.1.4:11211 350,10.0.1.5:11211 1000,10.0.1.6:11211 800,10.0.1.7:11211 950,10.0.1.8:11211 100");
+ memcached_server_push(memc, server_pool);
+
+ /* verify that the server list was parsed okay. */
+ test_true(memcached_server_count(memc) == 8);
+ test_true(strcmp(server_pool[0].hostname, "10.0.1.1") == 0);
+ test_true(server_pool[0].port == 11211);
+ test_true(server_pool[0].weight == 600);
+ test_true(strcmp(server_pool[2].hostname, "10.0.1.3") == 0);
+ test_true(server_pool[2].port == 11211);
+ test_true(server_pool[2].weight == 200);
+ test_true(strcmp(server_pool[7].hostname, "10.0.1.8") == 0);
+ test_true(server_pool[7].port == 11211);
+ test_true(server_pool[7].weight == 100);
+
+ instance= memcached_server_instance_by_position(memc, 2);
+ ((memcached_server_write_instance_st)instance)->next_retry = time(NULL) + 15;
+ memc->ketama.next_distribution_rebuild= time(NULL) - 1;
+
+ /*
+ This would not work if there were only two hosts.
+ */
+ for (size_t x= 0; x < 99; x++)
+ {
+ memcached_autoeject(memc);
+ uint32_t server_idx= memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key));
+ test_true(server_idx != 2);
+ }
+
+ /* and re-added when it's back. */
+ ((memcached_server_write_instance_st)instance)->next_retry = time(NULL) - 1;
+ memc->ketama.next_distribution_rebuild= time(NULL) - 1;
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION,
+ memc->distribution);
+ for (size_t x= 0; x < 99; x++)
+ {
+ uint32_t server_idx = memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key));
+ // We re-use instance from above.
+ instance=
+ memcached_server_instance_by_position(memc, server_idx);
+ const char *hostname = memcached_server_name(instance);
+ test_true(strcmp(hostname, ketama_test_cases[x].server) == 0);
+ }
+
+ memcached_server_list_free(server_pool);
+ memcached_free(memc);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t output_ketama_weighted_keys(memcached_st *trash)
+{
+ (void) trash;
+
+ memcached_return_t rc;
+ memcached_st *memc= memcached_create(NULL);
+ test_true(memc);
+
+
+ rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
+ test_true(value == 1);
+
+ rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
+ test_true(value == MEMCACHED_HASH_MD5);
+
+
+ test_true(memcached_behavior_set_distribution(memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY) == MEMCACHED_SUCCESS);
+
+ memcached_server_st *server_pool;
+ server_pool = memcached_servers_parse("10.0.1.1:11211,10.0.1.2:11211,10.0.1.3:11211,10.0.1.4:11211,10.0.1.5:11211,10.0.1.6:11211,10.0.1.7:11211,10.0.1.8:11211,192.168.1.1:11211,192.168.100.1:11211");
+ memcached_server_push(memc, server_pool);
+
+ // @todo this needs to be refactored to actually test something.
+#if 0
+ FILE *fp;
+ if ((fp = fopen("ketama_keys.txt", "w")))
+ {
+ // noop
+ } else {
+ printf("cannot write to file ketama_keys.txt");
+ return TEST_FAILURE;
+ }
+
+ for (int x= 0; x < 10000; x++)
+ {
+ char key[10];
+ snprintf(key, sizeof(key), "%d", x);
+
+ uint32_t server_idx = memcached_generate_hash(memc, key, strlen(key));
+ char *hostname = memc->hosts[server_idx].hostname;
+ in_port_t port = memc->hosts[server_idx].port;
+ fprintf(fp, "key %s is on host /%s:%u\n", key, hostname, port);
+ memcached_server_instance_st instance=
+ memcached_server_instance_by_position(memc, host_index);
+ }
+ fclose(fp);
+#endif
+ memcached_server_list_free(server_pool);
+ memcached_free(memc);
+
+ return TEST_SUCCESS;
+}
+
+
+static test_return_t result_static(memcached_st *memc)
+{
+ memcached_result_st result;
+ memcached_result_st *result_ptr;
+
+ result_ptr= memcached_result_create(memc, &result);
+ test_true(result.options.is_allocated == false);
+ test_true(memcached_is_initialized(&result) == true);
+ test_true(result_ptr);
+ test_true(result_ptr == &result);
+
+ memcached_result_free(&result);
+
+ test_true(result.options.is_allocated == false);
+ test_true(memcached_is_initialized(&result) == false);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t result_alloc(memcached_st *memc)
+{
+ memcached_result_st *result_ptr;
+
+ result_ptr= memcached_result_create(memc, NULL);
+ test_true(result_ptr);
+ test_true(result_ptr->options.is_allocated == true);
+ test_true(memcached_is_initialized(result_ptr) == true);
+ memcached_result_free(result_ptr);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t cleanup_pairs(memcached_st *memc)
+{
+ (void)memc;
+ pairs_free(global_pairs);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t generate_pairs(memcached_st *memc)
+{
+ (void)memc;
+ global_pairs= pairs_generate(GLOBAL_COUNT, 400);
+ global_count= GLOBAL_COUNT;
+
+ for (size_t x= 0; x < global_count; x++)
+ {
+ global_keys[x]= global_pairs[x].key;
+ global_keys_length[x]= global_pairs[x].key_length;
+ }
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t generate_large_pairs(memcached_st *)
+{
+ global_pairs= pairs_generate(GLOBAL2_COUNT, MEMCACHED_MAX_BUFFER+10);
+ global_count= GLOBAL2_COUNT;
+
+ for (size_t x= 0; x < global_count; x++)
+ {
+ global_keys[x]= global_pairs[x].key;
+ global_keys_length[x]= global_pairs[x].key_length;
+ }
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t generate_data(memcached_st *memc)
+{
+ unsigned int check_execute= execute_set(memc, global_pairs, global_count);
+
+ test_true(check_execute == global_count);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t generate_data_with_stats(memcached_st *memc)
+{
+ uint32_t host_index= 0;
+ unsigned int check_execute= execute_set(memc, global_pairs, global_count);
+
+ test_true(check_execute == global_count);
+
+ // @todo hosts used size stats
+ memcached_return_t rc;
+ memcached_stat_st *stat_p= memcached_stat(memc, NULL, &rc);
+ test_true(stat_p);
+
+ for (host_index= 0; host_index < SERVERS_TO_CREATE; host_index++)
+ {
+ /* This test was changes so that "make test" would work properlly */
+#ifdef DEBUG
+ memcached_server_instance_st instance=
+ memcached_server_instance_by_position(memc, host_index);
+
+ printf("\nserver %u|%s|%u bytes: %llu\n", host_index, instance->hostname, instance->port, (unsigned long long)(stat_p + host_index)->bytes);
+#endif
+ test_true((unsigned long long)(stat_p + host_index)->bytes);
+ }
+
+ memcached_stat_free(NULL, stat_p);
+
+ return TEST_SUCCESS;
+}
+static test_return_t generate_buffer_data(memcached_st *memc)
+{
+ size_t latch= 0;
+
+ latch= 1;
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch);
+ generate_data(memc);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t get_read_count(memcached_st *memc)
+{
+ memcached_st *memc_clone= memcached_clone(NULL, memc);
+ test_true(memc_clone);
+
+ memcached_server_add_with_weight(memc_clone, "localhost", 6666, 0);
+
+ {
+ char *return_value;
+ size_t return_value_length;
+ uint32_t flags;
+ uint32_t count;
+
+ for (size_t x= count= 0; x < global_count; x++)
+ {
+ memcached_return_t rc;
+ return_value= memcached_get(memc_clone, global_keys[x], global_keys_length[x],
+ &return_value_length, &flags, &rc);
+ if (rc == MEMCACHED_SUCCESS)
+ {
+ count++;
+ if (return_value)
+ free(return_value);
+ }
+ }
+ }
+
+ memcached_free(memc_clone);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t get_read(memcached_st *memc)
+{
+ for (size_t x= 0; x < global_count; x++)
+ {
+ size_t return_value_length;
+ uint32_t flags;
+ memcached_return_t rc;
+ char *return_value= memcached_get(memc, global_keys[x], global_keys_length[x],
+ &return_value_length, &flags, &rc);
+ /*
+ test_true(return_value);
+ test_true(rc == MEMCACHED_SUCCESS);
+ */
+ if (rc == MEMCACHED_SUCCESS && return_value)
+ free(return_value);
+ }
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t mget_read(memcached_st *memc)
+{
+
+ if (not libmemcached_util_version_check(memc, 1, 4, 4))
+ return TEST_SKIPPED;
+
+ memcached_return_t rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
+
+ test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
+
+ // Go fetch the keys and test to see if all of them were returned
+ {
+ size_t keys_returned;
+ test_true(fetch_all_results(memc, &keys_returned) == TEST_SUCCESS);
+ char buffer[30];
+ snprintf(buffer, sizeof(buffer), "%lu", (unsigned long)keys_returned);
+ test_true_got(global_count == keys_returned, buffer);
+ }
+
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t mget_read_result(memcached_st *memc)
+{
+
+ if (not libmemcached_util_version_check(memc, 1, 4, 4))
+ return TEST_SKIPPED;
+
+ memcached_return_t rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
+
+ test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
+
+ /* Turn this into a help function */
+ {
+ memcached_result_st results_obj;
+ memcached_result_st *results= memcached_result_create(memc, &results_obj);
+
+ while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
+ {
+ test_true(results);
+ test_true(rc == MEMCACHED_SUCCESS);
+ }
+
+ memcached_result_free(&results_obj);
+ }
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t mget_read_function(memcached_st *memc)
+{
+
+ if (not libmemcached_util_version_check(memc, 1, 4, 4))
+ return TEST_SKIPPED;
+
+ memcached_return_t rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
+
+ test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
+
+ memcached_execute_fn callbacks[]= { &callback_counter };
+ size_t counter= 0;
+ rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t delete_generate(memcached_st *memc)
+{
+ for (size_t x= 0; x < global_count; x++)
+ {
+ (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
+ }
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t delete_buffer_generate(memcached_st *memc)
+{
+ uint64_t latch= 1;
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch);
+
+ for (size_t x= 0; x < global_count; x++)
+ {
+ (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
+ }
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t add_host_test1(memcached_st *memc)
+{
+ memcached_return_t rc;
+ char servername[]= "0.example.com";
+
+ memcached_server_st *servers= memcached_server_list_append_with_weight(NULL, servername, 400, 0, &rc);
+ test_true(servers);
+ test_compare(1, memcached_server_list_count(servers));
+
+ for (size_t x= 2; x < 20; x++)
+ {
+ char buffer[SMALL_STRING_LEN];
+
+ snprintf(buffer, SMALL_STRING_LEN, "%lu.example.com", (unsigned long)(400 +x));
+ servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0,
+ &rc);
+ test_compare(MEMCACHED_SUCCESS, rc);
+ test_compare(x, memcached_server_list_count(servers));
+ }
+
+ test_compare(MEMCACHED_SUCCESS, memcached_server_push(memc, servers));
+ test_compare(MEMCACHED_SUCCESS, memcached_server_push(memc, servers));
+
+ memcached_server_list_free(servers);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t pre_nonblock(memcached_st *memc)
+{
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t pre_cork(memcached_st *memc)
+{
+#ifdef __APPLE__
+ return TEST_SKIPPED;
+#endif
+ bool set= true;
+ if (memcached_success(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CORK, set)))
+ return TEST_SUCCESS;
+
+ return TEST_SKIPPED;
+}
+
+static test_return_t pre_cork_and_nonblock(memcached_st *memc)
+{
+#ifdef __APPLE__
+ return TEST_SKIPPED;
+#endif
+ test_return_t test_rc;
+ if ((test_rc= pre_cork(memc)) != TEST_SUCCESS)
+ return test_rc;
+
+ return pre_nonblock(memc);
+}
+
+static test_return_t pre_nonblock_binary(memcached_st *memc)
+{
+ memcached_return_t rc= MEMCACHED_FAILURE;
+ memcached_st *memc_clone;
+
+ memc_clone= memcached_clone(NULL, memc);
+ test_true(memc_clone);
+ // The memcached_version needs to be done on a clone, because the server
+ // will not toggle protocol on an connection.
+ memcached_version(memc_clone);
+
+ if (libmemcached_util_version_check(memc_clone, 1, 4, 4))
+ {
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
+ rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1);
+ }
+ else
+ {
+ return TEST_SKIPPED;
+ }
+
+ memcached_free(memc_clone);
+
+ return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
+}
+
+static test_return_t pre_murmur(memcached_st *memc)
+{
+#ifdef HAVE_MURMUR_HASH
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR);
+ return TEST_SUCCESS;
+#else
+ (void) memc;
+ return TEST_SKIPPED;
+#endif
+}
+
+static test_return_t pre_jenkins(memcached_st *memc)
+{
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_JENKINS);
+
+ return TEST_SUCCESS;
+}
+
+
+static test_return_t pre_md5(memcached_st *memc)
+{
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MD5);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t pre_crc(memcached_st *memc)
+{
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_CRC);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t pre_hsieh(memcached_st *memc)
+{
+#ifdef HAVE_HSIEH_HASH
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_HSIEH);
+ return TEST_SUCCESS;
+#else
+ (void) memc;
+ return TEST_SKIPPED;
+#endif
+}
+
+static test_return_t pre_hash_fnv1_64(memcached_st *memc)
+{
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t pre_hash_fnv1a_64(memcached_st *memc)
+{
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1A_64);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t pre_hash_fnv1_32(memcached_st *memc)
+{
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1_32);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t pre_hash_fnv1a_32(memcached_st *memc)
+{
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1A_32);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t pre_behavior_ketama(memcached_st *memc)
+{
+ memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA, 1);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA);
+ test_true(value == 1);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t pre_behavior_ketama_weighted(memcached_st *memc)
+{
+ memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
+ test_true(value == 1);
+
+ rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
+ test_true(value == MEMCACHED_HASH_MD5);
+
+ return TEST_SUCCESS;
+}
+
+/**
+ @note This should be testing to see if the server really supports the binary protocol.
+*/
+static test_return_t pre_binary(memcached_st *memc)
+{
+ memcached_return_t rc= MEMCACHED_FAILURE;
+
+ if (libmemcached_util_version_check(memc, 1, 4, 4))
+ {
+ rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1);
+ }
+
+ return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
+}
+
+static test_return_t pre_sasl(memcached_st *memc)
+{
+ memcached_return_t rc= MEMCACHED_FAILURE;
+
+#ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
+ const char *server= getenv("LIBMEMCACHED_TEST_SASL_SERVER");
+ const char *user= getenv("LIBMEMCACHED_TEST_SASL_USERNAME");
+ const char *pass= getenv("LIBMEMCACHED_TEST_SASL_PASSWORD");
+
+ if (server and user and pass)
+ {
+ memcached_server_st *servers= memcached_servers_parse(server);
+ test_true(servers);
+ memcached_servers_reset(memc);
+ test_true(memcached_server_push(memc, servers) == MEMCACHED_SUCCESS);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
+ rc= memcached_set_sasl_auth_data(memc, user, pass);
+ test_true(rc == MEMCACHED_SUCCESS);
+ }
+#else
+ (void)memc;
+#endif
+
+ return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
+}
+
+static test_return_t pre_replication(memcached_st *memc)
+{
+ test_true(TEST_SUCCESS == pre_binary(memc));
+
+ /*
+ * Make sure that we store the item on all servers
+ * (master + replicas == number of servers)
+ */
+ memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS,
+ memcached_server_count(memc) - 1);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS) == memcached_server_count(memc) - 1);
+
+ return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
+}
+
+
+static test_return_t pre_replication_noblock(memcached_st *memc)
+{
+ test_compare(TEST_SUCCESS, pre_replication(memc));
+
+ return pre_nonblock(memc);
+}
+
+
+static void my_free(const memcached_st *ptr, void *mem, void *context)
+{
+ (void)context;
+ (void)ptr;
+#ifdef HARD_MALLOC_TESTS
+ void *real_ptr= (mem == NULL) ? mem : (void*)((caddr_t)mem - 8);
+ free(real_ptr);
+#else
+ free(mem);
+#endif
+}
+
+
+static void *my_malloc(const memcached_st *ptr, const size_t size, void *context)
+{
+ (void)context;
+ (void)ptr;
+#ifdef HARD_MALLOC_TESTS
+ void *ret= malloc(size + 8);
+ if (ret != NULL)
+ {
+ ret= (void*)((caddr_t)ret + 8);
+ }
+#else
+ void *ret= malloc(size);
+#endif
+
+ if (ret != NULL)
+ {
+ memset(ret, 0xff, size);
+ }
+
+ return ret;
+}
+
+
+static void *my_realloc(const memcached_st *ptr, void *mem, const size_t size, void *)
+{
+#ifdef HARD_MALLOC_TESTS
+ void *real_ptr= (mem == NULL) ? NULL : (void*)((caddr_t)mem - 8);
+ void *nmem= realloc(real_ptr, size + 8);
+
+ void *ret= NULL;
+ if (nmem != NULL)
+ {
+ ret= (void*)((caddr_t)nmem + 8);
+ }
+
+ return ret;
+#else
+ (void)ptr;
+ return realloc(mem, size);
+#endif
+}
+
+
+static void *my_calloc(const memcached_st *ptr, size_t nelem, const size_t size, void *)
+{
+#ifdef HARD_MALLOC_TESTS
+ void *mem= my_malloc(ptr, nelem * size);
+ if (mem)
+ {
+ memset(mem, 0, nelem * size);
+ }
+
+ return mem;
+#else
+ (void)ptr;
+ return calloc(nelem, size);
+#endif
+}
+
+static test_return_t set_prefix(memcached_st *memc)
+{
+ memcached_return_t rc;
+ const char *key= "mine";
+ char *value;
+
+ /* Make sure be default none exists */
+ value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
+ test_true(rc == MEMCACHED_FAILURE);
+
+ /* Test a clean set */
+ rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, (void *)key);
+ test_true_got(rc == MEMCACHED_SUCCESS, memcached_last_error_message(memc));
+
+ value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
+ test_true(value);
+ test_true(memcmp(value, key, 4) == 0);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ /* Test that we can turn it off */
+ rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
+ test_false(value);
+ test_true(rc == MEMCACHED_FAILURE);
+
+ /* Now setup for main test */
+ rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, (void *)key);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ value= (char *)memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
+ test_true(value);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(memcmp(value, key, 4) == 0);
+
+ /* Set to Zero, and then Set to something too large */
+ {
+ char long_key[255];
+ memset(long_key, 0, 255);
+
+ rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
+ test_false(value);
+ test_true(rc == MEMCACHED_FAILURE);
+ test_true(value == NULL);
+
+ /* Test a long key for failure */
+ /* TODO, extend test to determine based on setting, what result should be */
+ strncpy(long_key, "Thisismorethentheallottednumberofcharacters", sizeof(long_key));
+ rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
+ //test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
+ strncpy(long_key, "This is more then the allotted number of characters", sizeof(long_key));
+ rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
+ test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
+
+ /* Test for a bad prefix, but with a short key */
+ rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_VERIFY_KEY, 1);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ strncpy(long_key, "dog cat", sizeof(long_key));
+ rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
+ test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
+ }
+
+ return TEST_SUCCESS;
+}
+
+
+#ifdef MEMCACHED_ENABLE_DEPRECATED
+static test_return_t deprecated_set_memory_alloc(memcached_st *memc)
+{
+ void *test_ptr= NULL;
+ void *cb_ptr= NULL;
+ {
+ memcached_malloc_fn malloc_cb=
+ (memcached_malloc_fn)my_malloc;
+ cb_ptr= *(void **)&malloc_cb;
+ memcached_return_t rc;
+
+ rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, cb_ptr);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, &rc);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(test_ptr == cb_ptr);
+ }
+
+ {
+ memcached_realloc_fn realloc_cb=
+ (memcached_realloc_fn)my_realloc;
+ cb_ptr= *(void **)&realloc_cb;
+ memcached_return_t rc;
+
+ rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, cb_ptr);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, &rc);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(test_ptr == cb_ptr);
+ }
+
+ {
+ memcached_free_fn free_cb=
+ (memcached_free_fn)my_free;
+ cb_ptr= *(void **)&free_cb;
+ memcached_return_t rc;
+
+ rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, cb_ptr);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, &rc);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(test_ptr == cb_ptr);
+ }
+
+ return TEST_SUCCESS;
+}
+#endif
+
+
+static test_return_t set_memory_alloc(memcached_st *memc)
+{
+ memcached_return_t rc;
+ rc= memcached_set_memory_allocators(memc, NULL, my_free,
+ my_realloc, my_calloc, NULL);
+ test_true(rc == MEMCACHED_FAILURE);
+
+ rc= memcached_set_memory_allocators(memc, my_malloc, my_free,
+ my_realloc, my_calloc, NULL);
+
+ memcached_malloc_fn mem_malloc;
+ memcached_free_fn mem_free;
+ memcached_realloc_fn mem_realloc;
+ memcached_calloc_fn mem_calloc;
+ memcached_get_memory_allocators(memc, &mem_malloc, &mem_free,
+ &mem_realloc, &mem_calloc);
+
+ test_true(mem_malloc == my_malloc);
+ test_true(mem_realloc == my_realloc);
+ test_true(mem_calloc == my_calloc);
+ test_true(mem_free == my_free);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t enable_consistent_crc(memcached_st *memc)
+{
+ test_return_t rc;
+ memcached_server_distribution_t value= MEMCACHED_DISTRIBUTION_CONSISTENT;
+ memcached_hash_t hash;
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, value);
+ if ((rc= pre_crc(memc)) != TEST_SUCCESS)
+ return rc;
+
+ value= (memcached_server_distribution_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION);
+ test_true(value == MEMCACHED_DISTRIBUTION_CONSISTENT);
+
+ hash= (memcached_hash_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
+
+ if (hash != MEMCACHED_HASH_CRC)
+ return TEST_SKIPPED;
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t enable_consistent_hsieh(memcached_st *memc)
+{
+ test_return_t rc;
+ memcached_server_distribution_t value= MEMCACHED_DISTRIBUTION_CONSISTENT;
+ memcached_hash_t hash;
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, value);
+ if ((rc= pre_hsieh(memc)) != TEST_SUCCESS)
+ return rc;
+
+ value= (memcached_server_distribution_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION);
+ test_true(value == MEMCACHED_DISTRIBUTION_CONSISTENT);
+
+ hash= (memcached_hash_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
+
+ if (hash != MEMCACHED_HASH_HSIEH)
+ return TEST_SKIPPED;
+
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t enable_cas(memcached_st *memc)
+{
+ unsigned int set= 1;
+
+ if (libmemcached_util_version_check(memc, 1, 2, 4))
+ {
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
+
+ return TEST_SUCCESS;
+ }
+
+ return TEST_SKIPPED;
+}
+
+static test_return_t check_for_1_2_3(memcached_st *memc)
+{
+ memcached_version(memc);
+
+ memcached_server_instance_st instance=
+ memcached_server_instance_by_position(memc, 0);
+
+ if ((instance->major_version >= 1 && (instance->minor_version == 2 && instance->micro_version >= 4))
+ || instance->minor_version > 2)
+ {
+ return TEST_SUCCESS;
+ }
+
+ return TEST_SKIPPED;
+}
+
+static test_return_t pre_unix_socket(memcached_st *memc)
+{
+ memcached_return_t rc;
+ struct stat buf;
+
+ memcached_servers_reset(memc);
+
+ if (stat("/tmp/memcached.socket", &buf))
+ return TEST_SKIPPED;
+
+ rc= memcached_server_add_unix_socket_with_weight(memc, "/tmp/memcached.socket", 0);
+
+ return ( rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_FAILURE );
+}
+
+static test_return_t pre_nodelay(memcached_st *memc)
+{
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 0);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t pre_settimer(memcached_st *memc)
+{
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 1000);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 1000);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t poll_timeout(memcached_st *memc)
+{
+ size_t timeout;
+
+ timeout= 100;
+
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
+
+ timeout= (size_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
+
+ test_true(timeout == 100);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t noreply_test(memcached_st *memc)
+{
+ memcached_return_t ret;
+ ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1);
+ test_true(ret == MEMCACHED_SUCCESS);
+ ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
+ test_true(ret == MEMCACHED_SUCCESS);
+ ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1);
+ test_true(ret == MEMCACHED_SUCCESS);
+ test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NOREPLY) == 1);
+ test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS) == 1);
+ test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS) == 1);
+
+ for (int count=0; count < 5; ++count)
+ {
+ for (size_t x= 0; x < 100; ++x)
+ {
+ char key[10];
+ int check_length= (size_t)snprintf(key, sizeof(key), "%lu", (unsigned long)x);
+ test_false((size_t)check_length >= sizeof(key) || check_length < 0);
+
+ size_t len= (size_t)check_length;
+
+ switch (count)
+ {
+ case 0:
+ ret= memcached_add(memc, key, len, key, len, 0, 0);
+ break;
+ case 1:
+ ret= memcached_replace(memc, key, len, key, len, 0, 0);
+ break;
+ case 2:
+ ret= memcached_set(memc, key, len, key, len, 0, 0);
+ break;
+ case 3:
+ ret= memcached_append(memc, key, len, key, len, 0, 0);
+ break;
+ case 4:
+ ret= memcached_prepend(memc, key, len, key, len, 0, 0);
+ break;
+ default:
+ test_true(count);
+ break;
+ }
+ test_true(ret == MEMCACHED_SUCCESS || ret == MEMCACHED_BUFFERED);
+ }
+
+ /*
+ ** NOTE: Don't ever do this in your code! this is not a supported use of the
+ ** API and is _ONLY_ done this way to verify that the library works the
+ ** way it is supposed to do!!!!
+ */
+ int no_msg=0;
+ for (uint32_t x= 0; x < memcached_server_count(memc); ++x)
+ {
+ memcached_server_instance_st instance=
+ memcached_server_instance_by_position(memc, x);
+ no_msg+=(int)(instance->cursor_active);
+ }
+
+ test_true(no_msg == 0);
+ test_true(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
+
+ /*
+ ** Now validate that all items was set properly!
+ */
+ for (size_t x= 0; x < 100; ++x)
+ {
+ char key[10];
+
+ int check_length= (size_t)snprintf(key, sizeof(key), "%lu", (unsigned long)x);
+
+ test_false((size_t)check_length >= sizeof(key) || check_length < 0);
+
+ size_t len= (size_t)check_length;
+ size_t length;
+ uint32_t flags;
+ char* value=memcached_get(memc, key, strlen(key),
+ &length, &flags, &ret);
+ test_true(ret == MEMCACHED_SUCCESS && value != NULL);
+ switch (count)
+ {
+ case 0: /* FALLTHROUGH */
+ case 1: /* FALLTHROUGH */
+ case 2:
+ test_true(strncmp(value, key, len) == 0);
+ test_true(len == length);
+ break;
+ case 3:
+ test_true(length == len * 2);
+ break;
+ case 4:
+ test_true(length == len * 3);
+ break;
+ default:
+ test_true(count);
+ break;
+ }
+ free(value);
+ }
+ }
+
+ /* Try setting an illegal cas value (should not return an error to
+ * the caller (because we don't expect a return message from the server)
+ */
+ const char* keys[]= {"0"};
+ size_t lengths[]= {1};
+ size_t length;
+ uint32_t flags;
+ memcached_result_st results_obj;
+ memcached_result_st *results;
+ ret= memcached_mget(memc, keys, lengths, 1);
+ test_true(ret == MEMCACHED_SUCCESS);
+
+ results= memcached_result_create(memc, &results_obj);
+ test_true(results);
+ results= memcached_fetch_result(memc, &results_obj, &ret);
+ test_true(results);
+ test_true(ret == MEMCACHED_SUCCESS);
+ uint64_t cas= memcached_result_cas(results);
+ memcached_result_free(&results_obj);
+
+ ret= memcached_cas(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0, cas);
+ test_true(ret == MEMCACHED_SUCCESS);
+
+ /*
+ * The item will have a new cas value, so try to set it again with the old
+ * value. This should fail!
+ */
+ ret= memcached_cas(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0, cas);
+ test_true(ret == MEMCACHED_SUCCESS);
+ test_true(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
+ char* value=memcached_get(memc, keys[0], lengths[0], &length, &flags, &ret);
+ test_true(ret == MEMCACHED_SUCCESS && value != NULL);
+ free(value);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t analyzer_test(memcached_st *memc)
+{
+ memcached_return_t rc;
+ memcached_stat_st *memc_stat;
+ memcached_analysis_st *report;
+
+ memc_stat= memcached_stat(memc, NULL, &rc);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(memc_stat);
+
+ report= memcached_analyze(memc, memc_stat, &rc);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(report);
+
+ free(report);
+ memcached_stat_free(NULL, memc_stat);
+
+ return TEST_SUCCESS;
+}
+
+/* Count the objects */
+static memcached_return_t callback_dump_counter(const memcached_st *ptr,
+ const char *key,
+ size_t key_length,
+ void *context)
+{
+ (void)ptr; (void)key; (void)key_length;
+ size_t *counter= (size_t *)context;
+
+ *counter= *counter + 1;
+
+ return MEMCACHED_SUCCESS;
+}
+
+static test_return_t dump_test(memcached_st *memc)
+{
+ size_t counter= 0;
+ memcached_dump_fn callbacks[1];
+ test_return_t main_rc;
+
+ callbacks[0]= &callback_dump_counter;
+
+ /* No support for Binary protocol yet */
+ if (memc->flags.binary_protocol)
+ return TEST_SUCCESS;
+
+ main_rc= set_test3(memc);
+
+ test_true (main_rc == TEST_SUCCESS);
+
+ memcached_return_t rc= memcached_dump(memc, callbacks, (void *)&counter, 1);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ /* We may have more then 32 if our previous flush has not completed */
+ test_true(counter >= 32);
+
+ return TEST_SUCCESS;
+}
+
+#ifdef HAVE_LIBMEMCACHEDUTIL
+
+struct test_pool_context_st {
+ memcached_pool_st* pool;
+ memcached_st* mmc;
+};
+
+static void* connection_release(void *arg)
+{
+ test_pool_context_st *resource= static_cast<test_pool_context_st *>(arg);
+
+ usleep(250);
+ // Release all of the memc we are holding
+ assert(memcached_pool_push(resource->pool, resource->mmc) == MEMCACHED_SUCCESS);
+ return arg;
+}
+
+#define POOL_SIZE 10
+static test_return_t connection_pool_test(memcached_st *memc)
+{
+ memcached_pool_st* pool= memcached_pool_create(memc, 5, POOL_SIZE);
+ test_true(pool != NULL);
+ memcached_st *mmc[POOL_SIZE];
+ memcached_return_t rc;
+
+ // Fill up our array that we will store the memc that are in the pool
+ for (size_t x= 0; x < POOL_SIZE; ++x)
+ {
+ mmc[x]= memcached_pool_pop(pool, false, &rc);
+ test_true(mmc[x] != NULL);
+ test_true(rc == MEMCACHED_SUCCESS);
+ }
+
+ // All memc should be gone
+ test_true(memcached_pool_pop(pool, false, &rc) == NULL);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ pthread_t tid;
+ test_pool_context_st item= { pool, mmc[9] };
+
+ pthread_create(&tid, NULL, connection_release, &item);
+ mmc[9]= memcached_pool_pop(pool, true, &rc);
+ test_true(rc == MEMCACHED_SUCCESS);
+ pthread_join(tid, NULL);
+ test_true(mmc[9]);
+ const char *key= "key";
+ size_t keylen= strlen(key);
+
+ // verify that I can do ops with all connections
+ rc= memcached_set(mmc[0], key, keylen, "0", 1, 0, 0);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ for (size_t x= 0; x < POOL_SIZE; ++x)
+ {
+ uint64_t number_value;
+ rc= memcached_increment(mmc[x], key, keylen, 1, &number_value);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(number_value == (x+1));
+ }
+
+ // Release them..
+ for (size_t x= 0; x < POOL_SIZE; ++x)
+ {
+ test_true(memcached_pool_push(pool, mmc[x]) == MEMCACHED_SUCCESS);
+ }
+
+
+ /* verify that I can set behaviors on the pool when I don't have all
+ * of the connections in the pool. It should however be enabled
+ * when I push the item into the pool
+ */
+ mmc[0]= memcached_pool_pop(pool, false, &rc);
+ test_true(mmc[0] != NULL);
+
+ rc= memcached_pool_behavior_set(pool, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK, 9999);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ mmc[1]= memcached_pool_pop(pool, false, &rc);
+ test_true(mmc[1] != NULL);
+
+ test_true(memcached_behavior_get(mmc[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK) == 9999);
+ test_true(memcached_pool_push(pool, mmc[1]) == MEMCACHED_SUCCESS);
+ test_true(memcached_pool_push(pool, mmc[0]) == MEMCACHED_SUCCESS);
+
+ mmc[0]= memcached_pool_pop(pool, false, &rc);
+ test_true(memcached_behavior_get(mmc[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK) == 9999);
+ test_true(memcached_pool_push(pool, mmc[0]) == MEMCACHED_SUCCESS);
+
+ test_true(memcached_pool_destroy(pool) == memc);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t util_version_test(memcached_st *memc)
+{
+ bool if_successful;
+
+ if_successful= libmemcached_util_version_check(memc, 0, 0, 0);
+ test_true(if_successful == true);
+
+ if_successful= libmemcached_util_version_check(memc, 9, 9, 9);
+
+ // We expect failure
+ if (if_successful)
+ {
+ fprintf(stderr, "\n----------------------------------------------------------------------\n");
+ fprintf(stderr, "\nDumping Server Information\n\n");
+ memcached_server_fn callbacks[1];
+
+ callbacks[0]= dump_server_information;
+ memcached_server_cursor(memc, callbacks, (void *)stderr, 1);
+ fprintf(stderr, "\n----------------------------------------------------------------------\n");
+ }
+ test_true(if_successful == false);
+
+ memcached_server_instance_st instance=
+ memcached_server_instance_by_position(memc, 0);
+
+ memcached_version(memc);
+
+ // We only use one binary when we test, so this should be just fine.
+ if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, instance->micro_version);
+ test_true(if_successful == true);
+
+ if (instance->micro_version > 0)
+ if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, (uint8_t)(instance->micro_version -1));
+ else if (instance->minor_version > 0)
+ if_successful= libmemcached_util_version_check(memc, instance->major_version, (uint8_t)(instance->minor_version - 1), instance->micro_version);
+ else if (instance->major_version > 0)
+ if_successful= libmemcached_util_version_check(memc, (uint8_t)(instance->major_version -1), instance->minor_version, instance->micro_version);
+
+ test_true(if_successful == true);
+
+ if (instance->micro_version > 0)
+ if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, (uint8_t)(instance->micro_version +1));
+ else if (instance->minor_version > 0)
+ if_successful= libmemcached_util_version_check(memc, instance->major_version, (uint8_t)(instance->minor_version +1), instance->micro_version);
+ else if (instance->major_version > 0)
+ if_successful= libmemcached_util_version_check(memc, (uint8_t)(instance->major_version +1), instance->minor_version, instance->micro_version);
+
+ test_true(if_successful == false);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t ping_test(memcached_st *memc)
+{
+ memcached_return_t rc;
+ memcached_server_instance_st instance=
+ memcached_server_instance_by_position(memc, 0);
+
+ // Test both the version that returns a code, and the one that does not.
+ test_true(libmemcached_util_ping(memcached_server_name(instance),
+ memcached_server_port(instance), NULL));
+
+ test_true(libmemcached_util_ping(memcached_server_name(instance),
+ memcached_server_port(instance), &rc));
+
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ return TEST_SUCCESS;
+}
+#endif
+
+
+#if 0
+static test_return_t hash_sanity_test (memcached_st *memc)
+{
+ (void)memc;
+
+ assert(MEMCACHED_HASH_DEFAULT == MEMCACHED_HASH_DEFAULT);
+ assert(MEMCACHED_HASH_MD5 == MEMCACHED_HASH_MD5);
+ assert(MEMCACHED_HASH_CRC == MEMCACHED_HASH_CRC);
+ assert(MEMCACHED_HASH_FNV1_64 == MEMCACHED_HASH_FNV1_64);
+ assert(MEMCACHED_HASH_FNV1A_64 == MEMCACHED_HASH_FNV1A_64);
+ assert(MEMCACHED_HASH_FNV1_32 == MEMCACHED_HASH_FNV1_32);
+ assert(MEMCACHED_HASH_FNV1A_32 == MEMCACHED_HASH_FNV1A_32);
+#ifdef HAVE_HSIEH_HASH
+ assert(MEMCACHED_HASH_HSIEH == MEMCACHED_HASH_HSIEH);
+#endif
+ assert(MEMCACHED_HASH_MURMUR == MEMCACHED_HASH_MURMUR);
+ assert(MEMCACHED_HASH_JENKINS == MEMCACHED_HASH_JENKINS);
+ assert(MEMCACHED_HASH_MAX == MEMCACHED_HASH_MAX);
+
+ return TEST_SUCCESS;
+}
+#endif
+
+static test_return_t hsieh_avaibility_test (memcached_st *memc)
+{
+ memcached_return_t expected_rc= MEMCACHED_INVALID_ARGUMENTS;
+#ifdef HAVE_HSIEH_HASH
+ expected_rc= MEMCACHED_SUCCESS;
+#endif
+ memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH,
+ (uint64_t)MEMCACHED_HASH_HSIEH);
+ test_true(rc == expected_rc);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t murmur_avaibility_test (memcached_st *memc)
+{
+ memcached_return_t expected_rc= MEMCACHED_INVALID_ARGUMENTS;
+#ifdef HAVE_MURMUR_HASH
+ expected_rc= MEMCACHED_SUCCESS;
+#endif
+ memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH,
+ (uint64_t)MEMCACHED_HASH_MURMUR);
+ test_true(rc == expected_rc);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t one_at_a_time_run (memcached_st *memc)
+{
+ uint32_t x;
+ const char **ptr;
+ (void)memc;
+
+ for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+ {
+ uint32_t hash_val;
+
+ hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_DEFAULT);
+ test_true(one_at_a_time_values[x] == hash_val);
+ }
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t md5_run (memcached_st *memc)
+{
+ uint32_t x;
+ const char **ptr;
+ (void)memc;
+
+ for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+ {
+ uint32_t hash_val;
+
+ hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_MD5);
+ test_true(md5_values[x] == hash_val);
+ }
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t crc_run (memcached_st *memc)
+{
+ uint32_t x;
+ const char **ptr;
+ (void)memc;
+
+ for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+ {
+ uint32_t hash_val;
+
+ hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_CRC);
+ test_true(crc_values[x] == hash_val);
+ }
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t fnv1_64_run (memcached_st *memc)
+{
+ uint32_t x;
+ const char **ptr;
+ (void)memc;
+
+ for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+ {
+ uint32_t hash_val;
+
+ hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_64);
+ test_true(fnv1_64_values[x] == hash_val);
+ }
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t fnv1a_64_run (memcached_st *memc)
+{
+ uint32_t x;
+ const char **ptr;
+ (void)memc;
+
+ for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+ {
+ uint32_t hash_val;
+
+ hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_64);
+ test_true(fnv1a_64_values[x] == hash_val);
+ }
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t fnv1_32_run (memcached_st *memc)
+{
+ uint32_t x;
+ const char **ptr;
+ (void)memc;
+
+ for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+ {
+ uint32_t hash_val;
+
+ hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_32);
+ test_true(fnv1_32_values[x] == hash_val);
+ }
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t fnv1a_32_run (memcached_st *memc)
+{
+ uint32_t x;
+ const char **ptr;
+ (void)memc;
+
+ for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+ {
+ uint32_t hash_val;
+
+ hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_32);
+ test_true(fnv1a_32_values[x] == hash_val);
+ }
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t hsieh_run (memcached_st *memc)
+{
+ uint32_t x;
+ const char **ptr;
+ (void)memc;
+
+ for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+ {
+ uint32_t hash_val;
+
+ hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_HSIEH);
+ test_true(hsieh_values[x] == hash_val);
+ }
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t murmur_run (memcached_st *memc)
+{
+#ifdef WORDS_BIGENDIAN
+ (void)murmur_values;
+ return TEST_SKIPPED;
+#else
+ uint32_t x;
+ const char **ptr;
+ (void)memc;
+
+ for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+ {
+ uint32_t hash_val;
+
+ hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_MURMUR);
+ test_true(murmur_values[x] == hash_val);
+ }
+
+ return TEST_SUCCESS;
+#endif
+}
+
+static test_return_t jenkins_run (memcached_st *memc)
+{
+ uint32_t x;
+ const char **ptr;
+ (void)memc;
+
+ for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+ {
+ uint32_t hash_val;
+
+ hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_JENKINS);
+ test_true(jenkins_values[x] == hash_val);
+ }
+
+ return TEST_SUCCESS;
+}
+
+static uint32_t hash_md5_test_function(const char *string, size_t string_length, void *context)
+{
+ (void)context;
+ return libhashkit_md5(string, string_length);
+}
+
+static uint32_t hash_crc_test_function(const char *string, size_t string_length, void *context)
+{
+ (void)context;
+ return libhashkit_crc32(string, string_length);
+}
+
+static test_return_t memcached_get_hashkit_test (memcached_st *memc)
+{
+ uint32_t x;
+ const char **ptr;
+ const hashkit_st *kit;
+ hashkit_st new_kit;
+ hashkit_return_t hash_rc;
+
+ uint32_t md5_hosts[]= {4U, 1U, 0U, 1U, 4U, 2U, 0U, 3U, 0U, 0U, 3U, 1U, 0U, 0U, 1U, 3U, 0U, 0U, 0U, 3U, 1U, 0U, 4U, 4U, 3U};
+ uint32_t crc_hosts[]= {2U, 4U, 1U, 0U, 2U, 4U, 4U, 4U, 1U, 2U, 3U, 4U, 3U, 4U, 1U, 3U, 3U, 2U, 0U, 0U, 0U, 1U, 2U, 4U, 0U};
+
+ kit= memcached_get_hashkit(memc);
+
+ hashkit_clone(&new_kit, kit);
+ hash_rc= hashkit_set_custom_function(&new_kit, hash_md5_test_function, NULL);
+ test_true(hash_rc == HASHKIT_SUCCESS);
+
+ memcached_set_hashkit(memc, &new_kit);
+
+ /*
+ Verify Setting the hash.
+ */
+ for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+ {
+ uint32_t hash_val;
+
+ hash_val= hashkit_digest(kit, *ptr, strlen(*ptr));
+ test_true(md5_values[x] == hash_val);
+ }
+
+
+ /*
+ Now check memcached_st.
+ */
+ for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+ {
+ uint32_t hash_val;
+
+ hash_val= memcached_generate_hash(memc, *ptr, strlen(*ptr));
+ test_true(md5_hosts[x] == hash_val);
+ }
+
+ hash_rc= hashkit_set_custom_function(&new_kit, hash_crc_test_function, NULL);
+ test_true(hash_rc == HASHKIT_SUCCESS);
+
+ memcached_set_hashkit(memc, &new_kit);
+
+ /*
+ Verify Setting the hash.
+ */
+ for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+ {
+ uint32_t hash_val;
+
+ hash_val= hashkit_digest(kit, *ptr, strlen(*ptr));
+ test_true(crc_values[x] == hash_val);
+ }
+
+ for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+ {
+ uint32_t hash_val;
+
+ hash_val= memcached_generate_hash(memc, *ptr, strlen(*ptr));
+ test_true(crc_hosts[x] == hash_val);
+ }
+
+ return TEST_SUCCESS;
+}
+
+/*
+ Test case adapted from John Gorman <johngorman2@gmail.com>
+
+ We are testing the error condition when we connect to a server via memcached_get()
+ but find that the server is not available.
+*/
+static test_return_t memcached_get_MEMCACHED_ERRNO(memcached_st *memc)
+{
+ (void)memc;
+ memcached_st *tl_memc_h;
+ memcached_server_st *servers;
+
+ const char *key= "MemcachedLives";
+ size_t len;
+ uint32_t flags;
+ memcached_return rc;
+ char *value;
+
+ // Create a handle.
+ tl_memc_h= memcached_create(NULL);
+ servers= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
+ memcached_server_push(tl_memc_h, servers);
+ memcached_server_list_free(servers);
+
+ // See if memcached is reachable.
+ value= memcached_get(tl_memc_h, key, strlen(key), &len, &flags, &rc);
+
+ test_false(value);
+ test_true(len == 0);
+ test_false(rc == MEMCACHED_SUCCESS);
+
+ memcached_free(tl_memc_h);
+
+ return TEST_SUCCESS;
+}
+
+/*
+ We connect to a server which exists, but search for a key that does not exist.
+*/
+static test_return_t memcached_get_MEMCACHED_NOTFOUND(memcached_st *memc)
+{
+ const char *key= "MemcachedKeyNotEXIST";
+ size_t len;
+ uint32_t flags;
+ memcached_return rc;
+ char *value;
+
+ // See if memcached is reachable.
+ value= memcached_get(memc, key, strlen(key), &len, &flags, &rc);
+
+ test_false(value);
+ test_true(len == 0);
+ test_true(rc == MEMCACHED_NOTFOUND);
+
+ return TEST_SUCCESS;
+}
+
+/*
+ Test case adapted from John Gorman <johngorman2@gmail.com>
+
+ We are testing the error condition when we connect to a server via memcached_get_by_key()
+ but find that the server is not available.
+*/
+static test_return_t memcached_get_by_key_MEMCACHED_ERRNO(memcached_st *memc)
+{
+ (void)memc;
+ memcached_st *tl_memc_h;
+ memcached_server_st *servers;
+
+ const char *key= "MemcachedLives";
+ size_t len;
+ uint32_t flags;
+ memcached_return rc;
+ char *value;
+
+ // Create a handle.
+ tl_memc_h= memcached_create(NULL);
+ servers= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
+ memcached_server_push(tl_memc_h, servers);
+ memcached_server_list_free(servers);
+
+ // See if memcached is reachable.
+ value= memcached_get_by_key(tl_memc_h, key, strlen(key), key, strlen(key), &len, &flags, &rc);
+
+ test_false(value);
+ test_true(len == 0);
+ test_false(rc == MEMCACHED_SUCCESS);
+
+ memcached_free(tl_memc_h);
+
+ return TEST_SUCCESS;
+}
+
+/*
+ We connect to a server which exists, but search for a key that does not exist.
+*/
+static test_return_t memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st *memc)
+{
+ const char *key= "MemcachedKeyNotEXIST";
+ size_t len;
+ uint32_t flags;
+ memcached_return rc;
+ char *value;
+
+ // See if memcached is reachable.
+ value= memcached_get_by_key(memc, key, strlen(key), key, strlen(key), &len, &flags, &rc);
+
+ test_false(value);
+ test_true(len == 0);
+ test_true(rc == MEMCACHED_NOTFOUND);
+
+ return TEST_SUCCESS;
+}
+
+
+static test_return_t ketama_compatibility_libmemcached(memcached_st *trash)
+{
+ memcached_return_t rc;
+ uint64_t value;
+ int x;
+ memcached_server_st *server_pool;
+ memcached_st *memc;
+
+ (void)trash;
+
+ memc= memcached_create(NULL);
+ test_true(memc);
+
+ rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
+ test_true(value == 1);
+
+ test_true(memcached_behavior_set_distribution(memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA) == MEMCACHED_SUCCESS);
+ test_true(memcached_behavior_get_distribution(memc) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA);
+
+
+ server_pool = memcached_servers_parse("10.0.1.1:11211 600,10.0.1.2:11211 300,10.0.1.3:11211 200,10.0.1.4:11211 350,10.0.1.5:11211 1000,10.0.1.6:11211 800,10.0.1.7:11211 950,10.0.1.8:11211 100");
+ memcached_server_push(memc, server_pool);
+
+ /* verify that the server list was parsed okay. */
+ test_true(memcached_server_count(memc) == 8);
+ test_strcmp(server_pool[0].hostname, "10.0.1.1");
+ test_true(server_pool[0].port == 11211);
+ test_true(server_pool[0].weight == 600);
+ test_strcmp(server_pool[2].hostname, "10.0.1.3");
+ test_true(server_pool[2].port == 11211);
+ test_true(server_pool[2].weight == 200);
+ test_strcmp(server_pool[7].hostname, "10.0.1.8");
+ test_true(server_pool[7].port == 11211);
+ test_true(server_pool[7].weight == 100);
+
+ /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
+ * us test the boundary wraparound.
+ */
+ test_true(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->ketama.continuum[0].index);
+
+ /* verify the standard ketama set. */
+ for (x= 0; x < 99; x++)
+ {
+ uint32_t server_idx = memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key));
+ memcached_server_instance_st instance=
+ memcached_server_instance_by_position(memc, server_idx);
+ const char *hostname = memcached_server_name(instance);
+
+ test_strcmp(hostname, ketama_test_cases[x].server);
+ }
+
+ memcached_server_list_free(server_pool);
+ memcached_free(memc);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t ketama_compatibility_spymemcached(memcached_st *trash)
+{
+ memcached_return_t rc;
+ uint64_t value;
+ memcached_server_st *server_pool;
+ memcached_st *memc;
+
+ (void)trash;
+
+ memc= memcached_create(NULL);
+ test_true(memc);
+
+ rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
+ test_true(value == 1);
+
+ test_true(memcached_behavior_set_distribution(memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY) == MEMCACHED_SUCCESS);
+ test_true(memcached_behavior_get_distribution(memc) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY);
+
+ server_pool = memcached_servers_parse("10.0.1.1:11211 600,10.0.1.2:11211 300,10.0.1.3:11211 200,10.0.1.4:11211 350,10.0.1.5:11211 1000,10.0.1.6:11211 800,10.0.1.7:11211 950,10.0.1.8:11211 100");
+ assert(server_pool);
+ memcached_server_push(memc, server_pool);
+
+ /* verify that the server list was parsed okay. */
+ test_true(memcached_server_count(memc) == 8);
+ test_strcmp(server_pool[0].hostname, "10.0.1.1");
+ test_true(server_pool[0].port == 11211);
+ test_true(server_pool[0].weight == 600);
+ test_strcmp(server_pool[2].hostname, "10.0.1.3");
+ test_true(server_pool[2].port == 11211);
+ test_true(server_pool[2].weight == 200);
+ test_strcmp(server_pool[7].hostname, "10.0.1.8");
+ test_true(server_pool[7].port == 11211);
+ test_true(server_pool[7].weight == 100);
+
+ /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
+ * us test the boundary wraparound.
+ */
+ test_true(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->ketama.continuum[0].index);
+
+ /* verify the standard ketama set. */
+ for (uint32_t x= 0; x < 99; x++)
+ {
+ uint32_t server_idx= memcached_generate_hash(memc, ketama_test_cases_spy[x].key, strlen(ketama_test_cases_spy[x].key));
+
+ memcached_server_instance_st instance=
+ memcached_server_instance_by_position(memc, server_idx);
+
+ const char *hostname= memcached_server_name(instance);
+
+ test_strcmp(hostname, ketama_test_cases_spy[x].server);
+ }
+
+ memcached_server_list_free(server_pool);
+ memcached_free(memc);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t regression_bug_434484(memcached_st *memc)
+{
+ test_return_t test_rc;
+ test_rc= pre_binary(memc);
+
+ if (test_rc != TEST_SUCCESS)
+ return test_rc;
+
+ const char *key= "regression_bug_434484";
+ size_t keylen= strlen(key);
+
+ memcached_return_t ret= memcached_append(memc, key, keylen, key, keylen, 0, 0);
+ test_true(ret == MEMCACHED_NOTSTORED);
+
+ size_t size= 2048 * 1024;
+ char *data= (char*)calloc(1, size);
+ test_true(data);
+ ret= memcached_set(memc, key, keylen, data, size, 0, 0);
+ test_true(ret == MEMCACHED_E2BIG);
+ free(data);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t regression_bug_434843(memcached_st *memc)
+{
+ test_return_t test_rc;
+ test_rc= pre_binary(memc);
+
+ if (test_rc != TEST_SUCCESS)
+ return test_rc;
+
+ memcached_return_t rc;
+ size_t counter= 0;
+ memcached_execute_fn callbacks[]= { &callback_counter };
+
+ /*
+ * I only want to hit only _one_ server so I know the number of requests I'm
+ * sending in the pipleine to the server. Let's try to do a multiget of
+ * 1024 (that should satisfy most users don't you think?). Future versions
+ * will include a mget_execute function call if you need a higher number.
+ */
+ uint32_t number_of_hosts= memcached_server_count(memc);
+ memc->number_of_hosts= 1;
+ const size_t max_keys= 1024;
+ char **keys= (char**)calloc(max_keys, sizeof(char*));
+ size_t *key_length= (size_t *)calloc(max_keys, sizeof(size_t));
+
+ for (size_t x= 0; x < max_keys; ++x)
+ {
+ char k[251];
+
+ key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
+ keys[x]= strdup(k);
+ test_true(keys[x] != NULL);
+ }
+
+ /*
+ * Run two times.. the first time we should have 100% cache miss,
+ * and the second time we should have 100% cache hits
+ */
+ for (size_t y= 0; y < 2; y++)
+ {
+ rc= memcached_mget(memc, (const char**)keys, key_length, max_keys);
+ test_true(rc == MEMCACHED_SUCCESS);
+ rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
+
+ if (y == 0)
+ {
+ /* The first iteration should give me a 100% cache miss. verify that*/
+ char blob[1024]= { 0 };
+
+ test_true(counter == 0);
+
+ for (size_t x= 0; x < max_keys; ++x)
+ {
+ rc= memcached_add(memc, keys[x], key_length[x],
+ blob, sizeof(blob), 0, 0);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ }
+ }
+ else
+ {
+ /* Verify that we received all of the key/value pairs */
+ test_true(counter == max_keys);
+ }
+ }
+
+ /* Release allocated resources */
+ for (size_t x= 0; x < max_keys; ++x)
+ {
+ free(keys[x]);
+ }
+ free(keys);
+ free(key_length);
+
+ memc->number_of_hosts= number_of_hosts;
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t regression_bug_434843_buffered(memcached_st *memc)
+{
+ memcached_return_t rc;
+ rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ return regression_bug_434843(memc);
+}
+
+static test_return_t regression_bug_421108(memcached_st *memc)
+{
+ memcached_return_t rc;
+ memcached_stat_st *memc_stat= memcached_stat(memc, NULL, &rc);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ char *bytes= memcached_stat_get_value(memc, memc_stat, "bytes", &rc);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(bytes != NULL);
+ char *bytes_read= memcached_stat_get_value(memc, memc_stat,
+ "bytes_read", &rc);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(bytes_read != NULL);
+
+ char *bytes_written= memcached_stat_get_value(memc, memc_stat,
+ "bytes_written", &rc);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(bytes_written != NULL);
+
+ test_true(strcmp(bytes, bytes_read) != 0);
+ test_true(strcmp(bytes, bytes_written) != 0);
+
+ /* Release allocated resources */
+ free(bytes);
+ free(bytes_read);
+ free(bytes_written);
+ memcached_stat_free(NULL, memc_stat);
+
+ return TEST_SUCCESS;
+}
+
+/*
+ * The test case isn't obvious so I should probably document why
+ * it works the way it does. Bug 442914 was caused by a bug
+ * in the logic in memcached_purge (it did not handle the case
+ * where the number of bytes sent was equal to the watermark).
+ * In this test case, create messages so that we hit that case
+ * and then disable noreply mode and issue a new command to
+ * verify that it isn't stuck. If we change the format for the
+ * delete command or the watermarks, we need to update this
+ * test....
+ */
+static test_return_t regression_bug_442914(memcached_st *memc)
+{
+ memcached_return_t rc;
+ rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1);
+ test_true(rc == MEMCACHED_SUCCESS);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1);
+
+ uint32_t number_of_hosts= memcached_server_count(memc);
+ memc->number_of_hosts= 1;
+
+ char k[250];
+ size_t len;
+
+ for (uint32_t x= 0; x < 250; ++x)
+ {
+ len= (size_t)snprintf(k, sizeof(k), "%0250u", x);
+ rc= memcached_delete(memc, k, len, 0);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ }
+
+ (void)snprintf(k, sizeof(k), "%037u", 251U);
+ len= strlen(k);
+
+ rc= memcached_delete(memc, k, len, 0);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+
+ rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 0);
+ test_true(rc == MEMCACHED_SUCCESS);
+ rc= memcached_delete(memc, k, len, 0);
+ test_true(rc == MEMCACHED_NOTFOUND);
+
+ memc->number_of_hosts= number_of_hosts;
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t regression_bug_447342(memcached_st *memc)
+{
+ memcached_server_instance_st instance_one;
+ memcached_server_instance_st instance_two;
+
+ if (memcached_server_count(memc) < 3 || pre_replication(memc) != TEST_SUCCESS)
+ return TEST_SKIPPED;
+
+ memcached_return_t rc;
+
+ rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 2);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ const size_t max_keys= 100;
+ char **keys= (char**)calloc(max_keys, sizeof(char*));
+ size_t *key_length= (size_t *)calloc(max_keys, sizeof(size_t));
+
+ for (size_t x= 0; x < max_keys; ++x)
+ {
+ char k[251];
+
+ key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
+ keys[x]= strdup(k);
+ test_true(keys[x] != NULL);
+ rc= memcached_set(memc, k, key_length[x], k, key_length[x], 0, 0);
+ test_true(rc == MEMCACHED_SUCCESS);
+ }
+
+ /*
+ ** We are using the quiet commands to store the replicas, so we need
+ ** to ensure that all of them are processed before we can continue.
+ ** In the test we go directly from storing the object to trying to
+ ** receive the object from all of the different servers, so we
+ ** could end up in a race condition (the memcached server hasn't yet
+ ** processed the quiet command from the replication set when it process
+ ** the request from the other client (created by the clone)). As a
+ ** workaround for that we call memcached_quit to send the quit command
+ ** to the server and wait for the response ;-) If you use the test code
+ ** as an example for your own code, please note that you shouldn't need
+ ** to do this ;-)
+ */
+ memcached_quit(memc);
+
+ /* Verify that all messages are stored, and we didn't stuff too much
+ * into the servers
+ */
+ rc= memcached_mget(memc, (const char* const *)keys, key_length, max_keys);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ size_t counter= 0;
+ memcached_execute_fn callbacks[]= { &callback_counter };
+ rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
+ /* Verify that we received all of the key/value pairs */
+ test_true(counter == max_keys);
+
+ memcached_quit(memc);
+ /*
+ * Don't do the following in your code. I am abusing the internal details
+ * within the library, and this is not a supported interface.
+ * This is to verify correct behavior in the library. Fake that two servers
+ * are dead..
+ */
+ instance_one= memcached_server_instance_by_position(memc, 0);
+ instance_two= memcached_server_instance_by_position(memc, 2);
+ in_port_t port0= instance_one->port;
+ in_port_t port2= instance_two->port;
+
+ ((memcached_server_write_instance_st)instance_one)->port= 0;
+ ((memcached_server_write_instance_st)instance_two)->port= 0;
+
+ rc= memcached_mget(memc, (const char* const *)keys, key_length, max_keys);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ counter= 0;
+ rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
+ test_true(counter == (unsigned int)max_keys);
+
+ /* restore the memc handle */
+ ((memcached_server_write_instance_st)instance_one)->port= port0;
+ ((memcached_server_write_instance_st)instance_two)->port= port2;
+
+ memcached_quit(memc);
+
+ /* Remove half of the objects */
+ for (size_t x= 0; x < max_keys; ++x)
+ {
+ if (x & 1)
+ {
+ rc= memcached_delete(memc, keys[x], key_length[x], 0);
+ test_true(rc == MEMCACHED_SUCCESS);
+ }
+ }
+
+ memcached_quit(memc);
+ ((memcached_server_write_instance_st)instance_one)->port= 0;
+ ((memcached_server_write_instance_st)instance_two)->port= 0;
+
+ /* now retry the command, this time we should have cache misses */
+ rc= memcached_mget(memc, (const char* const *)keys, key_length, max_keys);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ counter= 0;
+ rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
+ test_true(counter == (unsigned int)(max_keys >> 1));
+
+ /* Release allocated resources */
+ for (size_t x= 0; x < max_keys; ++x)
+ {
+ free(keys[x]);
+ }
+ free(keys);
+ free(key_length);
+
+ /* restore the memc handle */
+ ((memcached_server_write_instance_st)instance_one)->port= port0;
+ ((memcached_server_write_instance_st)instance_two)->port= port2;
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t regression_bug_463297(memcached_st *memc)
+{
+ memcached_st *memc_clone= memcached_clone(NULL, memc);
+ test_true(memc_clone != NULL);
+ test_true(memcached_version(memc_clone) == MEMCACHED_SUCCESS);
+
+ memcached_server_instance_st instance=
+ memcached_server_instance_by_position(memc_clone, 0);
+
+ if (instance->major_version > 1 ||
+ (instance->major_version == 1 &&
+ instance->minor_version > 2))
+ {
+ /* Binary protocol doesn't support deferred delete */
+ memcached_st *bin_clone= memcached_clone(NULL, memc);
+ test_true(bin_clone != NULL);
+ test_true(memcached_behavior_set(bin_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1) == MEMCACHED_SUCCESS);
+ test_true(memcached_delete(bin_clone, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS);
+ memcached_free(bin_clone);
+
+ memcached_quit(memc_clone);
+
+ /* If we know the server version, deferred delete should fail
+ * with invalid arguments */
+ test_true(memcached_delete(memc_clone, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS);
+
+ /* If we don't know the server version, we should get a protocol error */
+ memcached_return_t rc= memcached_delete(memc, "foo", 3, 1);
+
+ /* but there is a bug in some of the memcached servers (1.4) that treats
+ * the counter as noreply so it doesn't send the proper error message
+ */
+ test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc));
+
+ /* And buffered mode should be disabled and we should get protocol error */
+ test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1) == MEMCACHED_SUCCESS);
+ rc= memcached_delete(memc, "foo", 3, 1);
+ test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc));
+
+ /* Same goes for noreply... */
+ test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1) == MEMCACHED_SUCCESS);
+ rc= memcached_delete(memc, "foo", 3, 1);
+ test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc));
+
+ /* but a normal request should go through (and be buffered) */
+ test_true((rc= memcached_delete(memc, "foo", 3, 0)) == MEMCACHED_BUFFERED);
+ test_true(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
+
+ test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 0) == MEMCACHED_SUCCESS);
+ /* unbuffered noreply should be success */
+ test_true(memcached_delete(memc, "foo", 3, 0) == MEMCACHED_SUCCESS);
+ /* unbuffered with reply should be not found... */
+ test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 0) == MEMCACHED_SUCCESS);
+ test_true(memcached_delete(memc, "foo", 3, 0) == MEMCACHED_NOTFOUND);
+ }
+
+ memcached_free(memc_clone);
+ return TEST_SUCCESS;
+}
+
+
+/* Test memcached_server_get_last_disconnect
+ * For a working server set, shall be NULL
+ * For a set of non existing server, shall not be NULL
+ */
+static test_return_t test_get_last_disconnect(memcached_st *memc)
+{
+ memcached_return_t rc;
+ memcached_server_instance_st disconnected_server;
+
+ /* With the working set of server */
+ const char *key= "marmotte";
+ const char *value= "milka";
+
+ memcached_reset_last_disconnected_server(memc);
+ rc= memcached_set(memc, key, strlen(key),
+ value, strlen(value),
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+
+ disconnected_server = memcached_server_get_last_disconnect(memc);
+ test_true(disconnected_server == NULL);
+
+ /* With a non existing server */
+ memcached_st *mine;
+ memcached_server_st *servers;
+
+ const char *server_list= "localhost:9";
+
+ servers= memcached_servers_parse(server_list);
+ test_true(servers);
+ mine= memcached_create(NULL);
+ rc= memcached_server_push(mine, servers);
+ test_true(rc == MEMCACHED_SUCCESS);
+ memcached_server_list_free(servers);
+ test_true(mine);
+
+ rc= memcached_set(mine, key, strlen(key),
+ value, strlen(value),
+ (time_t)0, (uint32_t)0);
+ test_true(rc != MEMCACHED_SUCCESS);
+
+ disconnected_server= memcached_server_get_last_disconnect(mine);
+ if (disconnected_server == NULL)
+ {
+ fprintf(stderr, "RC %s\n", memcached_strerror(mine, rc));
+ abort();
+ }
+ test_true(disconnected_server != NULL);
+ test_true(memcached_server_port(disconnected_server)== 9);
+ test_true(strncmp(memcached_server_name(disconnected_server),"localhost",9) == 0);
+
+ memcached_quit(mine);
+ memcached_free(mine);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t test_verbosity(memcached_st *memc)
+{
+ memcached_verbosity(memc, 3);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t test_server_failure(memcached_st *memc)
+{
+ memcached_st *local_memc;
+ memcached_server_instance_st instance= memcached_server_instance_by_position(memc, 0);
+
+ local_memc= memcached_create(NULL);
+
+ memcached_server_add(local_memc, memcached_server_name(instance), memcached_server_port(instance));
+ memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 2);
+
+ uint32_t server_count= memcached_server_count(local_memc);
+
+ test_true(server_count == 1);
+
+ // Disable the server
+ instance= memcached_server_instance_by_position(local_memc, 0);
+ ((memcached_server_write_instance_st)instance)->server_failure_counter= 2;
+
+ memcached_return_t rc;
+ rc= memcached_set(local_memc, "foo", strlen("foo"),
+ NULL, 0,
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SERVER_MARKED_DEAD);
+
+ ((memcached_server_write_instance_st)instance)->server_failure_counter= 0;
+ rc= memcached_set(local_memc, "foo", strlen("foo"),
+ NULL, 0,
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+
+ memcached_free(local_memc);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t test_cull_servers(memcached_st *memc)
+{
+ uint32_t count = memcached_server_count(memc);
+
+ // Do not do this in your code, it is not supported.
+ memc->servers[1].options.is_dead= true;
+ memc->state.is_time_for_rebuild= true;
+
+ uint32_t new_count= memcached_server_count(memc);
+ test_true(count == new_count);
+
+#if 0
+ test_true(count == new_count + 1 );
+#endif
+
+ return TEST_SUCCESS;
+}
+
+
+static memcached_return_t stat_printer(memcached_server_instance_st server,
+ const char *key, size_t key_length,
+ const char *value, size_t value_length,
+ void *context)
+{
+ (void)server;
+ (void)context;
+ (void)key;
+ (void)key_length;
+ (void)value;
+ (void)value_length;
+
+ return MEMCACHED_SUCCESS;
+}
+
+static test_return_t memcached_stat_execute_test(memcached_st *memc)
+{
+ memcached_return_t rc= memcached_stat_execute(memc, NULL, stat_printer, NULL);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ rc= memcached_stat_execute(memc, "slabs", stat_printer, NULL);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ rc= memcached_stat_execute(memc, "items", stat_printer, NULL);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ rc= memcached_stat_execute(memc, "sizes", stat_printer, NULL);
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ return TEST_SUCCESS;
+}
+
+/*
+ * This test ensures that the failure counter isn't incremented during
+ * normal termination of the memcached instance.
+ */
+static test_return_t wrong_failure_counter_test(memcached_st *memc)
+{
+ memcached_return_t rc;
+ memcached_server_instance_st instance;
+
+ /* Set value to force connection to the server */
+ const char *key= "marmotte";
+ const char *value= "milka";
+
+ /*
+ * Please note that I'm abusing the internal structures in libmemcached
+ * in a non-portable way and you shouldn't be doing this. I'm only
+ * doing this in order to verify that the library works the way it should
+ */
+ uint32_t number_of_hosts= memcached_server_count(memc);
+ memc->number_of_hosts= 1;
+
+ /* Ensure that we are connected to the server by setting a value */
+ rc= memcached_set(memc, key, strlen(key),
+ value, strlen(value),
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+
+
+ instance= memcached_server_instance_by_position(memc, 0);
+ /* The test is to see that the memcached_quit doesn't increase the
+ * the server failure conter, so let's ensure that it is zero
+ * before sending quit
+ */
+ ((memcached_server_write_instance_st)instance)->server_failure_counter= 0;
+
+ memcached_quit(memc);
+
+ /* Verify that it memcached_quit didn't increment the failure counter
+ * Please note that this isn't bullet proof, because an error could
+ * occur...
+ */
+ test_true(instance->server_failure_counter == 0);
+
+ /* restore the instance */
+ memc->number_of_hosts= number_of_hosts;
+
+ return TEST_SUCCESS;
+}
+
+/*
+ * This tests ensures expected disconnections (for some behavior changes
+ * for instance) do not wrongly increase failure counter
+ */
+static test_return_t wrong_failure_counter_two_test(memcached_st *memc)
+{
+ memcached_return rc;
+
+ memcached_st *memc_clone;
+ memc_clone= memcached_clone(NULL, memc);
+ test_true(memc_clone);
+
+ /* Set value to force connection to the server */
+ const char *key= "marmotte";
+ const char *value= "milka";
+ char *string = NULL;
+ size_t string_length;
+ uint32_t flags;
+
+ rc= memcached_set(memc_clone, key, strlen(key),
+ value, strlen(value),
+ (time_t)0, (uint32_t)0);
+ test_true_got(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc));
+
+
+ /* put failure limit to 1 */
+ rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 1);
+ assert(rc == MEMCACHED_SUCCESS);
+
+ /* Put a retry timeout to effectively activate failure_limit effect */
+ rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 1);
+ assert(rc == MEMCACHED_SUCCESS);
+
+ /* change behavior that triggers memcached_quit()*/
+ rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1);
+ assert(rc == MEMCACHED_SUCCESS);
+
+
+ /* Check if we still are connected */
+ string= memcached_get(memc_clone, key, strlen(key),
+ &string_length, &flags, &rc);
+
+ test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
+ test_true(string);
+ free(string);
+ memcached_free(memc_clone);
+
+ return TEST_SUCCESS;
+}
+
+
+
+
+/*
+ * Test that ensures mget_execute does not end into recursive calls that finally fails
+ */
+static test_return_t regression_bug_490486(memcached_st *memc)
+{
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 1);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, 1000);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 1);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 3600);
+
+#ifdef __APPLE__
+ return TEST_SKIPPED; // My MAC can't handle this test
+#endif
+
+ /*
+ * I only want to hit _one_ server so I know the number of requests I'm
+ * sending in the pipeline.
+ */
+ uint32_t number_of_hosts= memc->number_of_hosts;
+ memc->number_of_hosts= 1;
+ size_t max_keys= 20480;
+
+
+ char **keys= (char **)calloc(max_keys, sizeof(char*));
+ size_t *key_length= (size_t *)calloc(max_keys, sizeof(size_t));
+
+ /* First add all of the items.. */
+ bool slept= false;
+ char blob[1024]= { 0 };
+ memcached_return rc;
+ for (size_t x= 0; x < max_keys; ++x)
+ {
+ char k[251];
+ key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
+ keys[x]= strdup(k);
+ assert(keys[x] != NULL);
+ rc= memcached_set(memc, keys[x], key_length[x], blob, sizeof(blob), 0, 0);
+#ifdef __APPLE__
+ if (rc == MEMCACHED_SERVER_MARKED_DEAD)
+ {
+ break; // We are out of business
+ }
+#endif
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED || rc == MEMCACHED_TIMEOUT); // MEMCACHED_TIMEOUT <-- only observed on OSX
+
+ if (rc == MEMCACHED_TIMEOUT && slept == false)
+ {
+ x++;
+ sleep(1);// We will try to sleep
+ slept= true;
+ }
+ else if (rc == MEMCACHED_TIMEOUT && slept == true)
+ {
+ // We failed to send everything.
+ break;
+ }
+ }
+
+ if (rc != MEMCACHED_SERVER_MARKED_DEAD)
+ {
+
+ /* Try to get all of them with a large multiget */
+ size_t counter= 0;
+ memcached_execute_function callbacks[]= { &callback_counter };
+ rc= memcached_mget_execute(memc, (const char**)keys, key_length,
+ (size_t)max_keys, callbacks, &counter, 1);
+
+ assert(rc == MEMCACHED_SUCCESS);
+ char* the_value= NULL;
+ char the_key[MEMCACHED_MAX_KEY];
+ size_t the_key_length;
+ size_t the_value_length;
+ uint32_t the_flags;
+
+ do {
+ the_value= memcached_fetch(memc, the_key, &the_key_length, &the_value_length, &the_flags, &rc);
+
+ if ((the_value!= NULL) && (rc == MEMCACHED_SUCCESS))
+ {
+ ++counter;
+ free(the_value);
+ }
+
+ } while ( (the_value!= NULL) && (rc == MEMCACHED_SUCCESS));
+
+
+ assert(rc == MEMCACHED_END);
+
+ /* Verify that we got all of the items */
+ assert(counter == max_keys);
+ }
+
+ /* Release all allocated resources */
+ for (size_t x= 0; x < max_keys; ++x)
+ {
+ free(keys[x]);
+ }
+ free(keys);
+ free(key_length);
+
+ memc->number_of_hosts= number_of_hosts;
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t regression_bug_583031(memcached_st *)
+{
+ memcached_st *memc= memcached_create(NULL);
+ test_true(memc);
+ test_true(memcached_success(memcached_server_add(memc, "10.2.3.4", 11211)));
+
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, 1000);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 1000);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 1000);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 1000);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, 1000);
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 3);
+
+ memcached_return_t rc;
+ size_t length;
+ uint32_t flags;
+
+ const char *value= memcached_get(memc, "dsf", 3, &length, &flags, &rc);
+ test_false(value);
+ test_compare(0, length);
+
+ test_true_got(rc == MEMCACHED_TIMEOUT || rc == MEMCACHED_ERRNO || rc == MEMCACHED_FAILURE, memcached_strerror(memc, rc));
+
+ memcached_free(memc);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t regression_bug_581030(memcached_st *)
+{
+#ifndef DEBUG
+ memcached_stat_st *local_stat= memcached_stat(NULL, NULL, NULL);
+ test_false(local_stat);
+
+ memcached_stat_free(NULL, NULL);
+#endif
+
+ return TEST_SUCCESS;
+}
+
+static void memcached_die(memcached_st* mc, memcached_return error, const char* what, uint32_t it)
+{
+ fprintf(stderr, "Iteration #%u: ", it);
+
+ if(error == MEMCACHED_ERRNO)
+ {
+ fprintf(stderr, "system error %d from %s: %s\n",
+ errno, what, strerror(errno));
+ }
+ else
+ {
+ fprintf(stderr, "error %d from %s: %s\n", error, what,
+ memcached_strerror(mc, error));
+ }
+}
+
+#define TEST_CONSTANT_CREATION 200
+
+static test_return_t regression_bug_(memcached_st *memc)
+{
+ const char *remote_server;
+ (void)memc;
+
+ if (! (remote_server= getenv("LIBMEMCACHED_REMOTE_SERVER")))
+ {
+ return TEST_SKIPPED;
+ }
+
+ for (uint32_t x= 0; x < TEST_CONSTANT_CREATION; x++)
+ {
+ memcached_st* mc= memcached_create(NULL);
+ memcached_return rc;
+
+ rc= memcached_behavior_set(mc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
+ if (rc != MEMCACHED_SUCCESS)
+ {
+ memcached_die(mc, rc, "memcached_behavior_set", x);
+ }
+
+ rc= memcached_behavior_set(mc, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS, 1);
+ if (rc != MEMCACHED_SUCCESS)
+ {
+ memcached_die(mc, rc, "memcached_behavior_set", x);
+ }
+
+ rc= memcached_server_add(mc, remote_server, 0);
+ if (rc != MEMCACHED_SUCCESS)
+ {
+ memcached_die(mc, rc, "memcached_server_add", x);
+ }
+
+ const char *set_key= "akey";
+ const size_t set_key_len= strlen(set_key);
+ const char *set_value= "a value";
+ const size_t set_value_len= strlen(set_value);
+
+ if (rc == MEMCACHED_SUCCESS)
+ {
+ if (x > 0)
+ {
+ size_t get_value_len;
+ char *get_value;
+ uint32_t get_value_flags;
+
+ get_value= memcached_get(mc, set_key, set_key_len, &get_value_len,
+ &get_value_flags, &rc);
+ if (rc != MEMCACHED_SUCCESS)
+ {
+ memcached_die(mc, rc, "memcached_get", x);
+ }
+ else
+ {
+
+ if (x != 0 &&
+ (get_value_len != set_value_len
+ || 0!=strncmp(get_value, set_value, get_value_len)))
+ {
+ fprintf(stderr, "Values don't match?\n");
+ rc= MEMCACHED_FAILURE;
+ }
+ free(get_value);
+ }
+ }
+
+ rc= memcached_set(mc,
+ set_key, set_key_len,
+ set_value, set_value_len,
+ 0, /* time */
+ 0 /* flags */
+ );
+ if (rc != MEMCACHED_SUCCESS)
+ {
+ memcached_die(mc, rc, "memcached_set", x);
+ }
+ }
+
+ memcached_quit(mc);
+ memcached_free(mc);
+
+ if (rc != MEMCACHED_SUCCESS)
+ {
+ break;
+ }
+ }
+
+ return TEST_SUCCESS;
+}
+
+/*
+ * Test that the sasl authentication works. We cannot use the default
+ * pool of servers, because that would require that all servers we want
+ * to test supports SASL authentication, and that they use the default
+ * creds.
+ */
+static test_return_t sasl_auth_test(memcached_st *memc)
+{
+#ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
+ memcached_return_t rc;
+
+ rc= memcached_set(memc, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true((rc= memcached_delete(memc, "foo", 3, 0)) == MEMCACHED_SUCCESS);
+ test_true((rc= memcached_destroy_sasl_auth_data(memc)) == MEMCACHED_SUCCESS);
+ test_true((rc= memcached_destroy_sasl_auth_data(memc)) == MEMCACHED_FAILURE);
+ test_true((rc= memcached_destroy_sasl_auth_data(NULL)) == MEMCACHED_FAILURE);
+ memcached_quit(memc);
+
+ rc= memcached_set_sasl_auth_data(memc,
+ getenv("LIBMEMCACHED_TEST_SASL_USERNAME"),
+ getenv("LIBMEMCACHED_TEST_SASL_SERVER"));
+ test_true(rc == MEMCACHED_SUCCESS);
+
+ rc= memcached_set(memc, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_AUTH_FAILURE);
+ test_true(memcached_destroy_sasl_auth_data(memc) == MEMCACHED_SUCCESS);
+
+ memcached_quit(memc);
+ return TEST_SUCCESS;
+#else
+ (void)memc;
+ return TEST_FAILURE;
+#endif
+}
+
+/* Clean the server before beginning testing */
+test_st tests[] ={
+ {"util_version", 1, (test_callback_fn)util_version_test },
+ {"flush", 0, (test_callback_fn)flush_test },
+ {"init", 0, (test_callback_fn)init_test },
+ {"allocation", 0, (test_callback_fn)allocation_test },
+ {"server_list_null_test", 0, (test_callback_fn)server_list_null_test},
+ {"server_unsort", 0, (test_callback_fn)server_unsort_test},
+ {"server_sort", 0, (test_callback_fn)server_sort_test},
+ {"server_sort2", 0, (test_callback_fn)server_sort2_test},
+ {"memcached_server_remove", 0, (test_callback_fn)memcached_server_remove_test},
+ {"clone_test", 0, (test_callback_fn)clone_test },
+ {"connection_test", 0, (test_callback_fn)connection_test},
+ {"callback_test", 0, (test_callback_fn)callback_test},
+ {"userdata_test", 0, (test_callback_fn)userdata_test},
+ {"error", 0, (test_callback_fn)error_test },
+ {"set", 0, (test_callback_fn)set_test },
+ {"set2", 0, (test_callback_fn)set_test2 },
+ {"set3", 0, (test_callback_fn)set_test3 },
+ {"dump", 1, (test_callback_fn)dump_test},
+ {"add", 1, (test_callback_fn)add_test },
+ {"replace", 1, (test_callback_fn)replace_test },
+ {"delete", 1, (test_callback_fn)delete_test },
+ {"get", 1, (test_callback_fn)get_test },
+ {"get2", 0, (test_callback_fn)get_test2 },
+ {"get3", 0, (test_callback_fn)get_test3 },
+ {"get4", 0, (test_callback_fn)get_test4 },
+ {"partial mget", 0, (test_callback_fn)get_test5 },
+ {"stats_servername", 0, (test_callback_fn)stats_servername_test },
+ {"increment", 0, (test_callback_fn)increment_test },
+ {"increment_with_initial", 1, (test_callback_fn)increment_with_initial_test },
+ {"decrement", 0, (test_callback_fn)decrement_test },
+ {"decrement_with_initial", 1, (test_callback_fn)decrement_with_initial_test },
+ {"increment_by_key", 0, (test_callback_fn)increment_by_key_test },
+ {"increment_with_initial_by_key", 1, (test_callback_fn)increment_with_initial_by_key_test },
+ {"decrement_by_key", 0, (test_callback_fn)decrement_by_key_test },
+ {"decrement_with_initial_by_key", 1, (test_callback_fn)decrement_with_initial_by_key_test },
+ {"quit", 0, (test_callback_fn)quit_test },
+ {"mget", 1, (test_callback_fn)mget_test },
+ {"mget_result", 1, (test_callback_fn)mget_result_test },
+ {"mget_result_alloc", 1, (test_callback_fn)mget_result_alloc_test },
+ {"mget_result_function", 1, (test_callback_fn)mget_result_function },
+ {"mget_execute", 1, (test_callback_fn)mget_execute },
+ {"mget_end", 0, (test_callback_fn)mget_end },
+ {"get_stats", 0, (test_callback_fn)get_stats },
+ {"add_host_test", 0, (test_callback_fn)add_host_test },
+ {"add_host_test_1", 0, (test_callback_fn)add_host_test1 },
+ {"get_stats_keys", 0, (test_callback_fn)get_stats_keys },
+ {"version_string_test", 0, (test_callback_fn)version_string_test},
+ {"bad_key", 1, (test_callback_fn)bad_key_test },
+ {"memcached_server_cursor", 1, (test_callback_fn)memcached_server_cursor_test },
+ {"read_through", 1, (test_callback_fn)read_through },
+ {"delete_through", 1, (test_callback_fn)delete_through },
+ {"noreply", 1, (test_callback_fn)noreply_test},
+ {"analyzer", 1, (test_callback_fn)analyzer_test},
+ {"connectionpool", 1, (test_callback_fn)connection_pool_test },
+ {"memcached_pool_test", 1, (test_callback_fn)memcached_pool_test },
+ {"ping", 1, (test_callback_fn)ping_test },
+ {"test_get_last_disconnect", 1, (test_callback_fn)test_get_last_disconnect},
+ {"verbosity", 1, (test_callback_fn)test_verbosity},
+ {"test_server_failure", 1, (test_callback_fn)test_server_failure},
+ {"cull_servers", 1, (test_callback_fn)test_cull_servers},
+ {"memcached_stat_execute", 1, (test_callback_fn)memcached_stat_execute_test},
+ {0, 0, 0}
+};
+
+test_st behavior_tests[] ={
+ {"behavior_test", 0, (test_callback_fn)behavior_test},
+ {"MEMCACHED_BEHAVIOR_CORK", 0, (test_callback_fn)MEMCACHED_BEHAVIOR_CORK_test},
+ {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", 0, (test_callback_fn)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test},
+ {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", 0, (test_callback_fn)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test},
+ {0, 0, 0}
+};
+
+test_st basic_tests[] ={
+ {"init", 1, (test_callback_fn)basic_init_test},
+ {"clone", 1, (test_callback_fn)basic_clone_test},
+ {"reset", 1, (test_callback_fn)basic_reset_stack_test},
+ {"reset heap", 1, (test_callback_fn)basic_reset_heap_test},
+ {"reset stack clone", 1, (test_callback_fn)basic_reset_stack_clone_test},
+ {"reset heap clone", 1, (test_callback_fn)basic_reset_heap_clone_test},
+ {0, 0, 0}
+};
+
+test_st regression_binary_vs_block[] ={
+ {"block add", 1, (test_callback_fn)block_add_regression},
+ {"binary add", 1, (test_callback_fn)binary_add_regression},
+ {0, 0, 0}
+};
+
+test_st async_tests[] ={
+ {"add", 1, (test_callback_fn)add_wrapper },
+ {0, 0, 0}
+};
+
+test_st string_tests[] ={
+ {"string static with null", 0, (test_callback_fn)string_static_null },
+ {"string alloc with null", 0, (test_callback_fn)string_alloc_null },
+ {"string alloc with 1K", 0, (test_callback_fn)string_alloc_with_size },
+ {"string alloc with malloc failure", 0, (test_callback_fn)string_alloc_with_size_toobig },
+ {"string append", 0, (test_callback_fn)string_alloc_append },
+ {"string append failure (too big)", 0, (test_callback_fn)string_alloc_append_toobig },
+ {"string_alloc_append_multiple", 0, (test_callback_fn)string_alloc_append_multiple },
+ {0, 0, (test_callback_fn)0}
+};
+
+test_st result_tests[] ={
+ {"result static", 0, (test_callback_fn)result_static},
+ {"result alloc", 0, (test_callback_fn)result_alloc},
+ {0, 0, (test_callback_fn)0}
+};
+
+test_st version_1_2_3[] ={
+ {"append", 0, (test_callback_fn)append_test },
+ {"prepend", 0, (test_callback_fn)prepend_test },
+ {"cas", 0, (test_callback_fn)cas_test },
+ {"cas2", 0, (test_callback_fn)cas2_test },
+ {"append_binary", 0, (test_callback_fn)append_binary_test },
+ {0, 0, (test_callback_fn)0}
+};
+
+test_st user_tests[] ={
+ {"user_supplied_bug1", 0, (test_callback_fn)user_supplied_bug1 },
+ {"user_supplied_bug2", 0, (test_callback_fn)user_supplied_bug2 },
+ {"user_supplied_bug3", 0, (test_callback_fn)user_supplied_bug3 },
+ {"user_supplied_bug4", 0, (test_callback_fn)user_supplied_bug4 },
+ {"user_supplied_bug5", 1, (test_callback_fn)user_supplied_bug5 },
+ {"user_supplied_bug6", 1, (test_callback_fn)user_supplied_bug6 },
+ {"user_supplied_bug7", 1, (test_callback_fn)user_supplied_bug7 },
+ {"user_supplied_bug8", 1, (test_callback_fn)user_supplied_bug8 },
+ {"user_supplied_bug9", 1, (test_callback_fn)user_supplied_bug9 },
+ {"user_supplied_bug10", 1, (test_callback_fn)user_supplied_bug10 },
+ {"user_supplied_bug11", 1, (test_callback_fn)user_supplied_bug11 },
+ {"user_supplied_bug12", 1, (test_callback_fn)user_supplied_bug12 },
+ {"user_supplied_bug13", 1, (test_callback_fn)user_supplied_bug13 },
+ {"user_supplied_bug14", 1, (test_callback_fn)user_supplied_bug14 },
+ {"user_supplied_bug15", 1, (test_callback_fn)user_supplied_bug15 },
+ {"user_supplied_bug16", 1, (test_callback_fn)user_supplied_bug16 },
+#if !defined(__sun) && !defined(__OpenBSD__)
+ /*
+ ** It seems to be something weird with the character sets..
+ ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
+ ** guess I need to find out how this is supposed to work.. Perhaps I need
+ ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
+ ** so just disable the code for now...).
+ */
+ {"user_supplied_bug17", 1, (test_callback_fn)user_supplied_bug17 },
+#endif
+ {"user_supplied_bug18", 1, (test_callback_fn)user_supplied_bug18 },
+ {"user_supplied_bug19", 1, (test_callback_fn)user_supplied_bug19 },
+ {"user_supplied_bug20", 1, (test_callback_fn)user_supplied_bug20 },
+ {"user_supplied_bug21", 1, (test_callback_fn)user_supplied_bug21 },
+ {"wrong_failure_counter_test", 1, (test_callback_fn)wrong_failure_counter_test},
+ {"wrong_failure_counter_two_test", 1, (test_callback_fn)wrong_failure_counter_two_test},
+ {0, 0, (test_callback_fn)0}
+};
+
+test_st replication_tests[]= {
+ {"set", 1, (test_callback_fn)replication_set_test },
+ {"get", 0, (test_callback_fn)replication_get_test },
+ {"mget", 0, (test_callback_fn)replication_mget_test },
+ {"delete", 0, (test_callback_fn)replication_delete_test },
+ {"rand_mget", 0, (test_callback_fn)replication_randomize_mget_test },
+ {0, 0, (test_callback_fn)0}
+};
+
+/*
+ * The following test suite is used to verify that we don't introduce
+ * regression bugs. If you want more information about the bug / test,
+ * you should look in the bug report at
+ * http://bugs.launchpad.net/libmemcached
+ */
+test_st regression_tests[]= {
+ {"lp:434484", 1, (test_callback_fn)regression_bug_434484 },
+ {"lp:434843", 1, (test_callback_fn)regression_bug_434843 },
+ {"lp:434843-buffered", 1, (test_callback_fn)regression_bug_434843_buffered },
+ {"lp:421108", 1, (test_callback_fn)regression_bug_421108 },
+ {"lp:442914", 1, (test_callback_fn)regression_bug_442914 },
+ {"lp:447342", 1, (test_callback_fn)regression_bug_447342 },
+ {"lp:463297", 1, (test_callback_fn)regression_bug_463297 },
+ {"lp:490486", 1, (test_callback_fn)regression_bug_490486 },
+ {"lp:583031", 1, (test_callback_fn)regression_bug_583031 },
+ {"lp:?", 1, (test_callback_fn)regression_bug_ },
+ {"lp:728286", 1, (test_callback_fn)regression_bug_728286 },
+ {"lp:581030", 1, (test_callback_fn)regression_bug_581030 },
+ {0, 0, (test_callback_fn)0}
+};
+
+test_st sasl_auth_tests[]= {
+ {"sasl_auth", 1, (test_callback_fn)sasl_auth_test },
+ {0, 0, (test_callback_fn)0}
+};
+
+test_st ketama_compatibility[]= {
+ {"libmemcached", 1, (test_callback_fn)ketama_compatibility_libmemcached },
+ {"spymemcached", 1, (test_callback_fn)ketama_compatibility_spymemcached },
+ {0, 0, (test_callback_fn)0}
+};
+
+test_st generate_tests[] ={
+ {"generate_pairs", 1, (test_callback_fn)generate_pairs },
+ {"generate_data", 1, (test_callback_fn)generate_data },
+ {"get_read", 0, (test_callback_fn)get_read },
+ {"delete_generate", 0, (test_callback_fn)delete_generate },
+ {"generate_buffer_data", 1, (test_callback_fn)generate_buffer_data },
+ {"delete_buffer", 0, (test_callback_fn)delete_buffer_generate},
+ {"generate_data", 1, (test_callback_fn)generate_data },
+ {"mget_read", 0, (test_callback_fn)mget_read },
+ {"mget_read_result", 0, (test_callback_fn)mget_read_result },
+ {"mget_read_function", 0, (test_callback_fn)mget_read_function },
+ {"cleanup", 1, (test_callback_fn)cleanup_pairs },
+ {"generate_large_pairs", 1, (test_callback_fn)generate_large_pairs },
+ {"generate_data", 1, (test_callback_fn)generate_data },
+ {"generate_buffer_data", 1, (test_callback_fn)generate_buffer_data },
+ {"cleanup", 1, (test_callback_fn)cleanup_pairs },
+ {0, 0, (test_callback_fn)0}
+};
+
+test_st consistent_tests[] ={
+ {"generate_pairs", 1, (test_callback_fn)generate_pairs },
+ {"generate_data", 1, (test_callback_fn)generate_data },
+ {"get_read", 0, (test_callback_fn)get_read_count },
+ {"cleanup", 1, (test_callback_fn)cleanup_pairs },
+ {0, 0, (test_callback_fn)0}
+};
+
+test_st consistent_weighted_tests[] ={
+ {"generate_pairs", 1, (test_callback_fn)generate_pairs },
+ {"generate_data", 1, (test_callback_fn)generate_data_with_stats },
+ {"get_read", 0, (test_callback_fn)get_read_count },
+ {"cleanup", 1, (test_callback_fn)cleanup_pairs },
+ {0, 0, (test_callback_fn)0}
+};
+
+test_st hsieh_availability[] ={
+ {"hsieh_avaibility_test", 0, (test_callback_fn)hsieh_avaibility_test},
+ {0, 0, (test_callback_fn)0}
+};
+
+test_st murmur_availability[] ={
+ {"murmur_avaibility_test", 0, (test_callback_fn)murmur_avaibility_test},
+ {0, 0, (test_callback_fn)0}
+};
+
+#if 0
+test_st hash_sanity[] ={
+ {"hash sanity", 0, (test_callback_fn)hash_sanity_test},
+ {0, 0, (test_callback_fn)0}
+};
+#endif
+
+test_st ketama_auto_eject_hosts[] ={
+ {"auto_eject_hosts", 1, (test_callback_fn)auto_eject_hosts },
+ {"output_ketama_weighted_keys", 1, (test_callback_fn)output_ketama_weighted_keys },
+ {0, 0, (test_callback_fn)0}
+};
+
+test_st hash_tests[] ={
+ {"one_at_a_time_run", 0, (test_callback_fn)one_at_a_time_run },
+ {"md5", 0, (test_callback_fn)md5_run },
+ {"crc", 0, (test_callback_fn)crc_run },
+ {"fnv1_64", 0, (test_callback_fn)fnv1_64_run },
+ {"fnv1a_64", 0, (test_callback_fn)fnv1a_64_run },
+ {"fnv1_32", 0, (test_callback_fn)fnv1_32_run },
+ {"fnv1a_32", 0, (test_callback_fn)fnv1a_32_run },
+ {"hsieh", 0, (test_callback_fn)hsieh_run },
+ {"murmur", 0, (test_callback_fn)murmur_run },
+ {"jenkis", 0, (test_callback_fn)jenkins_run },
+ {"memcached_get_hashkit", 0, (test_callback_fn)memcached_get_hashkit_test },
+ {0, 0, (test_callback_fn)0}
+};
+
+test_st error_conditions[] ={
+ {"memcached_get(MEMCACHED_ERRNO)", 0, (test_callback_fn)memcached_get_MEMCACHED_ERRNO },
+ {"memcached_get(MEMCACHED_NOTFOUND)", 0, (test_callback_fn)memcached_get_MEMCACHED_NOTFOUND },
+ {"memcached_get_by_key(MEMCACHED_ERRNO)", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_ERRNO },
+ {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_NOTFOUND },
+ {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_NOTFOUND },
+ {"memcached_increment(MEMCACHED_NO_SERVERS)", 0, (test_callback_fn)memcached_increment_MEMCACHED_NO_SERVERS },
+ {0, 0, (test_callback_fn)0}
+};
+
+
+test_st parser_tests[] ={
+ {"behavior", 0, (test_callback_fn)behavior_parser_test },
+ {"boolean_options", 0, (test_callback_fn)parser_boolean_options_test },
+ {"configure_file", 0, (test_callback_fn)memcached_create_with_options_with_filename },
+ {"distribtions", 0, (test_callback_fn)parser_distribution_test },
+ {"hash", 0, (test_callback_fn)parser_hash_test },
+ {"libmemcached_check_configuration", 0, (test_callback_fn)libmemcached_check_configuration_test },
+ {"libmemcached_check_configuration_with_filename", 0, (test_callback_fn)libmemcached_check_configuration_with_filename_test },
+ {"number_options", 0, (test_callback_fn)parser_number_options_test },
+ {"randomly generated options", 0, (test_callback_fn)random_statement_build_test },
+ {"prefix_key", 0, (test_callback_fn)parser_key_prefix_test },
+ {"server", 0, (test_callback_fn)server_test },
+ {"bad server strings", 0, (test_callback_fn)servers_bad_test },
+ {"server with weights", 0, (test_callback_fn)server_with_weight_test },
+ {0, 0, (test_callback_fn)0}
+};
+
+test_st virtual_bucket_tests[] ={
+ {"basic", 0, (test_callback_fn)virtual_back_map },
+ {0, 0, (test_callback_fn)0}
+};
+
+collection_st collection[] ={
+#if 0
+ {"hash_sanity", 0, 0, hash_sanity},
+#endif
+ {"basic", 0, 0, basic_tests},
+ {"hsieh_availability", 0, 0, hsieh_availability},
+ {"murmur_availability", 0, 0, murmur_availability},
+ {"block", 0, 0, tests},
+ {"binary", (test_callback_fn)pre_binary, 0, tests},
+ {"nonblock", (test_callback_fn)pre_nonblock, 0, tests},
+ {"nodelay", (test_callback_fn)pre_nodelay, 0, tests},
+ {"settimer", (test_callback_fn)pre_settimer, 0, tests},
+ {"md5", (test_callback_fn)pre_md5, 0, tests},
+ {"crc", (test_callback_fn)pre_crc, 0, tests},
+ {"hsieh", (test_callback_fn)pre_hsieh, 0, tests},
+ {"jenkins", (test_callback_fn)pre_jenkins, 0, tests},
+ {"fnv1_64", (test_callback_fn)pre_hash_fnv1_64, 0, tests},
+ {"fnv1a_64", (test_callback_fn)pre_hash_fnv1a_64, 0, tests},
+ {"fnv1_32", (test_callback_fn)pre_hash_fnv1_32, 0, tests},
+ {"fnv1a_32", (test_callback_fn)pre_hash_fnv1a_32, 0, tests},
+ {"ketama", (test_callback_fn)pre_behavior_ketama, 0, tests},
+ {"ketama_auto_eject_hosts", (test_callback_fn)pre_behavior_ketama, 0, ketama_auto_eject_hosts},
+ {"unix_socket", (test_callback_fn)pre_unix_socket, 0, tests},
+ {"unix_socket_nodelay", (test_callback_fn)pre_nodelay, 0, tests},
+ {"poll_timeout", (test_callback_fn)poll_timeout, 0, tests},
+ {"gets", (test_callback_fn)enable_cas, 0, tests},
+ {"consistent_crc", (test_callback_fn)enable_consistent_crc, 0, tests},
+ {"consistent_hsieh", (test_callback_fn)enable_consistent_hsieh, 0, tests},
+#ifdef MEMCACHED_ENABLE_DEPRECATED
+ {"deprecated_memory_allocators", (test_callback_fn)deprecated_set_memory_alloc, 0, tests},
+#endif
+ {"memory_allocators", (test_callback_fn)set_memory_alloc, 0, tests},
+ {"prefix", (test_callback_fn)set_prefix, 0, tests},
+ {"sasl_auth", (test_callback_fn)pre_sasl, 0, sasl_auth_tests },
+ {"sasl", (test_callback_fn)pre_sasl, 0, tests },
+ {"version_1_2_3", (test_callback_fn)check_for_1_2_3, 0, version_1_2_3},
+ {"string", 0, 0, string_tests},
+ {"result", 0, 0, result_tests},
+ {"async", (test_callback_fn)pre_nonblock, 0, async_tests},
+ {"async_binary", (test_callback_fn)pre_nonblock_binary, 0, async_tests},
+ {"user", 0, 0, user_tests},
+ {"generate", 0, 0, generate_tests},
+ {"generate_hsieh", (test_callback_fn)pre_hsieh, 0, generate_tests},
+ {"generate_ketama", (test_callback_fn)pre_behavior_ketama, 0, generate_tests},
+ {"generate_hsieh_consistent", (test_callback_fn)enable_consistent_hsieh, 0, generate_tests},
+ {"generate_md5", (test_callback_fn)pre_md5, 0, generate_tests},
+ {"generate_murmur", (test_callback_fn)pre_murmur, 0, generate_tests},
+ {"generate_jenkins", (test_callback_fn)pre_jenkins, 0, generate_tests},
+ {"generate_nonblock", (test_callback_fn)pre_nonblock, 0, generate_tests},
+ // Too slow
+ {"generate_corked", (test_callback_fn)pre_cork, 0, generate_tests},
+ {"generate_corked_and_nonblock", (test_callback_fn)pre_cork_and_nonblock, 0, generate_tests},
+ {"consistent_not", 0, 0, consistent_tests},
+ {"consistent_ketama", (test_callback_fn)pre_behavior_ketama, 0, consistent_tests},
+ {"consistent_ketama_weighted", (test_callback_fn)pre_behavior_ketama_weighted, 0, consistent_weighted_tests},
+ {"ketama_compat", 0, 0, ketama_compatibility},
+ {"test_hashes", 0, 0, hash_tests},
+ {"replication", (test_callback_fn)pre_replication, 0, replication_tests},
+ {"replication_noblock", (test_callback_fn)pre_replication_noblock, 0, replication_tests},
+ {"regression", 0, 0, regression_tests},
+ {"behaviors", 0, 0, behavior_tests},
+ {"regression_binary_vs_block", (test_callback_fn)key_setup, (test_callback_fn)key_teardown, regression_binary_vs_block},
+ {"error_conditions", 0, 0, error_conditions},
+ {"parser", 0, 0, parser_tests},
+ {"virtual buckets", 0, 0, virtual_bucket_tests},
+ {0, 0, 0, 0}
+};
+
+#include "tests/libmemcached_world.h"
+
+void get_world(world_st *world)
+{
+ world->collections= collection;
+
+ world->create= (test_callback_create_fn)world_create;
+ world->destroy= (test_callback_fn)world_destroy;
+
+ world->test.startup= (test_callback_fn)world_test_startup;
+ world->test.flush= (test_callback_fn)world_flush;
+ world->test.pre_run= (test_callback_fn)world_pre_run;
+ world->test.post_run= (test_callback_fn)world_post_run;
+ world->test.on_error= (test_callback_error_fn)world_on_error;
+
+ world->collection.startup= (test_callback_fn)world_container_startup;
+ world->collection.shutdown= (test_callback_fn)world_container_shutdown;
+
+ world->runner= &defualt_libmemcached_runner;
+}
#include <errno.h>
#define BUILDING_LIBMEMCACHED
-#include <libmemcached/memcached.h>
+// !NEVER use common.h, always use memcached.h in your own apps
+#include <libmemcached/common.h>
#include "tests/parser.h"
#include "tests/print.h"
memcached_st *memc_ptr;
memc_ptr= memcached(STRING_WITH_LEN("--CONFIGURE-FILE=\"support/example.cnf\""));
- test_true_got(memc_ptr, memcached_last_error_message(memc_ptr));
+ test_true_got(memc_ptr, "memcached() failed");
+ test_strcmp(SUPPORT_EXAMPLE_CNF, memcached_array_string(memc_ptr->configure.filename));
memcached_free(memc_ptr);
return TEST_SUCCESS;
char buffer[BUFSIZ];
rc= libmemcached_check_configuration(STRING_WITH_LEN("--CONFIGURE-FILE=\"support/example.cnf\""), buffer, sizeof(buffer));
- test_true_got(rc == MEMCACHED_SUCCESS, buffer);
+ test_true_got(rc == MEMCACHED_SUCCESS, (rc == MEMCACHED_ERRNO) ? strerror(errno) : memcached_strerror(NULL, rc));
rc= libmemcached_check_configuration(STRING_WITH_LEN("--CONFIGURE-FILE=support/example.cnf"), buffer, sizeof(buffer));
- test_false_with(rc == MEMCACHED_SUCCESS, buffer);
+ test_false_with(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
rc= libmemcached_check_configuration(STRING_WITH_LEN("--CONFIGURE-FILE=\"bad-path/example.cnf\""), buffer, sizeof(buffer));
- test_true_got(rc == MEMCACHED_ERRNO, buffer);
+ test_true_got(rc == MEMCACHED_ERRNO, memcached_strerror(NULL, rc));
return TEST_SUCCESS;
}
test_return_t string_alloc_append_multiple(memcached_st *memc)
{
memcached_string_st *error_string= memcached_string_create(memc, NULL, 1024);
- memcached_string_append(error_string, memcached_string_with_size("Error occured while parsing: "));
+ memcached_string_append(error_string, memcached_literal_param("Error occured while parsing: "));
memcached_string_append(error_string, memcached_string_make_from_cstr("jog the strlen() method"));
- memcached_string_append(error_string, memcached_string_with_size(" ("));
+ memcached_string_append(error_string, memcached_literal_param(" ("));
memcached_string_append(error_string, memcached_string_make_from_cstr(memcached_strerror(NULL, MEMCACHED_SUCCESS)));
- memcached_string_append(error_string, memcached_string_with_size(")"));
+ memcached_string_append(error_string, memcached_literal_param(")"));
memcached_string_free(error_string);
projects / awesomized / libmemcached / commitdiff
