Merge lp:~trond-norbye/libmemcached/no-docs into lp:~brianaker/libmemcached/build

[Trond Norbye]

Added --without-docs to configure

The purpose of this option is to be able to disable generation of manual
pages from pod2man (to enable compilation of libmemcached on systems
without a working pod2man)

[Brian Aker (brianaker)]

This was applied to the tree a while ago.

Unmerged revisions

883. By Trond Norbye on 2010-07-21

Added --without-docs to configure

The purpose of this option is to be able to disable generation of manual
pages from pod2man (to enable compilation of libmemcached on systems
without a working pod2man)

882. By Brian Aker <brian@gaz> on 2010-07-20

Found issue from Fedora builder compiling with --with-debug

881. By Brian Aker <brian@gaz> on 2010-07-20

Merge in cast fix for H algo

880. By Brian Aker <brian@gaz> on 2010-07-17

Type on attribute.

879. By Brian Aker <brian@gaz> on 2010-07-16

Verify that servers have started up by reading their pid file.

878. By Brian Aker <brian@gaz> on 2010-07-16

Possible fix for OSX slow server startup

877. By Brian Aker <brian@gaz> on 2010-07-16

Tiny style fix

876. By Brian Aker <brian@gaz> on 2010-07-16

Merge in usage for execute_stat.

875. By Brian Aker <brian@gaz> on 2010-07-16

Merge in memcached_stat_execute().

874. By Brian Aker <brian@gaz> on 2010-07-06

Fix for versioning information.

=== modified file '.bzrignore'
--- .bzrignore	2010-02-21 10:59:22 +0000
+++ .bzrignore	2010-07-21 16:27:47 +0000
@@ -181,3 +181,4 @@
 tests/testhashkit
 tests/testplus
 tests/testudp
+unittests/unittests
 
=== modified file 'ChangeLog'
--- ChangeLog	2010-06-11 01:43:08 +0000
+++ ChangeLog	2010-07-21 16:27:47 +0000
@@ -1,6 +1,15 @@
-0.41
+0.43
+  * memcached_stat_execute() merged. 
+
+0.42 Tue Jul  6 12:29:50 PDT 2010
+  * Mistake in libtool caused issue with library version
+
+0.41 Wed Jun 30 13:15:19 PDT 2010
   * Added --file for memcat.
   * Added limemcached_ping() to libmemcached_util
+  * Bugfix for some cases where connect would have issues with timeout.
+  * Wrong value for errno given as error on an IO failure inside of poll.
+  * Bug fix for issue where multiple interfaces with bad DNS were not being caught.
 
 0.40 Thu Apr 22 19:01:25 PDT 2010
   * Placed retry logic in for busted resolvers
 
=== modified file 'Makefile.am'
--- Makefile.am	2010-06-13 16:21:08 +0000
+++ Makefile.am	2010-07-21 16:27:47 +0000
@@ -12,6 +12,7 @@
 noinst_PROGRAMS =
 include_HEADERS =
 nobase_include_HEADERS =
+check_PROGRAMS =
 EXTRA_HEADERS =
 BUILT_SOURCES=
 EXTRA_DIST= \
@@ -29,19 +30,23 @@
 	    m4/po.m4 \
 	    m4/progtest.m4
 
-
+TEST_DOCS=
+if BUILD_DOCS
 SUBDIRS = docs
+TEST_DOCS+=test-docs
+endif
 
 test-docs:
 	(cd docs && $(MAKE) test-docs)
 include libmemcached/include.am
 include clients/include.am
 include libhashkit/include.am
+include unittests/include.am
 include tests/include.am
 include example/include.am
 include support/include.am
 
-check-local: test-no-outputdiff
+TESTS += ${check_PROGRAMS}
 
 
 fedora:
@@ -82,7 +87,7 @@
 	genhtml -o lcov --function-coverage -t libmemcached libmemcached/lcov.out
 
 lcov-clean: clean
-	rm -rf lcov */lcov.out 
+	rm -rf lcov */lcov.out
 	find . -name '*.gcno' | xargs rm -f
 	find . -name '*.gcda' | xargs rm -f
 
 
=== modified file 'clients/execute.c'
--- clients/execute.c	2010-01-16 01:50:37 +0000
+++ clients/execute.c	2010-07-21 16:27:47 +0000
@@ -14,8 +14,7 @@
   Return the number of rows set.
 */
 
-#include "libmemcached/common.h"
-
+#include "config.h"
 #include "execute.h"
 
 unsigned int execute_set(memcached_st *memc, pairs_st *pairs, unsigned int number_of)
@@ -108,12 +107,11 @@
   rc= memcached_mget_execute(memc, keys, key_length,
                              (size_t)number_of, callbacks, &retrieved, 1);
 
-  likely (rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOTFOUND ||
+  if (rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOTFOUND ||
           rc == MEMCACHED_BUFFERED || rc == MEMCACHED_END)
   {
     rc= memcached_fetch_execute(memc, callbacks, (void *)&retrieved, 1);
-    unlikely (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_NOTFOUND &&
-              rc != MEMCACHED_END)
+    if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_NOTFOUND && rc != MEMCACHED_END)
     {
       fprintf(stderr, "Failed to execute mget: %s\n",
               memcached_strerror(memc, rc));
 
=== modified file 'clients/execute.h'
--- clients/execute.h	2009-12-16 19:03:49 +0000
+++ clients/execute.h	2010-07-21 16:27:47 +0000
@@ -11,6 +11,9 @@
 
 #ifndef CLIENTS_EXECUTE_H
 #define CLIENTS_EXECUTE_H
+
+#include <stdio.h>
+
 #include "libmemcached/memcached.h"
 #include "generator.h"
 
 
=== modified file 'clients/generator.c'
--- clients/generator.c	2010-04-22 00:49:09 +0000
+++ clients/generator.c	2010-07-21 16:27:47 +0000
@@ -9,7 +9,7 @@
  *
  */
 
-#include "libmemcached/common.h"
+#include "config.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 
=== modified file 'clients/memcat.c'
--- clients/memcat.c	2010-06-08 19:05:16 +0000
+++ clients/memcat.c	2010-07-21 16:27:47 +0000
@@ -9,7 +9,8 @@
  *
  */
 
-#include "libmemcached/common.h"
+#include "config.h"
+
 #include <stdio.h>
 #include <inttypes.h>
 #include <string.h>
 
=== modified file 'clients/memcp.c'
--- clients/memcp.c	2010-03-03 10:50:13 +0000
+++ clients/memcp.c	2010-07-21 16:27:47 +0000
@@ -9,7 +9,8 @@
  *
  */
 
-#include "libmemcached/common.h"
+#include "config.h"
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <inttypes.h>
@@ -22,6 +23,10 @@
 #include <errno.h>
 #include <strings.h>
 #include <string.h>
+#include <sys/types.h>
+#include <stdlib.h>
+#include <limits.h>
+
 
 #include <libmemcached/memcached.h>
 
 
=== modified file 'clients/memdump.c'
--- clients/memdump.c	2010-03-03 10:50:13 +0000
+++ clients/memdump.c	2010-07-21 16:27:47 +0000
@@ -9,7 +9,8 @@
  *
  */
 
-#include "libmemcached/common.h"
+#include "config.h"
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <inttypes.h>
 
=== modified file 'clients/memerror.c'
--- clients/memerror.c	2010-01-14 21:37:53 +0000
+++ clients/memerror.c	2010-07-21 16:27:47 +0000
@@ -8,8 +8,8 @@
  * Summary:
  *
  */
+#include "config.h"
 
-#include "libmemcached/common.h"
 #include <stdio.h>
 #include <inttypes.h>
 #include <string.h>
 
=== modified file 'clients/memflush.c'
--- clients/memflush.c	2010-03-03 10:50:13 +0000
+++ clients/memflush.c	2010-07-21 16:27:47 +0000
@@ -8,8 +8,8 @@
  * Summary:
  *
  */
+#include "config.h"
 
-#include "libmemcached/common.h"
 #include <stdio.h>
 #include <unistd.h>
 #include <string.h>
 
=== modified file 'clients/memrm.c'
--- clients/memrm.c	2010-03-03 10:50:13 +0000
+++ clients/memrm.c	2010-07-21 16:27:47 +0000
@@ -8,8 +8,8 @@
  * Summary:
  *
  */
+#include "config.h"
 
-#include "libmemcached/common.h"
 #include <stdio.h>
 #include <unistd.h>
 #include <getopt.h>
 
=== modified file 'clients/memstat.c'
--- clients/memstat.c	2010-03-10 00:45:36 +0000
+++ clients/memstat.c	2010-07-21 16:27:47 +0000
@@ -11,8 +11,8 @@
  *          Brian Aker
  *          Toru Maesaka
  */
+#include "config.h"
 
-#include "libmemcached/common.h"
 #include <stdio.h>
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -56,36 +56,22 @@
 };
 
 
-static memcached_return_t server_print_callback(const memcached_st *memc,
-                                                memcached_server_instance_st instance,
-                                                void *context)
+static memcached_return_t stat_printer(memcached_server_instance_st instance,
+                                       const char *key, size_t key_length,
+                                       const char *value, size_t value_length,
+                                       void *context)
 {
-  memcached_stat_st server_stat;
-  memcached_return_t rc;
-  char **list;
-  char **ptr;
-
+  static memcached_server_instance_st last= NULL;
   (void)context;
 
-  rc= memcached_stat_servername(&server_stat, NULL,
-                                memcached_server_name(instance),
-                                memcached_server_port(instance));
-
-  list= memcached_stat_get_keys(memc, &server_stat, &rc);
-
-  printf("Server: %s (%u)\n", memcached_server_name(instance),
-         (uint32_t)memcached_server_port(instance));
-
-  for (ptr= list; *ptr; ptr++)
+  if (last != instance)
   {
-    char *value= memcached_stat_get_value(memc, &server_stat, *ptr, &rc);
-
-    printf("\t %s: %s\n", *ptr, value);
-    free(value);
+    printf("Server: %s (%u)\n", memcached_server_name(instance),
+           (uint32_t)memcached_server_port(instance));
+    last= instance;
   }
 
-  free(list);
-  printf("\n");
+  printf("\t %.*s: %.*s\n", (int)key_length, key, (int)value_length, value);
 
   return MEMCACHED_SUCCESS;
 }
@@ -140,12 +126,7 @@
   }
   else
   {
-    memcached_server_fn callbacks[1];
-
-    callbacks[0]= server_print_callback;
-    rc= memcached_server_cursor(memc, callbacks,
-                                NULL, 1);
-
+    rc= memcached_stat_execute(memc, NULL, stat_printer, NULL);
   }
 
   free(opt_servers);
 
