couchbase-memcached 1.2.8

data/ext/libmemcached-0.50/libmemcached/io.h

@@ -0,0 +1,119 @@
+/*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ * 
+ *  LibMemcached
+ *
+ *  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.
+ *
+ */
+
+#pragma once
+
+#include <libmemcached/memcached.h>
+
+#define MAX_UDP_DATAGRAM_LENGTH 1400
+#define UDP_DATAGRAM_HEADER_LENGTH 8
+#define UDP_REQUEST_ID_MSG_SIG_DIGITS 10
+#define UDP_REQUEST_ID_THREAD_MASK 0xFFFF << UDP_REQUEST_ID_MSG_SIG_DIGITS
+#define get_udp_datagram_request_id(A) ntohs((A)->request_id)
+#define get_udp_datagram_seq_num(A) ntohs((A)->sequence_number)
+#define get_udp_datagram_num_datagrams(A) ntohs((A)->num_datagrams)
+#define get_msg_num_from_request_id(A) ( (A) & (~(UDP_REQUEST_ID_THREAD_MASK)) )
+#define get_thread_id_from_request_id(A) ( (A) & (UDP_REQUEST_ID_THREAD_MASK) ) >> UDP_REQUEST_ID_MSG_SIG_DIGITS
+#define generate_udp_request_thread_id(A) (A) << UDP_REQUEST_ID_MSG_SIG_DIGITS
+#define UDP_REQUEST_ID_MAX_THREAD_ID get_thread_id_from_request_id(0xFFFF)
+
+struct udp_datagram_header_st
+{
+  uint16_t request_id;
+  uint16_t sequence_number;
+  uint16_t num_datagrams;
+  uint16_t reserved;
+};
+
+struct libmemcached_io_vector_st
+{
+  size_t length;
+  const void *buffer;
+};
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+LIBMEMCACHED_LOCAL
+memcached_return_t memcached_io_wait_for_write(memcached_server_write_instance_st ptr);
+
+LIBMEMCACHED_LOCAL
+ssize_t memcached_io_writev(memcached_server_write_instance_st ptr,
+                            const struct libmemcached_io_vector_st *vector,
+                            size_t number_of, bool with_flush);
+
+LIBMEMCACHED_LOCAL
+ssize_t memcached_io_write(memcached_server_write_instance_st ptr,
+                           const void *buffer, size_t length, bool with_flush);
+
+LIBMEMCACHED_LOCAL
+void memcached_io_reset(memcached_server_write_instance_st ptr);
+
+LIBMEMCACHED_LOCAL
+memcached_return_t memcached_io_read(memcached_server_write_instance_st ptr,
+                                     void *buffer, size_t length, ssize_t *nread);
+
+/* Read a line (terminated by '\n') into the buffer */
+LIBMEMCACHED_LOCAL
+memcached_return_t memcached_io_readline(memcached_server_write_instance_st ptr,
+                                         char *buffer_ptr,
+                                         size_t size);
+
+LIBMEMCACHED_LOCAL
+void memcached_io_close(memcached_server_write_instance_st ptr);
+
+/* Read n bytes of data from the server and store them in dta */
+LIBMEMCACHED_LOCAL
+memcached_return_t memcached_safe_read(memcached_server_write_instance_st ptr,
+                                       void *dta,
+                                       size_t size);
+
+LIBMEMCACHED_LOCAL
+memcached_return_t memcached_io_init_udp_header(memcached_server_write_instance_st ptr,
+                                                uint16_t thread_id);
+
+LIBMEMCACHED_LOCAL
+memcached_server_write_instance_st memcached_io_get_readable_server(memcached_st *memc);
+
+LIBMEMCACHED_LOCAL
+memcached_return_t memcached_io_slurp(memcached_server_write_instance_st ptr);
+
+#ifdef __cplusplus
+}
+#endif

data/ext/libmemcached-0.50/libmemcached/is.h

@@ -0,0 +1,48 @@
+/*  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
+
+/* These are private */ 
+#define memcached_is_allocated(__object) ((__object)->options.is_allocated)
+#define memcached_is_initialized(__object) ((__object)->options.is_initialized)
+#define memcached_is_purging(__object) ((__object)->state.is_purging)
+#define memcached_is_processing_input(__object) ((__object)->state.is_processing_input)
+#define memcached_set_purging(__object, __value) ((__object)->state.is_purging= (__value))
+#define memcached_set_processing_input(__object, __value) ((__object)->state.is_processing_input= (__value))
+#define memcached_set_initialized(__object, __value) ((__object)->options.is_initialized(= (__value))
+#define memcached_set_allocated(__object, __value) ((__object)->options.is_allocated= (__value))

