couchbase-memcached 1.2.8

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

@@ -0,0 +1,86 @@
+/*  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
+
+#ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
+#include <sasl/sasl.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+LIBMEMCACHED_API
+void memcached_set_sasl_callbacks(memcached_st *ptr,
+                                  const sasl_callback_t *callbacks);
+
+LIBMEMCACHED_API
+memcached_return_t  memcached_set_sasl_auth_data(memcached_st *ptr,
+                                                 const char *username,
+                                                 const char *password);
+
+LIBMEMCACHED_API
+memcached_return_t memcached_destroy_sasl_auth_data(memcached_st *ptr);
+
+
+LIBMEMCACHED_API
+const sasl_callback_t *memcached_get_sasl_callbacks(memcached_st *ptr);
+
+LIBMEMCACHED_LOCAL
+memcached_return_t memcached_clone_sasl(memcached_st *clone, const  memcached_st *source);
+
+LIBMEMCACHED_LOCAL
+memcached_return_t memcached_sasl_authenticate_connection(memcached_server_st *server);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LIBMEMCACHED_WITH_SASL_SUPPORT */
+
+struct memcached_sasl_st {
+#ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
+    const sasl_callback_t *callbacks;
+#else
+    const void *callbacks;
+#endif
+    /*
+    ** Did we allocate data inside the callbacks, or did the user
+    ** supply that.
+    */
+    bool is_allocated;
+};

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