=== modified file 'clients/utilities.c'
--- clients/utilities.c	2010-05-24 09:08:06 +0000
+++ clients/utilities.c	2010-07-21 16:27:47 +0000
@@ -8,8 +8,8 @@
  * Summary:
  *
  */
+#include "config.h"
 
-#include "libmemcached/common.h"
 #include <stdio.h>
 #include <ctype.h>
 #include <string.h>
 
=== modified file 'clients/utilities.h'
--- clients/utilities.h	2010-03-03 10:50:13 +0000
+++ clients/utilities.h	2010-07-21 16:27:47 +0000
@@ -11,6 +11,7 @@
 
 #include <getopt.h>
 #include <libmemcached/memcached.h>
+#include "libmemcached/watchpoint.h"
 #include "client_options.h"
 
 #if TIME_WITH_SYS_TIME
 
=== modified file 'configure.ac'
--- configure.ac	2010-06-13 15:01:04 +0000
+++ configure.ac	2010-07-21 16:27:47 +0000
@@ -7,14 +7,16 @@
 # the COPYING file in this directory for full text.
 
 AC_PREREQ(2.59)
-AC_INIT([libmemcached],[0.41],[http://libmemcached.org/])
+AC_INIT([libmemcached],[0.42],[http://libmemcached.org/])
 AC_CONFIG_SRCDIR([libmemcached/memcached.c])
 AC_CONFIG_AUX_DIR(config)
 
 PANDORA_CANONICAL_TARGET
 
 #shared library versioning
-MEMCACHED_LIBRARY_VERSION=5:1:1
+MEMCACHED_UTIL_LIBRARY_VERSION=1:0:0
+MEMCACHED_PROTOCAL_LIBRARY_VERSION=0:0:0
+MEMCACHED_LIBRARY_VERSION=5:1:0
 #                         | | |
 #                  +------+ | +---+
 #                  |        |     |
@@ -25,6 +27,8 @@
 #                  |        +- increment if source code has changed
 #                  |           set to zero if current is incremented
 #                  +- increment if interfaces have been added, removed or changed
+AC_SUBST(MEMCACHED_UTIL_LIBRARY_VERSION)
+AC_SUBST(MEMCACHED_PROTOCAL_LIBRARY_VERSION)
 AC_SUBST(MEMCACHED_LIBRARY_VERSION)
 
 
@@ -36,6 +40,7 @@
 
 AC_CHECK_FUNCS([getline])
 
+PANDORA_HAVE_LIBGTEST
 PANDORA_HAVE_LIBEVENT
 PANDORA_REQUIRE_PTHREAD
 PANDORA_CXX_DEMANGLE
@@ -45,8 +50,6 @@
 ENABLE_UTILLIB
 SETSOCKOPT_SANITY
 ENABLE_HSIEH_HASH
-REQUIRE_POD2MAN
-REQUIRE_PODCHECKER
 PROTOCOL_BINARY_TEST
 WITH_MEMCACHED
 ENABLE_DEPRECATED
@@ -68,6 +71,20 @@
 	              [1],
                       [Define to true if you want to use functions from atomic.h])])])
 