data/ext/libmemcached-0.50/libmemcached/key.cc

@@ -0,0 +1,23 @@
+#include "common.h"
+
+memcached_return_t memcached_key_test(const char * const *keys,
+                                      const size_t *key_length,
+                                      size_t number_of_keys)
+{
+  for (uint32_t x= 0; x < number_of_keys; x++)
+  {
+    memcached_return_t rc;
+    rc= memcached_validate_key_length(*(key_length + x), false);
+    if (rc != MEMCACHED_SUCCESS)
+      return rc;
+ 
+    for (size_t y= 0; y < *(key_length + x); y++)
+    {
+      if ((isgraph(keys[x][y])) == 0)
+        return MEMCACHED_BAD_KEY_PROVIDED;
+    }
+  }
+
+  return MEMCACHED_SUCCESS;
+}
+

data/ext/libmemcached-0.50/libmemcached/libmemcached_probes.d

@@ -0,0 +1,30 @@
+provider libmemcached {
+	probe memcached_delete_start();
+	probe memcached_delete_end();
+	probe memcached_increment_with_initial_start();
+	probe memcached_increment_with_initial_end();
+	probe memcached_decrement_with_initial_start();
+	probe memcached_decrement_with_initial_end();
+	probe memcached_increment_start();
+	probe memcached_increment_end();
+	probe memcached_decrement_start();
+	probe memcached_decrement_end();
+	probe memcached_flush_start();
+	probe memcached_flush_end();
+	probe memcached_set_start();
+	probe memcached_set_end();
+	probe memcached_add_start();
+	probe memcached_add_end();
+	probe memcached_replace_start();
+	probe memcached_replace_end();
+	probe memcached_get_start();
+	probe memcached_get_end();
+ 	probe memcached_touch_start();
+ 	probe memcached_touch_end();
+	probe memcached_mget_start();
+	probe memcached_mget_end();
+	probe memcached_connect_start();
+	probe memcached_connect_end();
+	probe memcached_server_add_start();
+	probe memcached_server_add_end();
+};

data/ext/libmemcached-0.50/libmemcached/libmemcached_probes.h

@@ -0,0 +1,118 @@
+/*  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.
+ *
+ */
+
+#pragma once
+
+
+/*
+ * This file contains the definition of the various probes supported by
+ * libmemcached. Currently it only support DTRACE, but just create an
+ * implementation of the following macros to create your own sort of
+ * probing :)
+ */
+
+#ifdef HAVE_DTRACE
+/*
+ * Create the DTrace probes on the system using it (to support both Solaris
+ * and MacOS X
+ */
+#include "libmemcached/dtrace_probes.h"
+
+#else
+/*
+ * Provide dummy macros so that we don't need to clutter the code with
+ * ifdefs when we want to use the probes.
+ */
+
+#define	LIBMEMCACHED_MEMCACHED_ADD_END()
+#define	LIBMEMCACHED_MEMCACHED_ADD_END_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_ADD_START()
+#define	LIBMEMCACHED_MEMCACHED_ADD_START_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_CONNECT_END()
+#define	LIBMEMCACHED_MEMCACHED_CONNECT_END_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_CONNECT_START()
+#define	LIBMEMCACHED_MEMCACHED_CONNECT_START_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_DECREMENT_END()
+#define	LIBMEMCACHED_MEMCACHED_DECREMENT_END_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_DECREMENT_START()
+#define	LIBMEMCACHED_MEMCACHED_DECREMENT_START_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_DECREMENT_WITH_INITIAL_END()
+#define	LIBMEMCACHED_MEMCACHED_DECREMENT_WITH_INITIAL_END_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_DECREMENT_WITH_INITIAL_START()
+#define	LIBMEMCACHED_MEMCACHED_DECREMENT_WITH_INITIAL_START_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_DELETE_END()
+#define	LIBMEMCACHED_MEMCACHED_DELETE_END_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_DELETE_START()
+#define	LIBMEMCACHED_MEMCACHED_DELETE_START_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_FLUSH_END()
+#define	LIBMEMCACHED_MEMCACHED_FLUSH_END_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_FLUSH_START()
+#define	LIBMEMCACHED_MEMCACHED_FLUSH_START_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_GET_END()
+#define	LIBMEMCACHED_MEMCACHED_GET_END_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_GET_START()
+#define	LIBMEMCACHED_MEMCACHED_GET_START_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_TOUCH_END()
+#define	LIBMEMCACHED_MEMCACHED_TOUCH_END_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_TOUCH_START()
+#define	LIBMEMCACHED_MEMCACHED_TOUCH_START_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_INCREMENT_END()
+#define	LIBMEMCACHED_MEMCACHED_INCREMENT_END_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_INCREMENT_START()
+#define	LIBMEMCACHED_MEMCACHED_INCREMENT_START_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_INCREMENT_WITH_INITIAL_END()
+#define	LIBMEMCACHED_MEMCACHED_INCREMENT_WITH_INITIAL_END_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_INCREMENT_WITH_INITIAL_START()
+#define	LIBMEMCACHED_MEMCACHED_INCREMENT_WITH_INITIAL_START_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_MGET_END()
+#define	LIBMEMCACHED_MEMCACHED_MGET_END_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_MGET_START()
+#define	LIBMEMCACHED_MEMCACHED_MGET_START_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_REPLACE_END()
+#define	LIBMEMCACHED_MEMCACHED_REPLACE_END_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_REPLACE_START()
+#define	LIBMEMCACHED_MEMCACHED_REPLACE_START_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_SERVER_ADD_END()
+#define	LIBMEMCACHED_MEMCACHED_SERVER_ADD_END_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_SERVER_ADD_START()
+#define	LIBMEMCACHED_MEMCACHED_SERVER_ADD_START_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_SET_END()
+#define	LIBMEMCACHED_MEMCACHED_SET_END_ENABLED() (0)
+#define	LIBMEMCACHED_MEMCACHED_SET_START()
+#define	LIBMEMCACHED_MEMCACHED_SET_START_ENABLED() (0)
+
+#endif