@@ -0,0 +1,351 @@
+/*  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.
+ *
+ */
+
+/*
+  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, memcached_st *root,
+                                const char *hostname, in_port_t port,
+                                uint32_t weight, memcached_connection_t type)
+{
+  self->options.is_shutting_down= false;
+  self->options.is_dead= false;
+  self->number_of_hosts= 0;
+  self->cursor_active= 0;
+  self->port= port;
+  self->cached_errno= 0;
+  self->fd= -1;
+  self->io_bytes_sent= 0;
+  self->server_failure_counter= 0;
+  self->weight= weight ? weight : 1; // 1 is the default weight value
+  WATCHPOINT_SET(self->io_wait_count.read= 0);
+  WATCHPOINT_SET(self->io_wait_count.write= 0);
+  self->major_version= UINT8_MAX;
+  self->micro_version= UINT8_MAX;
+  self->minor_version= UINT8_MAX;
+  self->type= type;
+  self->read_ptr= self->read_buffer;
+  self->cached_server_error= NULL;
+  self->read_buffer_length= 0;
+  self->read_data_length= 0;
+  self->write_buffer_offset= 0;
+  self->address_info= NULL;
+  self->address_info_next= NULL;
+
+  self->state= MEMCACHED_SERVER_STATE_NEW;
+
+  if (root)
+  {
+    self->next_retry= root->retry_timeout;
+  }
+  else
+  {
+    self->next_retry= 0;
+  }
+
+  self->root= root;
+  self->limit_maxbytes= 0;
+  if (hostname)
+  {
+    strncpy(self->hostname, hostname, NI_MAXHOST - 1);
+  }
+  else
+  {
+    self->hostname[0]= 0;
+  }
+}
+
+static memcached_server_st *_server_create(memcached_server_st *self, const memcached_st *memc)
+{
+  if (not self)
+  {
+   self= (memcached_server_st *)libmemcached_malloc(memc, sizeof(memcached_server_st));
+
+    if (not self)
+      return NULL; /*  MEMCACHED_MEMORY_ALLOCATION_FAILURE */
+
+    self->options.is_allocated= true;
+  }
+  else
+  {
+    self->options.is_allocated= false;
+  }
+
+  self->options.is_initialized= true;
+
+  return self;
+}
+
+memcached_server_st *memcached_server_create_with(const memcached_st *memc,
+                                                  memcached_server_write_instance_st self,
+                                                  const char *hostname, in_port_t port,
+                                                  uint32_t weight, memcached_connection_t type)
+{
+  self= _server_create(self, memc);
+
+  if (not self)
+    return NULL;
+
+  _server_init(self, const_cast<memcached_st *>(memc), hostname, port, weight, type);
+
+
+  if (type == MEMCACHED_CONNECTION_UDP)
+  {
+    self->write_buffer_offset= UDP_DATAGRAM_HEADER_LENGTH;
+    memcached_io_init_udp_header(self, 0);
+  }
+
+  return self;
+}
+
+void memcached_server_free(memcached_server_st *self)
+{
+  if (not self)
+    return;
+
+  memcached_quit_server(self, false);
+
+  if (self->cached_server_error)
+    free(self->cached_server_error);
+
+  if (self->address_info)
+    freeaddrinfo(self->address_info);
+
+  if (memcached_is_allocated(self))
+  {
+    libmemcached_free(self->root, self);
+  }
+  else
+  {
+    self->options.is_initialized= false;
+  }
+}
+
+/*
+  If we do not have a valid object to clone from, we toss an error.
+*/
+memcached_server_st *memcached_server_clone(memcached_server_st *destination,
+                                            const memcached_server_st *source)
+{
+  /* We just do a normal create if source is missing */
+  if (not source)
+    return NULL;
+
+  destination= memcached_server_create_with(source->root, destination,
+                                            source->hostname, source->port, source->weight,
+                                            source->type);
+  if (not destination)
+  {
+    destination->cached_errno= source->cached_errno;
+
+    if (source->cached_server_error)
+      destination->cached_server_error= strdup(source->cached_server_error);
+  }
+
+  return destination;
+
+}
+
+memcached_return_t memcached_server_cursor(const memcached_st *ptr,
+                                           const memcached_server_fn *callback,
+                                           void *context,
+                                           uint32_t number_of_callbacks)
+{
+  memcached_return_t rc;
+  if (memcached_failed(rc= initialize_const_query(ptr)))
+  {
+    return rc;
+  }
+
+  for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
+  {
+    memcached_server_instance_st instance=
+      memcached_server_instance_by_position(ptr, x);
+
+    for (uint32_t y= 0; y < number_of_callbacks; y++)
+    {
+      unsigned int iferror;
+
+      iferror= (*callback[y])(ptr, instance, context);
+
+      if (iferror)
+        continue;
+    }
+  }
+
+  return MEMCACHED_SUCCESS;
+}
+
+memcached_return_t memcached_server_execute(memcached_st *ptr,
+                                            memcached_server_execute_fn callback,
+                                            void *context)
+{
+  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= (*callback)(ptr, instance, context);
+
+    if (iferror)
+      continue;
+  }
+
+  return MEMCACHED_SUCCESS;
+}
+
+memcached_server_instance_st memcached_server_by_key(const memcached_st *ptr,
+                                                     const char *key,
+                                                     size_t key_length,
+                                                     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)))
+  {
+    *error= rc;
+    return NULL;
+  }
+
+  if (memcached_failed(rc= memcached_validate_key_length(key_length, ptr->flags.binary_protocol)))
+  {
+    *error= rc;
+    return NULL;
+  }
+
+  if (ptr->flags.verify_key && (memcached_key_test((const char **)&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED))
+  {
+    *error= MEMCACHED_BAD_KEY_PROVIDED;
+    return NULL;
+  }
+
+  uint32_t server_key= memcached_generate_hash(ptr, key, key_length);
+  return memcached_server_instance_by_position(ptr, server_key);
+
+}
+
+void memcached_server_error_reset(memcached_server_st *self)
+{
+  WATCHPOINT_ASSERT(self);
+  if (not self)
+    return;
+
+  self->cached_server_error[0]= 0;
+}
+
+memcached_server_instance_st memcached_server_get_last_disconnect(const memcached_st *self)
+{
+  WATCHPOINT_ASSERT(self);
+  if (not self)
+    return 0;
+
+  return self->last_disconnected_server;
+}
+
+void memcached_server_list_free(memcached_server_list_st self)
+{
+  if (not self)
+    return;
+
+  for (uint32_t x= 0; x < memcached_server_list_count(self); x++)
+  {
+    if (self[x].address_info)
+    {
+      freeaddrinfo(self[x].address_info);
+      self[x].address_info= NULL;
+    }
+  }
+
+  libmemcached_free(self->root, self);
+}
+
+uint32_t memcached_servers_set_count(memcached_server_st *servers, uint32_t count)
+{
+  WATCHPOINT_ASSERT(servers);
+  if (not servers)
+    return 0;
+
+  return servers->number_of_hosts= count;
+}
+
+uint32_t memcached_server_count(const memcached_st *self)
+{
+  WATCHPOINT_ASSERT(self);
+  if (not self)
+    return 0;
+
+  return self->number_of_hosts;
+}
+
+const char *memcached_server_name(memcached_server_instance_st self)
+{
+  WATCHPOINT_ASSERT(self);
+  if (not self)
+    return NULL;
+
+  return self->hostname;
+}
+
+in_port_t memcached_server_port(memcached_server_instance_st self)
+{
+  WATCHPOINT_ASSERT(self);
+  if (not self)
+    return 0;
+
+  return self->port;
+}
+
+uint32_t memcached_server_response_count(memcached_server_instance_st self)
+{
+  WATCHPOINT_ASSERT(self);
+  if (not self)
+    return 0;
+
+  return self->cursor_active;
+}
+
+const char *memcached_server_error(memcached_server_instance_st ptr)
+{
+  return ptr ?  ptr->cached_server_error : NULL;
+}
+

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