+AC_ARG_WITH([docs],
+  [AS_HELP_STRING([--with-docs],
+    [Generate documentation (yes|no) @<:@default=yes@:>@])],
+  [with_docs=$withval],
+  [with_docs=yes])
+
+AS_IF([test "$with_docs" = "yes"],
+  [
+    REQUIRE_POD2MAN
+    REQUIRE_PODCHECKER
+  ])
+AM_CONDITIONAL(BUILD_DOCS, test "$with_docs" = "yes")
+
+
 AC_CONFIG_FILES([
   Makefile
   docs/Makefile
@@ -104,3 +121,13 @@
   ;;
 esac
 
+AS_IF(test "$with_docs" = "no",
+  [
+    echo "*****"
+    echo "*"
+    echo "*  WARNING: You are not generating any documentation."
+    echo "*           Please don't ship libmemcached to an end user"
+    echo "*           without documentation..."
+    echo "*"
+    echo "*****"
+  ])
 
=== modified file 'libhashkit/hsieh.c'
--- libhashkit/hsieh.c	2010-01-19 23:39:13 +0000
+++ libhashkit/hsieh.c	2010-07-21 16:27:47 +0000
@@ -17,7 +17,7 @@
                       +(uint32_t)(((const uint8_t *)(d))[0]) )
 #endif
 
-uint32_t hashkit_hsieh(const char *key, size_t key_length, void *context__attribute__((unused)))
+uint32_t hashkit_hsieh(const char *key, size_t key_length, void *context __attribute__((unused)))
 {
   uint32_t hash = 0, tmp;
   int rem;
@@ -43,16 +43,18 @@
   {
   case 3: hash += get16bits (key);
           hash ^= hash << 16;
-          hash ^= key[sizeof (uint16_t)] << 18;
+          hash ^= (uint32_t)key[sizeof (uint16_t)] << 18;
           hash += hash >> 11;
           break;
   case 2: hash += get16bits (key);
           hash ^= hash << 11;
           hash += hash >> 17;
           break;
-  case 1: hash += *key;
+  case 1: hash += (unsigned char)(*key);
           hash ^= hash << 10;
           hash += hash >> 1;
+  default:
+          break;
   }
 
   /* Force "avalanching" of final 127 bits */
 
=== modified file 'libmemcached/behavior.c'
--- libmemcached/behavior.c	2010-04-05 19:01:19 +0000
+++ libmemcached/behavior.c	2010-07-21 16:27:47 +0000
@@ -55,6 +55,7 @@
     ptr->server_failure_limit= (uint32_t)data;
     break;
   case MEMCACHED_BEHAVIOR_BINARY_PROTOCOL:
+    memcached_quit(ptr); // We need t shutdown all of the connections to make sure we do the correct protocol
     if (data)
     {
       ptr->flags.verify_key= false;
 
=== modified file 'libmemcached/common.h'
--- libmemcached/common.h	2010-04-21 03:14:19 +0000
+++ libmemcached/common.h	2010-07-21 16:27:47 +0000
@@ -56,9 +56,17 @@
 
 typedef struct memcached_server_st * memcached_server_write_instance_st;
 
+typedef memcached_return_t (*memcached_server_execute_fn)(memcached_st *ptr, memcached_server_write_instance_st server, void *context);
+
 LIBMEMCACHED_LOCAL
 memcached_server_write_instance_st memcached_server_instance_fetch(memcached_st *ptr, uint32_t server_key);
 
+LIBMEMCACHED_LOCAL
+memcached_return_t memcached_server_execute(memcached_st *ptr,
+                                            memcached_server_execute_fn callback,
+                                            void *context);
+
+
 /* These are private not to be installed headers */
 #include "libmemcached/io.h"
 #include "libmemcached/do.h"
@@ -79,7 +87,7 @@
 typedef enum {
   MEM_NOT= -1,
   MEM_FALSE= false,
-  MEM_TRUE= true,
+  MEM_TRUE= true
 } memcached_ternary_t;
 
 
 
=== modified file 'libmemcached/connect.c'
--- libmemcached/connect.c	2010-06-13 21:04:20 +0000
+++ libmemcached/connect.c	2010-07-21 16:27:47 +0000
@@ -1,9 +1,96 @@
+/* LibMemcached
+ * Copyright (C) 2006-2010 Brian Aker
+ * All rights reserved.
+ *
+ * Use and distribution licensed under the BSD license.  See
+ * the COPYING file in the parent directory for full text.
+ *
+ * Summary: Server IO, Not public!
+ *
+ */
+
 #include "common.h"
 #include <netdb.h>
 #include <poll.h>
 #include <sys/time.h>
 #include <time.h>
 
+static memcached_return_t connect_poll(memcached_server_st *ptr)
+{
+  struct pollfd fds[1];
+  fds[0].fd = ptr->fd;
+  fds[0].events = POLLOUT;
+
+  int timeout= ptr->root->connect_timeout;
+  if (ptr->root->flags.no_block == true)
+    timeout= -1;
+
+  int error;
+  size_t loop_max= 5;
+
+  while (--loop_max) // Should only loop on cases of ERESTART or EINTR
+  {
+    error= poll(fds, 1, timeout);
+
+    switch (error)
+    {
+    case 1:
+      {
+        int err;
+        socklen_t len= sizeof (err);
+        (void)getsockopt(ptr->fd, SOL_SOCKET, SO_ERROR, &err, &len);
+
+        // We check the value to see what happened wth the socket.
+        if (err == 0)
+        {
+          return MEMCACHED_SUCCESS;
+        }
+        else
+        {
+          ptr->cached_errno= errno;
+
+          return MEMCACHED_ERRNO;
+        }
+      }
+    case 0:
+      return MEMCACHED_TIMEOUT;
+    default: // A real error occurred and we need to completely bail
+      WATCHPOINT_ERRNO(errno);
+      switch (errno)
+      {
+#ifdef TARGET_OS_LINUX
+      case ERESTART:
+#endif
+      case EINTR:
+        continue;
+      default:
+        if (fds[0].revents & POLLERR)
+        {
+          int err;
+          socklen_t len= sizeof (err);
+          (void)getsockopt(ptr->fd, SOL_SOCKET, SO_ERROR, &err, &len);
+          ptr->cached_errno= (err == 0) ? errno : err;
+        }
+        else
+        {
+          ptr->cached_errno= errno;
+        }
+
+        (void)close(ptr->fd);
+        ptr->fd= -1;
+
+        return MEMCACHED_ERRNO;
+      }
+    }
+    WATCHPOINT_ASSERT(0); // Programming error
+  }
+
+  // This should only be possible from ERESTART or EINTR;
+  ptr->cached_errno= errno;
+
+  return MEMCACHED_ERRNO;
+}
+
 static memcached_return_t set_hostinfo(memcached_server_st *server)
 {
   struct addrinfo *ai;
@@ -225,36 +312,35 @@
 {
   struct sockaddr_un servAddr;
 
-  if (ptr->fd == -1)
+  WATCHPOINT_ASSERT(ptr->fd == -1);
+
+  if ((ptr->fd= socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
   {
-    if ((ptr->fd= socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
-    {
-      ptr->cached_errno= errno;
-      return MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE;
-    }
+    ptr->cached_errno= errno;
+    return MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE;
+  }
 
-    memset(&servAddr, 0, sizeof (struct sockaddr_un));
-    servAddr.sun_family= AF_UNIX;
-    strcpy(servAddr.sun_path, ptr->hostname); /* Copy filename */
+  memset(&servAddr, 0, sizeof (struct sockaddr_un));
+  servAddr.sun_family= AF_UNIX;
+  strcpy(servAddr.sun_path, ptr->hostname); /* Copy filename */
 
 test_connect:
-    if (connect(ptr->fd,
-                (struct sockaddr *)&servAddr,
-                sizeof(servAddr)) < 0)
+  if (connect(ptr->fd,
+              (struct sockaddr *)&servAddr,
+              sizeof(servAddr)) < 0)
+  {
+    switch (errno)
     {
-      switch (errno)
-      {
-      case EINPROGRESS:
-      case EALREADY:
-      case EINTR:
-        goto test_connect;
-      case EISCONN: /* We were spinning waiting on connect */
-        break;
-      default:
-        WATCHPOINT_ERRNO(errno);
-        ptr->cached_errno= errno;
-        return MEMCACHED_ERRNO;
-      }
+    case EINPROGRESS:
+    case EALREADY:
+    case EINTR:
+      goto test_connect;
+    case EISCONN: /* We were spinning waiting on connect */
+      break;
+    default:
+      WATCHPOINT_ERRNO(errno);
+      ptr->cached_errno= errno;
+      return MEMCACHED_ERRNO;
     }
   }
 
@@ -265,134 +351,78 @@
 
 static memcached_return_t network_connect(memcached_server_st *ptr)
 {
-  if (ptr->fd == -1)
-  {
-    struct addrinfo *use;
-
-    WATCHPOINT_ASSERT(ptr->cursor_active == 0);
-
-    if (! ptr->options.sockaddr_inited ||
-        (!(ptr->root->flags.use_cache_lookups)))
+  bool timeout_error_occured= false;
+
+  
+  WATCHPOINT_ASSERT(ptr->fd == -1);
+  WATCHPOINT_ASSERT(ptr->cursor_active == 0);
+
+  if (! ptr->options.sockaddr_inited || (!(ptr->root->flags.use_cache_lookups)))
+  {
+    memcached_return_t rc;
+
+    rc= set_hostinfo(ptr);
+    if (rc != MEMCACHED_SUCCESS)
+      return rc;
+    ptr->options.sockaddr_inited= true;
+  }
+
+  struct addrinfo *use= ptr->address_info;
+  /* Create the socket */
+  while (use != NULL)
+  {
+    /* Memcache server does not support IPV6 in udp mode, so skip if not ipv4 */
+    if (ptr->type == MEMCACHED_CONNECTION_UDP && use->ai_family != AF_INET)
+    {
+      use= use->ai_next;
+      continue;
+    }
+
+    if ((ptr->fd= socket(use->ai_family,
+                         use->ai_socktype,
+                         use->ai_protocol)) < 0)
+    {
+      ptr->cached_errno= errno;
+      WATCHPOINT_ERRNO(errno);
+      return MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE;
+    }
+
+    (void)set_socket_options(ptr);
+
+    /* connect to server */
+    if ((connect(ptr->fd, use->ai_addr, use->ai_addrlen) > -1))
+    {
+      break; // Success
+    }
+
+    /* An error occurred */
+    ptr->cached_errno= errno;
+    if (errno == EINPROGRESS || /* nonblocking mode - first return, */
+        errno == EALREADY) /* nonblocking mode - subsequent returns */
     {
       memcached_return_t rc;
-
-      rc= set_hostinfo(ptr);
-      if (rc != MEMCACHED_SUCCESS)
-        return rc;
-      ptr->options.sockaddr_inited= true;
-    }
-
-    use= ptr->address_info;
-    /* Create the socket */
-    while (use != NULL)
-    {
-      /* Memcache server does not support IPV6 in udp mode, so skip if not ipv4 */
-      if (ptr->type == MEMCACHED_CONNECTION_UDP && use->ai_family != AF_INET)
-      {
-        use= use->ai_next;
-        continue;
-      }
-
-      if ((ptr->fd= socket(use->ai_family,
-                           use->ai_socktype,
-                           use->ai_protocol)) < 0)
-      {
-        ptr->cached_errno= errno;
-        WATCHPOINT_ERRNO(errno);
-        return MEMCACHED_CONNECTION_SOCKET_CREATE_FAILURE;
-      }
-
-      (void)set_socket_options(ptr);
-
-      /* connect to server */
-      if ((connect(ptr->fd, use->ai_addr, use->ai_addrlen) == -1))
-      {
-        ptr->cached_errno= errno;
-        if (errno == EINPROGRESS || /* nonblocking mode - first return, */
-            errno == EALREADY) /* nonblocking mode - subsequent returns */
-        {
-          struct pollfd fds[1];
-          fds[0].fd = ptr->fd;
-          fds[0].events = POLLOUT;
-
-          int timeout= ptr->root->connect_timeout;
-          if (ptr->root->flags.no_block == true)
-            timeout= -1;
-
-          size_t loop_max= 5;
-          while (--loop_max)
-          {
-            int error= poll(fds, 1, timeout);
-
-            switch (error)
-            {
-            case 1:
-              loop_max= 1;
-              break;
-            case 0:
-              if (loop_max==1) 
-                return MEMCACHED_TIMEOUT;
-              continue;
-              // A real error occurred and we need to completely bail
-            default:
-              WATCHPOINT_ERRNO(errno);
-              switch (errno)
-              {
-#ifdef TARGET_OS_LINUX
-              case ERESTART:
-#endif
-              case EINTR:
-                continue;
-              default:
-                if (fds[0].revents & POLLERR)
-                {
-                  int err;
-                  socklen_t len= sizeof (err);
-                  (void)getsockopt(ptr->fd, SOL_SOCKET, SO_ERROR, &err, &len);
-                  ptr->cached_errno= (err == 0) ? errno : err;
-                }
-
-                (void)close(ptr->fd);
-                ptr->fd= -1;
-
-                break;
-              }
-            }
-          }
-        }
-        else if (errno == EISCONN) /* we are connected :-) */
-        {
-          break;
-        }
-        else if (errno != EINTR)
-        {
-          (void)close(ptr->fd);
-          ptr->fd= -1;
-          break;
-        }
-      }
-
-#ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
-      if (ptr->fd != -1 && ptr->root->sasl && ptr->root->sasl->callbacks)
-      {
-        memcached_return rc= memcached_sasl_authenticate_connection(ptr);
-        if (rc != MEMCACHED_SUCCESS)
-        {
-          (void)close(ptr->fd);
-          ptr->fd= -1;
-
-          return rc;
-        }
-      }
-#endif
-
-
-      if (ptr->fd != -1)
-      {
-        return MEMCACHED_SUCCESS;
-      }
-      use = use->ai_next;
-    }
+      rc= connect_poll(ptr);
+
+      if (rc == MEMCACHED_TIMEOUT)
+        timeout_error_occured= true;
+
+      if (rc == MEMCACHED_SUCCESS)
+        break;
+    }
+    else if (errno == EISCONN) /* we are connected :-) */
+    {
+      break;
+    }
+    else if (errno == EINTR) // Special case, we retry ai_addr
+    {
+      (void)close(ptr->fd);
+      ptr->fd= -1;
+      continue;
+    }
+
+    (void)close(ptr->fd);
+    ptr->fd= -1;
+    use= use->ai_next;
   }
 
   if (ptr->fd == -1)
@@ -408,7 +438,7 @@
         ptr->next_retry= next_time.tv_sec + ptr->root->retry_timeout;
     }
 
-    if (ptr->cached_errno == 0)
+    if (timeout_error_occured)
       return MEMCACHED_TIMEOUT;
 
     return MEMCACHED_ERRNO; /* The last error should be from connect() */
@@ -435,6 +465,10 @@
 memcached_return_t memcached_connect(memcached_server_write_instance_st ptr)
 {
   memcached_return_t rc= MEMCACHED_NO_SERVERS;
+
+  if (ptr->fd > -1)
+    return MEMCACHED_SUCCESS;
+
   LIBMEMCACHED_MEMCACHED_CONNECT_START();
 
   /* both retry_timeout and server_failure_limit must be set in order to delay retrying a server on error. */
@@ -481,6 +515,17 @@
   case MEMCACHED_CONNECTION_UDP:
   case MEMCACHED_CONNECTION_TCP:
     rc= network_connect(ptr);
+#ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
+    if (ptr->fd != -1 && ptr->root->sasl && ptr->root->sasl->callbacks)
+    {
+      rc= memcached_sasl_authenticate_connection(ptr);
+      if (rc != MEMCACHED_SUCCESS)
+      {
+        (void)close(ptr->fd);
+        ptr->fd= -1;
+      }
+    }
+#endif
     break;
   case MEMCACHED_CONNECTION_UNIX_SOCKET:
     rc= unix_socket_connect(ptr);
 
=== modified file 'libmemcached/delete.c'
--- libmemcached/delete.c	2010-04-02 19:55:21 +0000
+++ libmemcached/delete.c	2010-07-21 16:27:47 +0000
@@ -45,7 +45,7 @@
 
   if (ptr->flags.binary_protocol)
   {
-    likely (!expiration)
+    likely (! expiration)
     {
       rc= binary_delete(ptr, server_key, key, key_length, to_write);
     }
 
=== modified file 'libmemcached/include.am'
--- libmemcached/include.am	2010-06-15 06:31:25 +0000
+++ libmemcached/include.am	2010-07-21 16:27:47 +0000
@@ -65,7 +65,7 @@
 						libmemcached/protocol/pedantic.c \
 						libmemcached/protocol/protocol_handler.c
 
-libmemcached_libmemcachedprotocol_la_LDFLAGS= ${AM_LDFLAGS} -version-info 0:0:0
+libmemcached_libmemcachedprotocol_la_LDFLAGS= ${AM_LDFLAGS} -version-info ${MEMCACHED_PROTOCAL_LIBRARY_VERSION}
 
 noinst_LTLIBRARIES+= \
 		     libmemcached/libmemcachedcallbacks.la
@@ -133,7 +133,7 @@
 					  libmemcached/util/pool.c \
 					  libmemcached/util/version.c
 libmemcached_libmemcachedutil_la_LIBADD= libmemcached/libmemcached.la
-libmemcached_libmemcachedutil_la_LDFLAGS= ${AM_LDFLAGS} -version-info 0:0:0
+libmemcached_libmemcachedutil_la_LDFLAGS= ${AM_LDFLAGS} -version-info ${MEMCACHED_UTIL_LIBRARY_VERSION}
 libmemcached_libmemcachedutil_la_DEPENDENCIES= libmemcached/libmemcached.la
 
 if BUILD_BYTEORDER
@@ -158,6 +158,7 @@
 if DTRACE_NEEDS_OBJECTS
 libmemcached_libmemcached_la_SOURCES += libmemcached/libmemcached_probes.d
 libmemcached_libmemcached_la_DEPENDENCIES += libmemcached/libmemcached_probes.o
+CLEANFILES+= libmemcached/libmemcached_probes.o
 endif
 
 SUFFIXES+= .d
@@ -165,7 +166,7 @@
 libmemcached/dtrace_probes.h: libmemcached/libmemcached_probes.d
 	$(DTRACE) $(DTRACEFLAGS) -h -o libmemcached/dtrace_probes.h -s ${top_srcdir}/libmemcached/libmemcached_probes.d
 
-libmemcached/libmemcached_probes.o: libmemcached/libmemcached_probes.d ${libmemcached_libmemcached_OBJECTS} config.h
+libmemcached/libmemcached_probes.o: libmemcached/libmemcached_probes.d ${libmemcached_libmemcached_la_OBJECTS} config.h
 
 .d.o:
 	$(DTRACE) $(DTRACEFLAGS) -o libmemcached/libmemcached_probes.o -G -s ${top_srcdir}/libmemcached/libmemcached_probes.d `grep '^pic_object' ${top_builddir}/libmemcached/*.lo | cut -f 2 -d\' | sed "s/^/${top_builddir}\//"`
 
=== modified file 'libmemcached/io.c'
--- libmemcached/io.c	2010-04-22 22:51:37 +0000
+++ libmemcached/io.c	2010-07-21 16:27:47 +0000
@@ -62,45 +62,50 @@
     timeout= -1;
 
   size_t loop_max= 5;
-  while (--loop_max)
+  while (--loop_max) // While loop is for ERESTART or EINTR
   {
     error= poll(&fds, 1, timeout);
 
     switch (error)
     {
-    case 1:
+    case 1: // Success!
       WATCHPOINT_IF_LABELED_NUMBER(read_or_write && loop_max < 4, "read() times we had to loop, decremented down from 5", loop_max);
       WATCHPOINT_IF_LABELED_NUMBER(!read_or_write && loop_max < 4, "write() times we had to loop, decremented down from 5", loop_max);
 
       return MEMCACHED_SUCCESS;
-    case 0:
+    case 0: // Timeout occured, we let the while() loop do its thing.
       return MEMCACHED_TIMEOUT;
     default:
       WATCHPOINT_ERRNO(errno);
+      switch (errno)
       {
-        switch (errno)
-        {
 #ifdef TARGET_OS_LINUX
-        case ERESTART:
+      case ERESTART:
 #endif
-        case EINTR:
-          continue;
-        default:
-          ptr->cached_errno= error;
-          memcached_quit_server(ptr, true);
+      case EINTR:
+        break;
+      default:
+        if (fds.revents & POLLERR)
+        {
+          int err;
+          socklen_t len= sizeof (err);
+          (void)getsockopt(ptr->fd, SOL_SOCKET, SO_ERROR, &err, &len);
+          ptr->cached_errno= (err == 0) ? errno : err;
+        }
+        else
+        {
+          ptr->cached_errno= errno;
+        }
+        memcached_quit_server(ptr, true);
 
-          return MEMCACHED_FAILURE;
-        }
+        return MEMCACHED_FAILURE;
       }
     }
   }
 
-  if (loop_max == 0 && error == 0)
-    return MEMCACHED_TIMEOUT;
-
   /* Imposssible for anything other then -1 */
   WATCHPOINT_ASSERT(error == -1);
-  ptr->cached_errno= error;
+  ptr->cached_errno= errno;
   memcached_quit_server(ptr, true);
 
   return MEMCACHED_FAILURE;
 
=== modified file 'libmemcached/response.c'
--- libmemcached/response.c	2010-04-22 22:51:37 +0000
+++ libmemcached/response.c	2010-07-21 16:27:47 +0000
@@ -61,6 +61,7 @@
    * compatibility.
  */
   if (ptr->root->flags.binary_protocol == false)
+  {
     while (memcached_server_response_count(ptr) > 1)
     {
       memcached_return_t rc= memcached_read_one_response(ptr, buffer, buffer_length, result);
@@ -75,6 +76,7 @@
                 rc != MEMCACHED_DATA_EXISTS)
         return rc;
     }
+  }
 
   return memcached_read_one_response(ptr, buffer, buffer_length, result);
 }
 
=== modified file 'libmemcached/server.c'
--- libmemcached/server.c	2010-04-22 00:49:09 +0000
+++ libmemcached/server.c	2010-07-21 16:27:47 +0000
@@ -172,6 +172,26 @@
   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;
+
+    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,
 
=== modified file 'libmemcached/stats.c'
--- libmemcached/stats.c	2010-04-02 19:55:21 +0000
+++ libmemcached/stats.c	2010-07-21 16:27:47 +0000
@@ -29,6 +29,13 @@
   NULL
 };
 
+struct local_context
+{
+  memcached_stat_fn func;
+  void *context;
+  const char *args;
+};
+
 
 static memcached_return_t set_data(memcached_stat_st *memc_stat, char *key, char *value)
 {
@@ -228,8 +235,9 @@
 }
 
 static memcached_return_t binary_stats_fetch(memcached_stat_st *memc_stat,
-                                             char *args,
-                                             memcached_server_write_instance_st instance)
+                                             const char *args,
+                                             memcached_server_write_instance_st instance,
+                                             struct local_context *check)
 {
   memcached_return_t rc;
 
@@ -286,10 +294,23 @@
       return rc;
     }
 
-    unlikely((set_data(memc_stat, buffer, buffer + strlen(buffer) + 1)) == MEMCACHED_UNKNOWN_STAT_KEY)
-    {
-      WATCHPOINT_ERROR(MEMCACHED_UNKNOWN_STAT_KEY);
-      WATCHPOINT_ASSERT(0);
+    if (memc_stat)
+    {
+      unlikely((set_data(memc_stat, buffer, buffer + strlen(buffer) + 1)) == MEMCACHED_UNKNOWN_STAT_KEY)
+      {
+        WATCHPOINT_ERROR(MEMCACHED_UNKNOWN_STAT_KEY);
+        WATCHPOINT_ASSERT(0);
+      }
+    }
+    
+    if (check && check->func)
+    {
+      size_t key_length= strlen(buffer);
+
+      check->func(instance,
+                  buffer, key_length,
+                  buffer+key_length+1, strlen(buffer+key_length+1),
+                  check->context);
     }
   } while (1);
 
@@ -302,8 +323,9 @@
 }
 
 static memcached_return_t ascii_stats_fetch(memcached_stat_st *memc_stat,
-                                            char *args,
-                                            memcached_server_write_instance_st instance)
+                                            const char *args,
+                                            memcached_server_write_instance_st instance,
+                                            struct local_context *check)
 {
   memcached_return_t rc;
   char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
@@ -343,10 +365,21 @@
       value= string_ptr;
       value[(size_t)(end_ptr-string_ptr)]= 0;
       string_ptr= end_ptr + 2;
-      unlikely((set_data(memc_stat, key, value)) == MEMCACHED_UNKNOWN_STAT_KEY)
-      {
-        WATCHPOINT_ERROR(MEMCACHED_UNKNOWN_STAT_KEY);
-        WATCHPOINT_ASSERT(0);
+      if (memc_stat)
+      {
+        unlikely((set_data(memc_stat, key, value)) == MEMCACHED_UNKNOWN_STAT_KEY)
+        {
+          WATCHPOINT_ERROR(MEMCACHED_UNKNOWN_STAT_KEY);
+          WATCHPOINT_ASSERT(0);
+        }
+      }
+
+      if (check && check->func)
+      {
+        check->func(instance,
+                    key, strlen(key),
+                    value, strlen(value),
+                    check->context);
       }
     }
     else
@@ -394,11 +427,11 @@
 
     if (ptr->flags.binary_protocol)
     {
-      temp_return= binary_stats_fetch(stat_instance, args, instance);
+      temp_return= binary_stats_fetch(stat_instance, args, instance, NULL);
     }
     else
     {
-      temp_return= ascii_stats_fetch(stat_instance, args, instance);
+      temp_return= ascii_stats_fetch(stat_instance, args, instance, NULL);
     }
 
     if (temp_return != MEMCACHED_SUCCESS)
@@ -428,11 +461,11 @@
 
   if (memc.flags.binary_protocol)
   {
-    rc= binary_stats_fetch(memc_stat, args, instance);
+    rc= binary_stats_fetch(memc_stat, args, instance, NULL);
   }
   else
   {
-    rc= ascii_stats_fetch(memc_stat, args, instance);
+    rc= ascii_stats_fetch(memc_stat, args, instance, NULL);
   }
 
   memcached_free(&memc);
@@ -489,3 +522,31 @@
     free(memc_stat);
   }
 }
+
+static memcached_return_t call_stat_fn(memcached_st *ptr,
+                                       memcached_server_write_instance_st instance,
+                                       void *context)
+{
+  memcached_return_t rc;
+  struct local_context *check= (struct local_context *)context;
+
+  if (ptr->flags.binary_protocol)
+  {
+    rc= binary_stats_fetch(NULL, check->args, instance, check);
+  }
+  else
+  {
+    rc= ascii_stats_fetch(NULL, check->args, instance, check);
+  }
+
+  return rc;
+}
+
+memcached_return_t memcached_stat_execute(memcached_st *memc, const char *args,  memcached_stat_fn func, void *context)
+{
+  memcached_version(memc);
+
+ struct local_context check= { .func= func, .context= context, .args= args };
+
+ return memcached_server_execute(memc, call_stat_fn, (void *)&check);
+}
 
=== modified file 'libmemcached/stats.h'
--- libmemcached/stats.h	2010-02-17 01:58:35 +0000
+++ libmemcached/stats.h	2010-07-21 16:27:47 +0000
@@ -62,6 +62,9 @@
 char ** memcached_stat_get_keys(const memcached_st *ptr, memcached_stat_st *memc_stat,
                                 memcached_return_t *error);
 
+LIBMEMCACHED_API
+memcached_return_t memcached_stat_execute(memcached_st *memc, const char *args,  memcached_stat_fn func, void *context);
+
 #ifdef __cplusplus
 } // extern "C"
 #endif
 
=== modified file 'libmemcached/types.h'
--- libmemcached/types.h	2010-02-17 01:58:35 +0000
+++ libmemcached/types.h	2010-07-21 16:27:47 +0000
@@ -47,6 +47,10 @@
 
 typedef memcached_return_t (*memcached_execute_fn)(const memcached_st *ptr, memcached_result_st *result, void *context);
 typedef memcached_return_t (*memcached_server_fn)(const memcached_st *ptr, memcached_server_instance_st server, void *context);
+typedef memcached_return_t (*memcached_stat_fn)(memcached_server_instance_st server,
+                                                const char *key, size_t key_length,
+                                                const char *value, size_t value_length,
+                                                void *context);
 
 /**
   Trigger functions.
 
=== modified file 'libmemcached/util/version.c'
--- libmemcached/util/version.c	2010-06-15 06:31:25 +0000
+++ libmemcached/util/version.c	2010-07-21 16:27:47 +0000
@@ -16,8 +16,8 @@
 struct local_context
 {
   uint8_t major_version;
+  uint8_t minor_version;
   uint8_t micro_version;
-  uint8_t minor_version;
 
   bool truth;
 };
@@ -30,8 +30,8 @@
   struct local_context *check= (struct local_context *)context;
 
   if (instance->major_version >= check->major_version &&
-      instance->micro_version >= check->micro_version &&
-      instance->minor_version >= check->minor_version)
+      instance->minor_version >= check->minor_version &&
+      instance->micro_version >= check->micro_version )
   {
     return MEMCACHED_SUCCESS;
   }
@@ -43,13 +43,14 @@
 
 bool libmemcached_util_version_check(memcached_st *memc, 
                                      uint8_t major_version,
-                                     uint8_t micro_version,
-                                     uint8_t minor_version)
+                                     uint8_t minor_version,
+                                     uint8_t micro_version)
 {
   memcached_server_fn callbacks[1];
   memcached_version(memc);
 
- struct local_context check= { .major_version= major_version, .micro_version= micro_version, .minor_version= minor_version, .truth= true };
+  struct local_context check= { .major_version= major_version, .minor_version= minor_version, .micro_version= micro_version, .truth= true };
+  memcached_version(memc);
 
   callbacks[0]= check_server_version;
   memcached_server_cursor(memc, callbacks, (void *)&check,  1);
 
=== modified file 'libmemcached/util/version.h'
--- libmemcached/util/version.h	2010-06-15 06:31:25 +0000
+++ libmemcached/util/version.h	2010-07-21 16:27:47 +0000
@@ -19,8 +19,8 @@
 LIBMEMCACHED_API
   bool libmemcached_util_version_check(memcached_st *memc, 
                                        uint8_t major_version,
-                                       uint8_t micro_version,
-                                       uint8_t minor_version);
+                                       uint8_t minor_version,
+                                       uint8_t micro_version);
 
 #ifdef __cplusplus
 }
 
=== modified file 'libmemcached/version.c'
--- libmemcached/version.c	2010-04-02 19:55:21 +0000
+++ libmemcached/version.c	2010-07-21 16:27:47 +0000
@@ -13,10 +13,19 @@
   if (ptr->flags.use_udp)
     return MEMCACHED_NOT_SUPPORTED;
 
+  bool was_blocking= ptr->flags.no_block;
+  memcached_return_t rc;
+
+  ptr->flags.no_block= false;
+
   if (ptr->flags.binary_protocol)
-    return memcached_version_binary(ptr);
+    rc= memcached_version_binary(ptr);
   else
-    return memcached_version_textual(ptr);      
+    rc= memcached_version_textual(ptr);      
+
+  ptr->flags.no_block= was_blocking;
+
+  return rc;
 }
 
 static inline memcached_return_t memcached_version_textual(memcached_st *ptr)
 
=== modified file 'm4/pandora_warnings.m4'
--- m4/pandora_warnings.m4	2010-06-13 16:24:20 +0000
+++ m4/pandora_warnings.m4	2010-07-21 16:27:47 +0000
@@ -145,7 +145,7 @@
       m4_if(PW_LESS_WARNINGS,[no],[
         BASE_WARNINGS_FULL="-Wformat=2 ${W_CONVERSION} -Wstrict-aliasing"
         CC_WARNINGS_FULL="-Wswitch-default -Wswitch-enum -Wwrite-strings"
-        CXX_WARNINGS_FULL="-Weffc++ -Wold-style-cast"
+        CXX_WARNINGS_FULL="-Wold-style-cast"
         NO_OLD_STYLE_CAST="-Wno-old-style-cast"
         NO_EFF_CXX="-Wno-effc++"
       ],[
 
=== modified file 'support/libmemcached.spec.in'
--- support/libmemcached.spec.in	2010-04-05 16:41:24 +0000
+++ support/libmemcached.spec.in	2010-07-21 16:27:47 +0000
@@ -82,10 +82,14 @@
 %exclude %{_libdir}/libhashkit.la
 %exclude %{_libdir}/libmemcachedutil.la
 %exclude %{_libdir}/libmemcachedprotocol.la
-%{_libdir}/libhashkit.so.*
-%{_libdir}/libmemcached.so.*
-%{_libdir}/libmemcachedutil.so.*
-%{_libdir}/libmemcachedprotocol.so.*
+%{_libdir}/libhashkit.so.0.0.0
+%{_libdir}/libmemcached.so.5.0.1
+%{_libdir}/libmemcachedutil.so.1.0.0
+%{_libdir}/libmemcachedprotocol.so.0.0.0
+%{_libdir}/libhashkit.so.0
+%{_libdir}/libmemcached.so.5
+%{_libdir}/libmemcachedprotocol.so.0
+%{_libdir}/libmemcachedutil.so.1
 %{_mandir}/man1/memcapable.1.gz
 %{_mandir}/man1/memcat.1.gz
 %{_mandir}/man1/memcp.1.gz
@@ -104,14 +108,6 @@
 %{_includedir}/libmemcached/delete.h
 %{_includedir}/libmemcached/fetch.h
 %{_includedir}/libmemcached/flush.h
-%{_includedir}/libmemcached/flush_buffers.h
-%{_includedir}/libmemcached/hash.h
-%{_includedir}/libmemcached/parse.h
-%{_includedir}/libmemcached/quit.h
-%{_includedir}/libmemcached/sasl.h
-%{_includedir}/libmemcached/strerror.h
-%{_includedir}/libmemcached/verbosity.h
-%{_includedir}/libmemcached/version.h
 %{_includedir}/libhashkit/algorithm.h
 %{_includedir}/libhashkit/behavior.h
 %{_includedir}/libhashkit/configure.h
@@ -129,21 +125,32 @@
 %{_includedir}/libmemcached/constants.h
 %{_includedir}/libmemcached/dump.h
 %{_includedir}/libmemcached/exception.hpp
+%{_includedir}/libmemcached/flush_buffers.h
 %{_includedir}/libmemcached/get.h
+%{_includedir}/libmemcached/hash.h
 %{_includedir}/libmemcached/memcached.h
 %{_includedir}/libmemcached/memcached.hpp
 %{_includedir}/libmemcached/memcached_util.h
+%{_includedir}/libmemcached/parse.h
 %{_includedir}/libmemcached/protocol/cache.h
 %{_includedir}/libmemcached/protocol/callback.h
 %{_includedir}/libmemcached/protocol_handler.h
+%{_includedir}/libmemcached/quit.h
 %{_includedir}/libmemcached/result.h
+%{_includedir}/libmemcached/sasl.h
 %{_includedir}/libmemcached/server.h
 %{_includedir}/libmemcached/server_list.h
 %{_includedir}/libmemcached/stats.h
 %{_includedir}/libmemcached/storage.h
+%{_includedir}/libmemcached/strerror.h
 %{_includedir}/libmemcached/string.h
 %{_includedir}/libmemcached/types.h
+%{_includedir}/libmemcached/util.h
+%{_includedir}/libmemcached/util/ping.h
 %{_includedir}/libmemcached/util/pool.h
+%{_includedir}/libmemcached/util/version.h
+%{_includedir}/libmemcached/verbosity.h
+%{_includedir}/libmemcached/version.h
 %{_includedir}/libmemcached/visibility.h
 %{_includedir}/libmemcached/watchpoint.h
 %{_includedir}/libmemcached/memcached/protocol_binary.h
@@ -187,6 +194,7 @@
 %{_mandir}/man3/memcached_decrement_with_initial.3.gz
 %{_mandir}/man3/memcached_delete.3.gz
 %{_mandir}/man3/memcached_delete_by_key.3.gz
+%{_mandir}/man3/memcached_destroy_sasl_auth_data.3.gz
 %{_mandir}/man3/memcached_dump.3.gz
 %{_mandir}/man3/memcached_fetch.3.gz
 %{_mandir}/man3/memcached_fetch_execute.3.gz
@@ -197,6 +205,7 @@
 %{_mandir}/man3/memcached_get.3.gz
 %{_mandir}/man3/memcached_get_by_key.3.gz
 %{_mandir}/man3/memcached_get_memory_allocators.3.gz
+%{_mandir}/man3/memcached_get_sasl_callbacks.3.gz
 %{_mandir}/man3/memcached_get_user_data.3.gz
 %{_mandir}/man3/memcached_increment.3.gz
 %{_mandir}/man3/memcached_increment_with_initial.3.gz
@@ -216,6 +225,7 @@
 %{_mandir}/man3/memcached_quit.3.gz
 %{_mandir}/man3/memcached_replace.3.gz
 %{_mandir}/man3/memcached_replace_by_key.3.gz
+%{_mandir}/man3/memcached_sasl_set_auth_data.3.gz
 %{_mandir}/man3/memcached_server_add.3.gz
 %{_mandir}/man3/memcached_server_count.3.gz
 %{_mandir}/man3/memcached_server_cursor.3.gz
@@ -228,6 +238,7 @@
 %{_mandir}/man3/memcached_set.3.gz
 %{_mandir}/man3/memcached_set_by_key.3.gz
 %{_mandir}/man3/memcached_set_memory_allocators.3.gz
+%{_mandir}/man3/memcached_set_sasl_callbacks.3.gz
 %{_mandir}/man3/memcached_set_user_data.3.gz
 %{_mandir}/man3/memcached_stat.3.gz
 %{_mandir}/man3/memcached_stat_get_keys.3.gz
 
=== modified file 'tests/atomsmasher.c'
--- tests/atomsmasher.c	2010-01-15 21:49:15 +0000
+++ tests/atomsmasher.c	2010-07-21 16:27:47 +0000
@@ -12,10 +12,14 @@
 /*
   Sample test application.
 */
-#include "libmemcached/common.h"
+#include "config.h"
+
+#include "libmemcached/memcached.h"
+#include "libmemcached/watchpoint.h"
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <stdint.h>
 #include <string.h>
 #include <sys/time.h>
 #include <sys/types.h>
@@ -26,14 +30,6 @@
 #include "../clients/generator.h"
 #include "../clients/execute.h"
 
-#ifndef INT64_MAX
-#define INT64_MAX LONG_MAX
-#endif
-#ifndef INT32_MAX
-#define INT32_MAX INT_MAX
-#endif
-
-
 #include "test.h"
 
 /* Number of items generated for tests */
 
=== modified file 'tests/hashkit_functions.c'
--- tests/hashkit_functions.c	2010-04-11 17:56:46 +0000
+++ tests/hashkit_functions.c	2010-07-21 16:27:47 +0000
@@ -6,6 +6,8 @@
  * the COPYING file in the parent directory for full text.
  */
 
+#include "config.h"
+
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 
=== modified file 'tests/include.am'
--- tests/include.am	2010-06-13 16:43:30 +0000
+++ tests/include.am	2010-07-21 16:27:47 +0000
@@ -4,7 +4,7 @@
 
 TESTS_LDADDS = libmemcached/libmemcached.la
 
-VALGRIND_COMMAND= $(LIBTOOL) --mode=execute valgrind --leak-check=yes --show-reachable=yes
+VALGRIND_COMMAND= $(LIBTOOL) --mode=execute valgrind --leak-check=yes --show-reachable=yes --track-fds=yes
 
 DEBUG_COMMAND= $(LIBTOOL) --mode=execute gdb
 
@@ -41,6 +41,7 @@
 tests_testapp_CFLAGS= $(AM_CFLAGS) $(NO_CONVERSION) $(NO_STRICT_ALIASING)
 tests_testapp_SOURCES= tests/mem_functions.c
 tests_testapp_DEPENDENCIES= \
+			    $(BUILT_SOURCES) \
 			    clients/libgenexec.la \
 			    tests/libserver.la \
 			    tests/libtest.la \
@@ -86,12 +87,14 @@
 tests_memplus_SOURCES = tests/mem_plus.cc
 tests_memplus_CXXFLAGS = $(AM_CXXFLAGS) $(NO_EFF_CXX)
 tests_memplus_DEPENDENCIES = tests/libtest.la tests/libserver.la libmemcached/libmemcached.la
-tests_memplus_LDADD = $(tests_memplus_DEPENDENCIES)
-
-test: test-docs test-mem test-hash memcapable
+tests_memplus_LDADD = $(tests_memplus_DEPENDENCIES) $(LIBSASL)
+
+test: check
+
+check-local: $(TEST_DOCS) test-mem test-hash memcapable
 	echo "Tests completed"
 
-test-x: test-docs test-plus test-mem test-hash memcapable test-memcat test-memcp test-memrm test-memerror test-memdump test-memflush test-memstat
+test-x: check-local test-plus test-memcat test-memcp test-memrm test-memerror test-memdump test-memflush test-memstat
 	echo "Tests completed"
 
 memcapable: clients/memcapable
 
=== modified file 'tests/mem_functions.c'
--- tests/mem_functions.c	2010-06-15 06:31:25 +0000
+++ tests/mem_functions.c	2010-07-21 16:27:47 +0000
@@ -10,10 +10,11 @@
   Sample test application.
 */
 
-#include "libmemcached/common.h"
+#include "config.h"
 
 #include <assert.h>
 #include <stdio.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/time.h>
@@ -22,20 +23,18 @@
 #include <signal.h>
 #include <unistd.h>
 #include <time.h>
+
+#include "libmemcached/common.h"
+
 #include "server.h"
 #include "clients/generator.h"
 #include "clients/execute.h"
 
-#ifndef INT64_MAX
-#define INT64_MAX LONG_MAX
-#endif
-#ifndef INT32_MAX
-#define INT32_MAX INT_MAX
-#endif
-
+#define SMALL_STRING_LEN 1024
 
 #include "test.h"
 
+
 #ifdef HAVE_LIBMEMCACHEDUTIL
 #include <pthread.h>
 #include "libmemcached/memcached_util.h"
@@ -682,7 +681,6 @@
 */
 static test_return_t add_wrapper(memcached_st *memc)
 {
-  unsigned int x;
   unsigned int max= 10000;
 #ifdef __sun
   max= 10;
@@ -691,7 +689,7 @@
   max= 10;
 #endif
 
-  for (x= 0; x < max; x++)
+  for (uint32_t x= 0; x < max; x++)
     add_test(memc);
 
   return TEST_SUCCESS;
@@ -3599,7 +3597,7 @@
   // will not toggle protocol on an connection.
   memcached_version(memc_clone);
 
-  if (libmemcached_util_version_check(memc_clone, 1, 2, 0))
+  if (libmemcached_util_version_check(memc_clone, 1, 3, 0))
   {
     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
     rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
@@ -3724,23 +3722,14 @@
 static test_return_t pre_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, 2, 0))
+
+  if (libmemcached_util_version_check(memc, 1, 3, 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);
   }
 
-  memcached_free(memc_clone);
-
   return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
 }
 
@@ -4432,24 +4421,24 @@
   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->micro_version, instance->minor_version);
-  test_true(if_successful == true);
-
-  if (instance->minor_version > 0)
-    if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->micro_version, instance->minor_version -1);
-  else if (instance->micro_version > 0)
-    if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->micro_version - 1, instance->minor_version);
-  else if (instance->major_version > 0)
-    if_successful= libmemcached_util_version_check(memc, instance->major_version -1, instance->micro_version, instance->minor_version);
-
-  test_true(if_successful == true);
-
-  if (instance->minor_version > 0)
-    if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->micro_version, instance->minor_version +1);
-  else if (instance->micro_version > 0)
-    if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->micro_version +1, instance->minor_version);
-  else if (instance->major_version > 0)
-    if_successful= libmemcached_util_version_check(memc, instance->major_version +1, instance->micro_version, instance->minor_version);
+  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);
 