data/ext/libmemcached-0.50/libmemcached/memcached.cc

@@ -0,0 +1,437 @@
+/*  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>
+
+#include <libmemcached/options.hpp>
+#include <libmemcached/virtual_bucket.h>
+
+#if 0
+static const memcached_st global_copy= {
+  .state= {
+    .is_purging= false, // .is_purging
+    .is_processing_input= false, // is_processing_input
+    .is_time_for_rebuild= false,
+  },
+  .flags= {
+    .auto_eject_hosts= false,
+    .binary_protocol= false,
+    .buffer_requests= false,
+    .hash_with_prefix_key= false,
+    .no_block= false,
+    .no_reply= false,
+    .randomize_replica_read= false,
+    .support_cas= false,
+    .tcp_nodelay= false,
+    .use_sort_hosts= false,
+    .use_udp= false,
+    .verify_key= false,
+    .tcp_keepalive= false,
+  },
+};
+#endif
+
+static inline bool _memcached_init(memcached_st *self)
+{
+  self->state.is_purging= false;
+  self->state.is_processing_input= false;
+  self->state.is_time_for_rebuild= false;
+
+  self->flags.auto_eject_hosts= false;
+  self->flags.binary_protocol= false;
+  self->flags.buffer_requests= false;
+  self->flags.hash_with_prefix_key= false;
+  self->flags.no_block= false;
+  self->flags.no_reply= false;
+  self->flags.randomize_replica_read= false;
+  self->flags.support_cas= false;
+  self->flags.tcp_nodelay= false;
+  self->flags.use_sort_hosts= false;
+  self->flags.use_udp= false;
+  self->flags.verify_key= false;
+  self->flags.tcp_keepalive= false;
+
+  self->virtual_bucket= NULL;
+
+  self->distribution= MEMCACHED_DISTRIBUTION_MODULA;
+
+  if (not hashkit_create(&self->hashkit))
+    return false;
+
+  self->ketama.continuum= NULL;
+  self->ketama.continuum_count= 0;
+  self->ketama.continuum_points_counter= 0;
+  self->ketama.next_distribution_rebuild= 0;
+  self->ketama.weighted= false;
+
+  self->number_of_hosts= 0;
+  self->servers= NULL;
+  self->last_disconnected_server= NULL;
+
+  self->snd_timeout= 0;
+  self->rcv_timeout= 0;
+  self->server_failure_limit= 0;
+  self->query_id= 1; // 0 is considered invalid
+
+  /* TODO, Document why we picked these defaults */
+  self->io_msg_watermark= 500;
+  self->io_bytes_watermark= 65 * 1024;
+
+  self->tcp_keepidle= 0;
+
+  self->io_key_prefetch= 0;
+  self->poll_timeout= MEMCACHED_DEFAULT_TIMEOUT;
+  self->connect_timeout= MEMCACHED_DEFAULT_CONNECT_TIMEOUT;
+  self->retry_timeout= 0;
+
+  self->send_size= -1;
+  self->recv_size= -1;
+
+  self->user_data= NULL;
+  self->number_of_replicas= 0;
+
+  self->allocators= memcached_allocators_return_default();
+
+  self->on_clone= NULL;
+  self->on_cleanup= NULL;
+  self->get_key_failure= NULL;
+  self->delete_trigger= NULL;
+  self->callbacks= NULL;
+  self->sasl.callbacks= NULL;
+  self->sasl.is_allocated= false;
+
+  self->error_messages= NULL;
+  self->prefix_key= NULL;
+  self->configure.initial_pool_size= 1;
+  self->configure.max_pool_size= 1;
+  self->configure.version= -1;
+  self->configure.filename= NULL;
+
+  return true;
+}
+
+static void _free(memcached_st *ptr, bool release_st)
+{
+  /* If we have anything open, lets close it now */
+  send_quit(ptr);
+  memcached_server_list_free(memcached_server_list(ptr));
+  memcached_result_free(&ptr->result);
+
+  memcached_virtual_bucket_free(ptr);
+
+  memcached_server_free(ptr->last_disconnected_server);
+
+  if (ptr->on_cleanup)
+    ptr->on_cleanup(ptr);
+
+  libmemcached_free(ptr, ptr->ketama.continuum);
+
+  memcached_array_free(ptr->prefix_key);
+  ptr->prefix_key= NULL;
+
+  memcached_error_free(ptr);
+
+  if (ptr->sasl.callbacks)
+  {
+#ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
+    memcached_destroy_sasl_auth_data(ptr);
+#endif
+  }
+
+  if (release_st)
+  {
+    memcached_array_free(ptr->configure.filename);
+    ptr->configure.filename= NULL;
+  }
+
+  if (memcached_is_allocated(ptr) && release_st)
+  {
+    libmemcached_free(ptr, ptr);
+  }
+}
+
+memcached_st *memcached_create(memcached_st *ptr)
+{
+  if (ptr == NULL)
+  {
+    ptr= (memcached_st *)malloc(sizeof(memcached_st));
+
+    if (not ptr)
+    {
+      return NULL; /*  MEMCACHED_MEMORY_ALLOCATION_FAILURE */
+    }
+
+    ptr->options.is_allocated= true;
+  }
+  else
+  {
+    ptr->options.is_allocated= false;
+  }
+
+#if 0
+  memcached_set_purging(ptr, false);
+  memcached_set_processing_input(ptr, false);
+#endif
+
+  if (! _memcached_init(ptr))
+  {
+    memcached_free(ptr);
+    return NULL;
+  }
+
+  if (! memcached_result_create(ptr, &ptr->result))
+  {
+    memcached_free(ptr);
+    return NULL;
+  }
+
+  WATCHPOINT_ASSERT_INITIALIZED(&ptr->result);
+
+  return ptr;
+}
+
+memcached_st *memcached(const char *string, size_t length)
+{
+  memcached_st *self= memcached_create(NULL);
+  if (not self)
+  {
+    errno= ENOMEM;
+    return NULL;
+  }
+
+  if (not length)
+    return self;
+
+  memcached_return_t rc= memcached_parse_configuration(self, string, length);
+
+  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 (memcached_failed(rc))
+  {
+    memcached_free(self);
+    errno= EINVAL;
+    return NULL;
+  }
+
+  return self;
+}
+
+memcached_return_t memcached_reset(memcached_st *ptr)
+{
+  WATCHPOINT_ASSERT(ptr);
+  if (not ptr)
+    return MEMCACHED_INVALID_ARGUMENTS;
+
+  bool stored_is_allocated= memcached_is_allocated(ptr);
+  uint64_t query_id= ptr->query_id;
+  _free(ptr, false);
+  memcached_create(ptr);
+  memcached_set_allocated(ptr, stored_is_allocated);
+  ptr->query_id= query_id;
+
+  if (ptr->configure.filename)
+  {
+    return memcached_parse_configure_file(*ptr, memcached_param_array(ptr->configure.filename));
+  }
+
+  return MEMCACHED_SUCCESS;
+}
+
+void memcached_servers_reset(memcached_st *self)
+{
+  if (not self)
+    return;
+
+  memcached_server_list_free(memcached_server_list(self));
+
+  memcached_server_list_set(self, NULL);
+  self->number_of_hosts= 0;
+  memcached_server_free(self->last_disconnected_server);
+  self->last_disconnected_server= NULL;
+  self->server_failure_limit= 0;
+}
+
+void memcached_reset_last_disconnected_server(memcached_st *self)
+{
+  if (not self)
+    return;
+
+  memcached_server_free(self->last_disconnected_server);
+  self->last_disconnected_server= NULL;
+}
+
+void memcached_free(memcached_st *ptr)
+{
+  if (not ptr)
+    return;
+
+  _free(ptr, true);
+}
+
+/*
+  clone is the destination, while source is the structure to clone.
+  If source is NULL the call is the same as if a memcached_create() was
+  called.
+*/
+memcached_st *memcached_clone(memcached_st *clone, const memcached_st *source)
+{
+  memcached_return_t rc= MEMCACHED_SUCCESS;
+
+  if (not source)
+    return memcached_create(clone);
+
+  if (clone && memcached_is_allocated(clone))
+  {
+    return NULL;
+  }
+
+  memcached_st *new_clone= memcached_create(clone);
+
+  if (not new_clone)
+    return NULL;
+
+  new_clone->flags= source->flags;
+  new_clone->send_size= source->send_size;
+  new_clone->recv_size= source->recv_size;
+  new_clone->poll_timeout= source->poll_timeout;
+  new_clone->connect_timeout= source->connect_timeout;
+  new_clone->retry_timeout= source->retry_timeout;
+  new_clone->distribution= source->distribution;
+
+  if (not hashkit_clone(&new_clone->hashkit, &source->hashkit))
+  {
+    memcached_free(new_clone);
+    return NULL;
+  }
+
+  new_clone->user_data= source->user_data;
+
+  new_clone->snd_timeout= source->snd_timeout;
+  new_clone->rcv_timeout= source->rcv_timeout;
+
+  new_clone->on_clone= source->on_clone;
+  new_clone->on_cleanup= source->on_cleanup;
+
+  new_clone->allocators= source->allocators;
+
+  new_clone->get_key_failure= source->get_key_failure;
+  new_clone->delete_trigger= source->delete_trigger;
+  new_clone->server_failure_limit= source->server_failure_limit;
+  new_clone->io_msg_watermark= source->io_msg_watermark;
+  new_clone->io_bytes_watermark= source->io_bytes_watermark;
+  new_clone->io_key_prefetch= source->io_key_prefetch;
+  new_clone->number_of_replicas= source->number_of_replicas;
+  new_clone->tcp_keepidle= source->tcp_keepidle;
+
+  if (memcached_server_count(source))
+    rc= memcached_push(new_clone, source);
+
+  if (rc != MEMCACHED_SUCCESS)
+  {
+    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)
+  {
+    if (memcached_clone_sasl(new_clone, source) != MEMCACHED_SUCCESS)
+    {
+      memcached_free(new_clone);
+      return NULL;
+    }
+  }
+#endif
+
+  rc= run_distribution(new_clone);
+
+  if (rc != MEMCACHED_SUCCESS)
+  {
+    memcached_free(new_clone);
+
+    return NULL;
+  }
+
+  if (source->on_clone)
+    source->on_clone(new_clone, source);
+
+  return new_clone;
+}
+
+void *memcached_get_user_data(const memcached_st *ptr)
+{
+  return ptr->user_data;
+}
+
+void *memcached_set_user_data(memcached_st *ptr, void *data)
+{
+  void *ret= ptr->user_data;
+  ptr->user_data= data;
+
+  return ret;
+}
+
+memcached_return_t memcached_push(memcached_st *destination, const memcached_st *source)
+{
+  return memcached_server_push(destination, source->servers);
+}
+
+memcached_server_write_instance_st memcached_server_instance_fetch(memcached_st *ptr, uint32_t server_key)
+{
+  return &ptr->servers[server_key];
+}
+
+memcached_server_instance_st memcached_server_instance_by_position(const memcached_st *ptr, uint32_t server_key)
+{
+  return &ptr->servers[server_key];
+}
+
+uint64_t memcached_query_id(const memcached_st *self)
+{
+  if (not self)
+    return 0;
+
+  return self->query_id;
+}