@@ -0,0 +1,169 @@
+/*  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
+
+enum memcached_server_state_t {
+  MEMCACHED_SERVER_STATE_NEW, // fd == -1, no address lookup has been done
+  MEMCACHED_SERVER_STATE_ADDRINFO, // ADDRRESS information has been gathered
+  MEMCACHED_SERVER_STATE_IN_PROGRESS,
+  MEMCACHED_SERVER_STATE_CONNECTED
+};
+
+struct memcached_server_st {
+  struct {
+    bool is_allocated:1;
+    bool is_initialized:1;
+    bool is_shutting_down:1;
+    bool is_dead:1;
+  } options;
+  uint32_t number_of_hosts;
+  uint32_t cursor_active;
+  in_port_t port;
+  int cached_errno;
+  memcached_socket_t fd;
+  uint32_t io_bytes_sent; /* # bytes sent since last read */
+  uint32_t server_failure_counter;
+  uint32_t weight;
+  enum memcached_server_state_t state;
+  struct {
+    uint32_t read;
+    uint32_t write;
+  } io_wait_count;
+  uint8_t major_version; // Default definition of UINT8_MAX means that it has not been set.
+  uint8_t micro_version; // ditto
+  uint8_t minor_version; // ditto
+  memcached_connection_t type;
+  char *read_ptr;
+  char *cached_server_error;
+  size_t read_buffer_length;
+  size_t read_data_length;
+  size_t write_buffer_offset;
+  struct addrinfo *address_info;
+  struct addrinfo *address_info_next;
+  time_t next_retry;
+  memcached_st *root;
+  uint64_t limit_maxbytes;
+  char read_buffer[MEMCACHED_MAX_BUFFER];
+  char write_buffer[MEMCACHED_MAX_BUFFER];
+  char hostname[NI_MAXHOST];
+};
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+LIBMEMCACHED_API
+memcached_return_t memcached_server_cursor(const memcached_st *ptr,
+                                           const memcached_server_fn *callback,
+                                           void *context,
+                                           uint32_t number_of_callbacks);
+
+LIBMEMCACHED_API
+  memcached_server_instance_st memcached_server_by_key(const memcached_st *ptr,
+                                                        const char *key,
+                                                        size_t key_length,
+                                                        memcached_return_t *error);
+
+LIBMEMCACHED_API
+void memcached_server_error_reset(memcached_server_st *ptr);
+
+LIBMEMCACHED_API
+void memcached_server_free(memcached_server_st *ptr);
+
+LIBMEMCACHED_LOCAL
+memcached_server_st *memcached_server_clone(memcached_server_st *destination,
+                                            const memcached_server_st *source);
+
+LIBMEMCACHED_API
+memcached_server_instance_st memcached_server_get_last_disconnect(const memcached_st *ptr);
+
+
+LIBMEMCACHED_API
+memcached_return_t memcached_server_add_udp(memcached_st *ptr,
+                                            const char *hostname,
+                                            in_port_t port);
+LIBMEMCACHED_API
+memcached_return_t memcached_server_add_unix_socket(memcached_st *ptr,
+                                                    const char *filename);
+LIBMEMCACHED_API
+memcached_return_t memcached_server_add(memcached_st *ptr,
+                                        const char *hostname, in_port_t port);
+
+LIBMEMCACHED_LOCAL
+  memcached_return_t memcached_server_add_parsed(memcached_st *ptr,
+                                                 const char *hostname,
+                                                 size_t hostname_length,
+                                                 in_port_t port,
+                                                 uint32_t weight);
+
+LIBMEMCACHED_API
+memcached_return_t memcached_server_add_udp_with_weight(memcached_st *ptr,
+                                                        const char *hostname,
+                                                        in_port_t port,
+                                                        uint32_t weight);
+LIBMEMCACHED_API
+memcached_return_t memcached_server_add_unix_socket_with_weight(memcached_st *ptr,
+                                                                const char *filename,
+                                                                uint32_t weight);
+LIBMEMCACHED_API
+memcached_return_t memcached_server_add_with_weight(memcached_st *ptr, const char *hostname,
+                                                    in_port_t port,
+                                                    uint32_t weight);
+
+/**
+  Operations on Single Servers.
+*/
+LIBMEMCACHED_API
+uint32_t memcached_server_response_count(memcached_server_instance_st self);
+
+LIBMEMCACHED_API
+const char *memcached_server_name(memcached_server_instance_st self);
+
+LIBMEMCACHED_API
+in_port_t memcached_server_port(memcached_server_instance_st self);
+
+LIBMEMCACHED_API
+const char *memcached_server_error(memcached_server_instance_st ptr);
+
+
+
+#ifdef __cplusplus
+} // extern "C"
+#endif