@@ -5018,7 +5007,7 @@
   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_SOME_ERRORS(memcached_st *memc)
+static test_return_t memcached_get_MEMCACHED_ERRNO(memcached_st *memc)
 {
   (void)memc;
   memcached_st *tl_memc_h;
@@ -5032,21 +5021,18 @@
 
   // Create a handle.
   tl_memc_h= memcached_create(NULL);
-  servers= memcached_servers_parse("localhost:9898"); // This server should not exist
+  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);
 
-  if (value)
-  {
-    free(value);
-    test_true(value); // Pointer won't be zero so this is fine.
-  }
-
+  test_false(value);
   test_true(len == 0);
-  test_true(rc == MEMCACHED_SOME_ERRORS);
+  test_true(rc == MEMCACHED_ERRNO);
+
+  memcached_free(tl_memc_h);
 
   return TEST_SUCCESS;
 }
@@ -5065,12 +5051,7 @@
   // See if memcached is reachable.
   value= memcached_get(memc, key, strlen(key), &len, &flags, &rc);
 
-  if (value)
-  {
-    free(value);
-    test_true(value); // Pointer won't be zero so this is fine.
-  }
-
+  test_false(value);
   test_true(len == 0);
   test_true(rc == MEMCACHED_NOTFOUND);
 
@@ -5083,7 +5064,7 @@
   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_SOME_ERRORS(memcached_st *memc)
+static test_return_t memcached_get_by_key_MEMCACHED_ERRNO(memcached_st *memc)
 {
   (void)memc;
   memcached_st *tl_memc_h;
@@ -5097,21 +5078,18 @@
 
   // Create a handle.
   tl_memc_h= memcached_create(NULL);
-  servers= memcached_servers_parse("localhost:9898"); // This server should not exist
+  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);
 
-  if (value)
-  {
-    free(value);
-    test_true(value); // Pointer won't be zero so this is fine.
-  }
-
+  test_false(value);
   test_true(len == 0);
-  test_true(rc == MEMCACHED_SOME_ERRORS);
+  test_true(rc == MEMCACHED_ERRNO);
+
+  memcached_free(tl_memc_h);
 
   return TEST_SUCCESS;
 }
@@ -5130,12 +5108,7 @@
   // See if memcached is reachable.
   value= memcached_get_by_key(memc, key, strlen(key), key, strlen(key), &len, &flags, &rc);
 
-  if (value)
-  {
-    free(value);
-    test_true(value); // Pointer won't be zero so this is fine.
-  }
-
+  test_false(value);
   test_true(len == 0);
   test_true(rc == MEMCACHED_NOTFOUND);
 
@@ -5575,54 +5548,58 @@
 
 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);
-
-
-  if (libmemcached_util_version_check(memc_clone, 1, 1, 2))
+  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(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR);
-
-     /* 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(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR);
-
-     /* 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(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR);
-
-     /* 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);
+    /* 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(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR);
+
+    /* 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(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR);
+
+    /* 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(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR);
+
+    /* 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);
@@ -5748,6 +5725,39 @@
   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.
@@ -6080,6 +6090,7 @@
 
 /* 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 },
@@ -6135,12 +6146,12 @@
 #ifdef HAVE_LIBMEMCACHEDUTIL
   {"connectionpool", 1, (test_callback_fn)connection_pool_test },
   {"ping", 1, (test_callback_fn)ping_test },
-  {"util_version", 1, (test_callback_fn)util_version_test },
 #endif
   {"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}
 };
 
@@ -6332,9 +6343,9 @@
 };
 
 test_st error_conditions[] ={
-  {"memcached_get_MEMCACHED_SOME_ERRORS", 0, (test_callback_fn)memcached_get_MEMCACHED_SOME_ERRORS },
+  {"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_SOME_ERRORS", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_SOME_ERRORS },
+  {"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 },
   {0, 0, (test_callback_fn)0}
 };
 
=== modified file 'tests/mem_udp.c'
--- tests/mem_udp.c	2010-02-18 06:22:15 +0000
+++ tests/mem_udp.c	2010-07-21 16:27:47 +0000
@@ -10,10 +10,13 @@
   Sample test application.
 */
 
+#include "config.h"
+
 #include "libmemcached/common.h"
 
 #include <assert.h>
 #include <stdio.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/time.h>
@@ -25,14 +28,6 @@
 
 #include "server.h"
 
-#ifndef INT64_MAX
-#define INT64_MAX LONG_MAX
-#endif
-#ifndef INT32_MAX
-#define INT32_MAX INT_MAX
-#endif
-
-
 #include "test.h"
 
 #define SERVERS_TO_CREATE 5
 
=== modified file 'tests/server.c'
--- tests/server.c	2010-06-15 06:31:25 +0000
+++ tests/server.c	2010-07-21 16:27:47 +0000
@@ -26,12 +26,12 @@
 #include <libmemcached/memcached.h>
 #include <libmemcached/util.h>
 #include <unistd.h>
+#include <time.h>
+
 #include "server.h"
 
 void server_startup(server_startup_st *construct)
 {
-  unsigned int x;
-
   if ((construct->server_list= getenv("MEMCACHED_SERVERS")))
   {
     printf("servers %s\n", construct->server_list);
@@ -46,7 +46,7 @@
       char *end_ptr;
       end_ptr= server_string_buffer;
 
-      for (x= 0; x < construct->count; x++)
+      for (uint32_t x= 0; x < construct->count; x++)
       {
         char buffer[1024]; /* Nothing special for number */
         int count;
@@ -95,6 +95,39 @@
       }
       *end_ptr= 0;
 
+      for (uint32_t x= 0; x < construct->count; x++)
+      {
+        uint32_t counter= 3;
+        char buffer[1024]; /* Nothing special for number */
+
+        snprintf(buffer, sizeof(buffer), "/tmp/%umemc.pid", x);
+
+        while (--counter)
+        {
+          int memcached_pid;
+
+          FILE *file;
+          file= fopen(buffer, "r");
+          if (file == NULL)
+          {
+            struct timespec req= { .tv_sec= 0, .tv_nsec= 5000 };
+            nanosleep(&req, NULL);
+
+            continue;
+          }
+          char *found= fgets(buffer, sizeof(buffer), file);
+          if (!found)
+          {
+            abort();
+          }
+          // Yes, we currently pitch this and don't make use of it.
+          memcached_pid= atoi(buffer);
+          fclose(file);
+        }
+
+
+      }
+
       construct->server_list= strdup(server_string_buffer);
     }
     printf("servers %s\n", construct->server_list);
@@ -105,7 +138,7 @@
 
   srandom((unsigned int)time(NULL));
 
-  for (x= 0; x < memcached_server_list_count(construct->servers); x++)
+  for (uint32_t x= 0; x < memcached_server_list_count(construct->servers); x++)
   {
     printf("\t%s : %d\n", memcached_server_name(&construct->servers[x]), memcached_server_port(&construct->servers[x]));
     assert(construct->servers[x].fd == -1);
@@ -117,11 +150,9 @@
 
 void server_shutdown(server_startup_st *construct)
 {
-  unsigned int x;
-
   if (construct->server_list)
   {
-    for (x= 0; x < construct->count; x++)
+    for (uint32_t x= 0; x < construct->count; x++)
     {
       char buffer[1024]; /* Nothing special for number */
       sprintf(buffer, "cat /tmp/%umemc.pid | xargs kill", x);
 
=== modified file 'tests/start.c'
--- tests/start.c	2009-12-16 19:03:49 +0000
+++ tests/start.c	2010-07-21 16:27:47 +0000
@@ -9,6 +9,8 @@
  *
  */
 
+#include "config.h"
+
 #include <stdio.h>
 #include <string.h>
 #include "server.h"
 
=== modified file 'tests/test.c'
--- tests/test.c	2010-04-22 00:49:09 +0000
+++ tests/test.c	2010-07-21 16:27:47 +0000
@@ -9,6 +9,9 @@
 /*
   Sample test application.
 */
+
+#include "config.h"
+
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
@@ -22,6 +25,7 @@
 #include <stdint.h>
 
 #include "libmemcached/memcached.h"
+
 #include "test.h"
 
 static void world_stats_print(world_stats_st *stats)
 
=== added directory 'unittests'
=== added file 'unittests/include.am'
--- unittests/include.am	1970-01-01 00:00:00 +0000
+++ unittests/include.am	2010-07-21 16:27:47 +0000
@@ -0,0 +1,20 @@
+# vim:ft=automake
+# included from Top Level Makefile.am
+# All paths should be given relative to the root
+
+if HAVE_LIBGTEST
+check_PROGRAMS += unittests/unittests
+endif
+
+unittests_unittests_SOURCES= \
+			     unittests/main.cc \
+			     unittests/strings.cc
+
+unittests_unittest_CXXFLAGS= ${AM_CXXFLAGS} ${NO_WERROR}
+unittests_unittests_LDADD= \
+			   tests/libserver.la \
+			   libmemcached/libmemcachedinternal.la \
+			   ${TESTS_LDADDS} ${LTLIBGTEST}
+# Shorthand
+unit: check-TESTS
+
 
=== added file 'unittests/main.cc'
--- unittests/main.cc	1970-01-01 00:00:00 +0000
+++ unittests/main.cc	2010-07-21 16:27:47 +0000
@@ -0,0 +1,21 @@
+/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+ *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ *  Copyright (C) 2010 Monty Taylor
+ *
+ *  All rights reserved.
+ *
+ *  Use and distribution licensed under the BSD license.  See
+ *  the COPYING file in the parent directory for full text.
+ */
+
+#include "config.h"
+
+#include <gtest/gtest.h>
+
+
+int main(int argc, char **argv)
+{
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
 
=== added file 'unittests/strings.cc'
--- unittests/strings.cc	1970-01-01 00:00:00 +0000
+++ unittests/strings.cc	2010-07-21 16:27:47 +0000
@@ -0,0 +1,134 @@
+/* libMemcached
+ * Copyright (C) 2010 Brian Aker
+ * All rights reserved.
+ *
+ * Use and distribution licensed under the BSD license.  See
+ * the COPYING file in the parent directory for full text.
+ */
+
+#include "config.h"
+
+#define __STDC_LIMIT_MACROS
+#include <stdint.h>
+
+#include <gtest/gtest.h>
+
+#include <libmemcached/common.h>
+
+TEST(memcached_string_st, memcached_create_static)
+{
+  memcached_string_st string;
+  memcached_string_st *string_ptr;
+
+  memcached_st *memc= memcached_create(NULL);
+  string_ptr= memcached_string_create(memc, &string, 0);
+  ASSERT_TRUE(string.options.is_initialized);
+  ASSERT_TRUE(string_ptr);
+
+  /* The following two better be the same! */
+  ASSERT_FALSE(memcached_is_allocated(string_ptr));
+  ASSERT_FALSE(memcached_is_allocated(&string));
+  EXPECT_EQ(&string, string_ptr);
+
+  ASSERT_TRUE(string.options.is_initialized);
+  ASSERT_TRUE(memcached_is_initialized(&string));
+  memcached_string_free(&string);
+  ASSERT_FALSE(memcached_is_initialized(&string));
+
+  memcached_free(memc);
+}
+
+TEST(memcached_string_st, memcached_create_null)
+{
+  memcached_string_st *string;
+  memcached_st *memc= memcached_create(NULL);
+
+  string= memcached_string_create(memc, NULL, 0);
+  ASSERT_TRUE(string);
+  ASSERT_TRUE(memcached_is_allocated(string));
+  ASSERT_TRUE(memcached_is_initialized(string));
+  memcached_string_free(string);
+
+  memcached_free(memc);
+}
+
+TEST(memcached_string_st, string_alloc_with_size)
+{
+  memcached_string_st *string;
+  memcached_st *memc= memcached_create(NULL);
+
+  string= memcached_string_create(memc, NULL, 1024);
+  ASSERT_TRUE(string);
+  ASSERT_TRUE(memcached_is_allocated(string));
+  ASSERT_TRUE(memcached_is_initialized(string));
+  memcached_string_free(string);
+
+  memcached_free(memc);
+}
+
+TEST(memcached_string_st, string_alloc_with_size_toobig)
+{
+  memcached_st *memc= memcached_create(NULL);
+  memcached_string_st *string;
+
+  string= memcached_string_create(memc, NULL, SIZE_MAX);
+  ASSERT_FALSE(string);
+
+  memcached_free(memc);
+}
+
+TEST(memcached_string_st, string_alloc_append)
+{
+  char buffer[SMALL_STRING_LEN];
+  memcached_string_st *string;
+
+  memcached_st *memc= memcached_create(NULL);
+
+  /* Ring the bell! */
+  memset(buffer, 6, SMALL_STRING_LEN);
+
+  string= memcached_string_create(memc, NULL, 100);
+  ASSERT_TRUE(string);
+  ASSERT_TRUE(memcached_is_allocated(string));
+  ASSERT_TRUE(memcached_is_initialized(string));
+
+  for (uint32_t x= 0; x < 1024; x++)
+  {
+    memcached_return_t rc;
+    rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
+    EXPECT_EQ(rc, MEMCACHED_SUCCESS);
+  }
+  ASSERT_TRUE(memcached_is_allocated(string));
+  memcached_string_free(string);
+
+  memcached_free(memc);
+}
+
+TEST(memcached_string_st, string_alloc_append_toobig)
+{
+  memcached_return_t rc;
+  char buffer[SMALL_STRING_LEN];
+  memcached_string_st *string;
+
+  memcached_st *memc= memcached_create(NULL);
+
+  /* Ring the bell! */
+  memset(buffer, 6, SMALL_STRING_LEN);
+
+  string= memcached_string_create(memc, NULL, 100);
+  ASSERT_TRUE(string);
+  ASSERT_TRUE(memcached_is_allocated(string));
+  ASSERT_TRUE(memcached_is_initialized(string));
+
+  for (uint32_t x= 0; x < 1024; x++)
+  {
+    rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
+    EXPECT_EQ(rc, MEMCACHED_SUCCESS);
+  }
+  rc= memcached_string_append(string, buffer, SIZE_MAX);
+  EXPECT_EQ(rc, MEMCACHED_MEMORY_ALLOCATION_FAILURE);
+  ASSERT_TRUE(memcached_is_allocated(string));
+  memcached_string_free(string);
+
+  memcached_free(memc);
+}