Merge 1.0 tree

116 files changed, 1640 insertions, 712 deletions

diff --git a/ChangeLog b/ChangeLog
index 196f8dbe..b7c0898d 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,8 +1,14 @@
 1.1.0 
 * Enable MEMCACHED_BEHAVIOR_VERIFY_KEY by default
 
-1.0.16
+1.0.17 Tue Apr  2 14:02:01 HST 2013
+* Remove c++ namespace that was being exposed (the API should be plug compatible)..
+* Fix cases where --servers wasn't behaving the same in all clients.
+
+1.0.16 Thu Jan 31 19:14:32 EST 2013
 * Added support to do two part shutdown of socket.
+* Fixes for Fedora 18.
+* Fix for binary memcached_touch()
 
 1.0.15 Mon Dec 17 07:25:44 EST 2012
 * Added support for Murmur3 (HASHKIT_HASH_MURMUR3)
diff --git a/Makefile.am b/Makefile.am
index 596cb24d..24483736 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -71,6 +71,8 @@ TESTS += ${bin_PROGRAMS}
 TESTS += ${check_PROGRAMS}
 XFAIL_TESTS += ${bin_PROGRAMS}
 
+if ! BUILD_WIN32
+
 merge-clean:
 	@find ./ | $(GREP) \.gcda | xargs rm -f
 	@find ./ | $(GREP) \.gcno | xargs rm -f
@@ -86,8 +88,8 @@ merge-clean:
 	@echo "Files that need to be either removed or checked in:"
 	@bzr unknowns
 
-clean-local:
-	-rm -rf docs/_build docs/doctrees
+clean-local: clean-libtest-check clean-docs-check
+
 
 lcov: lcov-clean check
 	@echo
@@ -102,11 +104,10 @@ lcov-clean: clean
 	@rm -rf lcov */lcov.out
 	@find . -name '*.gcno' | xargs rm -f
 	@find . -name '*.gcda' | xargs rm -f
+endif
 
 DISTCLEANFILES+= config/top.h
 
-clean-local: clean-libtest-check clean-docs-check
-
 maintainer-clean-local:
 	find . -type f -name '*~' -exec rm -f '{}' \;
 	-rm -f @PACKAGE@-*.rpm
diff --git a/bootstrap.sh b/bootstrap.sh
index fdc43f99..a368197a 100755
--- a/bootstrap.sh
+++ b/bootstrap.sh
@@ -296,42 +296,42 @@ function run_configure ()
   # Arguments for configure
   local BUILD_CONFIGURE_ARG= 
 
-  # Set ENV DEBUG in order to enable debugging
+  # If ENV DEBUG is set we enable both debug and asssert, otherwise we see if this is a VCS checkout and if so enable assert
+  # Set ENV ASSERT in order to enable assert
   if $DEBUG; then 
-    BUILD_CONFIGURE_ARG='--enable-debug'
+    BUILD_CONFIGURE_ARG+=' --enable-debug --enable-assert'
+  elif [[ -n "$VCS_CHECKOUT" ]]; then
+    BUILD_CONFIGURE_ARG+=' --enable-assert'
   fi
 
-  # Set ENV ASSERT in order to enable assert
-  if [[ -n "$ASSERT" ]]; then 
-    local ASSERT_ARG=
-    ASSERT_ARG='--enable-assert'
-    BUILD_CONFIGURE_ARG="$ASSERT_ARG $BUILD_CONFIGURE_ARG"
+  if [[ -n "$CONFIGURE_ARG" ]]; then 
+    BUILD_CONFIGURE_ARG+=" $CONFIGURE_ARG"
   fi
 
-  if [[ -n "$CONFIGURE_ARG" ]]; then 
-    BUILD_CONFIGURE_ARG= "$BUILD_CONFIGURE_ARG $CONFIGURE_ARG"
+  if [[ -n "$PREFIX_ARG" ]]; then 
+    BUILD_CONFIGURE_ARG+=" $PREFIX_ARG"
   fi
 
   ret=1;
   # If we are executing on OSX use CLANG, otherwise only use it if we find it in the ENV
   case $HOST_OS in
     *-darwin-*)
-      CC=clang CXX=clang++ $top_srcdir/configure $BUILD_CONFIGURE_ARG || die "Cannot execute CC=clang CXX=clang++ configure $BUILD_CONFIGURE_ARG $PREFIX_ARG"
+      CC=clang CXX=clang++ $top_srcdir/configure $BUILD_CONFIGURE_ARG || die "Cannot execute CC=clang CXX=clang++ configure $BUILD_CONFIGURE_ARG"
       ret=$?
       ;;
     rhel-5*)
       command_exists 'gcc44' || die "Could not locate gcc44"
-      CC=gcc44 CXX=gcc44 $top_srcdir/configure $BUILD_CONFIGURE_ARG $PREFIX_ARG || die "Cannot execute CC=gcc44 CXX=gcc44 configure $BUILD_CONFIGURE_ARG $PREFIX_ARG"
+      CC=gcc44 CXX=gcc44 $top_srcdir/configure $BUILD_CONFIGURE_ARG || die "Cannot execute CC=gcc44 CXX=gcc44 configure $BUILD_CONFIGURE_ARG"
       ret=$?
       ;;
     *)
-      $CONFIGURE $BUILD_CONFIGURE_ARG $PREFIX_ARG
+      $CONFIGURE $BUILD_CONFIGURE_ARG
       ret=$?
       ;;
   esac
 
   if [ $ret -ne 0 ]; then
-    die "Could not execute $CONFIGURE $BUILD_CONFIGURE_ARG $PREFIX_ARG"
+    die "Could not execute $CONFIGURE $BUILD_CONFIGURE_ARG"
   fi
 
   if [ ! -f 'Makefile' ]; then
@@ -367,6 +367,10 @@ function save_BUILD ()
     die "OLD_CONFIGURE_ARG($OLD_CONFIGURE_ARG) was set on push, programmer error!"
   fi
 
+  if [[ -n "$OLD_PREFIX" ]]; then
+    die "OLD_PREFIX($OLD_PREFIX) was set on push, programmer error!"
+  fi
+
   if [[ -n "$OLD_MAKE" ]]; then
     die "OLD_MAKE($OLD_MAKE) was set on push, programmer error!"
   fi
@@ -402,6 +406,10 @@ function restore_BUILD ()
     CONFIGURE_ARG=$OLD_CONFIGURE_ARG
   fi
 
+  if [[ -n "$OLD_PREFIX" ]]; then
+    PREFIX_ARG=$OLD_PREFIX
+  fi
+
   if [[ -n "$OLD_MAKE" ]]; then
     MAKE=$OLD_MAKE
   fi
@@ -412,59 +420,13 @@ function restore_BUILD ()
 
   OLD_CONFIGURE=
   OLD_CONFIGURE_ARG=
+  OLD_PREFIX=
   OLD_MAKE=
   OLD_TESTS_ENVIRONMENT=
 
   export -n CC CXX
 }
 
-function push_PREFIX_ARG ()
-{
-  if [[ -n "$OLD_PREFIX_ARG" ]]; then
-    die "OLD_PREFIX_ARG was set on push, programmer error!"
-  fi
-
-  if [[ -n "$PREFIX_ARG" ]]; then
-    OLD_PREFIX_ARG=$PREFIX_ARG
-    PREFIX_ARG=
-  fi
-
-  if [[ -n "$1" ]]; then
-    PREFIX_ARG="--prefix=$1"
-  fi
-}
-
-function pop_PREFIX_ARG ()
-{
-  if [[ -n "$OLD_PREFIX_ARG" ]]; then
-    PREFIX_ARG=$OLD_PREFIX_ARG
-    OLD_PREFIX_ARG=
-  else
-    PREFIX_ARG=
-  fi
-}
-
-function push_TESTS_ENVIRONMENT ()
-{
-  if [[ -n "$OLD_TESTS_ENVIRONMENT" ]]; then
-    die "OLD_TESTS_ENVIRONMENT was set on push, programmer error!"
-  fi
-
-  if [[ -n "$TESTS_ENVIRONMENT" ]]; then
-    OLD_TESTS_ENVIRONMENT=$TESTS_ENVIRONMENT
-    TESTS_ENVIRONMENT=
-  fi
-}
-
-function pop_TESTS_ENVIRONMENT ()
-{
-  TESTS_ENVIRONMENT=
-  if [[ -n "$OLD_TESTS_ENVIRONMENT" ]]; then
-    TESTS_ENVIRONMENT=$OLD_TESTS_ENVIRONMENT
-    OLD_TESTS_ENVIRONMENT=
-  fi
-}
-
 function safe_pushd ()
 {
   pushd $1 &> /dev/null ;
@@ -513,11 +475,11 @@ function make_valgrind ()
     return 1
   fi
 
+  save_BUILD
+
   # If we are required to run configure, do so now
   run_configure_if_required
 
-  push_TESTS_ENVIRONMENT
-
   # If we don't have a configure, then most likely we will be missing libtool
   assert_file 'configure'
   if [[ -f 'libtool' ]]; then
@@ -528,13 +490,15 @@ function make_valgrind ()
 
   make_target 'check' || return 1
 
-  pop_TESTS_ENVIRONMENT
+  restore_BUILD
 }
 
 function make_install_system ()
 {
   local INSTALL_LOCATION=$(mktemp -d /tmp/XXXXXXXXXX)
-  push_PREFIX_ARG $INSTALL_LOCATION
+
+  save_BUILD
+  PREFIX_ARG="--prefix=$INSTALL_LOCATION"
 
   if [ ! -d $INSTALL_LOCATION ] ; then
     die "ASSERT temp directory not found '$INSTALL_LOCATION'"
@@ -542,17 +506,12 @@ function make_install_system ()
 
   run_configure #install_buid_dir
 
-  push_TESTS_ENVIRONMENT
-
   make_target 'install'
 
   make_target 'installcheck'
 
   make_target 'uninstall'
 
-  pop_TESTS_ENVIRONMENT
-  pop_PREFIX_ARG
-
   rm -r -f $INSTALL_LOCATION
   make 'distclean'
 
@@ -560,6 +519,7 @@ function make_install_system ()
     die "ASSERT Makefile should not exist"
   fi
 
+  restore_BUILD
   safe_popd
 }
 
@@ -848,7 +808,7 @@ function make_for_continuus_integration ()
 
       make_install_system
       ;;
-    *-precise-*)
+    *-ubuntu-quantal-*)
       run_configure
 
       assert_exec_file 'configure'
@@ -900,11 +860,11 @@ function make_install_html ()
 
 function make_gdb ()
 {
+  save_BUILD
+
   if command_exists 'gdb'; then
     run_configure_if_required
 
-    push_TESTS_ENVIRONMENT
-
     # Set ENV GDB_COMMAND
     if [[ -z "$GDB_COMMAND" ]]; then
       setup_gdb_command
@@ -924,8 +884,6 @@ function make_gdb ()
       rm 'gdb.txt'
     fi
 
-    pop_TESTS_ENVIRONMENT
-
     if [ -f '.gdb_history' ]; then
       rm '.gdb_history'
     fi
@@ -937,6 +895,8 @@ function make_gdb ()
     echo 'gdb was not present'
     return 1
   fi
+
+  restore_BUILD
 }
 
 # $1 target to compile
@@ -1142,6 +1102,8 @@ function determine_vcs ()
     VCS_CHECKOUT=svn
   elif [[ -d '.hg' ]]; then
     VCS_CHECKOUT=hg
+  else
+    VCS_CHECKOUT=
   fi
 
   if [[ -n "$VCS_CHECKOUT" ]]; then
@@ -1466,7 +1428,7 @@ function bootstrap ()
 
   # Set ENV PREFIX in order to set --prefix for ./configure
   if [[ -n "$PREFIX" ]]; then 
-    push_PREFIX_ARG $PREFIX
+    PREFIX_ARG="--prefix=$PREFIX"
   fi
 
   # We should always have a target by this point
@@ -1580,6 +1542,7 @@ function main ()
 
   local OLD_CONFIGURE=
   local OLD_CONFIGURE_ARG=
+  local OLD_PREFIX=
   local OLD_MAKE=
   local OLD_TESTS_ENVIRONMENT=
 
@@ -1726,11 +1689,13 @@ export AUTOHEADER
 export AUTOM4TE
 export AUTOMAKE
 export AUTORECONF
+export CONFIGURE_ARG
 export DEBUG
 export GNU_BUILD_FLAGS
 export LIBTOOLIZE
 export LIBTOOLIZE_OPTIONS
 export MAKE
+export PREFIX_ARG
 export TESTS_ENVIRONMENT
 export VERBOSE
 export WARNINGS
diff --git a/clients/memaslap.c b/clients/memaslap.c
index 1b5c223a..02907945 100644
--- a/clients/memaslap.c
+++ b/clients/memaslap.c
@@ -378,7 +378,13 @@ static int64_t ms_parse_size()
   char unit= optarg[strlen(optarg) - 1];
 
   optarg[strlen(optarg) - 1]= '\0';
+  errno= 0;
   ret= strtoll(optarg, (char **)NULL, 10);
+  if (errno != 0)
+  {
+    fprintf(stderr, "strtoll(optarg,..): %s\n", strerror(errno));
+    exit(1);
+  }
 
   switch (unit)
   {
@@ -434,8 +440,9 @@ static void ms_options_parse(int argc, char *argv[])
       break;
 
     case OPT_CONCURRENCY:       /* --concurrency or -c */
+      errno= 0;
       ms_setting.nconns= (uint32_t)strtoul(optarg, (char **) NULL, 10);
-      if (ms_setting.nconns <= 0)
+      if (ms_setting.nconns <= 0 || errno != 0)
       {
         fprintf(stderr, "Concurrency must be greater than 0.:-)\n");
         exit(1);
@@ -443,8 +450,9 @@ static void ms_options_parse(int argc, char *argv[])
       break;
 
     case OPT_EXECUTE_NUMBER:        /* --execute_number or -x */
+      errno= 0;
       ms_setting.exec_num= (int)strtol(optarg, (char **) NULL, 10);
-      if (ms_setting.exec_num <= 0)
+      if (ms_setting.exec_num <= 0 || errno != 0)
       {
         fprintf(stderr, "Execute number must be greater than 0.:-)\n");
         exit(1);
@@ -452,8 +460,9 @@ static void ms_options_parse(int argc, char *argv[])
       break;
 
     case OPT_THREAD_NUMBER:     /* --threads or -T */
+      errno= 0;
       ms_setting.nthreads= (uint32_t)strtoul(optarg, (char **) NULL, 10);
-      if (ms_setting.nthreads <= 0)
+      if (ms_setting.nthreads <= 0 || errno != 0)
       {
         fprintf(stderr, "Threads number must be greater than 0.:-)\n");
         exit(1);
@@ -461,8 +470,9 @@ static void ms_options_parse(int argc, char *argv[])
       break;
 
     case OPT_FIXED_LTH:         /* --fixed_size or -X */
+      errno= 0;
       ms_setting.fixed_value_size= (size_t)strtoull(optarg, (char **) NULL, 10);
-      if ((ms_setting.fixed_value_size <= 0)
+      if ((ms_setting.fixed_value_size <= 0 || errno != 0)
           || (ms_setting.fixed_value_size > MAX_VALUE_SIZE))
       {
         fprintf(stderr, "Value size must be between 0 and 1M.:-)\n");
@@ -482,8 +492,9 @@ static void ms_options_parse(int argc, char *argv[])
       break;
 
     case OPT_GETS_DIVISION:         /* --division or -d */
+      errno= 0;
       ms_setting.mult_key_num= (int)strtol(optarg, (char **) NULL, 10);
-      if (ms_setting.mult_key_num <= 0)
+      if (ms_setting.mult_key_num <= 0 || errno != 0)
       {
         fprintf(stderr, "Multi-get key number must be greater than 0.:-)\n");
         exit(1);
@@ -568,8 +579,9 @@ static void ms_options_parse(int argc, char *argv[])
       break;
 
     case OPT_SOCK_PER_CONN:         /* --conn_sock or -n */
+      errno= 0;
       ms_setting.sock_per_conn= (uint32_t)strtoul(optarg, (char **) NULL, 10);
-      if (ms_setting.sock_per_conn <= 0)
+      if (ms_setting.sock_per_conn <= 0 || errno != 0)
       {
         fprintf(stderr, "Number of socks of each concurrency "
                         "must be greater than 0.:-)\n");
@@ -605,8 +617,9 @@ static void ms_options_parse(int argc, char *argv[])
       break;
 
     case OPT_REP_WRITE_SRV:         /* --rep_write or -p */
+      errno= 0;
       ms_setting.rep_write_srv= (uint32_t)strtoul(optarg, (char **) NULL, 10);
-      if (ms_setting.rep_write_srv <= 0)
+      if (ms_setting.rep_write_srv <= 0 || errno != 0)
       {
         fprintf(stderr,
                 "Number of replication writing server must be greater "
diff --git a/clients/memcapable.cc b/clients/memcapable.cc
index 5dd78306..5566ea91 100644
--- a/clients/memcapable.cc
+++ b/clients/memcapable.cc
@@ -124,7 +124,7 @@ static struct addrinfo *lookuphost(const char *hostname, const char *port)
  */
 static memcached_socket_t set_noblock(void)
 {
-#ifdef WIN32
+#if defined(_WIN32)
   u_long arg = 1;
   if (ioctlsocket(sock, FIONBIO, &arg) == SOCKET_ERROR)
   {
@@ -1389,11 +1389,15 @@ static enum test_return ascii_get_unknown_value(char **key, char **value, ssize_
   verify(*key != NULL);
   char *ptr= end + 1;
 
+  errno= 0;
   unsigned long val= strtoul(ptr, &end, 10); /* flags */
+  verify(errno == 0);
   verify(ptr != end);
   verify(val == 0);
   verify(end != NULL);
+  errno= 0;
   *ndata = (ssize_t)strtoul(end, &end, 10); /* size */
+  verify(errno == 0);
   verify(ptr != end);
   verify(end != NULL);
   while (end and *end != '\n' and isspace(*end))
@@ -1424,11 +1428,16 @@ static enum test_return ascii_get_value(const char *key, const char *value)
   char *ptr= buffer + 6 + strlen(key) + 1;
   char *end;
 
+  errno= 0;
   unsigned long val= strtoul(ptr, &end, 10); /* flags */
+  verify(errno == 0);
   verify(ptr != end);
   verify(val == 0);
   verify(end != NULL);
+
+  errno= 0;
   val= strtoul(end, &end, 10); /* size */
+  verify(errno == 0);
   verify(ptr != end);
   verify(val == datasize);
   verify(end != NULL);
@@ -1486,15 +1495,23 @@ static enum test_return ascii_gets_value(const char *key, const char *value,
   char *ptr= buffer + 6 + strlen(key) + 1;
   char *end;
 
+  errno= 0;
   unsigned long val= strtoul(ptr, &end, 10); /* flags */
+  verify(errno == 0);
   verify(ptr != end);
   verify(val == 0);
   verify(end != NULL);
+
+  errno= 0;
   val= strtoul(end, &end, 10); /* size */
+  verify(errno == 0);
   verify(ptr != end);
   verify(val == datasize);
   verify(end != NULL);
+
+  errno= 0;
   *cas= strtoul(end, &end, 10); /* cas */
+  verify(errno == 0);
   verify(ptr != end);
   verify(val == datasize);
   verify(end != NULL);
diff --git a/clients/memcat.cc b/clients/memcat.cc
index 9aaa09af..faf7310f 100644
--- a/clients/memcat.cc
+++ b/clients/memcat.cc
@@ -39,19 +39,17 @@ static char *opt_file;
 
 int main(int argc, char *argv[])
 {
-  memcached_st *memc;
   char *string;
   size_t string_length;
   uint32_t flags;
   memcached_return_t rc;
-  memcached_server_st *servers;
 
   int return_code= EXIT_SUCCESS;
 
   options_parse(argc, argv);
   initialize_sockets();
 
-  if (!opt_servers)
+  if (opt_servers == NULL)
   {
     char *temp;
 
@@ -59,17 +57,23 @@ int main(int argc, char *argv[])
     {
       opt_servers= strdup(temp);
     }
-    else
+
+    if (opt_servers == NULL)
     {
       std::cerr << "No servers provied" << std::endl;
       exit(EXIT_FAILURE);
     }
   }
 
-  memc= memcached_create(NULL);
-  process_hash_option(memc, opt_hash);
+  memcached_server_st* servers= memcached_servers_parse(opt_servers);
+  if (servers == NULL or memcached_server_list_count(servers) == 0)
+  {
+    std::cerr << "Invalid server list provided:" << opt_servers << std::endl;
+    return EXIT_FAILURE;
+  }
 
-  servers= memcached_servers_parse(opt_servers);
+  memcached_st* memc= memcached_create(NULL);
+  process_hash_option(memc, opt_hash);
 
   memcached_server_push(memc, servers);
   memcached_server_list_free(servers);
@@ -253,7 +257,7 @@ void options_parse(int argc, char *argv[])
 
     case '?':
       /* getopt_long already printed an error message. */
-      exit(1);
+      exit(EXIT_FAILURE);
     default:
       abort();
     }
diff --git a/clients/memcp.cc b/clients/memcp.cc
index ddee8381..fb899e56 100644
--- a/clients/memcp.cc
+++ b/clients/memcp.cc
@@ -129,21 +129,23 @@ int main(int argc, char *argv[])
     {
       opt_servers= strdup(temp);
     }
-    else
+    else if (argc >= 1 and argv[--argc])
+    {
+      opt_servers= strdup(argv[--argc]);
+    }
+
+    if (opt_servers == NULL)
     {
       std::cerr << "No Servers provided" << std::endl;
       exit(EXIT_FAILURE);
     }
   }
 
-  memcached_server_st *servers;
-  if (opt_servers)
-  {
-    servers= memcached_servers_parse(opt_servers);
-  }
-  else
+  memcached_server_st* servers= memcached_servers_parse(opt_servers);
+  if (servers == NULL or memcached_server_list_count(servers) == 0)
   {
-    servers= memcached_servers_parse(argv[--argc]);
+    std::cerr << "Invalid server list provided:" << opt_servers << std::endl;
+    return EXIT_FAILURE;
   }
 
   memcached_server_push(memc, servers);
diff --git a/clients/memdump.cc b/clients/memdump.cc
index c9deb752..ca1c0430 100644
--- a/clients/memdump.cc
+++ b/clients/memdump.cc
@@ -62,9 +62,6 @@ int main(int argc, char *argv[])
 
   options_parse(argc, argv);
 
-  memcached_st *memc= memcached_create(NULL);
-  process_hash_option(memc, opt_hash);
-
   if (opt_servers == NULL)
   {
     char *temp;
@@ -73,22 +70,32 @@ int main(int argc, char *argv[])
     {
       opt_servers= strdup(temp);
     }
-    else
+    else if (argc >= 1 and argv[--argc])
+    {
+      opt_servers= strdup(argv[--argc]);
+    }
+
+    if (opt_servers == NULL)
     {
       std::cerr << "No Servers provided" << std::endl;
       exit(EXIT_FAILURE);
     }
   }
 
-  memcached_server_st *servers;
-  if (opt_servers)
+  memcached_server_st* servers= memcached_servers_parse(opt_servers);
+  if (servers == NULL or memcached_server_list_count(servers) == 0)
   {
-    servers= memcached_servers_parse(opt_servers);
+    std::cerr << "Invalid server list provided:" << opt_servers << std::endl;
+    return EXIT_FAILURE;
   }
-  else
+
+  memcached_st *memc= memcached_create(NULL);
+  if (memc == NULL)
   {
-    servers= memcached_servers_parse(argv[--argc]);
+    std::cerr << "Could not allocate a memcached_st structure.\n" << std::endl;
+    return EXIT_FAILURE;
   }
+  process_hash_option(memc, opt_hash);
 
   memcached_server_push(memc, servers);
   memcached_server_list_free(servers);
diff --git a/clients/memerror.cc b/clients/memerror.cc
index 654db143..27ab0c5e 100644
--- a/clients/memerror.cc
+++ b/clients/memerror.cc
@@ -47,7 +47,8 @@ int main(int argc, char *argv[])
     char *nptr;
     unsigned long value= strtoul(argv[optind], &nptr, 10);
 
-    if ((nptr == argv[optind] and value == 0) or
+    if ((errno != 0) or
+        (nptr == argv[optind] and value == 0) or
         (value == ULONG_MAX and errno == ERANGE) or
         (value == 0 and errno == EINVAL))
     {
diff --git a/clients/memexist.cc b/clients/memexist.cc
index cf3f9d7f..89f2a8e9 100644
--- a/clients/memexist.cc
+++ b/clients/memexist.cc
@@ -36,13 +36,10 @@ static void options_parse(int argc, char *argv[]);
 
 int main(int argc, char *argv[])
 {
-  memcached_st *memc;
-  memcached_server_st *servers;
-
   options_parse(argc, argv);
   initialize_sockets();
 
-  if (opt_servers == 0)
+  if (opt_servers == NULL)
   {
     char *temp;
 
@@ -50,17 +47,24 @@ int main(int argc, char *argv[])
     {
       opt_servers= strdup(temp);
     }
-    else
+
+    if (opt_servers == NULL)
     {
       std::cerr << "No Servers provided" << std::endl;
-      return EXIT_FAILURE;
+      exit(EXIT_FAILURE);
     }
   }
 
-  memc= memcached_create(NULL);
+  memcached_server_st* servers= memcached_servers_parse(opt_servers);
+  if (servers == NULL or memcached_server_list_count(servers) == 0)
+  {
+    std::cerr << "Invalid server list provided:" << opt_servers << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  memcached_st* memc= memcached_create(NULL);
   process_hash_option(memc, opt_hash);
 
-  servers= memcached_servers_parse(opt_servers);
   memcached_server_push(memc, servers);
   memcached_server_list_free(servers);
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL,
diff --git a/clients/memflush.cc b/clients/memflush.cc
index 0d798202..fcaea6e3 100644
--- a/clients/memflush.cc
+++ b/clients/memflush.cc
@@ -11,6 +11,7 @@
  */
 #include "mem_config.h"
 
+#include <cerrno>
 #include <cstdio>
 #include <cstring>
 #include <getopt.h>
@@ -47,16 +48,22 @@ int main(int argc, char *argv[])
     {
       opt_servers= strdup(temp);
     }
-    else
+
+    if (opt_servers == false)
     {
       std::cerr << "No Servers provided" << std::endl;
       exit(EXIT_FAILURE);
     }
   }
 
-  memcached_st *memc= memcached_create(NULL);
+  memcached_server_st* servers= memcached_servers_parse(opt_servers);
+  if (servers == NULL or memcached_server_list_count(servers) == 0)
+  {
+    std::cerr << "Invalid server list provided:" << opt_servers << std::endl;
+    return EXIT_FAILURE;
+  }
 
-  memcached_server_st *servers= memcached_servers_parse(opt_servers);
+  memcached_st *memc= memcached_create(NULL);
   memcached_server_push(memc, servers);
   memcached_server_list_free(servers);
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL,
@@ -148,7 +155,13 @@ void options_parse(int argc, char *argv[])
       break;
 
     case OPT_EXPIRE: /* --expire */
+      errno= 0;
       opt_expire= (time_t)strtoll(optarg, (char **)NULL, 10);
+      if (errno != 0)
+      {
+        std::cerr << "Incorrect value passed to --expire: `" << optarg << "`" << std::cerr;
+        exit(EXIT_FAILURE);
+      }
       break;
 
     case OPT_USERNAME:
diff --git a/clients/memping.cc b/clients/memping.cc
index 47dfe3e4..88e7063c 100644
--- a/clients/memping.cc
+++ b/clients/memping.cc
@@ -11,12 +11,17 @@
  */
 #include "mem_config.h"
 
-#include <stdio.h>
+#include <cerrno>
+#include <cstdio>
+#include <cstring>
+#include <getopt.h>
 #include <unistd.h>
 #include <string.h>
 #include <getopt.h>
+
 #include <libmemcached-1.2/memcached.h>
 #include <libmemcachedutil-1.2/util.h>
+
 #include "client_options.h"
 #include "utilities.h"
 
@@ -47,7 +52,8 @@ int main(int argc, char *argv[])
     {
       opt_servers= strdup(temp);
     }
-    else
+    
+    if (opt_servers == NULL)
     {
       std::cerr << "No Servers provided" << std::endl;
       exit(EXIT_FAILURE);
@@ -56,6 +62,12 @@ int main(int argc, char *argv[])
 
   int exit_code= EXIT_SUCCESS;
   memcached_server_st *servers= memcached_servers_parse(opt_servers);
+  if (servers == NULL or memcached_server_list_count(servers) == 0)
+  {
+    std::cerr << "Invalid server list provided:" << opt_servers << std::endl;
+    exit_code= EXIT_FAILURE;
+  }
+  else
   {
     for (uint32_t x= 0; x < memcached_server_list_count(servers); x++)
     {
@@ -63,6 +75,11 @@ int main(int argc, char *argv[])
       const char *hostname= servers[x].hostname;
       in_port_t port= servers[x].port;
 
+      if (opt_verbose)
+      {
+        std::cout << "Trying to ping " << hostname << ":" << port << std::endl;
+      }
+
       if (libmemcached_util_ping2(hostname, port, opt_username, opt_passwd, &instance_rc) == false)
       {
         std::cerr << "Failed to ping " << hostname << ":" << port << " " << memcached_strerror(NULL, instance_rc) <<  std::endl;
@@ -139,7 +156,13 @@ void options_parse(int argc, char *argv[])
       break;
 
     case OPT_EXPIRE: /* --expire */
-      opt_expire= (time_t)strtoll(optarg, (char **)NULL, 10);
+      errno= 0;
+      opt_expire= time_t(strtoll(optarg, (char **)NULL, 10));
+      if (errno != 0)
+      {
+        std::cerr << "Incorrect value passed to --expire: `" << optarg << "`" << std::cerr;
+        exit(EXIT_FAILURE);
+      }
       break;
 
     case OPT_USERNAME:
diff --git a/clients/memrm.cc b/clients/memrm.cc
index 80c53f00..226ec577 100644
--- a/clients/memrm.cc
+++ b/clients/memrm.cc
@@ -11,6 +11,7 @@
  */
 #include "mem_config.h"
 
+#include <cerrno>
 #include <cstdio>
 #include <cstring>
 #include <getopt.h>
@@ -38,13 +39,10 @@ static void options_parse(int argc, char *argv[]);
 
 int main(int argc, char *argv[])
 {
-  memcached_st *memc;
-  memcached_server_st *servers;
-
   options_parse(argc, argv);
   initialize_sockets();
 
-  if (opt_servers == 0)
+  if (opt_servers == NULL)
   {
     char *temp;
 
@@ -52,17 +50,24 @@ int main(int argc, char *argv[])
     {
       opt_servers= strdup(temp);
     }
-    else
+
+    if (opt_servers == NULL)
     {
       std::cerr << "No Servers provided" << std::endl;
-      return EXIT_FAILURE;
+      exit(EXIT_FAILURE);
     }
   }
 
-  memc= memcached_create(NULL);
+  memcached_server_st* servers= memcached_servers_parse(opt_servers);
+  if (servers == NULL or memcached_server_list_count(servers) == 0)
+  {
+    std::cerr << "Invalid server list provided:" << opt_servers << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  memcached_st* memc= memcached_create(NULL);
   process_hash_option(memc, opt_hash);
 
-  servers= memcached_servers_parse(opt_servers);
   memcached_server_push(memc, servers);
   memcached_server_list_free(servers);
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL,
@@ -205,7 +210,13 @@ static void options_parse(int argc, char *argv[])
       break;
 
     case OPT_EXPIRE: /* --expire */
+      errno= 0;
       opt_expire= (time_t)strtoll(optarg, (char **)NULL, 10);
+      if (errno != 0)
+      {
+        std::cerr << "Incorrect value passed to --expire: `" << optarg << "`" << std::cerr;
+        exit(EXIT_FAILURE);
+      }
       break;
 
     case OPT_HASH:
diff --git a/clients/memslap.cc b/clients/memslap.cc
index b839cb2d..30cc07f6 100644
--- a/clients/memslap.cc
+++ b/clients/memslap.cc
@@ -39,6 +39,7 @@
 #include <mem_config.h>
 
 #include <cassert>
+#include <cerrno>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
@@ -50,7 +51,6 @@
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/types.h>
-#include <sys/types.h>
 #include <unistd.h>
 
 #include <iostream>
@@ -212,14 +212,20 @@ int main(int argc, char *argv[])
     {
       opt_servers= strdup(temp);
     }
-    else
+    
+    if (opt_servers == NULL)
     {
-      fprintf(stderr, "No Servers provided\n");
-      return EXIT_FAILURE;
+      std::cerr << "No Servers provided" << std::endl;
+      exit(EXIT_FAILURE);
     }
   }
 
   memcached_server_st *servers= memcached_servers_parse(opt_servers);
+  if (servers == NULL or memcached_server_list_count(servers) == 0)
+  {
+    std::cerr << "Invalid server list provided:" << opt_servers << std::endl;
+    return EXIT_FAILURE;
+  }
 
   pthread_mutex_init(&sleeper_mutex, NULL);
   pthread_cond_init(&sleep_threshhold, NULL);
@@ -468,15 +474,33 @@ void options_parse(int argc, char *argv[])
       break;
 
     case OPT_SLAP_CONCURRENCY:
+      errno= 0;
       opt_concurrency= (unsigned int)strtoul(optarg, (char **)NULL, 10);
+      if (errno != 0)
+      {
+        fprintf(stderr, "Invalid value for concurrency: %s\n", optarg);
+        exit(EXIT_FAILURE);
+      }
       break;
 
     case OPT_SLAP_EXECUTE_NUMBER:
+      errno= 0;
       opt_execute_number= (unsigned int)strtoul(optarg, (char **)NULL, 10);
+      if (errno != 0)
+      {
+        fprintf(stderr, "Invalid value for execute: %s\n", optarg);
+        exit(EXIT_FAILURE);
+      }
       break;
 
     case OPT_SLAP_INITIAL_LOAD:
+      errno= 0;
       opt_createial_load= (unsigned int)strtoul(optarg, (char **)NULL, 10);
+      if (errno != 0)
+      {
+        fprintf(stderr, "Invalid value for initial load: %s\n", optarg);
+        exit(EXIT_FAILURE);
+      }
       break;
 
     case OPT_QUIET:
diff --git a/clients/memstat.cc b/clients/memstat.cc
index fb5a8586..93ec080c 100644
--- a/clients/memstat.cc
+++ b/clients/memstat.cc
@@ -68,12 +68,12 @@ static struct option long_options[]=
 };
 
 
-static memcached_return_t stat_printer(memcached_server_instance_st instance,
+static memcached_return_t stat_printer(const memcached_instance_st * instance,
                                        const char *key, size_t key_length,
                                        const char *value, size_t value_length,
                                        void *context)
 {
-  static memcached_server_instance_st last= NULL;
+  static const memcached_instance_st * last= NULL;
   (void)context;
 
   if (last != instance)
@@ -89,7 +89,7 @@ static memcached_return_t stat_printer(memcached_server_instance_st instance,
 }
 
 static memcached_return_t server_print_callback(const memcached_st *,
-                                                memcached_server_instance_st instance,
+                                                const memcached_instance_st * instance,
                                                 void *)
 {
   std::cerr << memcached_server_name(instance) << ":" << memcached_server_port(instance) <<
@@ -105,26 +105,36 @@ int main(int argc, char *argv[])
   options_parse(argc, argv);
   initialize_sockets();
 
-  if (opt_servers == false)
+  if (opt_servers == NULL)
   {
     char *temp;
     if ((temp= getenv("MEMCACHED_SERVERS")))
     {
       opt_servers= strdup(temp);
     }
-    else
+
+    if (opt_servers == NULL)
     {
       std::cerr << "No Servers provided" << std::endl;
       return EXIT_FAILURE;
     }
   }
 
+  memcached_server_st* servers= memcached_servers_parse(opt_servers);
+  if (servers == NULL or memcached_server_list_count(servers) == 0)
+  {
+    std::cerr << "Invalid server list provided:" << opt_servers << std::endl;
+    return EXIT_FAILURE;
+  }
+  
+  if (opt_servers)
+  {
+    free(opt_servers);
+  }
+
   memcached_st *memc= memcached_create(NULL);
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, opt_binary);
 
-  memcached_server_st *servers= memcached_servers_parse(opt_servers);
-  free(opt_servers);
-
   memcached_return_t rc= memcached_server_push(memc, servers);
   memcached_server_list_free(servers);
 
@@ -211,9 +221,8 @@ static void run_analyzer(memcached_st *memc, memcached_stat_st *memc_stat)
     uint32_t num_of_tests= 32;
     const char *test_key= "libmemcached_test_key";
 
-    memcached_st **servers;
-    servers= static_cast<memcached_st**>(malloc(sizeof(memcached_st*) * server_count));
-    if (not servers)
+    memcached_st **servers= static_cast<memcached_st**>(malloc(sizeof(memcached_st*) * server_count));
+    if (servers == NULL)
     {
       fprintf(stderr, "Failed to allocate memory\n");
       return;
@@ -221,20 +230,25 @@ static void run_analyzer(memcached_st *memc, memcached_stat_st *memc_stat)
 
     for (uint32_t x= 0; x < server_count; x++)
     {
-      memcached_server_instance_st instance=
+      const memcached_instance_st * instance=
         memcached_server_instance_by_position(memc, x);
 
       if ((servers[x]= memcached_create(NULL)) == NULL)
       {
         fprintf(stderr, "Failed to memcached_create()\n");
         if (x > 0)
+        {
           memcached_free(servers[0]);
+        }
         x--;
 
         for (; x > 0; x--)
+        {
           memcached_free(servers[x]);
+        }
 
         free(servers);
+
         return;
       }
       memcached_server_add(servers[x],
@@ -249,7 +263,7 @@ static void run_analyzer(memcached_st *memc, memcached_stat_st *memc_stat)
 
     for (uint32_t x= 0; x < server_count; x++)
     {
-      memcached_server_instance_st instance=
+      const memcached_instance_st * instance=
         memcached_server_instance_by_position(memc, x);
       gettimeofday(&start_time, NULL);
 
@@ -258,8 +272,10 @@ static void run_analyzer(memcached_st *memc, memcached_stat_st *memc_stat)
         size_t vlen;
         char *val= memcached_get(servers[x], test_key, strlen(test_key),
                                  &vlen, &flags, &rc);
-        if (rc != MEMCACHED_NOTFOUND && rc != MEMCACHED_SUCCESS)
+        if (rc != MEMCACHED_NOTFOUND and rc != MEMCACHED_SUCCESS)
+        {
           break;
+        }
         free(val);
       }
       gettimeofday(&end_time, NULL);
@@ -290,7 +306,7 @@ static void run_analyzer(memcached_st *memc, memcached_stat_st *memc_stat)
 
     if (server_count > 1 && slowest_time > 0)
     {
-      memcached_server_instance_st slowest=
+      const memcached_instance_st * slowest=
         memcached_server_instance_by_position(memc, slowest_server);
 
       printf("---\n");
@@ -302,7 +318,9 @@ static void run_analyzer(memcached_st *memc, memcached_stat_st *memc_stat)
     printf("\n");
 
     for (uint32_t x= 0; x < server_count; x++)
+    {
       memcached_free(servers[x]);
+    }
 
     free(servers);
     free(analyze_mode);
@@ -319,9 +337,9 @@ static void print_analysis_report(memcached_st *memc,
                                   
 {
   uint32_t server_count= memcached_server_count(memc);
-  memcached_server_instance_st most_consumed_server= memcached_server_instance_by_position(memc, report->most_consumed_server);
-  memcached_server_instance_st least_free_server= memcached_server_instance_by_position(memc, report->least_free_server);
-  memcached_server_instance_st oldest_server= memcached_server_instance_by_position(memc, report->oldest_server);
+  const memcached_instance_st * most_consumed_server= memcached_server_instance_by_position(memc, report->most_consumed_server);
+  const memcached_instance_st * least_free_server= memcached_server_instance_by_position(memc, report->least_free_server);
+  const memcached_instance_st * oldest_server= memcached_server_instance_by_position(memc, report->oldest_server);
 
   printf("Memcached Cluster Analysis Report\n\n");
 
diff --git a/clients/memtouch.cc b/clients/memtouch.cc
index 49d154e3..bb6da42f 100644
--- a/clients/memtouch.cc
+++ b/clients/memtouch.cc
@@ -12,14 +12,16 @@
 
 #include <mem_config.h>
 
+#include <cerrno>
 #include <cstdio>
 #include <cstring>
 #include <getopt.h>
 #include <iostream>
 #include <unistd.h>
+
 #include <libmemcached-1.2/memcached.h>
 
-#include "utilities.h"
+#include "clients/utilities.h"
 
 #define PROGRAM_NAME "memtouch"
 #define PROGRAM_DESCRIPTION "Update the expiration value of an alreasy existing value in the sever"
@@ -52,18 +54,24 @@ int main(int argc, char *argv[])
     {
       opt_servers= strdup(temp);
     }
-    else
+
+    if (opt_servers == NULL)
     {
       std::cerr << "No Servers provided" << std::endl;
-      return EXIT_FAILURE;
+      exit(EXIT_FAILURE);
     }
   }
 
+  memcached_server_st* servers= memcached_servers_parse(opt_servers);
+  if (servers == NULL or memcached_server_list_count(servers) == 0)
+  {
+    std::cerr << "Invalid server list provided:" << opt_servers << std::endl;
+    return EXIT_FAILURE;
+  }
+
   memcached_st *memc= memcached_create(NULL);
   process_hash_option(memc, opt_hash);
 
-  memcached_server_st *servers= memcached_servers_parse(opt_servers);
-
   memcached_server_push(memc, servers);
   memcached_server_list_free(servers);
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL,
@@ -212,7 +220,13 @@ void options_parse(int argc, char *argv[])
       break;
 
     case OPT_EXPIRE:
+      errno= 0;
       expiration= time_t(strtoul(optarg, (char **)NULL, 10));
+      if (errno != 0)
+      {
+        fprintf(stderr, "Invalid value for --expire: %s\n", optarg);
+        exit(EXIT_FAILURE);
+      }
       break;
 
     case OPT_QUIET:
diff --git a/clients/ms_conn.c b/clients/ms_conn.c
index 2cbc7e0b..2afc9fa1 100644
--- a/clients/ms_conn.c
+++ b/clients/ms_conn.c
@@ -1160,7 +1160,12 @@ static int ms_ascii_process_line(ms_conn_t *c, char *command)
     {
       token_t tokens[MAX_TOKENS];
       ms_tokenize_command(command, tokens, MAX_TOKENS);
+      errno= 0;
       value_len= strtol(tokens[VALUELEN_TOKEN].value, NULL, 10);
+      if (errno != 0)
+      {
+        printf("<%d ERROR %s\n", c->sfd, strerror(errno));
+      }
       c->currcmd.key_prefix= *(uint64_t *)tokens[KEY_TOKEN].value;
 
       /*
diff --git a/clients/utilities.cc b/clients/utilities.cc
index 5f5958e2..268b7904 100644
--- a/clients/utilities.cc
+++ b/clients/utilities.cc
@@ -144,7 +144,9 @@ void process_hash_option(memcached_st *memc, char *opt_hash)
   memcached_return_t rc;
 
   if (opt_hash == NULL)
+  {
     return;
+  }
 
   set= MEMCACHED_HASH_DEFAULT; /* Just here to solve warning */
   if (!strcasecmp(opt_hash, "CRC"))
@@ -184,12 +186,12 @@ void process_hash_option(memcached_st *memc, char *opt_hash)
 void initialize_sockets(void)
 {
   /* Define the function for all platforms to avoid #ifdefs in each program */
-#if defined(WIN32) && WIN32
+#if defined(_WIN32)
   WSADATA wsaData;
   if (WSAStartup(MAKEWORD(2,0), &wsaData) != 0)
   {
     fprintf(stderr, "Socket Initialization Error. Program aborted\n");
     exit(EXIT_FAILURE);
   }
-#endif
+#endif // #if defined(_WIN32)
 }
diff --git a/configure.ac b/configure.ac
index 724ad251..eadc533f 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1,5 +1,5 @@
 # LibmemcacheD
-# Copyright (C) 2011-2012 Data Differential, http://datadifferential.com/
+# Copyright (C) 2011-2013 Data Differential, http://datadifferential.com/
 # Copyright (C) 2006-2010 Brian Aker, Monty Taylor, Trond Norbye
 # All rights reserved.
 #
@@ -100,9 +100,13 @@ PROTOCOL_BINARY_TEST
 ENABLE_DEPRECATED
 
 # Checks for programs.
+AC_PROG_AWK
+AC_PROG_SED
+AC_PROG_MKDIR_P
 AC_CHECK_PROGS([LEX],['flex'],[:])
 AC_CHECK_PROGS([YACC],['bison'],[:])
 AX_PROG_SPHINX_BUILD
+AX_PROG_MEMCACHED
 
 # Checks for libraries.
 AC_SEARCH_LIBS([getopt_long],[gnugetopt])
@@ -287,10 +291,12 @@ AC_DEFUN([CHECK_FOR_PTHREAD_AND_SASL],
          ])
 CHECK_FOR_PTHREAD_AND_SASL
 
-
 # backtrace(), others require shared builds
-AS_IF([test "x$enable_shared" = "xyes"],
-      [AC_DEFINE([HAVE_SHARED_ENABLED],[1],[Enable code which requires shared library support. Like backtrace().])])
+AC_DEFUN([__ENABLE_SHARED],
+         [AC_REQUIRE([AX_PLATFORM])
+         AS_IF([test "x${TARGET_WINDOWS}" = "xtrue"],[enable_shared=no])
+         AS_IF([test "x$enable_shared" = "xyes"],
+               [AC_DEFINE([HAVE_SHARED_ENABLED],[1],[Enable code which requires shared library support. Like backtrace().])])])
 AM_CONDITIONAL([SHARED_ENABLED],[test "x$enable_shared" = "xyes"])
 
 PANDORA_ENABLE_DTRACE
diff --git a/docs/memcached_server_st.rst b/docs/memcached_server_st.rst
index 6bca49b8..63008795 100644
--- a/docs/memcached_server_st.rst
+++ b/docs/memcached_server_st.rst
@@ -11,13 +11,13 @@ SYNOPSIS
 
 #include <libmemcached/memcached.h>
 
-.. c:type:: memcached_server_instance_st
+.. c:type:: const memcached_instance_st *
 
 .. c:type:: memcached_server_list_st
 
 .. c:type:: memcached_server_st
 
-.. c:function:: const memcached_server_instance_st memcached_server_list (memcached_st *ptr)
+.. c:function:: const const memcached_instance_st * memcached_server_list (memcached_st *ptr)
 
 .. c:function:: void memcached_server_list_free (memcached_server_list_st list)
  
@@ -25,9 +25,9 @@ SYNOPSIS
  
 .. c:function:: uint32_t memcached_server_list_count (memcached_server_list_st list)
  
-.. c:function:: const char *memcached_server_error (memcached_server_instance_st instance)
+.. c:function:: const char *memcached_server_error (const memcached_instance_st * instance)
  
-.. c:function:: void memcached_server_error_reset (memcached_server_instance_st list)
+.. c:function:: void memcached_server_error_reset (const memcached_instance_st * list)
 .. deprecated:: 0.39
    
 .. c:function:: void memcached_servers_parse ()
diff --git a/docs/memcached_servers.rst b/docs/memcached_servers.rst
index e86dad81..d3c90379 100644
--- a/docs/memcached_servers.rst
+++ b/docs/memcached_servers.rst
@@ -20,9 +20,9 @@ SYNOPSIS
 
 .. c:function:: memcached_return_t memcached_server_push (memcached_st *ptr, const memcached_server_st *list) 
 
-.. c:function:: memcached_server_instance_st memcached_server_by_key (memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error)
+.. c:function:: const memcached_instance_st * memcached_server_by_key (memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error)
 
-.. c:function:: memcached_server_instance_st memcached_server_get_last_disconnect (const memcached_st *ptr)
+.. c:function:: const memcached_instance_st * memcached_server_get_last_disconnect (const memcached_st *ptr)
 
 .. c:function:: memcached_return_t memcached_server_cursor(const memcached_st *ptr, const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks)
 
diff --git a/docs/memcached_stats.rst b/docs/memcached_stats.rst
index 828ef8c6..c173619a 100644
--- a/docs/memcached_stats.rst
+++ b/docs/memcached_stats.rst
@@ -16,7 +16,7 @@ SYNOPSIS
 
 .. c:type:: memcached_stat_st
 
-.. c:type:: 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)
+.. c:type:: memcached_return_t (*memcached_stat_fn)(const memcached_instance_st * server, const char *key, size_t key_length, const char *value, size_t value_length, void *context)
 
 .. c:function:: memcached_stat_st *memcached_stat (memcached_st *ptr, char *args, memcached_return_t *error)
 
diff --git a/libhashkit/md5.cc b/libhashkit/md5.cc
index 71069dbd..ef867766 100644
--- a/libhashkit/md5.cc
+++ b/libhashkit/md5.cc
@@ -71,6 +71,14 @@ documentation and/or software.
 #include <string.h>
 #include <sys/types.h>
 
+#define GCC_VERSION (__GNUC__ * 10000 \
+                     + __GNUC_MINOR__ * 100 \
+                     + __GNUC_PATCHLEVEL__)
+
+#if GCC_VERSION > 40600
+# pragma GCC diagnostic ignored "-Wunsafe-loop-optimizations"
+#endif
+
 /* POINTER defines a generic pointer type */
 typedef unsigned char *POINTER;
 typedef const unsigned char *CONST_POINTER;
diff --git a/libmemcached-1.2/callbacks.h b/libmemcached-1.2/callbacks.h
index e321ceb4..7ab8cb1c 100644
--- a/libmemcached-1.2/callbacks.h
+++ b/libmemcached-1.2/callbacks.h
@@ -42,8 +42,8 @@ extern "C" {
 #endif
 
 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,
+typedef memcached_return_t (*memcached_server_fn)(const memcached_st *ptr, const memcached_instance_st * server, void *context);
+typedef memcached_return_t (*memcached_stat_fn)(const memcached_instance_st * server,
                                                 const char *key, size_t key_length,
                                                 const char *value, size_t value_length,
                                                 void *context);
diff --git a/libmemcached-1.2/error.h b/libmemcached-1.2/error.h
new file mode 100644
index 00000000..9346bb0b
--- /dev/null
+++ b/libmemcached-1.2/error.h
@@ -0,0 +1,67 @@
+/*  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
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+LIBMEMCACHED_API
+  const char *memcached_error(const memcached_st *);
+
+LIBMEMCACHED_API
+  const char *memcached_last_error_message(const memcached_st *);
+
+LIBMEMCACHED_API
+  void memcached_error_print(const memcached_st *);
+
+LIBMEMCACHED_API
+  memcached_return_t memcached_last_error(const memcached_st *);
+
+LIBMEMCACHED_API
+  int memcached_last_error_errno(const memcached_st *);
+
+LIBMEMCACHED_API
+  const char *memcached_server_error(const memcached_instance_st * ptr);
+
+LIBMEMCACHED_API
+  memcached_return_t memcached_server_error_return(const memcached_instance_st * ptr);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
diff --git a/libmemcached-1.2/memcached.h b/libmemcached-1.2/memcached.h
index 7d932471..2a2b54a7 100644
--- a/libmemcached-1.2/memcached.h
+++ b/libmemcached-1.2/memcached.h
@@ -154,7 +154,7 @@ LIBMEMCACHED_API
 memcached_return_t memcached_push(memcached_st *destination, const memcached_st *source);
 
 LIBMEMCACHED_API
-memcached_server_instance_st memcached_server_instance_by_position(const memcached_st *ptr, uint32_t server_key);
+const memcached_instance_st * memcached_server_instance_by_position(const memcached_st *ptr, uint32_t server_key);
 
 LIBMEMCACHED_API
 uint32_t memcached_server_count(const memcached_st *);
diff --git a/libmemcached-1.2/memcached.hpp b/libmemcached-1.2/memcached.hpp
index 0bcb200e..885e809d 100644
--- a/libmemcached-1.2/memcached.hpp
+++ b/libmemcached-1.2/memcached.hpp
@@ -847,7 +847,7 @@ public:
      */
     for (uint32_t x= 0; x < server_count; x++)
     {
-      memcached_server_instance_st instance= memcached_server_instance_by_position(memc_, x);
+      const memcached_instance_st * instance= memcached_server_instance_by_position(memc_, x);
       std::ostringstream strstm;
       std::string server_name(memcached_server_name(instance));
       server_name.append(":");
diff --git a/libmemcached-1.2/platform.h b/libmemcached-1.2/platform.h
index 9cbc705f..efdf53f8 100644
--- a/libmemcached-1.2/platform.h
+++ b/libmemcached-1.2/platform.h
@@ -38,7 +38,7 @@
 #pragma once
 
 
-#if defined(WIN32) || defined(__MINGW32__)
+#if defined(_WIN32)
 # include <winsock2.h>
 # include <ws2tcpip.h>
 
@@ -59,4 +59,4 @@ typedef SOCKET memcached_socket_t;
 
 typedef int memcached_socket_t;
 
-#endif /* WIN32 */
+#endif /* _WIN32 */
diff --git a/libmemcached-1.2/server.h b/libmemcached-1.2/server.h
index aad0c3ee..1999de0a 100644
--- a/libmemcached-1.2/server.h
+++ b/libmemcached-1.2/server.h
@@ -51,7 +51,7 @@ memcached_return_t memcached_server_cursor(const memcached_st *ptr,
                                            uint32_t number_of_callbacks);
 
 LIBMEMCACHED_API
-  memcached_server_instance_st memcached_server_by_key(memcached_st *ptr,
+  const memcached_instance_st * memcached_server_by_key(memcached_st *ptr,
                                                        const char *key,
                                                        size_t key_length,
                                                        memcached_return_t *error);
@@ -63,7 +63,7 @@ LIBMEMCACHED_API
 void memcached_server_free(memcached_server_st *ptr);
 
 LIBMEMCACHED_API
-memcached_server_instance_st memcached_server_get_last_disconnect(const memcached_st *ptr);
+const memcached_instance_st * memcached_server_get_last_disconnect(const memcached_st *ptr);
 
 
 LIBMEMCACHED_API
@@ -95,28 +95,28 @@ memcached_return_t memcached_server_add_with_weight(memcached_st *ptr, const cha
   Operations on Single Servers.
 */
 LIBMEMCACHED_API
-uint32_t memcached_server_response_count(const memcached_server_instance_st self);
+uint32_t memcached_server_response_count(const memcached_instance_st * self);
 
 LIBMEMCACHED_API
-const char *memcached_server_name(const memcached_server_instance_st self);
+const char *memcached_server_name(const memcached_instance_st * self);
 
 LIBMEMCACHED_API
-in_port_t memcached_server_port(const memcached_server_instance_st self);
+in_port_t memcached_server_port(const memcached_instance_st * self);
 
 LIBMEMCACHED_API
-void memcached_instance_next_retry(memcached_server_instance_st self, const time_t absolute_time);
+void memcached_instance_next_retry(const memcached_instance_st * self, const time_t absolute_time);
 
 LIBMEMCACHED_API
-const char *memcached_server_type(const memcached_server_instance_st ptr);
+const char *memcached_server_type(const memcached_instance_st * ptr);
 
 LIBMEMCACHED_API
-uint8_t memcached_server_major_version(const memcached_server_instance_st ptr);
+uint8_t memcached_server_major_version(const memcached_instance_st * ptr);
 
 LIBMEMCACHED_API
-uint8_t memcached_server_minor_version(const memcached_server_instance_st ptr);
+uint8_t memcached_server_minor_version(const memcached_instance_st * ptr);
 
 LIBMEMCACHED_API
-uint8_t memcached_server_micro_version(const memcached_server_instance_st ptr);
+uint8_t memcached_server_micro_version(const memcached_instance_st * ptr);
 
 #ifdef __cplusplus
 } // extern "C"
diff --git a/libmemcached-1.2/struct/memcached.h b/libmemcached-1.2/struct/memcached.h
index 624887b7..37df2751 100644
--- a/libmemcached-1.2/struct/memcached.h
+++ b/libmemcached-1.2/struct/memcached.h
@@ -74,13 +74,8 @@ struct memcached_st {
     unsigned int version;
   } server_info;
   uint32_t number_of_hosts;
-#ifdef __cplusplus
-  org::libmemcached::Instance* servers;
-  org::libmemcached::Instance* last_disconnected_server;
-#else
-  void *servers;
-  void *last_disconnected_server;
-#endif
+  memcached_instance_st *servers;
+  memcached_instance_st *last_disconnected_server;
   int32_t snd_timeout;
   int32_t rcv_timeout;
   uint32_t server_failure_limit;
diff --git a/libmemcached-1.2/types.h b/libmemcached-1.2/types.h
new file mode 100644
index 00000000..2c3f87af
--- /dev/null
+++ b/libmemcached-1.2/types.h
@@ -0,0 +1,83 @@
+/*  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 __cplusplus
+
+struct memcached_st;
+struct memcached_stat_st;
+struct memcached_analysis_st;
+struct memcached_result_st;
+struct memcached_array_st;
+struct memcached_error_t;
+
+// All of the flavors of memcache_server_st
+struct memcached_server_st;
+struct memcached_instance_st;
+typedef struct memcached_instance_st memcached_instance_st;
+typedef struct memcached_server_st *memcached_server_list_st;
+
+struct memcached_callback_st;
+
+// The following two structures are internal, and never exposed to users.
+struct memcached_string_st;
+struct memcached_string_t;
+struct memcached_continuum_item_st;
+
+#else
+
+typedef struct memcached_st memcached_st;
+typedef struct memcached_stat_st memcached_stat_st;
+typedef struct memcached_analysis_st memcached_analysis_st;
+typedef struct memcached_result_st memcached_result_st;
+typedef struct memcached_array_st memcached_array_st;
+typedef struct memcached_error_t memcached_error_t;
+
+// All of the flavors of memcache_server_st
+typedef struct memcached_server_st memcached_server_st;
+typedef struct memcached_instance_st memcached_instance_st;
+typedef struct memcached_server_st *memcached_server_list_st;
+
+typedef struct memcached_callback_st memcached_callback_st;
+
+// The following two structures are internal, and never exposed to users.
+typedef struct memcached_string_st memcached_string_st;
+typedef struct memcached_string_t memcached_string_t;
+
+#endif
diff --git a/libmemcached/auto.cc b/libmemcached/auto.cc
index b8187a05..111445fb 100644
--- a/libmemcached/auto.cc
+++ b/libmemcached/auto.cc
@@ -37,7 +37,7 @@
 
 #include <libmemcached/common.h>
 
-static void auto_response(org::libmemcached::Instance* instance, const bool reply,  memcached_return_t& rc, uint64_t* value)
+static void auto_response(memcached_instance_st* instance, const bool reply,  memcached_return_t& rc, uint64_t* value)
 {
   // If the message was successfully sent, then get the response, otherwise
   // fail.
@@ -63,7 +63,7 @@ static void auto_response(org::libmemcached::Instance* instance, const bool repl
   }
 }
 
-static memcached_return_t text_incr_decr(org::libmemcached::Instance* instance,
+static memcached_return_t text_incr_decr(memcached_instance_st* instance,
                                          const bool is_incr,
                                          const char *key, size_t key_length,
                                          const uint64_t offset,
@@ -97,7 +97,7 @@ static memcached_return_t text_incr_decr(org::libmemcached::Instance* instance,
   return memcached_vdo(instance, vector, 7, true);
 }
 
-static memcached_return_t binary_incr_decr(org::libmemcached::Instance* instance,
+static memcached_return_t binary_incr_decr(memcached_instance_st* instance,
                                            protocol_binary_command cmd,
                                            const char *key, const size_t key_length,
                                            const uint64_t offset,
@@ -180,7 +180,7 @@ static memcached_return_t increment_decrement_by_key(const protocol_binary_comma
   }
 
   uint32_t server_key= memcached_generate_hash_with_redistribution(memc, group_key, group_key_length);
-  org::libmemcached::Instance* instance= memcached_instance_fetch(memc, server_key);
+  memcached_instance_st* instance= memcached_instance_fetch(memc, server_key);
 
   bool reply= memcached_is_replying(instance->root);
 
@@ -239,7 +239,7 @@ static memcached_return_t increment_decrement_with_initial_by_key(const protocol
   }
 
   uint32_t server_key= memcached_generate_hash_with_redistribution(memc, group_key, group_key_length);
-  org::libmemcached::Instance* instance= memcached_instance_fetch(memc, server_key);
+  memcached_instance_st* instance= memcached_instance_fetch(memc, server_key);
 
   bool reply= memcached_is_replying(instance->root);
 
diff --git a/libmemcached/behavior.cc b/libmemcached/behavior.cc
index 7a8b9853..2675e236 100644
--- a/libmemcached/behavior.cc
+++ b/libmemcached/behavior.cc
@@ -413,7 +413,7 @@ uint64_t memcached_behavior_get(memcached_st *shell,
         return (uint64_t) ptr->send_size;
       }
 
-      org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, 0);
+      memcached_instance_st* instance= memcached_instance_fetch(ptr, 0);
 
       if (instance) // If we have an instance we test, otherwise we just set and pray
       {
@@ -447,7 +447,7 @@ uint64_t memcached_behavior_get(memcached_st *shell,
       if (ptr->recv_size != -1) // If value is -1 then we are using the default
         return (uint64_t) ptr->recv_size;
 
-      org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, 0);
+      memcached_instance_st* instance= memcached_instance_fetch(ptr, 0);
 
       /**
         @note REFACTOR
diff --git a/libmemcached/common.h b/libmemcached/common.h
index 0180baca..8e899b70 100644
--- a/libmemcached/common.h
+++ b/libmemcached/common.h
@@ -107,7 +107,7 @@
 # include <dlfcn.h>
 #endif
 
-#if defined(WIN32) || defined(__MINGW32__)
+#if defined(_WIN32)
 # include "libmemcached/windows.hpp"
 #endif
 
@@ -124,7 +124,7 @@ typedef struct memcached_st Memcached;
 #endif
 
 #ifdef __cplusplus
-org::libmemcached::Instance* memcached_instance_fetch(memcached_st *ptr, uint32_t server_key);
+memcached_instance_st* memcached_instance_fetch(memcached_st *ptr, uint32_t server_key);
 #endif
 
 /* These are private not to be installed headers */
@@ -199,7 +199,7 @@ extern "C" {
 memcached_return_t run_distribution(memcached_st *ptr);
 
 #ifdef __cplusplus
-static inline void memcached_server_response_increment(org::libmemcached::Instance* instance)
+static inline void memcached_server_response_increment(memcached_instance_st* instance)
 {
   instance->events(POLLIN);
   instance->cursor_active_++;
@@ -218,6 +218,6 @@ static inline void memcached_server_response_increment(org::libmemcached::Instan
 #endif
 
 #ifdef __cplusplus
-bool memcached_purge(org::libmemcached::Instance*);
-org::libmemcached::Instance* memcached_instance_by_position(const memcached_st *ptr, uint32_t server_key);
+bool memcached_purge(memcached_instance_st*);
+memcached_instance_st* memcached_instance_by_position(const memcached_st *ptr, uint32_t server_key);
 #endif
diff --git a/libmemcached/connect.cc b/libmemcached/connect.cc
index 2ec9975c..cb88c13b 100644
--- a/libmemcached/connect.cc
+++ b/libmemcached/connect.cc
@@ -64,7 +64,7 @@
 # define TCP_KEEPIDLE 0
 #endif
 
-static memcached_return_t connect_poll(org::libmemcached::Instance* server, const int connection_error)
+static memcached_return_t connect_poll(memcached_instance_st* server, const int connection_error)
 {
   struct pollfd fds[1];
   fds[0].fd= server->fd;
@@ -87,7 +87,7 @@ static memcached_return_t connect_poll(org::libmemcached::Instance* server, cons
       int local_errno= get_socket_errno(); // We cache in case closesocket() modifies errno
       switch (local_errno)
       {
-#ifdef TARGET_OS_LINUX
+#ifdef __linux__
       case ERESTART:
 #endif
       case EINTR:
@@ -103,22 +103,6 @@ static memcached_return_t connect_poll(org::libmemcached::Instance* server, cons
 
       default: // This should not happen
         break;
-#if 0
-        if (fds[0].revents & POLLERR)
-        {
-          int err;
-          socklen_t len= sizeof(err);
-          if (getsockopt(server->fd, SOL_SOCKET, SO_ERROR, (char*)&err, &len) == 0)
-          {
-            if (err == 0)
-            {
-              // This should never happen, if it does? Punt.  
-              continue;
-            }
-            local_errno= err;
-          }
-        }
-#endif
       }
 
       assert_msg(server->fd != INVALID_SOCKET, "poll() was passed an invalid file descriptor");
@@ -146,13 +130,9 @@ static memcached_return_t connect_poll(org::libmemcached::Instance* server, cons
         }
       }
 
-      return  memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT);
+      return  memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT, memcached_literal_param("(number_of == 0)"));
     }
 
-#if 0
-    server->revents(fds[0].revents);
-#endif
-
     assert (number_of == 1);
 
     if (fds[0].revents & POLLERR or
@@ -201,7 +181,7 @@ static memcached_return_t connect_poll(org::libmemcached::Instance* server, cons
   return memcached_set_errno(*server, connection_error, MEMCACHED_AT, memcached_literal_param("connect_poll() was exhausted"));
 }
 
-static memcached_return_t set_hostinfo(org::libmemcached::Instance* server)
+static memcached_return_t set_hostinfo(memcached_instance_st* server)
 {
   assert(server->type != MEMCACHED_CONNECTION_UNIX_SOCKET);
   server->clear_addrinfo();
@@ -265,9 +245,9 @@ static memcached_return_t set_hostinfo(org::libmemcached::Instance* server)
   return MEMCACHED_SUCCESS;
 }
 
-static inline void set_socket_nonblocking(org::libmemcached::Instance* server)
+static inline void set_socket_nonblocking(memcached_instance_st* server)
 {
-#ifdef WIN32
+#if defined(_WIN32)
   u_long arg= 1;
   if (ioctlsocket(server->fd, FIONBIO, &arg) == SOCKET_ERROR)
   {
@@ -305,7 +285,7 @@ static inline void set_socket_nonblocking(org::libmemcached::Instance* server)
 #endif
 }
 
-static bool set_socket_options(org::libmemcached::Instance* server)
+static bool set_socket_options(memcached_instance_st* server)
 {
   assert_msg(server->fd != INVALID_SOCKET, "invalid socket was passed to set_socket_options()");
 
@@ -372,7 +352,7 @@ static bool set_socket_options(org::libmemcached::Instance* server)
 
 #if defined(_WIN32)
 #else
-#if defined(SO_NOSIGPIPE)
+# if defined(SO_NOSIGPIPE)
   if (SO_NOSIGPIPE)
   {
     int set= 1;
@@ -388,7 +368,7 @@ static bool set_socket_options(org::libmemcached::Instance* server)
 #endif
     }
   }
-#endif // SO_NOSIGPIPE
+# endif // SO_NOSIGPIPE
 #endif // _WIN32
 
   if (server->root->flags.no_block)
@@ -459,9 +439,9 @@ static bool set_socket_options(org::libmemcached::Instance* server)
   return true;
 }
 
-static memcached_return_t unix_socket_connect(org::libmemcached::Instance* server)
+static memcached_return_t unix_socket_connect(memcached_instance_st* server)
 {
-#ifndef WIN32
+#ifndef _WIN32
   WATCHPOINT_ASSERT(server->fd == INVALID_SOCKET);
 
   do {
@@ -525,7 +505,7 @@ static memcached_return_t unix_socket_connect(org::libmemcached::Instance* serve
 #endif
 }
 
-static memcached_return_t network_connect(org::libmemcached::Instance* server)
+static memcached_return_t network_connect(memcached_instance_st* server)
 {
   bool timeout_error_occured= false;
 
@@ -663,7 +643,8 @@ static memcached_return_t network_connect(org::libmemcached::Instance* server)
 
   if (timeout_error_occured and server->state < MEMCACHED_SERVER_STATE_IN_PROGRESS)
   {
-    return memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT);
+    return memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT,
+                               memcached_literal_param("if (timeout_error_occured and server->state < MEMCACHED_SERVER_STATE_IN_PROGRESS)"));
   }
 
   return memcached_set_error(*server, MEMCACHED_CONNECTION_FAILURE, MEMCACHED_AT); /* The last error should be from connect() */
@@ -676,7 +657,7 @@ static memcached_return_t network_connect(org::libmemcached::Instance* server)
   Based on time/failure count fail the connect without trying. This prevents waiting in a state where
   we get caught spending cycles just waiting.
 */
-static memcached_return_t backoff_handling(org::libmemcached::Instance* server, bool& in_timeout)
+static memcached_return_t backoff_handling(memcached_instance_st* server, bool& in_timeout)
 {
   struct timeval curr_time;
   bool _gettime_success= (gettimeofday(&curr_time, NULL) == 0);
@@ -743,7 +724,7 @@ static memcached_return_t backoff_handling(org::libmemcached::Instance* server,
   return MEMCACHED_SUCCESS;
 }
 
-static memcached_return_t _memcached_connect(org::libmemcached::Instance* server, const bool set_last_disconnected)
+static memcached_return_t _memcached_connect(memcached_instance_st* server, const bool set_last_disconnected)
 {
   assert(server);
   if (server->fd != INVALID_SOCKET)
@@ -830,7 +811,7 @@ static memcached_return_t _memcached_connect(org::libmemcached::Instance* server
   return rc;
 }
 
-memcached_return_t memcached_connect(org::libmemcached::Instance* server)
+memcached_return_t memcached_connect(memcached_instance_st* server)
 {
   return _memcached_connect(server, true);
 }
diff --git a/libmemcached/connect.hpp b/libmemcached/connect.hpp
index de1c8df5..d1dafe5e 100644
--- a/libmemcached/connect.hpp
+++ b/libmemcached/connect.hpp
@@ -37,4 +37,4 @@
 
 #pragma once
 
-memcached_return_t memcached_connect(org::libmemcached::Instance*);
+memcached_return_t memcached_connect(memcached_instance_st*);
diff --git a/libmemcached/csl/parser.yy b/libmemcached/csl/parser.yy
index 6d4ccd55..dd9c720b 100644
--- a/libmemcached/csl/parser.yy
+++ b/libmemcached/csl/parser.yy
@@ -53,7 +53,7 @@ class Context;
 %parse-param { class Context *context }
 %parse-param { yyscan_t *scanner }
 %pure-parser
-%require "2.4"
+%require "2.5"
 %start begin
 %verbose
 
@@ -66,13 +66,14 @@ class Context;
 #include <libmemcached/csl/scanner.h>
 
 #ifndef __INTEL_COMPILER
-#pragma GCC diagnostic ignored "-Wold-style-cast"
+# pragma GCC diagnostic ignored "-Wold-style-cast"
 #endif
 
 #ifndef __INTEL_COMPILER
-#ifndef __clang__
-#pragma GCC diagnostic ignored "-Wlogical-op"
-#endif
+# ifndef __clang__
+#  pragma GCC diagnostic ignored "-Wlogical-op"
+#  pragma GCC diagnostic ignored "-Wunsafe-loop-optimizations"
+# endif
 #endif
 
 int conf_lex(YYSTYPE* lvalp, void* scanner);
diff --git a/libmemcached/delete.cc b/libmemcached/delete.cc
index 67957f45..55a8b4ca 100644
--- a/libmemcached/delete.cc
+++ b/libmemcached/delete.cc
@@ -44,7 +44,7 @@ memcached_return_t memcached_delete(memcached_st *shell, const char *key, size_t
   return memcached_delete_by_key(shell, key, key_length, key, key_length, expiration);
 }
 
-static inline memcached_return_t ascii_delete(org::libmemcached::Instance* instance,
+static inline memcached_return_t ascii_delete(memcached_instance_st* instance,
                                               uint32_t ,
                                               const char *key,
                                               const size_t key_length,
@@ -65,7 +65,7 @@ static inline memcached_return_t ascii_delete(org::libmemcached::Instance* insta
   return memcached_vdo(instance, vector, 6, is_buffering ? false : true);
 }
 
-static inline memcached_return_t binary_delete(org::libmemcached::Instance* instance,
+static inline memcached_return_t binary_delete(memcached_instance_st* instance,
                                                uint32_t server_key,
                                                const char *key,
                                                const size_t key_length,
@@ -118,7 +118,7 @@ static inline memcached_return_t binary_delete(org::libmemcached::Instance* inst
         server_key= 0;
       }
 
-      org::libmemcached::Instance* replica= memcached_instance_fetch(instance->root, server_key);
+      memcached_instance_st* replica= memcached_instance_fetch(instance->root, server_key);
 
       if (memcached_fatal(memcached_vdo(replica, vector, 4, should_flush)))
       {
@@ -161,7 +161,7 @@ memcached_return_t memcached_delete_by_key(memcached_st *shell,
   }
 
   uint32_t server_key= memcached_generate_hash_with_redistribution(memc, group_key, group_key_length);
-  org::libmemcached::Instance* instance= memcached_instance_fetch(memc, server_key);
+  memcached_instance_st* instance= memcached_instance_fetch(memc, server_key);
   
   bool is_buffering= memcached_is_buffering(instance->root);
   bool is_replying= memcached_is_replying(instance->root);
diff --git a/libmemcached/do.cc b/libmemcached/do.cc
index c9d8e7e5..9ba513f2 100644
--- a/libmemcached/do.cc
+++ b/libmemcached/do.cc
@@ -11,7 +11,7 @@
 
 #include <libmemcached/common.h>
 
-static memcached_return_t _vdo_udp(org::libmemcached::Instance* instance,
+static memcached_return_t _vdo_udp(memcached_instance_st* instance,
                                    libmemcached_io_vector_st vector[],
                                    const size_t count)
 {
@@ -30,7 +30,7 @@ static memcached_return_t _vdo_udp(org::libmemcached::Instance* instance,
   vector[0].length= UDP_DATAGRAM_HEADER_LENGTH;
 
   msg.msg_iov= (struct iovec*)vector;
-#if defined(TARGET_OS_OSX) && TARGET_OS_OSX
+#ifdef __APPLE__
   msg.msg_iovlen= int(count);
 #else
   msg.msg_iovlen= count;
@@ -64,7 +64,7 @@ static memcached_return_t _vdo_udp(org::libmemcached::Instance* instance,
 #endif
 }
 
-memcached_return_t memcached_vdo(org::libmemcached::Instance* instance,
+memcached_return_t memcached_vdo(memcached_instance_st* instance,
                                  libmemcached_io_vector_st vector[],
                                  const size_t count,
                                  const bool with_flush)
diff --git a/libmemcached/do.hpp b/libmemcached/do.hpp
index 109c0ac1..d2dc6671 100644
--- a/libmemcached/do.hpp
+++ b/libmemcached/do.hpp
@@ -2,7 +2,7 @@
  * 
  *  Libmemcached library
  *
- *  Copyright (C) 2011 Data Differential, http://datadifferential.com/
+ *  Copyright (C) 2011-2013 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
@@ -37,7 +37,7 @@
 
 #pragma once
 
-memcached_return_t memcached_vdo(org::libmemcached::Instance* ptr,
+memcached_return_t memcached_vdo(memcached_instance_st*,
                                  libmemcached_io_vector_st vector[],
                                  const size_t count,
                                  const bool with_flush);
diff --git a/libmemcached/dump.cc b/libmemcached/dump.cc
index 35da13f5..8ddb2eef 100644
--- a/libmemcached/dump.cc
+++ b/libmemcached/dump.cc
@@ -68,7 +68,7 @@ static memcached_return_t ascii_dump(Memcached *memc, memcached_dump_fn *callbac
     // Send message to all servers
     for (uint32_t server_key= 0; server_key < memcached_server_count(memc); server_key++)
     {
-      org::libmemcached::Instance* instance= memcached_instance_fetch(memc, server_key);
+      memcached_instance_st* instance= memcached_instance_fetch(memc, server_key);
 
       memcached_return_t vdo_rc;
       if (memcached_success((vdo_rc= memcached_vdo(instance, vector, 3, true))))
@@ -82,7 +82,7 @@ static memcached_return_t ascii_dump(Memcached *memc, memcached_dump_fn *callbac
     }
 
     // Collect the returned items
-    org::libmemcached::Instance* instance;
+    memcached_instance_st* instance;
     memcached_return_t read_ret= MEMCACHED_SUCCESS;
     while ((instance= memcached_io_get_readable_server(memc, read_ret)))
     {
diff --git a/libmemcached/error.cc b/libmemcached/error.cc
index 64aefa03..266f78b5 100644
--- a/libmemcached/error.cc
+++ b/libmemcached/error.cc
@@ -52,7 +52,7 @@ struct memcached_error_t
   char message[MAX_ERROR_LENGTH];
 };
 
-static void _set(org::libmemcached::Instance& server, Memcached& memc)
+static void _set(memcached_instance_st& server, Memcached& memc)
 {
   if (server.error_messages and server.error_messages->query_id != server.root->query_id)
   {
@@ -215,7 +215,7 @@ memcached_return_t memcached_set_error(Memcached& memc, memcached_return_t rc, c
   return memcached_set_error(memc, rc, at, tmp);
 }
 
-memcached_return_t memcached_set_error(org::libmemcached::Instance& self, memcached_return_t rc, const char *at, const char *str, size_t length)
+memcached_return_t memcached_set_error(memcached_instance_st& self, memcached_return_t rc, const char *at, const char *str, size_t length)
 {
   assert_msg(rc != MEMCACHED_ERRNO, "Programmer error, MEMCACHED_ERRNO was set to be returned to client");
   assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a Instance");
@@ -255,7 +255,7 @@ memcached_return_t memcached_set_parser_error(Memcached& memc,
   return memcached_set_error(memc, MEMCACHED_PARSE_ERROR, at, buffer, length);
 }
 
-static inline size_t append_host_to_string(org::libmemcached::Instance& self, char* buffer, const size_t buffer_length)
+static inline size_t append_host_to_string(memcached_instance_st& self, char* buffer, const size_t buffer_length)
 {
   size_t size= 0;
   switch (self.type)
@@ -275,10 +275,10 @@ static inline size_t append_host_to_string(org::libmemcached::Instance& self, ch
   return size;
 }
 
-memcached_return_t memcached_set_error(org::libmemcached::Instance& self, memcached_return_t rc, const char *at, memcached_string_t& str)
+memcached_return_t memcached_set_error(memcached_instance_st& self, memcached_return_t rc, const char *at, memcached_string_t& str)
 {
   assert_msg(rc != MEMCACHED_ERRNO, "Programmer error, MEMCACHED_ERRNO was set to be returned to client");
-  assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a org::libmemcached::Instance");
+  assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a memcached_instance_st");
   if (memcached_fatal(rc) == false and rc != MEMCACHED_CLIENT_ERROR)
   {
     return rc;
@@ -313,9 +313,9 @@ memcached_return_t memcached_set_error(org::libmemcached::Instance& self, memcac
   return rc;
 }
 
-memcached_return_t memcached_set_error(org::libmemcached::Instance& self, memcached_return_t rc, const char *at)
+memcached_return_t memcached_set_error(memcached_instance_st& self, memcached_return_t rc, const char *at)
 {
-  assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a org::libmemcached::Instance");
+  assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a memcached_instance_st");
   if (memcached_fatal(rc) == false)
   {
     return rc;
@@ -356,7 +356,7 @@ memcached_return_t memcached_set_errno(Memcached& self, int local_errno, const c
   return memcached_set_errno(self, local_errno, at, tmp);
 }
 
-memcached_return_t memcached_set_errno(org::libmemcached::Instance& self, int local_errno, const char *at, const char *str, size_t length)
+memcached_return_t memcached_set_errno(memcached_instance_st& self, int local_errno, const char *at, const char *str, size_t length)
 {
   memcached_string_t tmp= { str, length };
   return memcached_set_errno(self, local_errno, at, tmp);
@@ -388,7 +388,7 @@ memcached_return_t memcached_set_errno(Memcached& memc, int local_errno, const c
   return rc;
 }
 
-memcached_return_t memcached_set_errno(org::libmemcached::Instance& self, int local_errno, const char *at, memcached_string_t& str)
+memcached_return_t memcached_set_errno(memcached_instance_st& self, int local_errno, const char *at, memcached_string_t& str)
 {
   if (local_errno == 0)
   {
@@ -427,7 +427,7 @@ memcached_return_t memcached_set_errno(org::libmemcached::Instance& self, int lo
   return rc;
 }
 
-memcached_return_t memcached_set_errno(org::libmemcached::Instance& self, int local_errno, const char *at)
+memcached_return_t memcached_set_errno(memcached_instance_st& self, int local_errno, const char *at)
 {
   if (local_errno == 0)
   {
@@ -482,7 +482,7 @@ void memcached_error_print(const Memcached *shell)
 
   for (uint32_t x= 0; x < memcached_server_count(self); x++)
   {
-    org::libmemcached::Instance* instance= memcached_instance_by_position(self, x);
+    memcached_instance_st* instance= memcached_instance_by_position(self, x);
 
     _error_print(instance->error_messages);
   }
@@ -504,7 +504,7 @@ void memcached_error_free(Memcached& self)
   self.error_messages= NULL;
 }
 
-void memcached_error_free(org::libmemcached::Instance& self)
+void memcached_error_free(memcached_instance_st& self)
 {
   _error_free(self.error_messages);
   self.error_messages= NULL;
@@ -554,7 +554,7 @@ bool memcached_has_current_error(Memcached &memc)
   return false;
 }
 
-bool memcached_has_current_error(org::libmemcached::Instance& server)
+bool memcached_has_current_error(memcached_instance_st& server)
 {
   return memcached_has_current_error(*(server.root));
 }
@@ -591,7 +591,7 @@ int memcached_last_error_errno(const memcached_st *shell)
   return memc->error_messages->local_errno;
 }
 
-const char *memcached_server_error(const memcached_server_instance_st server)
+const char *memcached_server_error(const memcached_instance_st * server)
 {
   if (server == NULL)
   {
@@ -612,7 +612,7 @@ const char *memcached_server_error(const memcached_server_instance_st server)
 }
 
 
-memcached_error_t *memcached_error_copy(const org::libmemcached::Instance& server)
+memcached_error_t *memcached_error_copy(const memcached_instance_st& server)
 {
   if (server.error_messages == NULL)
   {
@@ -626,7 +626,7 @@ memcached_error_t *memcached_error_copy(const org::libmemcached::Instance& serve
   return error;
 }
 
-memcached_return_t memcached_server_error_return(memcached_server_instance_st ptr)
+memcached_return_t memcached_server_error_return(const memcached_instance_st * ptr)
 {
   if (ptr == NULL)
   {
@@ -641,7 +641,7 @@ memcached_return_t memcached_server_error_return(memcached_server_instance_st pt
   return MEMCACHED_SUCCESS;
 }
 
-memcached_return_t memcached_instance_error_return(org::libmemcached::Instance* instance)
+memcached_return_t memcached_instance_error_return(memcached_instance_st* instance)
 {
   if (instance == NULL)
   {
diff --git a/libmemcached/error.hpp b/libmemcached/error.hpp
index 733f7686..847dbc24 100644
--- a/libmemcached/error.hpp
+++ b/libmemcached/error.hpp
@@ -51,40 +51,40 @@ memcached_return_t memcached_set_parser_error(Memcached& memc,
 
 memcached_return_t memcached_set_error(Memcached&, memcached_return_t rc, const char *at);
 
-memcached_return_t memcached_set_error(org::libmemcached::Instance&, memcached_return_t rc, const char *at);
+memcached_return_t memcached_set_error(memcached_instance_st&, memcached_return_t rc, const char *at);
 
 memcached_return_t memcached_set_error(Memcached&, memcached_return_t rc, const char *at, const char *str, size_t length);
 
-memcached_return_t memcached_set_error(org::libmemcached::Instance&, memcached_return_t rc, const char *at, const char *str, size_t length);
+memcached_return_t memcached_set_error(memcached_instance_st&, memcached_return_t rc, const char *at, const char *str, size_t length);
 
 memcached_return_t memcached_set_error(Memcached& memc, memcached_return_t rc, const char *at, memcached_string_t& str);
 
-memcached_return_t memcached_set_error(org::libmemcached::Instance&, memcached_return_t rc, const char *at, memcached_string_t& str);
+memcached_return_t memcached_set_error(memcached_instance_st&, memcached_return_t rc, const char *at, memcached_string_t& str);
 
 memcached_return_t memcached_set_errno(Memcached& memc, int local_errno, const char *at, memcached_string_t& str);
 
-memcached_return_t memcached_set_errno(org::libmemcached::Instance&, int local_errno, const char *at, memcached_string_t& str);
+memcached_return_t memcached_set_errno(memcached_instance_st&, int local_errno, const char *at, memcached_string_t& str);
 
 memcached_return_t memcached_set_errno(Memcached& memc, int local_errno, const char *at, const char *str, size_t length);
 
-memcached_return_t memcached_set_errno(org::libmemcached::Instance&, int local_errno, const char *at, const char *str, size_t length);
+memcached_return_t memcached_set_errno(memcached_instance_st&, int local_errno, const char *at, const char *str, size_t length);
 
 memcached_return_t memcached_set_errno(Memcached& memc, int local_errno, const char *at);
 
-memcached_return_t memcached_set_errno(org::libmemcached::Instance&, int local_errno, const char *at);
+memcached_return_t memcached_set_errno(memcached_instance_st&, int local_errno, const char *at);
 
 bool memcached_has_current_error(Memcached&);
 
-bool memcached_has_current_error(org::libmemcached::Instance&);
+bool memcached_has_current_error(memcached_instance_st&);
 
 void memcached_error_free(Memcached&);
 
 void memcached_error_free(memcached_server_st&);
 
-void memcached_error_free(org::libmemcached::Instance& self);
+void memcached_error_free(memcached_instance_st& self);
 
-memcached_error_t *memcached_error_copy(const org::libmemcached::Instance&);
+memcached_error_t *memcached_error_copy(const memcached_instance_st&);
 
-memcached_return_t memcached_instance_error_return(org::libmemcached::Instance*);
+memcached_return_t memcached_instance_error_return(memcached_instance_st*);
 
 #endif
diff --git a/libmemcached/exist.cc b/libmemcached/exist.cc
index 8ed60545..3afb42d4 100644
--- a/libmemcached/exist.cc
+++ b/libmemcached/exist.cc
@@ -36,7 +36,7 @@
 
 #include <libmemcached/common.h>
 
-static memcached_return_t ascii_exist(Memcached *memc, org::libmemcached::Instance* instance, const char *key, size_t key_length)
+static memcached_return_t ascii_exist(Memcached *memc, memcached_instance_st* instance, const char *key, size_t key_length)
 {
   libmemcached_io_vector_st vector[]=
   {
@@ -74,7 +74,7 @@ static memcached_return_t ascii_exist(Memcached *memc, org::libmemcached::Instan
   return rc;
 }
 
-static memcached_return_t binary_exist(Memcached *memc, org::libmemcached::Instance* instance, const char *key, size_t key_length)
+static memcached_return_t binary_exist(Memcached *memc, memcached_instance_st* instance, const char *key, size_t key_length)
 {
   protocol_binary_request_set request= {};
   size_t send_length= sizeof(request.bytes);
@@ -144,7 +144,7 @@ memcached_return_t memcached_exist_by_key(memcached_st *shell,
   }
 
   uint32_t server_key= memcached_generate_hash_with_redistribution(memc, group_key, group_key_length);
-  org::libmemcached::Instance* instance= memcached_instance_fetch(memc, server_key);
+  memcached_instance_st* instance= memcached_instance_fetch(memc, server_key);
 
   if (memcached_is_binary(memc))
   {
diff --git a/libmemcached/fetch.cc b/libmemcached/fetch.cc
index 2843e973..f6fefe66 100644
--- a/libmemcached/fetch.cc
+++ b/libmemcached/fetch.cc
@@ -192,7 +192,7 @@ memcached_result_st *memcached_fetch_result(memcached_st *memc,
   }
 
   *error= MEMCACHED_MAXIMUM_RETURN; // We use this to see if we ever go into the loop
-  org::libmemcached::Instance *server;
+  memcached_instance_st *server;
   memcached_return_t read_ret= MEMCACHED_SUCCESS;
   while ((server= memcached_io_get_readable_server(memc, read_ret)))
   {
diff --git a/libmemcached/flush.cc b/libmemcached/flush.cc
index 521515ac..cbb66bfe 100644
--- a/libmemcached/flush.cc
+++ b/libmemcached/flush.cc
@@ -52,7 +52,7 @@ static memcached_return_t memcached_flush_binary(Memcached *ptr,
 
   for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
   {
-    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, x);
+    memcached_instance_st* instance= memcached_instance_fetch(ptr, x);
     initialize_binary_request(instance, request.message.header);
 
     if (reply)
@@ -84,7 +84,7 @@ static memcached_return_t memcached_flush_binary(Memcached *ptr,
 
   for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
   {
-    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, x);
+    memcached_instance_st* instance= memcached_instance_fetch(ptr, x);
 
     if (instance->response_count() > 0)
     {
@@ -115,7 +115,7 @@ static memcached_return_t memcached_flush_textual(Memcached *ptr,
   memcached_return_t rc= MEMCACHED_SUCCESS;
   for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
   {
-    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, x);
+    memcached_instance_st* instance= memcached_instance_fetch(ptr, x);
 
     libmemcached_io_vector_st vector[]=
     {
diff --git a/libmemcached/flush_buffers.cc b/libmemcached/flush_buffers.cc
index 3fa935c8..24f7c0df 100644
--- a/libmemcached/flush_buffers.cc
+++ b/libmemcached/flush_buffers.cc
@@ -46,7 +46,7 @@ memcached_return_t memcached_flush_buffers(memcached_st *shell)
 
     for (uint32_t x= 0; x < memcached_server_count(memc); ++x)
     {
-      org::libmemcached::Instance* instance= memcached_instance_fetch(memc, x);
+      memcached_instance_st* instance= memcached_instance_fetch(memc, x);
 
       if (instance->write_buffer_offset != 0) 
       {
diff --git a/libmemcached/get.cc b/libmemcached/get.cc
index 79e1d832..65a1dcad 100644
--- a/libmemcached/get.cc
+++ b/libmemcached/get.cc
@@ -2,7 +2,7 @@
  * 
  *  Libmemcached library
  *
- *  Copyright (C) 2011-2012 Data Differential, http://datadifferential.com/
+ *  Copyright (C) 2011-2013 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
@@ -50,13 +50,13 @@ char *memcached_get(memcached_st *ptr, const char *key,
                               flags, error);
 }
 
-static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
-                                                     const char *group_key,
-                                                     size_t group_key_length,
-                                                     const char * const *keys,
-                                                     const size_t *key_length,
-                                                     size_t number_of_keys,
-                                                     bool mget_mode);
+static memcached_return_t __mget_by_key_real(memcached_st *ptr,
+                                             const char *group_key,
+                                             size_t group_key_length,
+                                             const char * const *keys,
+                                             const size_t *key_length,
+                                             size_t number_of_keys,
+                                             const bool mget_mode);
 char *memcached_get_by_key(memcached_st *shell,
                            const char *group_key,
                            size_t group_key_length,
@@ -79,9 +79,9 @@ char *memcached_get_by_key(memcached_st *shell,
   }
 
   /* Request the key */
-  *error= memcached_mget_by_key_real(ptr, group_key, group_key_length,
-                                     (const char * const *)&key, &key_length, 
-                                     1, false);
+  *error= __mget_by_key_real(ptr, group_key, group_key_length,
+                             (const char * const *)&key, &key_length, 
+                             1, false);
   if (ptr)
   {
     assert_msg(ptr->query_id == query_id +1, "Programmer error, the query_id was not incremented.");
@@ -186,20 +186,20 @@ memcached_return_t memcached_mget(memcached_st *ptr,
 }
 
 static memcached_return_t binary_mget_by_key(memcached_st *ptr,
-                                             uint32_t master_server_key,
-                                             bool is_group_key_set,
+                                             const uint32_t master_server_key,
+                                             const bool is_group_key_set,
+                                             const char * const *keys,
+                                             const size_t *key_length,
+                                             const size_t number_of_keys,
+                                             const bool mget_mode);
+
+static memcached_return_t __mget_by_key_real(memcached_st *ptr,
+                                             const char *group_key,
+                                             const size_t group_key_length,
                                              const char * const *keys,
                                              const size_t *key_length,
                                              size_t number_of_keys,
-                                             bool mget_mode);
-
-static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
-                                                     const char *group_key,
-                                                     size_t group_key_length,
-                                                     const char * const *keys,
-                                                     const size_t *key_length,
-                                                     size_t number_of_keys,
-                                                     bool mget_mode)
+                                             const bool mget_mode)
 {
   bool failures_occured_in_sending= false;
   const char *get_command= "get";
@@ -244,7 +244,7 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
   */
   for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
   {
-    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, x);
+    memcached_instance_st* instance= memcached_instance_fetch(ptr, x);
 
     if (instance->response_count())
     {
@@ -293,7 +293,7 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
       server_key= memcached_generate_hash_with_redistribution(ptr, keys[x], key_length[x]);
     }
 
-    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, server_key);
+    memcached_instance_st* instance= memcached_instance_fetch(ptr, server_key);
 
     libmemcached_io_vector_st vector[]=
     {
@@ -354,7 +354,7 @@ static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr,
   bool success_happened= false;
   for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
   {
-    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, x);
+    memcached_instance_st* instance= memcached_instance_fetch(ptr, x);
 
     if (instance->response_count())
     {
@@ -393,8 +393,7 @@ memcached_return_t memcached_mget_by_key(memcached_st *shell,
                                          size_t number_of_keys)
 {
   Memcached* ptr= memcached2Memcached(shell);
-  return memcached_mget_by_key_real(ptr, group_key, group_key_length, keys,
-                                    key_length, number_of_keys, true);
+  return __mget_by_key_real(ptr, group_key, group_key_length, keys, key_length, number_of_keys, true);
 }
 
 memcached_return_t memcached_mget_execute(memcached_st *ptr,
@@ -449,15 +448,16 @@ memcached_return_t memcached_mget_execute_by_key(memcached_st *shell,
   rc= memcached_mget_by_key(ptr, group_key, group_key_length, keys,
                             key_length, number_of_keys);
   ptr->callbacks= original_callbacks;
+
   return rc;
 }
 
 static memcached_return_t simple_binary_mget(memcached_st *ptr,
-                                             uint32_t master_server_key,
+                                             const uint32_t master_server_key,
                                              bool is_group_key_set,
                                              const char * const *keys,
                                              const size_t *key_length,
-                                             size_t number_of_keys, bool mget_mode)
+                                             const size_t number_of_keys, const bool mget_mode)
 {
   memcached_return_t rc= MEMCACHED_NOTFOUND;
 
@@ -480,7 +480,7 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr,
       server_key= memcached_generate_hash_with_redistribution(ptr, keys[x], key_length[x]);
     }
 
-    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, server_key);
+    memcached_instance_st* instance= memcached_instance_fetch(ptr, server_key);
 
     if (instance->response_count() == 0)
     {
@@ -502,17 +502,17 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr,
       request.message.header.request.opcode= PROTOCOL_BINARY_CMD_GETK;
     }
 
-    memcached_return_t vk;
-    vk= memcached_validate_key_length(key_length[x],
-                                      ptr->flags.binary_protocol);
-    if (vk != MEMCACHED_SUCCESS)
     {
-      if (x > 0)
+      memcached_return_t vk= memcached_validate_key_length(key_length[x], ptr->flags.binary_protocol);
+      if (vk != MEMCACHED_SUCCESS)
       {
-        memcached_io_reset(instance);
-      }
+        if (x > 0)
+        {
+          memcached_io_reset(instance);
+        }
 
-      return vk;
+        return vk;
+      }
     }
 
     request.message.header.request.keylen= htons((uint16_t)(key_length[x] + memcached_array_size(ptr->_namespace)));
@@ -553,20 +553,13 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr,
 
     for (uint32_t x= 0; x < memcached_server_count(ptr); ++x)
     {
-      org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, x);
-      initialize_binary_request(instance, request.message.header);
+      memcached_instance_st* instance= memcached_instance_fetch(ptr, x);
 
       if (instance->response_count())
       {
-        if (memcached_io_write(instance) == false)
-        {
-          memcached_instance_response_reset(instance);
-          memcached_io_reset(instance);
-          rc= MEMCACHED_SOME_ERRORS;
-        }
-
-        if (memcached_io_write(instance, request.bytes,
-                               sizeof(request.bytes), true) == -1)
+        initialize_binary_request(instance, request.message.header);
+        if ((memcached_io_write(instance) == false) or
+            (memcached_io_write(instance, request.bytes, sizeof(request.bytes), true) == -1))
         {
           memcached_instance_response_reset(instance);
           memcached_io_reset(instance);
@@ -576,7 +569,6 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr,
     }
   }
 
-
   return rc;
 }
 
@@ -585,7 +577,7 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr,
                                                   bool* dead_servers,
                                                   const char *const *keys,
                                                   const size_t *key_length,
-                                                  size_t number_of_keys)
+                                                  const size_t number_of_keys)
 {
   memcached_return_t rc= MEMCACHED_NOTFOUND;
   uint32_t start= 0;
@@ -604,9 +596,11 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr,
     for (uint32_t x= 0; x < number_of_keys; ++x)
     {
       if (hash[x] == memcached_server_count(ptr))
+      {
         continue; /* Already successfully sent */
+      }
 
-      uint32_t server= hash[x] + replica;
+      uint32_t server= hash[x] +replica;
 
       /* In case of randomized reads */
       if (randomize_read and ((server + start) <= (hash[x] + ptr->number_of_replicas)))
@@ -624,7 +618,7 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr,
         continue;
       }
 
-      org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, server);
+      memcached_instance_st* instance= memcached_instance_fetch(ptr, server);
 
       if (instance->response_count() == 0)
       {
@@ -685,12 +679,12 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr,
 }
 
 static memcached_return_t binary_mget_by_key(memcached_st *ptr,
-                                             uint32_t master_server_key,
+                                             const uint32_t master_server_key,
                                              bool is_group_key_set,
                                              const char * const *keys,
                                              const size_t *key_length,
-                                             size_t number_of_keys,
-                                             bool mget_mode)
+                                             const size_t number_of_keys,
+                                             const bool mget_mode)
 {
   if (ptr->number_of_replicas == 0)
   {
diff --git a/libmemcached/hosts.cc b/libmemcached/hosts.cc
index 747245f9..121e8f7c 100644
--- a/libmemcached/hosts.cc
+++ b/libmemcached/hosts.cc
@@ -46,8 +46,8 @@ static memcached_return_t update_continuum(Memcached *ptr);
 
 static int compare_servers(const void *p1, const void *p2)
 {
-  memcached_server_instance_st a= (memcached_server_instance_st)p1;
-  memcached_server_instance_st b= (memcached_server_instance_st)p2;
+  const memcached_instance_st * a= (const memcached_instance_st *)p1;
+  const memcached_instance_st * b= (const memcached_instance_st *)p2;
 
   int return_value= strcmp(a->_hostname, b->_hostname);
 
@@ -63,7 +63,7 @@ static void sort_hosts(Memcached *ptr)
 {
   if (memcached_server_count(ptr))
   {
-    qsort(memcached_instance_list(ptr), memcached_server_count(ptr), sizeof(org::libmemcached::Instance), compare_servers);
+    qsort(memcached_instance_list(ptr), memcached_server_count(ptr), sizeof(memcached_instance_st), compare_servers);
   }
 }
 
@@ -146,7 +146,7 @@ static memcached_return_t update_continuum(Memcached *ptr)
     return memcached_set_errno(*ptr, errno, MEMCACHED_AT);
   }
 
-  org::libmemcached::Instance* list= memcached_instance_list(ptr);
+  memcached_instance_st* list= memcached_instance_list(ptr);
 
   /* count live servers (those without a retry delay set) */
   bool is_auto_ejecting= _is_auto_eject_host(ptr);
@@ -365,7 +365,7 @@ static memcached_return_t server_add(Memcached *memc,
   }
 
   uint32_t host_list_size= memc->number_of_hosts +1;
-  org::libmemcached::Instance* new_host_list= libmemcached_xrealloc(memc, memcached_instance_list(memc), host_list_size, org::libmemcached::Instance);
+  memcached_instance_st* new_host_list= libmemcached_xrealloc(memc, memcached_instance_list(memc), host_list_size, memcached_instance_st);
 
   if (new_host_list == NULL)
   {
@@ -376,7 +376,7 @@ static memcached_return_t server_add(Memcached *memc,
   assert(memc->number_of_hosts == host_list_size);
 
   /* TODO: Check return type */
-  org::libmemcached::Instance* instance= memcached_instance_fetch(memc, memcached_server_count(memc) -1);
+  memcached_instance_st* instance= memcached_instance_fetch(memc, memcached_server_count(memc) -1);
 
   if (__instance_create_with(memc, instance, hostname, port, weight, type) == NULL)
   {
@@ -409,7 +409,7 @@ memcached_return_t memcached_server_push(memcached_st *shell, const memcached_se
     uint32_t count= memcached_server_list_count(list);
     uint32_t host_list_size= count +original_host_size;
 
-    org::libmemcached::Instance* new_host_list= libmemcached_xrealloc(ptr, memcached_instance_list(ptr), host_list_size, org::libmemcached::Instance);
+    memcached_instance_st* new_host_list= libmemcached_xrealloc(ptr, memcached_instance_list(ptr), host_list_size, memcached_instance_st);
 
     if (new_host_list == NULL)
     {
@@ -424,7 +424,7 @@ memcached_return_t memcached_server_push(memcached_st *shell, const memcached_se
       WATCHPOINT_ASSERT(list[x].hostname[0] != 0);
 
       // We have extended the array, and now we will find it, and use it.
-      org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, original_host_size);
+      memcached_instance_st* instance= memcached_instance_fetch(ptr, original_host_size);
       WATCHPOINT_ASSERT(instance);
 
       memcached_string_t hostname= { memcached_string_make_from_cstr(list[x].hostname) };
@@ -449,7 +449,7 @@ memcached_return_t memcached_server_push(memcached_st *shell, const memcached_se
   return MEMCACHED_INVALID_ARGUMENTS;
 }
 
-memcached_return_t memcached_instance_push(memcached_st *ptr, const struct org::libmemcached::Instance* list, uint32_t number_of_hosts)
+memcached_return_t memcached_instance_push(memcached_st *ptr, const struct memcached_instance_st* list, uint32_t number_of_hosts)
 {
   if (list == NULL)
   {
@@ -458,7 +458,7 @@ memcached_return_t memcached_instance_push(memcached_st *ptr, const struct org::
 
   uint32_t original_host_size= memcached_server_count(ptr);
   uint32_t host_list_size= number_of_hosts +original_host_size;
-  org::libmemcached::Instance* new_host_list= libmemcached_xrealloc(ptr, memcached_instance_list(ptr), host_list_size, org::libmemcached::Instance);
+  memcached_instance_st* new_host_list= libmemcached_xrealloc(ptr, memcached_instance_list(ptr), host_list_size, memcached_instance_st);
 
   if (new_host_list == NULL)
   {
@@ -477,7 +477,7 @@ memcached_return_t memcached_instance_push(memcached_st *ptr, const struct org::
     WATCHPOINT_ASSERT(list[x]._hostname[0] != 0);
 
     // We have extended the array, and now we will find it, and use it.
-    org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, original_host_size);
+    memcached_instance_st* instance= memcached_instance_fetch(ptr, original_host_size);
     WATCHPOINT_ASSERT(instance);
 
     memcached_string_t hostname= { memcached_string_make_from_cstr(list[x]._hostname) };
diff --git a/libmemcached/include.am b/libmemcached/include.am
index a09a0066..c6e1c6d6 100644
--- a/libmemcached/include.am
+++ b/libmemcached/include.am
@@ -46,6 +46,7 @@ noinst_HEADERS+= libmemcached/udp.hpp
 noinst_HEADERS+= libmemcached/version.hpp 
 noinst_HEADERS+= libmemcached/virtual_bucket.h 
 noinst_HEADERS+= libmemcached/watchpoint.h
+noinst_HEADERS+= libmemcached/windows.hpp
 
 lib_LTLIBRARIES+= libmemcached/libmemcached.la
 EXTRA_libmemcached_libmemcached_la_DEPENDENCIES=
@@ -57,8 +58,8 @@ libmemcached_libmemcached_la_CXXFLAGS= -DBUILDING_LIBMEMCACHED
 if BUILD_WIN32
 libmemcached_libmemcached_la_CFLAGS+= -DBUILDING_HASHKIT
 libmemcached_libmemcached_la_CXXFLAGS+= -DBUILDING_HASHKIT
-libmemcached_libmemcached_la_LIBADD+= -lmingw64
-libmemcached_libmemcached_la_LIBADD+= -lws2_64
+libmemcached_libmemcached_la_LIBADD+= -lmingw32
+libmemcached_libmemcached_la_LIBADD+= -lws2_32
 endif
 
 libmemcached_libmemcached_la_SOURCES+= libmemcached/instance.cc
diff --git a/libmemcached/instance.cc b/libmemcached/instance.cc
index ca3a30d8..82621f7a 100644
--- a/libmemcached/instance.cc
+++ b/libmemcached/instance.cc
@@ -37,7 +37,7 @@
 
 #include <libmemcached/common.h>
 
-static inline void _server_init(org::libmemcached::Instance* self, Memcached *root,
+static inline void _server_init(memcached_instance_st* self, Memcached *root,
                                 const memcached_string_t& hostname,
                                 in_port_t port,
                                 uint32_t weight, memcached_connection_t type)
@@ -87,11 +87,11 @@ static inline void _server_init(org::libmemcached::Instance* self, Memcached *ro
   self->hostname(hostname);
 }
 
-static org::libmemcached::Instance* _server_create(org::libmemcached::Instance* self, const memcached_st *memc)
+static memcached_instance_st* _server_create(memcached_instance_st* self, const memcached_st *memc)
 {
   if (self == NULL)
   {
-   self= libmemcached_xmalloc(memc, org::libmemcached::Instance);
+   self= libmemcached_xmalloc(memc, memcached_instance_st);
 
     if (self == NULL)
     {
@@ -110,7 +110,7 @@ static org::libmemcached::Instance* _server_create(org::libmemcached::Instance*
   return self;
 }
 
-void org::libmemcached::Instance::events(short arg)
+void memcached_instance_st::events(short arg)
 {
   if ((_events | arg) == _events)
   {
@@ -120,7 +120,7 @@ void org::libmemcached::Instance::events(short arg)
   _events|= arg;
 }
 
-void org::libmemcached::Instance::revents(short arg)
+void memcached_instance_st::revents(short arg)
 {
   if (arg)
   {
@@ -131,8 +131,8 @@ void org::libmemcached::Instance::revents(short arg)
   _events&= short(~arg);
 }
 
-org::libmemcached::Instance* __instance_create_with(memcached_st *memc,
-                                                    org::libmemcached::Instance* self,
+memcached_instance_st* __instance_create_with(memcached_st *memc,
+                                                    memcached_instance_st* self,
                                                     const memcached_string_t& hostname,
                                                     const in_port_t port,
                                                     uint32_t weight, 
@@ -162,7 +162,7 @@ org::libmemcached::Instance* __instance_create_with(memcached_st *memc,
   return self;
 }
 
-void __instance_free(org::libmemcached::Instance* self)
+void __instance_free(memcached_instance_st* self)
 {
   memcached_quit_server(self, false);
 
@@ -181,7 +181,7 @@ void __instance_free(org::libmemcached::Instance* self)
   }
 }
 
-void memcached_instance_free(org::libmemcached::Instance* self)
+void memcached_instance_free(memcached_instance_st* self)
 {
   if (self)
   {
@@ -204,7 +204,7 @@ memcached_return_t memcached_server_cursor(const memcached_st* shell,
   size_t errors= 0;
   for (uint32_t x= 0; x < memcached_instance_list_count(memc); x++)
   {
-    org::libmemcached::Instance* instance= memcached_instance_by_position(memc, x);
+    memcached_instance_st* instance= memcached_instance_by_position(memc, x);
 
     for (uint32_t y= 0; y < number_of_callbacks; y++)
     {
@@ -233,7 +233,7 @@ memcached_return_t memcached_server_execute(memcached_st *memc,
   bool some_errors= false;;
   for (uint32_t x= 0; x < memcached_instance_list_count(memc); x++)
   {
-    org::libmemcached::Instance* instance= memcached_instance_fetch(memc, x);
+    memcached_instance_st* instance= memcached_instance_fetch(memc, x);
 
     memcached_return_t rc= (*callback)(memc, instance, context);
     if (rc == MEMCACHED_INVALID_ARGUMENTS)
@@ -250,7 +250,7 @@ memcached_return_t memcached_server_execute(memcached_st *memc,
   return MEMCACHED_SUCCESS;
 }
 
-memcached_server_instance_st memcached_server_by_key(memcached_st *shell,
+const memcached_instance_st * memcached_server_by_key(memcached_st *shell,
                                                      const char *key,
                                                      size_t key_length,
                                                      memcached_return_t *error)
@@ -283,7 +283,7 @@ memcached_server_instance_st memcached_server_by_key(memcached_st *shell,
 /*
   If we do not have a valid object to clone from, we toss an error.
 */
-static org::libmemcached::Instance* memcached_instance_clone(org::libmemcached::Instance* source)
+static memcached_instance_st* memcached_instance_clone(memcached_instance_st* source)
 {
   /* We just do a normal create if source is missing */
   if (source == NULL)
@@ -299,7 +299,7 @@ static org::libmemcached::Instance* memcached_instance_clone(org::libmemcached::
                                 source->type);
 }
 
-void set_last_disconnected_host(org::libmemcached::Instance* self)
+void set_last_disconnected_host(memcached_instance_st* self)
 {
   assert(self->root);
   if (self->root)
@@ -313,54 +313,48 @@ void set_last_disconnected_host(org::libmemcached::Instance* self)
     // const_cast
     memcached_st *root= (memcached_st *)self->root;
 
-    memcached_instance_free((org::libmemcached::Instance*)(root->last_disconnected_server));
+    memcached_instance_free((memcached_instance_st*)(root->last_disconnected_server));
 
     // We set is_parsing so that no lookup happens
     root->state.is_parsing= true;
     root->last_disconnected_server= memcached_instance_clone(self);
     root->state.is_parsing= false;
 
-    ((org::libmemcached::Instance*)memcached_server_get_last_disconnect(root))->version= self->version;
+    ((memcached_instance_st*)memcached_server_get_last_disconnect(root))->version= self->version;
   }
 }
 
-memcached_server_instance_st memcached_server_get_last_disconnect(const memcached_st *shell)
+const memcached_instance_st * memcached_server_get_last_disconnect(const memcached_st *shell)
 {
   const Memcached* self= memcached2Memcached(shell);
   if (self)
   {
-    return (memcached_server_instance_st)self->last_disconnected_server;
+    return (const memcached_instance_st *)self->last_disconnected_server;
   }
 
   return 0;
 }
 
-void memcached_instance_next_retry(memcached_server_instance_st self, const time_t absolute_time)
+void memcached_instance_next_retry(const memcached_instance_st * self, const time_t absolute_time)
 {
   WATCHPOINT_ASSERT(self);
   if (self)
   {
-    ((org::libmemcached::Instance*)self)->next_retry= absolute_time;
+    ((memcached_instance_st*)self)->next_retry= absolute_time;
   }
 }
 
-namespace org {
-namespace libmemcached {
-
-  bool Instance::valid() const
+bool memcached_instance_st::valid() const
+{
+  if (fd == INVALID_SOCKET)
   {
-    if (fd == INVALID_SOCKET)
-    {
-      return false;
-    }
-
-    return true;
+    return false;
   }
 
-  bool Instance::is_shutting_down() const
-  {
-    return options.is_shutting_down;
-  }
+  return true;
+}
 
-} // namespace libmemcached
-} // namespace org
+bool memcached_instance_st::is_shutting_down() const
+{
+  return options.is_shutting_down;
+}
diff --git a/libmemcached/instance.hpp b/libmemcached/instance.hpp
index d0a772b9..c76dc7ee 100644
--- a/libmemcached/instance.hpp
+++ b/libmemcached/instance.hpp
@@ -58,11 +58,8 @@
 
 #include "libmemcached/string.hpp"
 
-namespace org {
-namespace libmemcached {
-
 // @todo Complete class transformation
-struct Instance {
+struct memcached_instance_st {
   in_port_t port() const
   {
     return port_;
@@ -188,16 +185,13 @@ struct Instance {
   }
 };
 
-} // namespace libmemcached
-} // namespace org
-
-org::libmemcached::Instance* __instance_create_with(memcached_st *memc,
-                                                    org::libmemcached::Instance* self,
-                                                    const memcached_string_t& _hostname,
-                                                    const in_port_t port,
-                                                    uint32_t weight, 
-                                                    const memcached_connection_t type);
+memcached_instance_st* __instance_create_with(memcached_st *memc,
+                                              memcached_instance_st* self,
+                                              const memcached_string_t& _hostname,
+                                              const in_port_t port,
+                                              uint32_t weight, 
+                                              const memcached_connection_t type);
 
-memcached_return_t memcached_instance_push(memcached_st *ptr, const org::libmemcached::Instance*, uint32_t);
+memcached_return_t memcached_instance_push(memcached_st *ptr, const memcached_instance_st*, uint32_t);
 
-void __instance_free(org::libmemcached::Instance *);
+void __instance_free(memcached_instance_st *);
diff --git a/libmemcached/io.cc b/libmemcached/io.cc
index f6cc3696..cb8ed5c2 100644
--- a/libmemcached/io.cc
+++ b/libmemcached/io.cc
@@ -40,10 +40,10 @@
 #include <libmemcached/common.h>
 
 #ifdef HAVE_SYS_SOCKET_H
-#  include <sys/socket.h>
+# include <sys/socket.h>
 #endif
 
-void initialize_binary_request(org::libmemcached::Instance* server, protocol_binary_request_header& header)
+void initialize_binary_request(memcached_instance_st* server, protocol_binary_request_header& header)
 {
   server->request_id++;
   header.request.magic= PROTOCOL_BINARY_REQ;
@@ -61,7 +61,7 @@ enum memc_read_or_write {
  *
  * @param instance the server to pack
  */
-static bool repack_input_buffer(org::libmemcached::Instance* instance)
+static bool repack_input_buffer(memcached_instance_st* instance)
 {
   if (instance->read_ptr != instance->read_buffer)
   {
@@ -134,7 +134,7 @@ static bool repack_input_buffer(org::libmemcached::Instance* instance)
  * @param instance the server to star processing iput messages for
  * @return true if we processed anything, false otherwise
  */
-static bool process_input_buffer(org::libmemcached::Instance* instance)
+static bool process_input_buffer(memcached_instance_st* instance)
 {
   /*
    ** We might be able to process some of the response messages if we
@@ -176,7 +176,7 @@ static bool process_input_buffer(org::libmemcached::Instance* instance)
   return false;
 }
 
-static memcached_return_t io_wait(org::libmemcached::Instance* instance,
+static memcached_return_t io_wait(memcached_instance_st* instance,
                                   const memc_read_or_write read_or_write)
 {
   /*
@@ -212,7 +212,7 @@ static memcached_return_t io_wait(org::libmemcached::Instance* instance,
 
   if (instance->root->poll_timeout == 0) // Mimic 0 causes timeout behavior (not all platforms do this)
   {
-    return memcached_set_error(*instance, MEMCACHED_TIMEOUT, MEMCACHED_AT);
+    return memcached_set_error(*instance, MEMCACHED_TIMEOUT, MEMCACHED_AT, memcached_literal_param("poll_timeout() was set to zero"));
   }
 
   size_t loop_max= 5;
@@ -257,7 +257,7 @@ static memcached_return_t io_wait(org::libmemcached::Instance* instance,
 
     if (active_fd == 0)
     {
-      return memcached_set_error(*instance, MEMCACHED_TIMEOUT, MEMCACHED_AT);
+      return memcached_set_error(*instance, MEMCACHED_TIMEOUT, MEMCACHED_AT, memcached_literal_param("No active_fd were found"));
     }
 
     // Only an error should result in this code being called.
@@ -296,7 +296,7 @@ static memcached_return_t io_wait(org::libmemcached::Instance* instance,
                              memcached_literal_param("number of attempts to call io_wait() failed"));
 }
 
-static bool io_flush(org::libmemcached::Instance* instance,
+static bool io_flush(memcached_instance_st* instance,
                      const bool with_flush,
                      memcached_return_t& error)
 {
@@ -407,12 +407,12 @@ static bool io_flush(org::libmemcached::Instance* instance,
   return true;
 }
 
-memcached_return_t memcached_io_wait_for_write(org::libmemcached::Instance* instance)
+memcached_return_t memcached_io_wait_for_write(memcached_instance_st* instance)
 {
   return io_wait(instance, MEM_WRITE);
 }
 
-static memcached_return_t _io_fill(org::libmemcached::Instance* instance)
+static memcached_return_t _io_fill(memcached_instance_st* instance)
 {
   ssize_t data_read;
   do
@@ -488,7 +488,7 @@ static memcached_return_t _io_fill(org::libmemcached::Instance* instance)
   return MEMCACHED_SUCCESS;
 }
 
-memcached_return_t memcached_io_read(org::libmemcached::Instance* instance,
+memcached_return_t memcached_io_read(memcached_instance_st* instance,
                                      void *buffer, size_t length, ssize_t& nread)
 {
   assert(memcached_is_udp(instance->root) == false);
@@ -540,7 +540,7 @@ memcached_return_t memcached_io_read(org::libmemcached::Instance* instance,
   return MEMCACHED_SUCCESS;
 }
 
-memcached_return_t memcached_io_slurp(org::libmemcached::Instance* instance)
+memcached_return_t memcached_io_slurp(memcached_instance_st* instance)
 {
   assert_msg(instance, "Programmer error, invalid Instance");
   assert(memcached_is_udp(instance->root) == false);
@@ -597,7 +597,7 @@ memcached_return_t memcached_io_slurp(org::libmemcached::Instance* instance)
   return MEMCACHED_CONNECTION_FAILURE;
 }
 
-static bool _io_write(org::libmemcached::Instance* instance,
+static bool _io_write(memcached_instance_st* instance,
                       const void *buffer, size_t length, bool with_flush,
                       size_t& written)
 {
@@ -650,13 +650,13 @@ static bool _io_write(org::libmemcached::Instance* instance,
   return true;
 }
 
-bool memcached_io_write(org::libmemcached::Instance* instance)
+bool memcached_io_write(memcached_instance_st* instance)
 {
   size_t written;
   return _io_write(instance, NULL, 0, true, written);
 }
 
-ssize_t memcached_io_write(org::libmemcached::Instance* instance,
+ssize_t memcached_io_write(memcached_instance_st* instance,
                            const void *buffer, const size_t length, const bool with_flush)
 {
   size_t written;
@@ -669,7 +669,7 @@ ssize_t memcached_io_write(org::libmemcached::Instance* instance,
   return ssize_t(written);
 }
 
-bool memcached_io_writev(org::libmemcached::Instance* instance,
+bool memcached_io_writev(memcached_instance_st* instance,
                          libmemcached_io_vector_st vector[],
                          const size_t number_of, const bool with_flush)
 {
@@ -701,7 +701,7 @@ bool memcached_io_writev(org::libmemcached::Instance* instance,
   return (complete_total == total);
 }
 
-void org::libmemcached::Instance::start_close_socket()
+void memcached_instance_st::start_close_socket()
 {
   if (fd != INVALID_SOCKET)
   {
@@ -710,7 +710,7 @@ void org::libmemcached::Instance::start_close_socket()
   }
 }
 
-void org::libmemcached::Instance::reset_socket()
+void memcached_instance_st::reset_socket()
 {
   if (fd != INVALID_SOCKET)
   {
@@ -719,7 +719,7 @@ void org::libmemcached::Instance::reset_socket()
   }
 }
 
-void org::libmemcached::Instance::close_socket()
+void memcached_instance_st::close_socket()
 {
   if (fd != INVALID_SOCKET)
   {
@@ -755,7 +755,7 @@ void org::libmemcached::Instance::close_socket()
   major_version= minor_version= micro_version= UINT8_MAX;
 }
 
-org::libmemcached::Instance* memcached_io_get_readable_server(Memcached *memc, memcached_return_t&)
+memcached_instance_st* memcached_io_get_readable_server(Memcached *memc, memcached_return_t&)
 {
 #define MAX_SERVERS_TO_POLL 100
   struct pollfd fds[MAX_SERVERS_TO_POLL];
@@ -763,7 +763,7 @@ org::libmemcached::Instance* memcached_io_get_readable_server(Memcached *memc, m
 
   for (uint32_t x= 0; x < memcached_server_count(memc) and host_index < MAX_SERVERS_TO_POLL; ++x)
   {
-    org::libmemcached::Instance* instance= memcached_instance_fetch(memc, x);
+    memcached_instance_st* instance= memcached_instance_fetch(memc, x);
 
     if (instance->read_buffer_length > 0) /* I have data in the buffer */
     {
@@ -784,7 +784,7 @@ org::libmemcached::Instance* memcached_io_get_readable_server(Memcached *memc, m
     /* We have 0 or 1 server with pending events.. */
     for (uint32_t x= 0; x< memcached_server_count(memc); ++x)
     {
-      org::libmemcached::Instance* instance= memcached_instance_fetch(memc, x);
+      memcached_instance_st* instance= memcached_instance_fetch(memc, x);
 
       if (instance->response_count() > 0)
       {
@@ -811,7 +811,7 @@ org::libmemcached::Instance* memcached_io_get_readable_server(Memcached *memc, m
       {
         for (uint32_t y= 0; y < memcached_server_count(memc); ++y)
         {
-          org::libmemcached::Instance* instance= memcached_instance_fetch(memc, y);
+          memcached_instance_st* instance= memcached_instance_fetch(memc, y);
 
           if (instance->fd == fds[x].fd)
           {
@@ -828,7 +828,7 @@ org::libmemcached::Instance* memcached_io_get_readable_server(Memcached *memc, m
 /*
   Eventually we will just kill off the server with the problem.
 */
-void memcached_io_reset(org::libmemcached::Instance* instance)
+void memcached_io_reset(memcached_instance_st* instance)
 {
   memcached_quit_server(instance, true);
 }
@@ -837,7 +837,7 @@ void memcached_io_reset(org::libmemcached::Instance* instance)
  * Read a given number of bytes from the server and place it into a specific
  * buffer. Reset the IO channel on this server if an error occurs.
  */
-memcached_return_t memcached_safe_read(org::libmemcached::Instance* instance,
+memcached_return_t memcached_safe_read(memcached_instance_st* instance,
                                        void *dta,
                                        const size_t size)
 {
@@ -862,7 +862,7 @@ memcached_return_t memcached_safe_read(org::libmemcached::Instance* instance,
   return MEMCACHED_SUCCESS;
 }
 
-memcached_return_t memcached_io_readline(org::libmemcached::Instance* instance,
+memcached_return_t memcached_io_readline(memcached_instance_st* instance,
                                          char *buffer_ptr,
                                          size_t size,
                                          size_t& total_nr)
diff --git a/libmemcached/io.hpp b/libmemcached/io.hpp
index bf2133e8..f3fed345 100644
--- a/libmemcached/io.hpp
+++ b/libmemcached/io.hpp
@@ -38,35 +38,35 @@
 
 #pragma once
 
-void initialize_binary_request(org::libmemcached::Instance* server, protocol_binary_request_header&);
+void initialize_binary_request(memcached_instance_st* server, protocol_binary_request_header&);
 
-bool memcached_io_write(org::libmemcached::Instance* ptr);
+bool memcached_io_write(memcached_instance_st* ptr);
 
-ssize_t memcached_io_write(org::libmemcached::Instance* ptr,
+ssize_t memcached_io_write(memcached_instance_st* ptr,
                            const void *buffer, size_t length, bool with_flush);
 
-bool memcached_io_writev(org::libmemcached::Instance* ptr,
+bool memcached_io_writev(memcached_instance_st* ptr,
                          libmemcached_io_vector_st vector[],
                          const size_t number_of, const bool with_flush);
 
-memcached_return_t memcached_io_wait_for_write(org::libmemcached::Instance* ptr);
+memcached_return_t memcached_io_wait_for_write(memcached_instance_st* ptr);
 
-void memcached_io_reset(org::libmemcached::Instance* ptr);
+void memcached_io_reset(memcached_instance_st* ptr);
 
-memcached_return_t memcached_io_read(org::libmemcached::Instance* ptr,
+memcached_return_t memcached_io_read(memcached_instance_st* ptr,
                                      void *buffer, size_t length, ssize_t& nread);
 
 /* Read a line (terminated by '\n') into the buffer */
-memcached_return_t memcached_io_readline(org::libmemcached::Instance* ptr,
+memcached_return_t memcached_io_readline(memcached_instance_st* ptr,
                                          char *buffer_ptr,
                                          size_t size,
                                          size_t& total);
 
 /* Read n bytes of data from the server and store them in dta */
-memcached_return_t memcached_safe_read(org::libmemcached::Instance* ptr,
+memcached_return_t memcached_safe_read(memcached_instance_st* ptr,
                                        void *dta,
                                        const size_t size);
 
-org::libmemcached::Instance* memcached_io_get_readable_server(memcached_st *memc, memcached_return_t&);
+memcached_instance_st* memcached_io_get_readable_server(memcached_st *memc, memcached_return_t&);
 
-memcached_return_t memcached_io_slurp(org::libmemcached::Instance* ptr);
+memcached_return_t memcached_io_slurp(memcached_instance_st* ptr);
diff --git a/libmemcached/memcached.cc b/libmemcached/memcached.cc
index 41c058cd..e1519d1e 100644
--- a/libmemcached/memcached.cc
+++ b/libmemcached/memcached.cc
@@ -136,7 +136,7 @@ static void __memcached_free(Memcached *ptr, bool release_st)
 
   memcached_virtual_bucket_free(ptr);
 
-  memcached_instance_free((org::libmemcached::Instance*)ptr->last_disconnected_server);
+  memcached_instance_free((memcached_instance_st*)ptr->last_disconnected_server);
 
   if (ptr->on_cleanup)
   {
@@ -297,7 +297,7 @@ void memcached_reset_last_disconnected_server(memcached_st *shell)
   Memcached* self= memcached2Memcached(shell);
   if (self)
   {
-    memcached_instance_free((org::libmemcached::Instance*)self->last_disconnected_server);
+    memcached_instance_free((memcached_instance_st*)self->last_disconnected_server);
     self->last_disconnected_server= NULL;
   }
 }
@@ -432,10 +432,10 @@ void *memcached_set_user_data(memcached_st *shell, void *data)
 
 memcached_return_t memcached_push(memcached_st *destination, const memcached_st *source)
 {
-  return memcached_instance_push(destination, (org::libmemcached::Instance*)source->servers, source->number_of_hosts);
+  return memcached_instance_push(destination, (memcached_instance_st*)source->servers, source->number_of_hosts);
 }
 
-org::libmemcached::Instance* memcached_instance_fetch(Memcached *ptr, uint32_t server_key)
+memcached_instance_st* memcached_instance_fetch(Memcached *ptr, uint32_t server_key)
 {
   if (ptr == NULL)
   {
@@ -445,7 +445,7 @@ org::libmemcached::Instance* memcached_instance_fetch(Memcached *ptr, uint32_t s
   return &ptr->servers[server_key];
 }
 
-memcached_server_instance_st memcached_server_instance_by_position(const memcached_st *shell, uint32_t server_key)
+const memcached_instance_st * memcached_server_instance_by_position(const memcached_st *shell, uint32_t server_key)
 {
   const Memcached* memc= memcached2Memcached(shell);
   if (memc)
@@ -456,7 +456,7 @@ memcached_server_instance_st memcached_server_instance_by_position(const memcach
   return NULL;
 }
 
-org::libmemcached::Instance* memcached_instance_by_position(const memcached_st *shell, uint32_t server_key)
+memcached_instance_st* memcached_instance_by_position(const memcached_st *shell, uint32_t server_key)
 {
   const Memcached* memc= memcached2Memcached(shell);
   if (memc)
@@ -478,12 +478,12 @@ uint64_t memcached_query_id(const memcached_st *shell)
   return 0;
 }
 
-org::libmemcached::Instance* memcached_instance_list(const memcached_st *shell)
+memcached_instance_st* memcached_instance_list(const memcached_st *shell)
 {
   const Memcached* memc= memcached2Memcached(shell);
   if (memc)
   {
-    return (org::libmemcached::Instance*)memc->servers;
+    return (memcached_instance_st*)memc->servers;
   }
 
   return NULL;
diff --git a/libmemcached/parse.cc b/libmemcached/parse.cc
index 3284a4f6..7665b731 100644
--- a/libmemcached/parse.cc
+++ b/libmemcached/parse.cc
@@ -87,7 +87,13 @@ memcached_server_list_st memcached_servers_parse(const char *server_strings)
 
       ptr++;
 
+      errno= 0;
       port= (in_port_t) strtoul(ptr, (char **)NULL, 10);
+      if (errno != 0)
+      {
+        memcached_server_free(servers);
+        return NULL;
+      }
 
       ptr2= index(ptr, ' ');
       if (! ptr2)
@@ -96,14 +102,22 @@ memcached_server_list_st memcached_servers_parse(const char *server_strings)
       if (ptr2)
       {
         ptr2++;
-        weight = (uint32_t) strtoul(ptr2, (char **)NULL, 10);
+        errno= 0;
+        weight= uint32_t(strtoul(ptr2, (char **)NULL, 10));
+        if (errno != 0)
+        {
+          memcached_server_free(servers);
+          return NULL;
+        }
       }
     }
 
     servers= memcached_server_list_append_with_weight(servers, buffer, port, weight, &rc);
 
     if (isspace(*begin_ptr))
+    {
       begin_ptr++;
+    }
   }
 
   return servers;
diff --git a/libmemcached/poll.cc b/libmemcached/poll.cc
index abd15d4c..6fdf242c 100644
--- a/libmemcached/poll.cc
+++ b/libmemcached/poll.cc
@@ -12,7 +12,7 @@
 
 #include "libmemcached/common.h"
 
-#if defined(WIN32) || defined(__MINGW32__)
+#if defined(_WIN32)
 #include "libmemcached/poll.h"
 
 #include <sys/time.h>
@@ -31,7 +31,7 @@ int poll(struct pollfd fds[], nfds_t nfds, int tmo)
   {
     if (fds[x].events & (POLLIN | POLLOUT))
     {
-#ifndef WIN32
+#ifndef _WIN32
       if (fds[x].fd > maxfd)
       {
         maxfd= fds[x].fd;
@@ -82,4 +82,4 @@ int poll(struct pollfd fds[], nfds_t nfds, int tmo)
    return ret;
 }
 
-#endif // defined(WIN32) || defined(__MINGW32__)
+#endif // defined(_WIN32)
diff --git a/libmemcached/poll.h b/libmemcached/poll.h
index 8445f009..46636c40 100644
--- a/libmemcached/poll.h
+++ b/libmemcached/poll.h
@@ -12,7 +12,7 @@
 
 #pragma once
 
-#if defined(WIN32) || defined(__MINGW32__)
+#if defined(_WIN32)
 
 #include <winsock2.h>
 
@@ -22,7 +22,7 @@ extern "C" {
 
 typedef struct pollfd
 {
-#ifdef WIN32
+#if defined(_WIN32)
   SOCKET fd;
 #else
   int fd;
@@ -45,4 +45,4 @@ int poll(struct pollfd fds[], nfds_t nfds, int tmo);
 }
 #endif
 
-#endif // defined(WIN32) || defined(__MINGW32__)
+#endif // defined(_WIN32)
diff --git a/libmemcached/purge.cc b/libmemcached/purge.cc
index b1390d9c..5f6d4bb7 100644
--- a/libmemcached/purge.cc
+++ b/libmemcached/purge.cc
@@ -79,7 +79,7 @@ private:
   int32_t& _origin;
 };
 
-bool memcached_purge(org::libmemcached::Instance* ptr)
+bool memcached_purge(memcached_instance_st* ptr)
 {
   Memcached *root= (Memcached *)ptr->root;
 
diff --git a/libmemcached/quit.cc b/libmemcached/quit.cc
index 61930beb..7ece03b9 100644
--- a/libmemcached/quit.cc
+++ b/libmemcached/quit.cc
@@ -38,7 +38,7 @@
 #include <libmemcached/common.h>
 
 namespace {
-  memcached_return_t send_quit_message(org::libmemcached::Instance* instance)
+  memcached_return_t send_quit_message(memcached_instance_st* instance)
   {
     memcached_return_t rc;
     if (instance->root->flags.binary_protocol)
@@ -70,7 +70,7 @@ namespace {
     return rc;
   }
 
-  void drain_instance(org::libmemcached::Instance* instance)
+  void drain_instance(memcached_instance_st* instance)
   {
     /* read until socket is closed, or there is an error
      * closing the socket before all data is read
@@ -105,7 +105,7 @@ namespace {
   will force data to be completed.
 */
 
-void memcached_quit_server(org::libmemcached::Instance* instance, bool io_death)
+void memcached_quit_server(memcached_instance_st* instance, bool io_death)
 {
   if (instance->valid())
   {
@@ -130,7 +130,7 @@ void send_quit(Memcached *memc)
 {
   for (uint32_t x= 0; x < memcached_server_count(memc); x++)
   {
-    org::libmemcached::Instance* instance= memcached_instance_fetch(memc, x);
+    memcached_instance_st* instance= memcached_instance_fetch(memc, x);
 
     memcached_quit_server(instance, false);
   }
diff --git a/libmemcached/quit.hpp b/libmemcached/quit.hpp
index 76737b95..a48a8a7e 100644
--- a/libmemcached/quit.hpp
+++ b/libmemcached/quit.hpp
@@ -36,6 +36,6 @@
 
 #pragma once
 
-void memcached_quit_server(org::libmemcached::Instance* ptr, bool io_death);
+void memcached_quit_server(memcached_instance_st* ptr, bool io_death);
 
 void send_quit(memcached_st *ptr);
diff --git a/libmemcached/response.cc b/libmemcached/response.cc
index c3d7f2c8..f382671d 100644
--- a/libmemcached/response.cc
+++ b/libmemcached/response.cc
@@ -38,7 +38,7 @@
 #include <libmemcached/common.h>
 #include <libmemcached/string.hpp>
 
-static memcached_return_t textual_value_fetch(org::libmemcached::Instance* instance,
+static memcached_return_t textual_value_fetch(memcached_instance_st* instance,
                                               char *buffer,
                                               memcached_result_st *result)
 {
@@ -90,9 +90,11 @@ static memcached_return_t textual_value_fetch(org::libmemcached::Instance* insta
   }
 
   for (next_ptr= string_ptr; isdigit(*string_ptr); string_ptr++) {};
+
+  errno= 0;
   result->impl()->item_flags= (uint32_t) strtoul(next_ptr, &string_ptr, 10);
 
-  if (end_ptr == string_ptr)
+  if (errno != 0 or end_ptr == string_ptr)
   {
     goto read_error;
   }
@@ -105,9 +107,10 @@ static memcached_return_t textual_value_fetch(org::libmemcached::Instance* insta
   }
 
   for (next_ptr= string_ptr; isdigit(*string_ptr); string_ptr++) {};
+  errno= 0;
   value_length= (size_t)strtoull(next_ptr, &string_ptr, 10);
 
-  if (end_ptr == string_ptr)
+  if (errno != 0 or end_ptr == string_ptr)
   {
     goto read_error;
   }
@@ -121,11 +124,14 @@ static memcached_return_t textual_value_fetch(org::libmemcached::Instance* insta
   else
   {
     string_ptr++;
+
     for (next_ptr= string_ptr; isdigit(*string_ptr); string_ptr++) {};
+
+    errno= 0;
     result->impl()->item_cas= strtoull(next_ptr, &string_ptr, 10);
   }
 
-  if (end_ptr < string_ptr)
+  if (errno != 0 or end_ptr < string_ptr)
   {
     goto read_error;
   }
@@ -207,7 +213,7 @@ read_error:
   return MEMCACHED_PARTIAL_READ;
 }
 
-static memcached_return_t textual_read_one_response(org::libmemcached::Instance* instance,
+static memcached_return_t textual_read_one_response(memcached_instance_st* instance,
                                                     char *buffer, const size_t buffer_length,
                                                     memcached_result_st *result)
 {
@@ -238,8 +244,9 @@ static memcached_return_t textual_read_one_response(org::libmemcached::Instance*
         char *response_ptr= index(buffer, ' ');
 
         char *endptr;
+        errno= 0;
         long int version= strtol(response_ptr, &endptr, 10);
-        if (version == LONG_MIN or version == LONG_MAX or errno == EINVAL or version > UINT8_MAX or version == 0)
+        if (errno != 0 or version == LONG_MIN or version == LONG_MAX or version > UINT8_MAX or version == 0)
         {
           instance->major_version= instance->minor_version= instance->micro_version= UINT8_MAX;
           return memcached_set_error(*instance, MEMCACHED_UNKNOWN_READ_FAILURE, MEMCACHED_AT, memcached_literal_param("strtol() failed to parse major version"));
@@ -247,8 +254,9 @@ static memcached_return_t textual_read_one_response(org::libmemcached::Instance*
         instance->major_version= uint8_t(version);
 
         endptr++;
+        errno= 0;
         version= strtol(endptr, &endptr, 10);
-        if (version == LONG_MIN or version == LONG_MAX or errno == EINVAL or version > UINT8_MAX)
+        if (errno != 0 or version == LONG_MIN or version == LONG_MAX or version > UINT8_MAX)
         {
           instance->major_version= instance->minor_version= instance->micro_version= UINT8_MAX;
           return memcached_set_error(*instance, MEMCACHED_UNKNOWN_READ_FAILURE, MEMCACHED_AT, memcached_literal_param("strtol() failed to parse minor version"));
@@ -256,8 +264,9 @@ static memcached_return_t textual_read_one_response(org::libmemcached::Instance*
         instance->minor_version= uint8_t(version);
 
         endptr++;
+        errno= 0;
         version= strtol(endptr, &endptr, 10);
-        if (version == LONG_MIN or version == LONG_MAX or errno == EINVAL or version > UINT8_MAX)
+        if (errno != 0 or version == LONG_MIN or version == LONG_MAX or version > UINT8_MAX)
         {
           instance->major_version= instance->minor_version= instance->micro_version= UINT8_MAX;
           return memcached_set_error(*instance, MEMCACHED_UNKNOWN_READ_FAILURE, MEMCACHED_AT, memcached_literal_param("strtol() failed to parse micro version"));
@@ -442,6 +451,7 @@ static memcached_return_t textual_read_one_response(org::libmemcached::Instance*
   case '8': /* INCR/DECR response */
   case '9': /* INCR/DECR response */
     {
+      errno= 0;
       unsigned long long int auto_return_value= strtoull(buffer, (char **)NULL, 10);
 
       if (auto_return_value == ULLONG_MAX and errno == ERANGE)
@@ -456,6 +466,12 @@ static memcached_return_t textual_read_one_response(org::libmemcached::Instance*
         return memcached_set_error(*instance, MEMCACHED_UNKNOWN_READ_FAILURE, MEMCACHED_AT,
                                    memcached_literal_param("Numeric response was out of range"));
       }
+      else if (errno != 0)
+      {
+        result->impl()->numeric_value= UINT64_MAX;
+        return memcached_set_error(*instance, MEMCACHED_UNKNOWN_READ_FAILURE, MEMCACHED_AT,
+                                   memcached_literal_param("Numeric response was out of range"));
+      }
 
       result->impl()->numeric_value= uint64_t(auto_return_value);
 
@@ -480,7 +496,7 @@ static memcached_return_t textual_read_one_response(org::libmemcached::Instance*
                              buffer, total_read);
 }
 
-static memcached_return_t binary_read_one_response(org::libmemcached::Instance* instance,
+static memcached_return_t binary_read_one_response(memcached_instance_st* instance,
                                                    char *buffer, const size_t buffer_length,
                                                    memcached_result_st *result)
 {
@@ -620,8 +636,9 @@ static memcached_return_t binary_read_one_response(org::libmemcached::Instance*
         }
 
         char *endptr;
+        errno= 0;
         long int version= strtol(version_buffer, &endptr, 10);
-        if (version == LONG_MIN or version == LONG_MAX or errno == EINVAL or version > UINT8_MAX or version == 0)
+        if (errno != 0 or version == LONG_MIN or version == LONG_MAX or version > UINT8_MAX or version == 0)
         {
           instance->major_version= instance->minor_version= instance->micro_version= UINT8_MAX;
           return memcached_set_error(*instance, MEMCACHED_UNKNOWN_READ_FAILURE, MEMCACHED_AT, memcached_literal_param("strtol() failed to parse major version"));
@@ -629,8 +646,9 @@ static memcached_return_t binary_read_one_response(org::libmemcached::Instance*
         instance->major_version= uint8_t(version);
 
         endptr++;
+        errno= 0;
         version= strtol(endptr, &endptr, 10);
-        if (version == LONG_MIN or version == LONG_MAX or errno == EINVAL or version > UINT8_MAX)
+        if (errno != 0 or version == LONG_MIN or version == LONG_MAX or version > UINT8_MAX)
         {
           instance->major_version= instance->minor_version= instance->micro_version= UINT8_MAX;
           return memcached_set_error(*instance, MEMCACHED_UNKNOWN_READ_FAILURE, MEMCACHED_AT, memcached_literal_param("strtol() failed to parse minor version"));
@@ -638,8 +656,9 @@ static memcached_return_t binary_read_one_response(org::libmemcached::Instance*
         instance->minor_version= uint8_t(version);
 
         endptr++;
+        errno= 0;
         version= strtol(endptr, &endptr, 10);
-        if (version == LONG_MIN or version == LONG_MAX or errno == EINVAL or version > UINT8_MAX)
+        if (errno != 0 or version == LONG_MIN or version == LONG_MAX or version > UINT8_MAX)
         {
           instance->major_version= instance->minor_version= instance->micro_version= UINT8_MAX;
           return memcached_set_error(*instance, MEMCACHED_UNKNOWN_READ_FAILURE, MEMCACHED_AT, memcached_literal_param("strtol() failed to parse micro version"));
@@ -648,6 +667,25 @@ static memcached_return_t binary_read_one_response(org::libmemcached::Instance*
       }
       break;
 
+    case PROTOCOL_BINARY_CMD_TOUCH:
+      {
+        rc= MEMCACHED_SUCCESS;
+        if (bodylen == 4) // The four byte read is a bug?
+        {
+          char touch_buffer[4]; // @todo document this number
+          rc= memcached_safe_read(instance, touch_buffer, sizeof(touch_buffer));
+#if 0
+          fprintf(stderr, "%s:%d %d %d %d %d %.*s(%d)\n", __FILE__, __LINE__,
+                  int(touch_buffer[0]),
+                  int(touch_buffer[1]),
+                  int(touch_buffer[2]),
+                  int(touch_buffer[3]),
+                  int(bodylen), touch_buffer, int(bodylen));
+#endif
+        }
+        return memcached_set_error(*instance, rc, MEMCACHED_AT);
+      }
+
     case PROTOCOL_BINARY_CMD_FLUSH:
     case PROTOCOL_BINARY_CMD_QUIT:
     case PROTOCOL_BINARY_CMD_SET:
@@ -656,13 +694,8 @@ static memcached_return_t binary_read_one_response(org::libmemcached::Instance*
     case PROTOCOL_BINARY_CMD_APPEND:
     case PROTOCOL_BINARY_CMD_PREPEND:
     case PROTOCOL_BINARY_CMD_DELETE:
-    case PROTOCOL_BINARY_CMD_TOUCH:
       {
-        if (bodylen != 0)
-        {
-          char touch_buffer[32]; // @todo document this number
-          rc= memcached_safe_read(instance, buffer, sizeof(touch_buffer));
-        }
+        WATCHPOINT_ASSERT(bodylen == 0);
         return MEMCACHED_SUCCESS;
       }
 
@@ -801,7 +834,7 @@ static memcached_return_t binary_read_one_response(org::libmemcached::Instance*
   return rc;
 }
 
-static memcached_return_t _read_one_response(org::libmemcached::Instance* instance,
+static memcached_return_t _read_one_response(memcached_instance_st* instance,
                                              char *buffer, const size_t buffer_length,
                                              memcached_result_st *result)
 {
@@ -831,7 +864,7 @@ static memcached_return_t _read_one_response(org::libmemcached::Instance* instan
   return rc;
 }
 
-memcached_return_t memcached_read_one_response(org::libmemcached::Instance* instance,
+memcached_return_t memcached_read_one_response(memcached_instance_st* instance,
                                                memcached_result_st *result)
 {
   char buffer[SMALL_STRING_LEN];
@@ -845,7 +878,7 @@ memcached_return_t memcached_read_one_response(org::libmemcached::Instance* inst
   return _read_one_response(instance, buffer, sizeof(buffer), result);
 }
 
-memcached_return_t memcached_response(org::libmemcached::Instance* instance,
+memcached_return_t memcached_response(memcached_instance_st* instance,
                                       memcached_result_st *result)
 {
   char buffer[1024];
@@ -853,7 +886,7 @@ memcached_return_t memcached_response(org::libmemcached::Instance* instance,
   return memcached_response(instance, buffer, sizeof(buffer), result);
 }
 
-memcached_return_t memcached_response(org::libmemcached::Instance* instance,
+memcached_return_t memcached_response(memcached_instance_st* instance,
                                       char *buffer, size_t buffer_length,
                                       memcached_result_st *result)
 {
diff --git a/libmemcached/response.h b/libmemcached/response.h
index 6d6d5644..c066f3b3 100644
--- a/libmemcached/response.h
+++ b/libmemcached/response.h
@@ -38,12 +38,12 @@
 #pragma once
 
 /* Read a single response from the server */
-memcached_return_t memcached_read_one_response(org::libmemcached::Instance* ptr,
+memcached_return_t memcached_read_one_response(memcached_instance_st* ptr,
                                                memcached_result_st *result);
 
-memcached_return_t memcached_response(org::libmemcached::Instance* ptr,
+memcached_return_t memcached_response(memcached_instance_st* ptr,
                                       memcached_result_st *result);
 
-memcached_return_t memcached_response(org::libmemcached::Instance* ptr,
+memcached_return_t memcached_response(memcached_instance_st* ptr,
                                       char *buffer, size_t buffer_length,
                                       memcached_result_st *result);
diff --git a/libmemcached/sasl.cc b/libmemcached/sasl.cc
index 8e180d6f..ee225868 100644
--- a/libmemcached/sasl.cc
+++ b/libmemcached/sasl.cc
@@ -75,7 +75,7 @@ sasl_callback_t *memcached_get_sasl_callbacks(memcached_st *shell)
  * @param raddr remote address (out)
  * @return true on success false otherwise (errno contains more info)
  */
-static memcached_return_t resolve_names(org::libmemcached::Instance& server, char *laddr, size_t laddr_length, char *raddr, size_t raddr_length)
+static memcached_return_t resolve_names(memcached_instance_st& server, char *laddr, size_t laddr_length, char *raddr, size_t raddr_length)
 {
   char host[MEMCACHED_NI_MAXHOST];
   char port[MEMCACHED_NI_MAXSERV];
@@ -133,7 +133,7 @@ static void sasl_startup_function(void)
 
 } // extern "C"
 
-memcached_return_t memcached_sasl_authenticate_connection(org::libmemcached::Instance* server)
+memcached_return_t memcached_sasl_authenticate_connection(memcached_instance_st* server)
 {
   if (LIBMEMCACHED_WITH_SASL_SUPPORT == 0)
   {
diff --git a/libmemcached/sasl.hpp b/libmemcached/sasl.hpp
index c990cfb8..bda6b227 100644
--- a/libmemcached/sasl.hpp
+++ b/libmemcached/sasl.hpp
@@ -39,4 +39,4 @@
 
 memcached_return_t memcached_clone_sasl(memcached_st *clone, const  memcached_st *source);
 
-memcached_return_t memcached_sasl_authenticate_connection(org::libmemcached::Instance* server);
+memcached_return_t memcached_sasl_authenticate_connection(memcached_instance_st* server);
diff --git a/libmemcached/server.cc b/libmemcached/server.cc
index ba40a6ee..b38120ad 100644
--- a/libmemcached/server.cc
+++ b/libmemcached/server.cc
@@ -191,7 +191,7 @@ uint32_t memcached_server_count(const memcached_st *self)
   return self->number_of_hosts;
 }
 
-const char *memcached_server_name(const memcached_server_instance_st self)
+const char *memcached_server_name(const memcached_instance_st * self)
 {
   WATCHPOINT_ASSERT(self);
   if (self)
@@ -202,7 +202,7 @@ const char *memcached_server_name(const memcached_server_instance_st self)
   return NULL;
 }
 
-in_port_t memcached_server_port(const memcached_server_instance_st self)
+in_port_t memcached_server_port(const memcached_instance_st * self)
 {
   WATCHPOINT_ASSERT(self);
   if (self == NULL)
@@ -213,7 +213,7 @@ in_port_t memcached_server_port(const memcached_server_instance_st self)
   return self->port();
 }
 
-uint32_t memcached_server_response_count(const memcached_server_instance_st self)
+uint32_t memcached_server_response_count(const memcached_instance_st * self)
 {
   WATCHPOINT_ASSERT(self);
   if (self == NULL)
@@ -224,7 +224,7 @@ uint32_t memcached_server_response_count(const memcached_server_instance_st self
   return self->cursor_active_;
 }
 
-const char *memcached_server_type(const memcached_server_instance_st ptr)
+const char *memcached_server_type(const memcached_instance_st * ptr)
 {
   if (ptr)
   {
@@ -244,7 +244,7 @@ const char *memcached_server_type(const memcached_server_instance_st ptr)
   return "UNKNOWN";
 }
 
-uint8_t memcached_server_major_version(const memcached_server_instance_st instance)
+uint8_t memcached_server_major_version(const memcached_instance_st * instance)
 {
   if (instance)
   {
@@ -254,7 +254,7 @@ uint8_t memcached_server_major_version(const memcached_server_instance_st instan
   return UINT8_MAX;
 }
 
-uint8_t memcached_server_minor_version(const memcached_server_instance_st instance)
+uint8_t memcached_server_minor_version(const memcached_instance_st * instance)
 {
   if (instance)
   {
@@ -264,7 +264,7 @@ uint8_t memcached_server_minor_version(const memcached_server_instance_st instan
   return UINT8_MAX;
 }
 
-uint8_t memcached_server_micro_version(const memcached_server_instance_st instance)
+uint8_t memcached_server_micro_version(const memcached_instance_st * instance)
 {
   if (instance)
   {
diff --git a/libmemcached/server.hpp b/libmemcached/server.hpp
index 8cbdc151..0c6ac798 100644
--- a/libmemcached/server.hpp
+++ b/libmemcached/server.hpp
@@ -68,11 +68,11 @@ static inline bool memcached_is_valid_filename(const memcached_string_t& arg)
   return arg.c_str != NULL and arg.size > 0 and arg.size < MEMCACHED_NI_MAXHOST;
 }
 
-void memcached_instance_free(org::libmemcached::Instance *);
+void memcached_instance_free(memcached_instance_st *);
 
-void set_last_disconnected_host(org::libmemcached::Instance* self);
+void set_last_disconnected_host(memcached_instance_st* self);
 
-static inline void memcached_mark_server_for_timeout(org::libmemcached::Instance* server)
+static inline void memcached_mark_server_for_timeout(memcached_instance_st* server)
 {
   if (server->state != MEMCACHED_SERVER_STATE_IN_TIMEOUT)
   {
diff --git a/libmemcached/server_instance.h b/libmemcached/server_instance.h
index 3b69b77b..187f2744 100644
--- a/libmemcached/server_instance.h
+++ b/libmemcached/server_instance.h
@@ -38,8 +38,7 @@
 #pragma once
 
 #ifdef __cplusplus
-namespace org { namespace libmemcached { struct Instance; } }
-typedef struct org::libmemcached::Instance* memcached_server_write_instance_st;
+typedef struct memcached_instance_st* memcached_server_write_instance_st;
 #else
 typedef void* memcached_server_write_instance_st;
 #endif
diff --git a/libmemcached/server_list.cc b/libmemcached/server_list.cc
index b42a9095..b5d5b72e 100644
--- a/libmemcached/server_list.cc
+++ b/libmemcached/server_list.cc
@@ -127,7 +127,7 @@ uint32_t memcached_instance_list_count(const memcached_st* self)
     : self->number_of_hosts;
 }
 
-void memcached_instance_set(memcached_st* memc, org::libmemcached::Instance* list, const uint32_t host_list_size)
+void memcached_instance_set(memcached_st* memc, memcached_instance_st* list, const uint32_t host_list_size)
 {
   assert(memc);
   memc->servers= list;
@@ -148,7 +148,7 @@ void memcached_server_list_free(memcached_server_list_st self)
   }
 }
 
-void memcached_instance_list_free(org::libmemcached::Instance* self, uint32_t instance_count)
+void memcached_instance_list_free(memcached_instance_st* self, uint32_t instance_count)
 {
   if (self)
   {
diff --git a/libmemcached/server_list.hpp b/libmemcached/server_list.hpp
index ffbb6a36..0280332c 100644
--- a/libmemcached/server_list.hpp
+++ b/libmemcached/server_list.hpp
@@ -36,12 +36,12 @@
 
 #pragma once
 
-org::libmemcached::Instance* memcached_instance_list(const memcached_st *);
+memcached_instance_st* memcached_instance_list(const memcached_st *);
 
 uint32_t memcached_instance_list_count(const memcached_st*);
 
 uint32_t memcached_servers_set_count(memcached_server_list_st servers, uint32_t count);
 
-void memcached_instance_list_free(org::libmemcached::Instance* self, uint32_t count);
+void memcached_instance_list_free(memcached_instance_st* self, uint32_t count);
 
-void memcached_instance_set(memcached_st*, org::libmemcached::Instance*, const uint32_t host_list_size);
+void memcached_instance_set(memcached_st*, memcached_instance_st*, const uint32_t host_list_size);
diff --git a/libmemcached/stats.cc b/libmemcached/stats.cc
index 89d5be52..d70972ef 100644
--- a/libmemcached/stats.cc
+++ b/libmemcached/stats.cc
@@ -2,7 +2,7 @@
  * 
  *  Libmemcached library
  *
- *  Copyright (C) 2011 Data Differential, http://datadifferential.com/
+ *  Copyright (C) 2011-2013 Data Differential, http://datadifferential.com/
  *
  *  Redistribution and use in source and binary forms, with or without
  *  modification, are permitted provided that the following conditions are
@@ -91,7 +91,12 @@ static memcached_return_t set_data(memcached_stat_st *memc_stat, const char *key
   }
   else if (strcmp("pid", key) == 0)
   {
+    errno= 0;
     int64_t temp= strtoll(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
 
     if (temp <= INT32_MAX and ( sizeof(pid_t) == sizeof(int32_t) ))
     {
@@ -109,11 +114,21 @@ static memcached_return_t set_data(memcached_stat_st *memc_stat, const char *key
   }
   else if (not strcmp("uptime", key))
   {
+    errno= 0;
     memc_stat->uptime= strtoul(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("time", key))
   {
+    errno= 0;
     memc_stat->time= strtoul(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("version", key))
   {
@@ -122,7 +137,12 @@ static memcached_return_t set_data(memcached_stat_st *memc_stat, const char *key
   }
   else if (not strcmp("pointer_size", key))
   {
+    errno= 0;
     memc_stat->pointer_size= strtoul(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("rusage_user", key))
   {
@@ -130,8 +150,20 @@ static memcached_return_t set_data(memcached_stat_st *memc_stat, const char *key
     for (walk_ptr= (char*)value; (!ispunct(*walk_ptr)); walk_ptr++) {};
     *walk_ptr= 0;
     walk_ptr++;
+
+    errno= 0;
     memc_stat->rusage_user_seconds= strtoul(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
+
+    errno= 0;
     memc_stat->rusage_user_microseconds= strtoul(walk_ptr, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("rusage_system", key))
   {
@@ -139,85 +171,172 @@ static memcached_return_t set_data(memcached_stat_st *memc_stat, const char *key
     for (walk_ptr= (char*)value; (!ispunct(*walk_ptr)); walk_ptr++) {};
     *walk_ptr= 0;
     walk_ptr++;
+
+    errno= 0;
     memc_stat->rusage_system_seconds= strtoul(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
+
+    errno= 0;
     memc_stat->rusage_system_microseconds= strtoul(walk_ptr, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("curr_items", key))
   {
+    errno= 0;
     memc_stat->curr_items= strtoul(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("total_items", key))
   {
+    errno= 0;
     memc_stat->total_items= strtoul(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("bytes_read", key))
   {
+    errno= 0;
     memc_stat->bytes_read= strtoull(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("bytes_written", key))
   {
+    errno= 0;
     memc_stat->bytes_written= strtoull(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("bytes", key))
   {
+    errno= 0;
     memc_stat->bytes= strtoull(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("curr_connections", key))
   {
+    errno= 0;
     memc_stat->curr_connections= strtoull(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("total_connections", key))
   {
+    errno= 0;
     memc_stat->total_connections= strtoull(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("connection_structures", key))
   {
+    errno= 0;
     memc_stat->connection_structures= strtoul(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("cmd_get", key))
   {
+    errno= 0;
     memc_stat->cmd_get= strtoull(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("cmd_set", key))
   {
+    errno= 0;
     memc_stat->cmd_set= strtoull(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("get_hits", key))
   {
+    errno= 0;
     memc_stat->get_hits= strtoull(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("get_misses", key))
   {
+    errno= 0;
     memc_stat->get_misses= strtoull(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("evictions", key))
   {
+    errno= 0;
     memc_stat->evictions= strtoull(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("limit_maxbytes", key))
   {
+    errno= 0;
     memc_stat->limit_maxbytes= strtoull(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
   else if (not strcmp("threads", key))
   {
+    errno= 0;
     memc_stat->threads= strtoul(value, (char **)NULL, 10);
+    if (errno != 0)
+    {
+      return MEMCACHED_FAILURE;
+    }
   }
-  else if (not (strcmp("delete_misses", key) == 0 or /* New stats in the 1.3 beta */
-                strcmp("delete_hits", key) == 0 or /* Just swallow them for now.. */
-                strcmp("incr_misses", key) == 0 or
-                strcmp("incr_hits", key) == 0 or
-                strcmp("decr_misses", key) == 0 or
-                strcmp("decr_hits", key) == 0 or
-                strcmp("cas_misses", key) == 0 or
-                strcmp("cas_hits", key) == 0 or
-                strcmp("cas_badval", key) == 0 or
-                strcmp("cmd_flush", key) == 0 or
-                strcmp("accepting_conns", key) == 0 or
-                strcmp("listen_disabled_num", key) == 0 or
-                strcmp("conn_yields", key) == 0 or
-                strcmp("auth_cmds", key) == 0 or
-                strcmp("auth_errors", key) == 0 or
-                strcmp("reclaimed", key) == 0))
+  else if ((strcmp("delete_misses", key) == 0 or /* New stats in the 1.3 beta */
+            strcmp("delete_hits", key) == 0 or /* Just swallow them for now.. */
+            strcmp("incr_misses", key) == 0 or
+            strcmp("incr_hits", key) == 0 or
+            strcmp("decr_misses", key) == 0 or
+            strcmp("decr_hits", key) == 0 or
+            strcmp("cas_misses", key) == 0 or
+            strcmp("cas_hits", key) == 0 or
+            strcmp("cas_badval", key) == 0 or
+            strcmp("cmd_flush", key) == 0 or
+            strcmp("accepting_conns", key) == 0 or
+            strcmp("listen_disabled_num", key) == 0 or
+            strcmp("conn_yields", key) == 0 or
+            strcmp("auth_cmds", key) == 0 or
+            strcmp("auth_errors", key) == 0 or
+            strcmp("reclaimed", key) == 0) == 0)
   {
     WATCHPOINT_STRING(key);
     /* return MEMCACHED_UNKNOWN_STAT_KEY; */
@@ -358,7 +477,7 @@ char *memcached_stat_get_value(const memcached_st *, memcached_stat_st *memc_sta
 static memcached_return_t binary_stats_fetch(memcached_stat_st *memc_stat,
                                              const char *args,
                                              const size_t args_length,
-                                             org::libmemcached::Instance* instance,
+                                             memcached_instance_st* instance,
                                              struct local_context *check)
 {
   char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
@@ -448,7 +567,7 @@ static memcached_return_t binary_stats_fetch(memcached_stat_st *memc_stat,
 static memcached_return_t ascii_stats_fetch(memcached_stat_st *memc_stat,
                                             const char *args,
                                             const size_t args_length,
-                                            org::libmemcached::Instance* instance,
+                                            memcached_instance_st* instance,
                                             struct local_context *check)
 {
   libmemcached_io_vector_st vector[]=
@@ -565,7 +684,7 @@ memcached_stat_st *memcached_stat(memcached_st *shell, char *args, memcached_ret
     stat_instance->pid= -1;
     stat_instance->root= self;
 
-    org::libmemcached::Instance* instance= memcached_instance_fetch(self, x);
+    memcached_instance_st* instance= memcached_instance_fetch(self, x);
 
     memcached_return_t temp_return;
     if (memcached_is_binary(self))
@@ -632,7 +751,7 @@ memcached_return_t memcached_stat_servername(memcached_stat_st *memc_stat, char
 
     if (memcached_success(rc))
     {
-      org::libmemcached::Instance* instance= memcached_instance_fetch(memc_ptr, 0);
+      memcached_instance_st* instance= memcached_instance_fetch(memc_ptr, 0);
       if (memc.flags.binary_protocol)
       {
         rc= binary_stats_fetch(memc_stat, args, args_length, instance, NULL);
@@ -694,7 +813,7 @@ void memcached_stat_free(const memcached_st *, memcached_stat_st *memc_stat)
 }
 
 static memcached_return_t call_stat_fn(memcached_st *memc,
-                                       org::libmemcached::Instance* instance,
+                                       memcached_instance_st* instance,
                                        void *context)
 {
   if (memc)
diff --git a/libmemcached/storage.cc b/libmemcached/storage.cc
index 558d2ed5..80b5a7f1 100644
--- a/libmemcached/storage.cc
+++ b/libmemcached/storage.cc
@@ -139,7 +139,7 @@ static inline uint8_t get_com_code(const memcached_storage_action_t verb, const
 }
 
 static memcached_return_t memcached_send_binary(Memcached *ptr,
-                                                org::libmemcached::Instance* server,
+                                                memcached_instance_st* server,
                                                 uint32_t server_key,
                                                 const char *key,
                                                 const size_t key_length,
@@ -218,7 +218,7 @@ static memcached_return_t memcached_send_binary(Memcached *ptr,
         server_key= 0;
       }
 
-      org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, server_key);
+      memcached_instance_st* instance= memcached_instance_fetch(ptr, server_key);
 
       if (memcached_vdo(instance, vector, 5, false) != MEMCACHED_SUCCESS)
       {
@@ -246,7 +246,7 @@ static memcached_return_t memcached_send_binary(Memcached *ptr,
 }
 
 static memcached_return_t memcached_send_ascii(Memcached *ptr,
-                                               org::libmemcached::Instance* instance,
+                                               memcached_instance_st* instance,
                                                const char *key,
                                                const size_t key_length,
                                                const char *value,
@@ -373,7 +373,7 @@ static inline memcached_return_t memcached_send(memcached_st *shell,
   }
 
   uint32_t server_key= memcached_generate_hash_with_redistribution(ptr, group_key, group_key_length);
-  org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, server_key);
+  memcached_instance_st* instance= memcached_instance_fetch(ptr, server_key);
 
   WATCHPOINT_SET(instance->io_wait_count.read= 0);
   WATCHPOINT_SET(instance->io_wait_count.write= 0);
diff --git a/libmemcached/touch.cc b/libmemcached/touch.cc
index 0c24aed1..1f793c55 100644
--- a/libmemcached/touch.cc
+++ b/libmemcached/touch.cc
@@ -38,7 +38,7 @@
 #include <libmemcached/common.h>
 #include <libmemcached/memcached/protocol_binary.h>
 
-static memcached_return_t ascii_touch(org::libmemcached::Instance* instance,
+static memcached_return_t ascii_touch(memcached_instance_st* instance,
                                       const char *key, size_t key_length,
                                       time_t expiration)
 {
@@ -70,7 +70,7 @@ static memcached_return_t ascii_touch(org::libmemcached::Instance* instance,
   return rc;
 }
 
-static memcached_return_t binary_touch(org::libmemcached::Instance* instance,
+static memcached_return_t binary_touch(memcached_instance_st* instance,
                                        const char *key, size_t key_length,
                                        time_t expiration)
 {
@@ -130,7 +130,7 @@ memcached_return_t memcached_touch_by_key(memcached_st *shell,
   }
 
   uint32_t server_key= memcached_generate_hash_with_redistribution(ptr, group_key, group_key_length);
-  org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, server_key);
+  memcached_instance_st* instance= memcached_instance_fetch(ptr, server_key);
 
   if (ptr->flags.binary_protocol)
   {
diff --git a/libmemcached/udp.cc b/libmemcached/udp.cc
index 923e2734..5d21f9ff 100644
--- a/libmemcached/udp.cc
+++ b/libmemcached/udp.cc
@@ -48,7 +48,7 @@
  * extracts the message number from message_id, increments it and then
  * writes the new value back into the header
  */
-void increment_udp_message_id(org::libmemcached::Instance* ptr)
+void increment_udp_message_id(memcached_instance_st* ptr)
 {
   struct udp_datagram_header_st *header= (struct udp_datagram_header_st *)ptr->write_buffer;
   uint16_t cur_req= get_udp_datagram_request_id(header);
@@ -61,7 +61,7 @@ void increment_udp_message_id(org::libmemcached::Instance* ptr)
   header->request_id= htons((uint16_t) (thread_id | msg_num));
 }
 
-bool memcached_io_init_udp_header(org::libmemcached::Instance* ptr, const uint16_t thread_id)
+bool memcached_io_init_udp_header(memcached_instance_st* ptr, const uint16_t thread_id)
 {
   if (thread_id > UDP_REQUEST_ID_MAX_THREAD_ID)
   {
diff --git a/libmemcached/udp.hpp b/libmemcached/udp.hpp
index b2d2e9e9..7442c597 100644
--- a/libmemcached/udp.hpp
+++ b/libmemcached/udp.hpp
@@ -55,5 +55,5 @@ struct udp_datagram_header_st
   uint16_t reserved;
 };
 
-bool memcached_io_init_udp_header(org::libmemcached::Instance*, const uint16_t thread_id);
-void increment_udp_message_id(org::libmemcached::Instance*);
+bool memcached_io_init_udp_header(memcached_instance_st*, const uint16_t thread_id);
+void increment_udp_message_id(memcached_instance_st*);
diff --git a/libmemcached/verbosity.cc b/libmemcached/verbosity.cc
index 7f3a16e4..ed0e2440 100644
--- a/libmemcached/verbosity.cc
+++ b/libmemcached/verbosity.cc
@@ -44,7 +44,7 @@ struct context_st
 };
 
 static memcached_return_t _set_verbosity(const Memcached *,
-                                         const memcached_server_instance_st server,
+                                         const memcached_instance_st * server,
                                          void *context)
 {
  libmemcached_io_vector_st *vector= (libmemcached_io_vector_st *)context;
@@ -56,7 +56,7 @@ static memcached_return_t _set_verbosity(const Memcached *,
 
   if (rc == MEMCACHED_SUCCESS)
   {
-    org::libmemcached::Instance* instance= memcached_instance_fetch(memc_ptr, 0);
+    memcached_instance_st* instance= memcached_instance_fetch(memc_ptr, 0);
 
 
     rc= memcached_vdo(instance, vector, 4, true);
diff --git a/libmemcached/version.cc b/libmemcached/version.cc
index bbe46cc5..5f074912 100644
--- a/libmemcached/version.cc
+++ b/libmemcached/version.cc
@@ -52,7 +52,7 @@ static inline memcached_return_t memcached_version_textual(Memcached *memc)
   bool errors_happened= false;
   for (uint32_t x= 0; x < memcached_server_count(memc); x++)
   {
-    org::libmemcached::Instance* instance= memcached_instance_fetch(memc, x);
+    memcached_instance_st* instance= memcached_instance_fetch(memc, x);
 
     // Optimization, we only fetch version once.
     if (instance->major_version != UINT8_MAX)
@@ -73,7 +73,7 @@ static inline memcached_return_t memcached_version_textual(Memcached *memc)
   if (success)
   {
     // Collect the returned items
-    org::libmemcached::Instance* instance;
+    memcached_instance_st* instance;
     memcached_return_t readable_error;
     while ((instance= memcached_io_get_readable_server(memc, readable_error)))
     {
@@ -105,7 +105,7 @@ static inline memcached_return_t memcached_version_binary(Memcached *memc)
   bool errors_happened= false;
   for (uint32_t x= 0; x < memcached_server_count(memc); x++) 
   {
-    org::libmemcached::Instance* instance= memcached_instance_fetch(memc, x);
+    memcached_instance_st* instance= memcached_instance_fetch(memc, x);
 
     initialize_binary_request(instance, request.message.header);
 
@@ -128,7 +128,7 @@ static inline memcached_return_t memcached_version_binary(Memcached *memc)
   if (success)
   {
     // Collect the returned items
-    org::libmemcached::Instance* instance;
+    memcached_instance_st* instance;
     memcached_return_t readable_error;
     while ((instance= memcached_io_get_readable_server(memc, readable_error)))
     {
@@ -145,7 +145,7 @@ static inline memcached_return_t memcached_version_binary(Memcached *memc)
   return errors_happened ? MEMCACHED_SOME_ERRORS : MEMCACHED_SUCCESS;
 }
 
-static inline void version_ascii_instance(org::libmemcached::Instance* instance)
+static inline void version_ascii_instance(memcached_instance_st* instance)
 {
   if (instance->major_version != UINT8_MAX)
   {
@@ -158,7 +158,7 @@ static inline void version_ascii_instance(org::libmemcached::Instance* instance)
   }
 }
 
-static inline void version_binary_instance(org::libmemcached::Instance* instance)
+static inline void version_binary_instance(memcached_instance_st* instance)
 {
   if (instance->major_version != UINT8_MAX)
   {
@@ -178,7 +178,7 @@ static inline void version_binary_instance(org::libmemcached::Instance* instance
   }
 }
 
-void memcached_version_instance(org::libmemcached::Instance* instance)
+void memcached_version_instance(memcached_instance_st* instance)
 {
   if (instance)
   {
diff --git a/libmemcached/version.hpp b/libmemcached/version.hpp
index b4a8234b..f420a262 100644
--- a/libmemcached/version.hpp
+++ b/libmemcached/version.hpp
@@ -41,4 +41,4 @@
 
 #pragma once
 
-void memcached_version_instance(org::libmemcached::Instance*);
+void memcached_version_instance(memcached_instance_st*);
diff --git a/libmemcached/windows.hpp b/libmemcached/windows.hpp
new file mode 100644
index 00000000..40564b1d
--- /dev/null
+++ b/libmemcached/windows.hpp
@@ -0,0 +1,125 @@
+/*
+ * Libmemcached library
+ *
+ * Copyright (C) 2012 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
+
+#ifdef __cplusplus
+# include <cerrno>
+#else
+# include <errno.h>
+#endif
+
+#ifndef WIN32_LEAN_AND_MEAN
+# define WIN32_LEAN_AND_MEAN
+#endif
+
+#ifndef _WIN32_WINNT
+# define _WIN32_WINNT 0x0501
+#endif
+
+#ifdef __MINGW32__
+# if(_WIN32_WINNT >= 0x0501)
+# else
+#  undef _WIN32_WINNT
+#  define _WIN32_WINNT 0x0501
+# endif /* _WIN32_WINNT >= 0x0501 */
+#endif /* __MINGW32__ */
+
+#if defined(HAVE_WINSOCK2_H) && HAVE_WINSOCK2_H
+# include <winsock2.h>
+#endif
+
+#if defined(HAVE_WS2TCPIP_H) && HAVE_WS2TCPIP_H
+# include <ws2tcpip.h>
+#endif
+
+#if defined(HAVE_IO_H) && HAVE_IO_H
+# include <io.h>
+#endif
+
+struct sockaddr_un
+{
+  short int sun_family;
+  char sun_path[108];
+};
+
+static inline int translate_windows_error()
+{
+  int local_errno= WSAGetLastError();
+
+  switch(local_errno) {
+  case WSAEINVAL:
+    local_errno= EINPROGRESS;
+    break;
+  case WSAEALREADY:
+  case WSAEWOULDBLOCK:
+    local_errno= EAGAIN;
+    break;
+
+  case WSAECONNREFUSED:
+    local_errno= ECONNREFUSED;
+    break;
+
+  case WSAENETUNREACH:
+    local_errno= ENETUNREACH;
+    break;
+
+  case WSAETIMEDOUT:
+    local_errno= ETIMEDOUT;
+    break;
+
+  case WSAECONNRESET:
+    local_errno= ECONNRESET;
+    break;
+
+  case WSAEADDRINUSE:
+    local_errno= EADDRINUSE;
+    break;
+
+  case WSAEOPNOTSUPP:
+    local_errno= EOPNOTSUPP;
+    break;
+
+  case WSAENOPROTOOPT:
+    local_errno= ENOPROTOOPT;
+    break;
+
+  default:
+    break;
+  }
+
+  return local_errno;
+}
diff --git a/libmemcachedutil-1.2/pid.h b/libmemcachedutil-1.2/pid.h
index 01738acc..3ce0131c 100644
--- a/libmemcachedutil-1.2/pid.h
+++ b/libmemcachedutil-1.2/pid.h
@@ -36,8 +36,8 @@
 
 #pragma once
 
-#ifndef WIN32
-#include <netdb.h>
+#ifndef _WIN32
+# include <netdb.h>
 #endif
 
 #include <sys/types.h>
diff --git a/libmemcachedutil/pid.cc b/libmemcachedutil/pid.cc
index 51948383..34656118 100644
--- a/libmemcachedutil/pid.cc
+++ b/libmemcachedutil/pid.cc
@@ -74,7 +74,7 @@ pid_t libmemcached_util_getpid(const char *hostname, in_port_t port, memcached_r
     }
     else if (rc == MEMCACHED_SOME_ERRORS) // Generic answer, we will now find the specific reason (if one exists)
     {
-      memcached_server_instance_st instance= memcached_server_instance_by_position(memc_ptr, 0);
+      const memcached_instance_st * instance= memcached_server_instance_by_position(memc_ptr, 0);
 
       assert_msg(instance and memcached_server_error(instance), " ");
       if (instance and memcached_server_error(instance))
@@ -139,7 +139,7 @@ pid_t libmemcached_util_getpid2(const char *hostname, in_port_t port, const char
     }
     else if (rc == MEMCACHED_SOME_ERRORS) // Generic answer, we will now find the specific reason (if one exists)
     {
-      memcached_server_instance_st instance=
+      const memcached_instance_st * instance=
         memcached_server_instance_by_position(memc_ptr, 0);
 
 #if 0
diff --git a/libmemcachedutil/ping.cc b/libmemcachedutil/ping.cc
index e2831beb..a867c56b 100644
--- a/libmemcachedutil/ping.cc
+++ b/libmemcachedutil/ping.cc
@@ -64,7 +64,7 @@ bool libmemcached_util_ping(const char *hostname, in_port_t port, memcached_retu
 
     if (memcached_failed(rc) and rc == MEMCACHED_SOME_ERRORS)
     {
-      memcached_server_instance_st instance=
+      const memcached_instance_st * instance=
         memcached_server_instance_by_position(memc_ptr, 0);
 
       assert_msg(instance and memcached_server_error(instance), " ");
@@ -119,7 +119,7 @@ bool libmemcached_util_ping2(const char *hostname, in_port_t port, const char *u
 
   if (memcached_failed(rc) and rc == MEMCACHED_SOME_ERRORS)
   {
-    memcached_server_instance_st instance=
+    const memcached_instance_st * instance=
       memcached_server_instance_by_position(memc_ptr, 0);
 
     assert_msg(instance and memcached_server_error(instance), " ");
diff --git a/libmemcachedutil/version.cc b/libmemcachedutil/version.cc
index 9674c059..0fcfb5c5 100644
--- a/libmemcachedutil/version.cc
+++ b/libmemcachedutil/version.cc
@@ -49,7 +49,7 @@ struct local_context
 };
 
 static memcached_return_t check_server_version(const memcached_st *,
-                                               memcached_server_instance_st instance,
+                                               const memcached_instance_st * instance,
                                                void *context)
 {
   /* Do Nothing */
diff --git a/libtest/alarm.cc b/libtest/alarm.cc
index a8bf17e8..6193fbb3 100644
--- a/libtest/alarm.cc
+++ b/libtest/alarm.cc
@@ -76,7 +76,7 @@ void set_alarm(long tv_sec, long tv_usec)
     }
   }
 
-#if defined(TARGET_OS_OSX) && TARGET_OS_OSX
+#ifdef __APPLE__
   struct timeval it_value= { time_t(tv_sec), suseconds_t(tv_usec) };
 #else
   struct timeval it_value= { tv_sec, tv_usec };
diff --git a/libtest/common.h b/libtest/common.h
index 7be0221c..b611e1a9 100644
--- a/libtest/common.h
+++ b/libtest/common.h
@@ -69,7 +69,7 @@
 # include <arpa/inet.h>
 #endif
 
-#if defined(WIN32) || defined(__MINGW32__)
+#if defined(_WIN32)
 # include "win32/wrappers.h"
 # define get_socket_errno() WSAGetLastError()
 #else
diff --git a/libtest/dream.cc b/libtest/dream.cc
index 114ac672..cd7d6aa6 100644
--- a/libtest/dream.cc
+++ b/libtest/dream.cc
@@ -41,7 +41,7 @@ namespace libtest {
 
 void dream(time_t tv_sec, long tv_nsec)
 {
-#ifdef WIN32
+#if defined(_WIN32)
   if (tv_sec == 0 and tv_nsec)
   {
     tv_sec++;
diff --git a/libtest/lite.h b/libtest/lite.h
index 52e96380..70aee2b0 100644
--- a/libtest/lite.h
+++ b/libtest/lite.h
@@ -51,7 +51,7 @@
 # include <string.h>
 #endif
 
-#ifdef _WIN32
+#if defined(_WIN32)
 # include <malloc.h>
 #else
 # include <alloca.h>
@@ -348,7 +348,7 @@ do \
   } \
 } while (0)
 
-#define ASSERT_NEQ(__expected, __actual, ...) \
+#define ASSERT_NEQ(__expected, __actual) \
 do \
 { \
   if ((__expected) == (__actual)) { \
diff --git a/libtest/m4/memcached.m4 b/libtest/m4/memcached.m4
deleted file mode 100644
index 0fece500..00000000
--- a/libtest/m4/memcached.m4
+++ /dev/null
@@ -1,11 +0,0 @@
-#serial 2
-
-AC_DEFUN([YATL_MEMCACHED],
-         [AX_WITH_PROG(MEMCACHED_BINARY, [memcached])
-         AS_IF([test -f "$ac_cv_path_MEMCACHED_BINARY"],
-               [AC_DEFINE([HAVE_MEMCACHED_BINARY], [1], [If Memcached binary is available])
-               AC_DEFINE_UNQUOTED([MEMCACHED_BINARY], "$ac_cv_path_MEMCACHED_BINARY", [Name of the memcached binary used in make test])],
-               [AC_DEFINE([HAVE_MEMCACHED_BINARY], [1], [If Memcached binary is available])
-               AC_DEFINE([MEMCACHED_BINARY], ["memcached/memcached"], [Name of the memcached binary used in make test])
-               ])
-         ])
diff --git a/libtest/main.cc b/libtest/main.cc
index fe8938b9..80ffa769 100644
--- a/libtest/main.cc
+++ b/libtest/main.cc
@@ -158,7 +158,14 @@ int main(int argc, char *argv[])
         break;
 
       case OPT_LIBYATL_REPEAT:
+        errno= 0;
         opt_repeat= strtoul(optarg, (char **) NULL, 10);
+        if (errno != 0)
+        {
+          Error << "unknown value passed to --repeat: `" << optarg << "`";
+          exit(EXIT_FAILURE);
+        }
+
         break;
 
       case OPT_LIBYATL_MATCH_COLLECTION:
@@ -186,9 +193,16 @@ int main(int argc, char *argv[])
 
   srandom((unsigned int)time(NULL));
 
-  if (bool(getenv("YATL_REPEAT")) and (strtoul(getenv("YATL_REPEAT"), (char **) NULL, 10) > 1))
+  errno= 0;
+  if (bool(getenv("YATL_REPEAT")))
   {
+    errno= 0;
     opt_repeat= strtoul(getenv("YATL_REPEAT"), (char **) NULL, 10);
+    if (errno != 0)
+    {
+      Error << "ENV YATL_REPEAT passed an invalid value: `" << getenv("YATL_REPEAT") << "`";
+      exit(EXIT_FAILURE);
+    }
   }
 
   if ((bool(getenv("YATL_QUIET")) and (strcmp(getenv("YATL_QUIET"), "0") == 0)) or opt_quiet)
diff --git a/libtest/memcached.hpp b/libtest/memcached.hpp
index e0e14851..142f167c 100644
--- a/libtest/memcached.hpp
+++ b/libtest/memcached.hpp
@@ -39,7 +39,7 @@
 #if defined(HAVE_LIBMEMCACHED) && HAVE_LIBMEMCACHED
 inline bool operator== (const memcached_st& memc, const memcached_return_t rc)
 {
-  if (memcached_last_error(const_cast<memcached_st *>(&memc)) == rc)
+  if (memcached_last_error(&memc) == rc)
   {
     return true;
   }
@@ -47,7 +47,7 @@ inline bool operator== (const memcached_st& memc, const memcached_return_t rc)
   return false;
 }
 
-inline bool operator!= (const memcached_st& memc, const memcached_return_t rc)
+inline bool operator!= (const memcached_st& memc, memcached_return_t rc)
 {
   if (memcached_last_error(const_cast<memcached_st *>(&memc)) != rc)
   {
@@ -57,7 +57,27 @@ inline bool operator!= (const memcached_st& memc, const memcached_return_t rc)
   return false;
 }
 
-inline bool operator!= (const memcached_return_t rc, const memcached_st& memc)
+inline bool operator== (memcached_st* const memc, memcached_return_t rc)
+{
+  if (memcached_last_error(memc) == rc)
+  {
+    return true;
+  }
+
+  return false;
+}
+
+inline bool operator!= (memcached_st* const memc, memcached_return_t rc)
+{
+  if (memcached_last_error(memc) != rc)
+  {
+    return true;
+  }
+
+  return false;
+}
+
+inline bool operator!= (memcached_return_t rc, const memcached_st& memc)
 {
   if (memcached_last_error(const_cast<memcached_st *>(&memc)) != rc)
   {
@@ -66,5 +86,15 @@ inline bool operator!= (const memcached_return_t rc, const memcached_st& memc)
 
   return false;
 }
+
+inline bool operator!= (memcached_return_t rc, memcached_st* const memc)
+{
+  if (memcached_last_error(memc) != rc)
+  {
+    return true;
+  }
+
+  return false;
+}
 #endif
 
diff --git a/libtest/unittest.cc b/libtest/unittest.cc
index b96fea06..c7be63fa 100644
--- a/libtest/unittest.cc
+++ b/libtest/unittest.cc
@@ -184,11 +184,11 @@ static test_return_t test_throw_fail_TEST(void *)
 static test_return_t ASSERT_FALSE__TEST(void *)
 {
   try {
-    ASSERT_FALSE_(true, __func__);
+    ASSERT_FALSE(true);
   }
   catch (const libtest::__failure& e)
   {
-    ASSERT_STREQ(e.what(), "Assertion '!true' [ ASSERT_FALSE__TEST ]");
+    ASSERT_STREQ(e.what(), "Assertion '!true'");
     return TEST_SUCCESS;
   }
   catch (...)
@@ -199,6 +199,31 @@ static test_return_t ASSERT_FALSE__TEST(void *)
   return TEST_FAILURE;
 }
 
+static test_return_t ASSERT_NEQ_FAIL_TEST(void *)
+{
+  try {
+    ASSERT_NEQ(1,1);
+  }
+  catch (const libtest::__failure& e)
+  {
+    ASSERT_STREQ(e.what(), "Assertion '1' == '1'");
+    return TEST_SUCCESS;
+  }
+  catch (...)
+  {
+    return TEST_FAILURE;
+  }
+
+  return TEST_FAILURE;
+}
+
+static test_return_t ASSERT_NEQ_TEST(void *)
+{
+  ASSERT_NEQ(1,0);
+
+  return TEST_SUCCESS;
+}
+
 static test_return_t ASSERT_FALSE_TEST(void *)
 {
   try {
@@ -1012,6 +1037,8 @@ test_st tests_log[] ={
   {"FAIL", false, test_throw_fail_TEST },
   {"ASSERT_FALSE_", false, ASSERT_FALSE__TEST },
   {"ASSERT_FALSE", false, ASSERT_FALSE_TEST },
+  {"ASSERT_NEQ", false, ASSERT_NEQ_TEST },
+  {"ASSERT_NEQ FAIL", false, ASSERT_NEQ_FAIL_TEST },
   {0, 0, 0}
 };
 
diff --git a/libtest/yatl.m4 b/libtest/yatl.m4
index 4415863f..61d1a2f0 100644
--- a/libtest/yatl.m4
+++ b/libtest/yatl.m4
@@ -7,10 +7,8 @@ AC_SUBST([LIBTEST_VERSION],[1.0])
 AC_CONFIG_FILES([libtest/version.h])
 
 m4_include([libtest/m4/mysql.m4])
-m4_include([libtest/m4/memcached.m4])
 AC_DEFINE([HAVE_MEMCACHED_SASL_BINARY],[0],[If Memcached binary with sasl support is available])
 
 YATL_MYSQL
-YATL_MEMCACHED
 
 AC_CONFIG_FILES([libtest/yatlcon.h])
diff --git a/m4/ax_harden_compiler_flags.m4 b/m4/ax_harden_compiler_flags.m4
index b31518aa..2daeb1a1 100644
--- a/m4/ax_harden_compiler_flags.m4
+++ b/m4/ax_harden_compiler_flags.m4
@@ -1,3 +1,4 @@
+# vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 # ===========================================================================
 #      https://github.com/BrianAker/ddm4/
 # ===========================================================================
@@ -52,7 +53,7 @@
 # ?  _APPEND_COMPILE_FLAGS_ERROR([-Wlong-long]) -- Don't turn on for
 # compatibility issues memcached_stat_st
 
-#serial 7
+#serial 8
 
 AC_DEFUN([_WARNINGS_AS_ERRORS],
     [AC_CACHE_CHECK([if all warnings into errors],[ac_cv_warnings_as_errors],
@@ -75,10 +76,12 @@ AC_DEFUN([_APPEND_COMPILE_FLAGS_ERROR],
 # Everything above this does the heavy lifting, while what follows does the specifics.
 
 AC_DEFUN([_HARDEN_LINKER_FLAGS],
-         [_APPEND_LINK_FLAGS_ERROR([-z relro -z now])
-         #_APPEND_LINK_FLAGS_ERROR([-pie])
-         AS_IF([test "x$ac_cv_warnings_as_errors" = xyes],
-               [AX_APPEND_LINK_FLAGS([-Werror])])
+         [
+         AS_IF([test "$CC" != "clang"],
+           [_APPEND_LINK_FLAGS_ERROR([-z relro -z now])
+#_APPEND_LINK_FLAGS_ERROR([-pie])
+           AS_IF([test "x$ac_cv_warnings_as_errors" = xyes],
+             [AX_APPEND_LINK_FLAGS([-Werror])])])
          ])
 
 AC_DEFUN([_HARDEN_CC_COMPILER_FLAGS],
@@ -86,6 +89,7 @@ AC_DEFUN([_HARDEN_CC_COMPILER_FLAGS],
 
          AS_IF([test "x$ax_enable_debug" = xyes],
            [CFLAGS=''
+           _APPEND_COMPILE_FLAGS_ERROR([-H])
            _APPEND_COMPILE_FLAGS_ERROR([-ggdb])
            _APPEND_COMPILE_FLAGS_ERROR([-g])
            _APPEND_COMPILE_FLAGS_ERROR([-O0])],
@@ -93,19 +97,26 @@ AC_DEFUN([_HARDEN_CC_COMPILER_FLAGS],
            _APPEND_COMPILE_FLAGS_ERROR([-O2])])
 
          AS_IF([test "x$ac_cv_vcs_checkout" = xyes],
-           [_APPEND_COMPILE_FLAGS_ERROR([-fstack-check])],
-           [_APPEND_COMPILE_FLAGS_ERROR([-Wno-pragmas])])
+           [_APPEND_COMPILE_FLAGS_ERROR([-fstack-check])
+           _APPEND_COMPILE_FLAGS_ERROR([-Wpragmas])
+           _APPEND_COMPILE_FLAGS_ERROR([-Wunknown-pragmas])],
+           [_APPEND_COMPILE_FLAGS_ERROR([-Wno-unknown-pragmas])
+           _APPEND_COMPILE_FLAGS_ERROR([-Wno-pragmas])])
+
+         AS_IF([test "$CC" = "clang"],
+           [_APPEND_COMPILE_FLAGS_ERROR([-Qunused-arguments])])
 
          _APPEND_COMPILE_FLAGS_ERROR([-Wall])
          _APPEND_COMPILE_FLAGS_ERROR([-Wextra])
-         _APPEND_COMPILE_FLAGS_ERROR([-Wunknown-pragmas])
          _APPEND_COMPILE_FLAGS_ERROR([-Wthis-test-should-fail])
          _APPEND_COMPILE_FLAGS_ERROR([-std=c99])
 # Anything below this comment please keep sorted.
-         _APPEND_COMPILE_FLAGS_ERROR([--param=ssp-buffer-size=1])
 # _APPEND_COMPILE_FLAGS_ERROR([-Wmissing-format-attribute])
+          _APPEND_COMPILE_FLAGS_ERROR([-Wunsuffixed-float-constants])
+          _APPEND_COMPILE_FLAGS_ERROR([-Wjump-misses-init])
           _APPEND_COMPILE_FLAGS_ERROR([-Wno-attributes])
           _APPEND_COMPILE_FLAGS_ERROR([-Waddress])
+          _APPEND_COMPILE_FLAGS_ERROR([-Wvarargs])
           _APPEND_COMPILE_FLAGS_ERROR([-Warray-bounds])
           _APPEND_COMPILE_FLAGS_ERROR([-Wbad-function-cast])
 # Not in use -Wc++-compat
@@ -114,6 +125,7 @@ AC_DEFUN([_HARDEN_CC_COMPILER_FLAGS],
           _APPEND_COMPILE_FLAGS_ERROR([-Wfloat-equal])
           _APPEND_COMPILE_FLAGS_ERROR([-Wformat-security])
           _APPEND_COMPILE_FLAGS_ERROR([-Wformat=2])
+          _APPEND_COMPILE_FLAGS_ERROR([-Wformat-y2k])
           _APPEND_COMPILE_FLAGS_ERROR([-Wlogical-op])
           _APPEND_COMPILE_FLAGS_ERROR([-Wmaybe-uninitialized])
           _APPEND_COMPILE_FLAGS_ERROR([-Wmissing-field-initializers])
@@ -123,7 +135,6 @@ AC_DEFUN([_HARDEN_CC_COMPILER_FLAGS],
           _APPEND_COMPILE_FLAGS_ERROR([-Wmissing-prototypes])
           _APPEND_COMPILE_FLAGS_ERROR([-Wnested-externs])
           _APPEND_COMPILE_FLAGS_ERROR([-Wnormalized=id])
-          _APPEND_COMPILE_FLAGS_ERROR([-Wold-style-definition])
           _APPEND_COMPILE_FLAGS_ERROR([-Woverride-init])
           _APPEND_COMPILE_FLAGS_ERROR([-Wpointer-arith])
           _APPEND_COMPILE_FLAGS_ERROR([-Wpointer-sign])
@@ -140,10 +151,36 @@ AC_DEFUN([_HARDEN_CC_COMPILER_FLAGS],
           _APPEND_COMPILE_FLAGS_ERROR([-Wstrict-overflow=1])
           _APPEND_COMPILE_FLAGS_ERROR([-Wstrict-prototypes])
           _APPEND_COMPILE_FLAGS_ERROR([-Wswitch-enum])
+          _APPEND_COMPILE_FLAGS_ERROR([-Wtrampolines])
           _APPEND_COMPILE_FLAGS_ERROR([-Wundef])
+          _APPEND_COMPILE_FLAGS_ERROR([-Wunsafe-loop-optimizations])
+          _APPEND_COMPILE_FLAGS_ERROR([-funsafe-loop-optimizations])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=address])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=integer])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=thread])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=memory])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=alignment])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=bool])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=bounds])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=enum])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=float-cast-overflow])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=float-divide-by-zero])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=integer-divide-by-zero])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=null])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=object-size])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=return])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=shift])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=signed-integer-overflow])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=unreachable])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=unsigned-integer-overflow])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=vla-bound])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=vptr])
+          _APPEND_COMPILE_FLAGS_ERROR([-Wclobbered])
           _APPEND_COMPILE_FLAGS_ERROR([-Wunused])
           _APPEND_COMPILE_FLAGS_ERROR([-Wunused-result])
           _APPEND_COMPILE_FLAGS_ERROR([-Wunused-variable])
+          _APPEND_COMPILE_FLAGS_ERROR([-Wunused-parameter])
+          _APPEND_COMPILE_FLAGS_ERROR([-Wunused-local-typedefs])
           _APPEND_COMPILE_FLAGS_ERROR([-Wwrite-strings])
           _APPEND_COMPILE_FLAGS_ERROR([-floop-parallelize-all])
           _APPEND_COMPILE_FLAGS_ERROR([-fwrapv])
@@ -157,6 +194,7 @@ AC_DEFUN([_HARDEN_CC_COMPILER_FLAGS],
                   [_APPEND_COMPILE_FLAGS_ERROR([-D_FORTIFY_SOURCE=2])
                   #_APPEND_COMPILE_FLAGS_ERROR([-Wstack-protector])
                   #_APPEND_COMPILE_FLAGS_ERROR([-fstack-protector])
+                  #_APPEND_COMPILE_FLAGS_ERROR([--param=ssp-buffer-size=1])
                   _APPEND_COMPILE_FLAGS_ERROR([-fstack-protector-all])
                   ])])])])
 
@@ -172,6 +210,7 @@ AC_DEFUN([_HARDEN_CXX_COMPILER_FLAGS],
 
          AS_IF([test "x$ax_enable_debug" = xyes],
            [CXXFLAGS=''
+           _APPEND_COMPILE_FLAGS_ERROR([-H])
            _APPEND_COMPILE_FLAGS_ERROR([-ggdb])
            _APPEND_COMPILE_FLAGS_ERROR([-g])
            _APPEND_COMPILE_FLAGS_ERROR([-O0])],
@@ -179,17 +218,22 @@ AC_DEFUN([_HARDEN_CXX_COMPILER_FLAGS],
            _APPEND_COMPILE_FLAGS_ERROR([-O2])])
 
          AS_IF([test "x$ac_cv_vcs_checkout" = xyes],
-           [_APPEND_COMPILE_FLAGS_ERROR([-fstack-check])],
-           [_APPEND_COMPILE_FLAGS_ERROR([-Wno-pragmas])])
+           [_APPEND_COMPILE_FLAGS_ERROR([-fstack-check])
+           _APPEND_COMPILE_FLAGS_ERROR([-Wpragmas])
+           _APPEND_COMPILE_FLAGS_ERROR([-Wunknown-pragmas])],
+           [_APPEND_COMPILE_FLAGS_ERROR([-Wno-unknown-pragmas])
+           _APPEND_COMPILE_FLAGS_ERROR([-Wno-pragmas])])
+
+         AS_IF([test "$CXX" = "clang++"],
+           [_APPEND_COMPILE_FLAGS_ERROR([-Qunused-arguments])])
 
          _APPEND_COMPILE_FLAGS_ERROR([-Wall])
          _APPEND_COMPILE_FLAGS_ERROR([-Wextra])
-         _APPEND_COMPILE_FLAGS_ERROR([-Wunknown-pragmas])
          _APPEND_COMPILE_FLAGS_ERROR([-Wthis-test-should-fail])
 # Anything below this comment please keep sorted.
-         _APPEND_COMPILE_FLAGS_ERROR([--param=ssp-buffer-size=1])
 # _APPEND_COMPILE_FLAGS_ERROR([-Wmissing-format-attribute])
           _APPEND_COMPILE_FLAGS_ERROR([-Wno-attributes])
+          _APPEND_COMPILE_FLAGS_ERROR([-Wvarargs])
           _APPEND_COMPILE_FLAGS_ERROR([-Waddress])
           _APPEND_COMPILE_FLAGS_ERROR([-Warray-bounds])
           _APPEND_COMPILE_FLAGS_ERROR([-Wchar-subscripts])
@@ -197,6 +241,7 @@ AC_DEFUN([_HARDEN_CXX_COMPILER_FLAGS],
           _APPEND_COMPILE_FLAGS_ERROR([-Wctor-dtor-privacy])
           _APPEND_COMPILE_FLAGS_ERROR([-Wfloat-equal])
           _APPEND_COMPILE_FLAGS_ERROR([-Wformat=2])
+          _APPEND_COMPILE_FLAGS_ERROR([-Wformat-y2k])
           _APPEND_COMPILE_FLAGS_ERROR([-Wmaybe-uninitialized])
           _APPEND_COMPILE_FLAGS_ERROR([-Wmissing-field-initializers])
           _APPEND_COMPILE_FLAGS_ERROR([-Wlogical-op])
@@ -217,11 +262,39 @@ AC_DEFUN([_HARDEN_CXX_COMPILER_FLAGS],
           _APPEND_COMPILE_FLAGS_ERROR([-Wsign-compare])
           _APPEND_COMPILE_FLAGS_ERROR([-Wstrict-overflow=1])
           _APPEND_COMPILE_FLAGS_ERROR([-Wswitch-enum])
+          _APPEND_COMPILE_FLAGS_ERROR([-Wtrampolines])
           _APPEND_COMPILE_FLAGS_ERROR([-Wundef])
+          _APPEND_COMPILE_FLAGS_ERROR([-Wunsafe-loop-optimizations])
+          _APPEND_COMPILE_FLAGS_ERROR([-funsafe-loop-optimizations])
           _APPEND_COMPILE_FLAGS_ERROR([-Wc++11-compat])
+#         _APPEND_COMPILE_FLAGS_ERROR([-Weffc++])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=address])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=integer])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=thread])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=memory])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=alignment])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=bool])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=bounds])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=enum])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=float-cast-overflow])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=float-divide-by-zero])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=integer-divide-by-zero])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=null])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=object-size])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=return])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=shift])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=signed-integer-overflow])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=unreachable])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=unsigned-integer-overflow])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=vla-bound])
+          _APPEND_COMPILE_FLAGS_ERROR([-fsanitize=vptr])
+#          _APPEND_COMPILE_FLAGS_ERROR([-Wold-style-cast])
+          _APPEND_COMPILE_FLAGS_ERROR([-Wclobbered])
           _APPEND_COMPILE_FLAGS_ERROR([-Wunused])
           _APPEND_COMPILE_FLAGS_ERROR([-Wunused-result])
           _APPEND_COMPILE_FLAGS_ERROR([-Wunused-variable])
+          _APPEND_COMPILE_FLAGS_ERROR([-Wunused-parameter])
+          _APPEND_COMPILE_FLAGS_ERROR([-Wunused-local-typedefs])
           _APPEND_COMPILE_FLAGS_ERROR([-Wwrite-strings])
           _APPEND_COMPILE_FLAGS_ERROR([-Wformat-security])
           _APPEND_COMPILE_FLAGS_ERROR([-floop-parallelize-all])
@@ -236,6 +309,7 @@ AC_DEFUN([_HARDEN_CXX_COMPILER_FLAGS],
                 [_APPEND_COMPILE_FLAGS_ERROR([-D_FORTIFY_SOURCE=2])
                 #_APPEND_COMPILE_FLAGS_ERROR([-Wstack-protector])
                 #_APPEND_COMPILE_FLAGS_ERROR([-fstack-protector])
+                #_APPEND_COMPILE_FLAGS_ERROR([--param=ssp-buffer-size=1])
                 _APPEND_COMPILE_FLAGS_ERROR([-fstack-protector-all])
                 ])])])])
 
diff --git a/m4/ax_libevent.m4 b/m4/ax_libevent.m4
index 686bff23..c576bad5 100644
--- a/m4/ax_libevent.m4
+++ b/m4/ax_libevent.m4
@@ -20,7 +20,7 @@
 #   and this notice are preserved. This file is offered as-is, without any
 #   warranty.
 
-#serial 4
+#serial 5
  
 AC_DEFUN([AX_LIBEVENT],
          [AC_PREREQ([2.63])dnl
@@ -28,15 +28,15 @@ AC_DEFUN([AX_LIBEVENT],
            [AX_SAVE_FLAGS
            LIBS="-levent $LIBS"
            AC_LANG_PUSH([C])
-           AC_RUN_IFELSE([AC_LANG_PROGRAM([
+           AC_RUN_IFELSE([AC_LANG_PROGRAM([[
 #include <sys/types.h>
 #include <sys/time.h>
 #include <stdlib.h>
 #include <event.h>
-               ],[
+               ]],[[
                struct event_base *tmp_event= event_init();
                event_base_free(tmp_event);
-               ])],
+               ]])],
              [ax_cv_libevent=yes],
              [ax_cv_libevent=no],
              [AC_MSG_WARN([test program execution failed])])
@@ -62,15 +62,15 @@ AC_DEFUN([AX_LIBEVENT2],
       [AX_SAVE_FLAGS
       LIBS="-levent $LIBS"
       AC_LANG_PUSH([C])
-      AC_RUN_IFELSE([AC_LANG_PROGRAM([
+      AC_RUN_IFELSE([AC_LANG_PROGRAM([[
 #include <sys/types.h>
 #include <sys/time.h>
 #include <stdlib.h>
 #include <event2/event.h>
-          ],[
-          struct event_base *tmp_event= event_init();
-          event_base_free(tmp_event);
-          ])],
+          ]],[[
+          struct event_base *___event_base= event_base_new();  
+          event_base_free(___event_base);
+          ]])],
         [ax_cv_libevent2=yes],
         [ax_cv_libevent2=no],
         [AC_MSG_WARN([test program execution failed])])
@@ -97,16 +97,18 @@ AC_DEFUN([AX_LIBEVENT2_EVHTTP],
       [AX_SAVE_FLAGS
       LIBS="-levent $LIBS"
       AC_LANG_PUSH([C])
-      AC_RUN_IFELSE([AC_LANG_PROGRAM([
+      AC_RUN_IFELSE([AC_LANG_PROGRAM([[
 #include <sys/types.h>
 #include <sys/time.h>
 #include <stdlib.h>
 #include <event2/event.h>
 #include <event2/http.h>
-          ],[
-          struct event_base *libbase= event_base_new();  
-          struct evhttp *libsrvr= evhttp_new(libbase);
-          ])],
+          ]],[[
+          struct event_base *___event_base= event_base_new();  
+          struct evhttp *___evhttp= evhttp_new(___event_base);
+          evhttp_free(___evhttp);
+          event_base_free(___event_base);
+          ]])],
         [ax_cv_libevent2_evhttp=yes],
         [ax_cv_libevent2_evhttp=no],
         [AC_MSG_WARN([test program execution failed])])
diff --git a/m4/ax_memcached.m4 b/m4/ax_memcached.m4
new file mode 100644
index 00000000..21067c68
--- /dev/null
+++ b/m4/ax_memcached.m4
@@ -0,0 +1,58 @@
+# vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+# ===========================================================================
+#      https://github.com/BrianAker/ddm4/
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_PROG_MEMCACHED
+#
+# DESCRIPTION
+#
+#   Check for memcached and list version
+#
+# LICENSE
+#
+#  Copyright (C) 2013 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.
+
+#serial 3
+
+AC_DEFUN([AX_PROG_MEMCACHED],
+    [AX_WITH_PROG([MEMCACHED_BINARY],[memcached])
+    AS_IF([test -f "$ac_cv_path_MEMCACHED_BINARY"],
+      [AC_DEFINE([HAVE_MEMCACHED_BINARY], [1], [If Memcached binary is available])
+      AC_DEFINE_UNQUOTED([MEMCACHED_BINARY],"$ac_cv_path_MEMCACHED_BINARY",[Name of the memcached binary used in make test])
+      ax_memcached_version=`$MEMCACHED_BINARY -h | sed 1q | awk '{print \$ 2 }' | sed 's|[\-a-z0-9]*$||' | awk -F. '{printf "%d.%d.%d", $[]1, $[]2, $[]3}'`
+      AC_MSG_RESULT([memcached version "$ax_memcached_version"])
+      AC_DEFINE_UNQUOTED([MEMCACHED_VERSION],"$ax_memcached_version",[Memcached binary version])
+      ])
+    ])
diff --git a/m4/ax_platform.m4 b/m4/ax_platform.m4
index 56472c72..01ff25d9 100644
--- a/m4/ax_platform.m4
+++ b/m4/ax_platform.m4
@@ -49,8 +49,7 @@
         AC_DEFINE([__APPLE_CC__],[1],[Workaround for bug in FreeBSD headers])],
         [*solaris*],[AC_DEFINE([TARGET_OS_SOLARIS],[1],[Whether we are building for Solaris])],
         [*darwin*],
-        [TARGET_OSX="true"
-        AC_DEFINE([TARGET_OS_OSX],[1],[Whether we build for OSX])],
+        [TARGET_OSX="true"],
         [*linux*],
         [TARGET_LINUX="true"
         AC_DEFINE([TARGET_OS_LINUX],[1],[Whether we build for Linux])])
diff --git a/man/include.am b/man/include.am
index 512edc40..3b68557a 100644
--- a/man/include.am
+++ b/man/include.am
@@ -15,7 +15,6 @@ BUILT_SOURCES+= $(dist_man_MANS)
 endif
 endif
 
-if HAVE_RECENT_SPHINX
 dist_man_MANS+= man/memaslap.1
 dist_man_MANS+= man/memcapable.1
 dist_man_MANS+= man/memcat.1
@@ -134,4 +133,3 @@ dist_man_MANS+= man/memcached_touch.3
 dist_man_MANS+= man/memcached_touch_by_key.3
 dist_man_MANS+= man/memcached_verbosity.3
 dist_man_MANS+= man/memcached_version.3
-endif
diff --git a/support/libmemcached.spec.in b/support/libmemcached.spec.in
index fe372404..f179a1f5 100644
--- a/support/libmemcached.spec.in
+++ b/support/libmemcached.spec.in
@@ -25,7 +25,6 @@ BuildRequires: glibc-devel
 BuildRequires: glibc-headers
 BuildRequires: grep
 BuildRequires: gzip
-BuildRequires: hostname
 BuildRequires: libevent-devel
 BuildRequires: libstdc++-devel
 BuildRequires: libuuid-devel
diff --git a/tests/cli.am b/tests/cli.am
index bc0d9a06..573be2af 100644
--- a/tests/cli.am
+++ b/tests/cli.am
@@ -65,6 +65,13 @@ tests_memcat_LDADD= libtest/libtest.la $(TESTS_LDADDS)
 check_PROGRAMS+= tests/memcat
 noinst_PROGRAMS+= tests/memcat
 
+tests_memping_SOURCES= tests/memping.cc
+tests_memping_CXXFLAGS= $(AM_CXXFLAGS) $(NO_EFF_CXX)
+EXTRA_tests_memping_DEPENDENCIES= clients/memping
+tests_memping_LDADD= libtest/libtest.la $(TESTS_LDADDS)
+check_PROGRAMS+= tests/memping
+noinst_PROGRAMS+= tests/memping
+
 tests_memerror_SOURCES= tests/memerror.cc
 tests_memerror_CXXFLAGS= $(AM_CXXFLAGS) $(NO_EFF_CXX)
 EXTRA_tests_memerror_DEPENDENCIES= clients/memerror
@@ -101,6 +108,9 @@ test-memerror: tests/memerror
 test-memtouch: tests/memtouch
 	tests/memtouch
 
+test-memping: tests/memping
+	tests/memping
+
 valgrind-memerror: tests/memerror
 	 @$(VALGRIND_COMMAND) tests/memerror
 
diff --git a/tests/libmemcached-1.0/all_tests.h b/tests/libmemcached-1.0/all_tests.h
index fe28e733..2012d477 100644
--- a/tests/libmemcached-1.0/all_tests.h
+++ b/tests/libmemcached-1.0/all_tests.h
@@ -144,6 +144,7 @@ test_st behavior_tests[] ={
   {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", false, (test_callback_fn*)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test},
   {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", false, (test_callback_fn*)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test},
   {"MEMCACHED_BEHAVIOR_POLL_TIMEOUT", false, (test_callback_fn*)MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test},
+  {"MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH_TEST", true, (test_callback_fn*)MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH_TEST },
   {"MEMCACHED_CALLBACK_DELETE_TRIGGER_and_MEMCACHED_BEHAVIOR_NOREPLY", false, (test_callback_fn*)test_MEMCACHED_CALLBACK_DELETE_TRIGGER_and_MEMCACHED_BEHAVIOR_NOREPLY},
   {0, 0, 0}
 };
@@ -163,6 +164,7 @@ test_st basic_tests[] ={
   {"reset stack clone", true, (test_callback_fn*)basic_reset_stack_clone_test},
   {"reset heap clone", true, (test_callback_fn*)basic_reset_heap_clone_test},
   {"memcached_return_t", false, (test_callback_fn*)memcached_return_t_TEST },
+  {"c++ memcached_st == memcached_return_t", false, (test_callback_fn*)comparison_operator_memcached_st_and__memcached_return_t_TEST },
   {0, 0, 0}
 };
 
diff --git a/tests/libmemcached-1.0/debug.cc b/tests/libmemcached-1.0/debug.cc
index 36193582..8b0296e5 100644
--- a/tests/libmemcached-1.0/debug.cc
+++ b/tests/libmemcached-1.0/debug.cc
@@ -62,7 +62,7 @@ static memcached_return_t print_keys_callback(const memcached_st *,
 }
 
 static memcached_return_t server_wrapper_for_dump_callback(const memcached_st *,
-                                                           memcached_server_instance_st server,
+                                                           const memcached_instance_st * server,
                                                            void *)
 {
   memcached_st *memc= memcached_create(NULL);
diff --git a/tests/libmemcached-1.0/dump.cc b/tests/libmemcached-1.0/dump.cc
index a04a2c93..89487401 100644
--- a/tests/libmemcached-1.0/dump.cc
+++ b/tests/libmemcached-1.0/dump.cc
@@ -65,7 +65,7 @@ static memcached_return_t callback_dump_counter(const memcached_st *,
   return MEMCACHED_SUCCESS;
 }
 
-static memcached_return_t item_counter(memcached_server_instance_st ,
+static memcached_return_t item_counter(const memcached_instance_st * ,
                                        const char *key, size_t key_length,
                                        const char *value, size_t, // value_length,
                                        void *context)
diff --git a/tests/libmemcached-1.0/generate.cc b/tests/libmemcached-1.0/generate.cc
index 4b3de418..a0d19c49 100644
--- a/tests/libmemcached-1.0/generate.cc
+++ b/tests/libmemcached-1.0/generate.cc
@@ -131,7 +131,7 @@ test_return_t generate_data_with_stats(memcached_st *memc)
     /* This test was changes so that "make test" would work properlly */
     if (DEBUG)
     {
-      memcached_server_instance_st instance=
+      const memcached_instance_st * instance=
         memcached_server_instance_by_position(memc, host_index);
 
       printf("\nserver %u|%s|%u bytes: %llu\n",
diff --git a/tests/libmemcached-1.0/ketama.cc b/tests/libmemcached-1.0/ketama.cc
index 585a878e..cd9ca3f0 100644
--- a/tests/libmemcached-1.0/ketama.cc
+++ b/tests/libmemcached-1.0/ketama.cc
@@ -83,7 +83,7 @@ test_return_t ketama_compatibility_libmemcached(memcached_st *)
   for (uint32_t x= 0; x < 99; x++)
   {
     uint32_t server_idx = memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key));
-    memcached_server_instance_st instance=
+    const memcached_instance_st * instance=
       memcached_server_instance_by_position(memc, server_idx);
     const char *hostname = memcached_server_name(instance);
 
@@ -145,7 +145,7 @@ test_return_t user_supplied_bug18(memcached_st *trash)
   {
     uint32_t server_idx = memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key));
 
-    memcached_server_instance_st instance=
+    const memcached_instance_st * instance=
       memcached_server_instance_by_position(memc, server_idx);
 
     const char *hostname = memcached_server_name(instance);
@@ -201,7 +201,7 @@ test_return_t auto_eject_hosts(memcached_st *trash)
   test_true(server_pool[7].port == 11211);
   test_true(server_pool[7].weight == 100);
 
-  memcached_server_instance_st instance= memcached_server_instance_by_position(memc, 2);
+  const memcached_instance_st * instance= memcached_server_instance_by_position(memc, 2);
   memcached_instance_next_retry(instance, time(NULL) +15);
   memc->ketama.next_distribution_rebuild= time(NULL) - 1;
 
@@ -276,7 +276,7 @@ test_return_t ketama_compatibility_spymemcached(memcached_st *)
   {
     uint32_t server_idx= memcached_generate_hash(memc, ketama_test_cases_spy[x].key, strlen(ketama_test_cases_spy[x].key));
 
-    memcached_server_instance_st instance=
+    const memcached_instance_st * instance=
       memcached_server_instance_by_position(memc, server_idx);
 
     const char *hostname= memcached_server_name(instance);
diff --git a/tests/libmemcached-1.0/mem_functions.cc b/tests/libmemcached-1.0/mem_functions.cc
index 91e75372..de82e5d9 100644
--- a/tests/libmemcached-1.0/mem_functions.cc
+++ b/tests/libmemcached-1.0/mem_functions.cc
@@ -113,7 +113,7 @@ static memcached_st * create_single_instance_memcached(const memcached_st *origi
    * I only want to hit _one_ server so I know the number of requests I'm
    * sending in the pipeline.
    */
-  memcached_server_instance_st instance= memcached_server_instance_by_position(original_memc, 0);
+  const memcached_instance_st * instance= memcached_server_instance_by_position(original_memc, 0);
 
   char server_string[1024];
   int server_string_length;
@@ -176,7 +176,7 @@ test_return_t init_test(memcached_st *not_used)
 in_port_t test_ports[TEST_PORT_COUNT];
 
 static memcached_return_t server_display_function(const memcached_st *ptr,
-                                                  memcached_server_instance_st server,
+                                                  const memcached_instance_st * server,
                                                   void *context)
 {
   /* Do Nothing */
@@ -189,7 +189,7 @@ static memcached_return_t server_display_function(const memcached_st *ptr,
 }
 
 static memcached_return_t dump_server_information(const memcached_st *ptr,
-                                                  memcached_server_instance_st instance,
+                                                  const memcached_instance_st * instance,
                                                   void *context)
 {
   /* Do Nothing */
@@ -244,7 +244,7 @@ test_return_t server_sort2_test(memcached_st *ptr)
   size_t bigger= 0; /* Prime the value for the test_true in server_display_function */
   memcached_server_fn callbacks[1];
   memcached_st *local_memc;
-  memcached_server_instance_st instance;
+  const memcached_instance_st * instance;
   (void)ptr;
 
   local_memc= memcached_create(NULL);
@@ -295,7 +295,7 @@ test_return_t memcached_server_remove_test(memcached_st*)
 }
 
 static memcached_return_t server_display_unsort_function(const memcached_st*,
-                                                         memcached_server_instance_st server,
+                                                         const memcached_instance_st * server,
                                                          void *context)
 {
   /* Do Nothing */
@@ -956,7 +956,7 @@ test_return_t flush_test(memcached_st *memc)
 }
 
 static memcached_return_t  server_function(const memcached_st *,
-                                           memcached_server_instance_st,
+                                           const memcached_instance_st *,
                                            void *)
 {
   /* Do Nothing */
@@ -1259,7 +1259,7 @@ test_return_t mget_end(memcached_st *memc)
 test_return_t stats_servername_test(memcached_st *memc)
 {
   memcached_stat_st memc_stat;
-  memcached_server_instance_st instance=
+  const memcached_instance_st * instance=
     memcached_server_instance_by_position(memc, 0);
 
   if (LIBMEMCACHED_WITH_SASL_SUPPORT and memcached_get_sasl_callbacks(memc))
@@ -1751,6 +1751,54 @@ test_return_t mget_execute(memcached_st *original_memc)
   return TEST_SUCCESS;
 }
 
+test_return_t MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH_TEST(memcached_st *original_memc)
+{
+  test_skip(true, memcached_behavior_get(original_memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
+
+  memcached_st *memc= create_single_instance_memcached(original_memc, "--BINARY-PROTOCOL");
+  test_true(memc);
+
+  test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH, 8));
+
+  keys_st keys(20480);
+
+  /* First add all of the items.. */
+  char blob[1024] = {0};
+
+  for (size_t x= 0; x < keys.size(); ++x)
+  {
+    uint64_t query_id= memcached_query_id(memc);
+    memcached_return_t rc= memcached_add(memc,
+                                         keys.key_at(x), keys.length_at(x),
+                                         blob, sizeof(blob),
+                                         0, 0);
+    test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
+    test_compare(query_id +1, memcached_query_id(memc));
+  }
+
+  /* Try to get all of them with a large multiget */
+  size_t counter= 0;
+  memcached_execute_fn callbacks[]= { &callback_counter };
+  test_compare(MEMCACHED_SUCCESS, 
+               memcached_mget_execute(memc,
+                                      keys.keys_ptr(), keys.lengths_ptr(),
+                                      keys.size(), callbacks, &counter, 1));
+
+  {
+    uint64_t query_id= memcached_query_id(memc);
+    test_compare(MEMCACHED_SUCCESS, 
+                 memcached_fetch_execute(memc, callbacks, (void *)&counter, 1));
+    test_compare(query_id, memcached_query_id(memc));
+
+    /* Verify that we got all of the items */
+    test_compare(keys.size(), counter);
+  }
+
+  memcached_free(memc);
+
+  return TEST_SUCCESS;
+}
+
 #define REGRESSION_BINARY_VS_BLOCK_COUNT  20480
 static pairs_st *global_pairs= NULL;
 
@@ -1894,7 +1942,7 @@ test_return_t regression_1048945_TEST(memcached_st*)
   memcached_server_list_free(list);
   test_compare(status, MEMCACHED_SUCCESS);
 
-  memcached_server_instance_st server= memcached_server_by_key(memc, test_literal_param(__func__), &status);
+  const memcached_instance_st * server= memcached_server_by_key(memc, test_literal_param(__func__), &status);
   test_true(server);
   test_compare(status, MEMCACHED_SUCCESS);
 
@@ -2644,7 +2692,7 @@ test_return_t user_supplied_bug19(memcached_st *)
 
   memcached_st *memc= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
 
-  memcached_server_instance_st server= memcached_server_by_key(memc, "a", 1, &res);
+  const memcached_instance_st * server= memcached_server_by_key(memc, "a", 1, &res);
   test_true(server);
 
   memcached_free(memc);
@@ -2766,6 +2814,20 @@ test_return_t user_supplied_bug21(memcached_st *memc)
   return TEST_SUCCESS;
 }
 
+test_return_t comparison_operator_memcached_st_and__memcached_return_t_TEST(memcached_st *)
+{
+  test::Memc memc_;
+
+  memcached_st *memc= &memc_;
+
+  ASSERT_EQ(memc, MEMCACHED_SUCCESS);
+  test_compare(memc, MEMCACHED_SUCCESS);
+
+  ASSERT_NEQ(memc, MEMCACHED_FAILURE);
+
+  return TEST_SUCCESS;
+}
+
 test_return_t ketama_TEST(memcached_st *)
 {
   test::Memc memc("--server=10.0.1.1:11211 --server=10.0.1.2:11211");
@@ -2830,7 +2892,7 @@ test_return_t output_ketama_weighted_keys(memcached_st *)
     char *hostname = memc->hosts[server_idx].hostname;
     in_port_t port = memc->hosts[server_idx].port;
     fprintf(fp, "key %s is on host /%s:%u\n", key, hostname, port);
-    memcached_server_instance_st instance=
+    const memcached_instance_st * instance=
       memcached_server_instance_by_position(memc, host_index);
   }
   fclose(fp);
@@ -3203,7 +3265,7 @@ test_return_t check_for_1_2_3(memcached_st *memc)
 {
   memcached_version(memc);
 
-  memcached_server_instance_st instance=
+  const memcached_instance_st * instance=
     memcached_server_instance_by_position(memc, 0);
 
   if ((instance->major_version >= 1 && (instance->minor_version == 2 && instance->micro_version >= 4))
@@ -3283,7 +3345,7 @@ test_return_t noreply_test(memcached_st *memc)
     int no_msg=0;
     for (uint32_t x= 0; x < memcached_server_count(memc); ++x)
     {
-      memcached_server_instance_st instance=
+      const memcached_instance_st * instance=
         memcached_server_instance_by_position(memc, x);
       no_msg+=(int)(instance->cursor_active);
     }
@@ -3412,7 +3474,7 @@ test_return_t util_version_test(memcached_st *memc)
   }
   test_true(if_successful == false);
 
-  memcached_server_instance_st instance=
+  const memcached_instance_st * instance=
     memcached_server_instance_by_position(memc, 0);
 
   memcached_version(memc);
@@ -3458,7 +3520,7 @@ test_return_t getpid_connection_failure_test(memcached_st *memc)
 {
   test_skip(memc->servers[0].type, MEMCACHED_CONNECTION_TCP);
   memcached_return_t rc;
-  memcached_server_instance_st instance=
+  const memcached_instance_st * instance=
     memcached_server_instance_by_position(memc, 0);
 
   // Test both the version that returns a code, and the one that does not.
@@ -3476,7 +3538,7 @@ test_return_t getpid_connection_failure_test(memcached_st *memc)
 test_return_t getpid_test(memcached_st *memc)
 {
   memcached_return_t rc;
-  memcached_server_instance_st instance=
+  const memcached_instance_st * instance=
     memcached_server_instance_by_position(memc, 0);
 
   // Test both the version that returns a code, and the one that does not.
@@ -3491,7 +3553,7 @@ test_return_t getpid_test(memcached_st *memc)
 }
 
 static memcached_return_t ping_each_server(const memcached_st*,
-                                           memcached_server_instance_st instance,
+                                           const memcached_instance_st * instance,
                                            void*)
 {
   // Test both the version that returns a code, and the one that does not.
@@ -4146,8 +4208,8 @@ test_return_t regression_bug_447342(memcached_st *memc)
    * This is to verify correct behavior in the library. Fake that two servers
    * are dead..
  */
-  memcached_server_instance_st instance_one= memcached_server_instance_by_position(memc, 0);
-  memcached_server_instance_st instance_two= memcached_server_instance_by_position(memc, 2);
+  const memcached_instance_st * instance_one= memcached_server_instance_by_position(memc, 0);
+  const memcached_instance_st * instance_two= memcached_server_instance_by_position(memc, 2);
   in_port_t port0= instance_one->port();
   in_port_t port2= instance_two->port();
 
@@ -4210,7 +4272,7 @@ test_return_t regression_bug_463297(memcached_st *memc)
   test_true(memc_clone);
   test_true(memcached_version(memc_clone) == MEMCACHED_SUCCESS);
 
-  memcached_server_instance_st instance=
+  const memcached_instance_st * instance=
     memcached_server_instance_by_position(memc_clone, 0);
 
   if (instance->major_version > 1 ||
@@ -4274,7 +4336,7 @@ test_return_t regression_bug_463297(memcached_st *memc)
 test_return_t test_get_last_disconnect(memcached_st *memc)
 {
   memcached_return_t rc;
-  memcached_server_instance_st disconnected_server;
+  const memcached_instance_st * disconnected_server;
 
   /* With the working set of server */
   const char *key= "marmotte";
@@ -4342,7 +4404,7 @@ test_return_t test_multiple_get_last_disconnect(memcached_st *)
       memcached_return_t ret= memcached_set(memc, msg, strlen(msg), NULL, 0, (time_t)0, (uint32_t)0);
       test_true_got((ret == MEMCACHED_CONNECTION_FAILURE or ret == MEMCACHED_SERVER_TEMPORARILY_DISABLED), memcached_last_error_message(memc));
 
-      memcached_server_instance_st disconnected_server= memcached_server_get_last_disconnect(memc);
+      const memcached_instance_st * disconnected_server= memcached_server_get_last_disconnect(memc);
       test_true(disconnected_server);
       test_strcmp("localhost", memcached_server_name(disconnected_server));
       test_true(memcached_server_port(disconnected_server) >= 8888 and memcached_server_port(disconnected_server) <= 8892);
@@ -4367,7 +4429,7 @@ test_return_t test_verbosity(memcached_st *memc)
 }
 
 
-static memcached_return_t stat_printer(memcached_server_instance_st server,
+static memcached_return_t stat_printer(const memcached_instance_st * server,
                                        const char *key, size_t key_length,
                                        const char *value, size_t value_length,
                                        void *context)
@@ -4415,7 +4477,7 @@ test_return_t wrong_failure_counter_test(memcached_st *original_memc)
   test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
 
 
-  memcached_server_instance_st instance= memcached_server_instance_by_position(memc, 0);
+  const memcached_instance_st * instance= memcached_server_instance_by_position(memc, 0);
 
   /* The test is to see that the memcached_quit doesn't increase the
    * the server failure conter, so let's ensure that it is zero
@@ -4604,7 +4666,7 @@ test_return_t regression_bug_583031(memcached_st *)
 {
   memcached_st *memc= memcached_create(NULL);
   test_true(memc);
-  test_compare(MEMCACHED_SUCCESS, memcached_server_add(memc, "10.2.3.4", 11211));
+  test_compare(MEMCACHED_SUCCESS, memcached_server_add(memc, "10.2.251.4", 11211));
 
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, 3000);
   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 1000);
@@ -4621,7 +4683,7 @@ test_return_t regression_bug_583031(memcached_st *)
   test_false(value);
   test_zero(length);
 
-  test_compare_got(MEMCACHED_TIMEOUT, rc, memcached_error(memc));
+  test_compare(MEMCACHED_TIMEOUT, memc);
 
   memcached_free(memc);
 
@@ -4938,7 +5000,7 @@ test_return_t kill_HUP_TEST(memcached_st *original_memc)
   memcached_st *memc= create_single_instance_memcached(original_memc, 0);
   test_true(memc);
 
-  memcached_server_instance_st instance= memcached_server_instance_by_position(memc, 0);
+  const memcached_instance_st * instance= memcached_server_instance_by_position(memc, 0);
 
   pid_t pid;
   test_true((pid= libmemcached_util_getpid(memcached_server_name(instance),
@@ -4956,7 +5018,8 @@ test_return_t kill_HUP_TEST(memcached_st *original_memc)
                                         test_literal_param(__func__), // Keys
                                         test_literal_param(__func__), // Values
                                         0, 0);
-  test_compare(ret, MEMCACHED_CONNECTION_FAILURE);
+  test_compare(ret, memc);
+  test_compare(MEMCACHED_CONNECTION_FAILURE, memc);
 
   memcached_free(memc);
 
diff --git a/tests/libmemcached-1.0/mem_functions.h b/tests/libmemcached-1.0/mem_functions.h
index 374bc9c4..9edc820e 100644
--- a/tests/libmemcached-1.0/mem_functions.h
+++ b/tests/libmemcached-1.0/mem_functions.h
@@ -108,6 +108,7 @@ test_return_t memcached_server_remove_test(memcached_st*);
 test_return_t memcached_stat_execute_test(memcached_st *memc);
 test_return_t mget_end(memcached_st *memc);
 test_return_t mget_execute(memcached_st *original_memc);
+test_return_t MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH_TEST(memcached_st *original_memc);
 test_return_t mget_result_alloc_test(memcached_st *memc);
 test_return_t mget_result_function(memcached_st *memc);
 test_return_t mget_result_test(memcached_st *memc);
@@ -183,3 +184,4 @@ test_return_t regression_994772_TEST(memcached_st*);
 test_return_t regression_1009493_TEST(memcached_st*);
 test_return_t regression_1048945_TEST(memcached_st*);
 test_return_t regression_1067242_TEST(memcached_st*);
+test_return_t comparison_operator_memcached_st_and__memcached_return_t_TEST(memcached_st*);
diff --git a/tests/libmemcached-1.0/parser.cc b/tests/libmemcached-1.0/parser.cc
index bd84cd54..3c474fe7 100644
--- a/tests/libmemcached-1.0/parser.cc
+++ b/tests/libmemcached-1.0/parser.cc
@@ -85,7 +85,7 @@ struct scanner_variable_t {
 // Check and make sure the first host is what we expect it to be
 static test_return_t __check_host(memcached_st *memc, const scanner_string_st &hostname)
 {
-  memcached_server_instance_st instance=
+  const memcached_instance_st * instance=
     memcached_server_instance_by_position(memc, 0);
 
   test_true(instance);
@@ -617,7 +617,7 @@ test_return_t random_statement_build_test(memcached_st*)
 }
 
 static memcached_return_t dump_server_information(const memcached_st *,
-                                                  memcached_server_instance_st instance,
+                                                  const memcached_instance_st * instance,
                                                   void *)
 {
   if (strcmp(memcached_server_name(instance), "localhost")) 
@@ -667,7 +667,7 @@ struct socket_weight_t {
 };
 
 static memcached_return_t dump_socket_information(const memcached_st *,
-                                                  memcached_server_instance_st instance,
+                                                  const memcached_instance_st * instance,
                                                   void *context)
 {
   socket_weight_t *check= (socket_weight_t *)context;
diff --git a/tests/libmemcached-1.0/plus.cpp b/tests/libmemcached-1.0/plus.cpp
index ff6a5ab0..3079b9b3 100644
--- a/tests/libmemcached-1.0/plus.cpp
+++ b/tests/libmemcached-1.0/plus.cpp
@@ -218,7 +218,7 @@ static test_return_t lp_1010899_with_args_TEST(memcached_st *original)
 {
   // Check to see everything is setup internally even when a host is specified
   // on creation.
-  memcached_server_instance_st instance= memcached_server_instance_by_position(original, 0);
+  const memcached_instance_st* instance= memcached_server_instance_by_position(original, 0);
   Memcache memc(memcached_server_name(instance), memcached_server_port(instance));
 
   test_false(memc.increment(__func__, 0, NULL));
diff --git a/tests/libmemcached-1.0/pool.cc b/tests/libmemcached-1.0/pool.cc
index ced14bbc..577c0e94 100644
--- a/tests/libmemcached-1.0/pool.cc
+++ b/tests/libmemcached-1.0/pool.cc
@@ -340,7 +340,7 @@ static memcached_st * create_single_instance_memcached(const memcached_st *origi
    * I only want to hit _one_ server so I know the number of requests I'm
    * sending in the pipeline.
    */
-  memcached_server_instance_st instance= memcached_server_instance_by_position(original_memc, 0);
+  const memcached_instance_st * instance= memcached_server_instance_by_position(original_memc, 0);
 
   char server_string[1024];
   int server_string_length;
diff --git a/tests/libmemcached-1.0/print.cc b/tests/libmemcached-1.0/print.cc
index a05901d0..f1cfe462 100644
--- a/tests/libmemcached-1.0/print.cc
+++ b/tests/libmemcached-1.0/print.cc
@@ -48,7 +48,7 @@ using namespace libtest;
 #include "tests/print.h"
 
 memcached_return_t server_print_callback(const memcached_st*,
-                                         memcached_server_instance_st server,
+                                         const memcached_instance_st * server,
                                          void *context)
 {
   if (context)
@@ -59,18 +59,8 @@ memcached_return_t server_print_callback(const memcached_st*,
   return MEMCACHED_SUCCESS;
 }
 
-const char * print_version(memcached_st *memc)
-{
-  memcached_server_fn callbacks[1];
-  callbacks[0]= server_print_version_callback;
-  memcached_server_cursor(memc, callbacks, NULL,  1);
-
-  return "print_version()";
-}
-
-
 memcached_return_t server_print_version_callback(const memcached_st *,
-                                                 memcached_server_instance_st server,
+                                                 const memcached_instance_st * server,
                                                  void *)
 {
   std::cerr << "Server: " << memcached_server_name(server) << ":" << memcached_server_port(server) << " " 
@@ -81,3 +71,12 @@ memcached_return_t server_print_version_callback(const memcached_st *,
 
   return MEMCACHED_SUCCESS;
 }
+
+const char * print_version(memcached_st *memc)
+{
+  memcached_server_fn callbacks[1];
+  callbacks[0]= server_print_version_callback;
+  memcached_server_cursor(memc, callbacks, NULL,  1);
+
+  return "print_version()";
+}
diff --git a/tests/libmemcached-1.0/replication.cc b/tests/libmemcached-1.0/replication.cc
index 5a7fa876..9c31ab3d 100644
--- a/tests/libmemcached-1.0/replication.cc
+++ b/tests/libmemcached-1.0/replication.cc
@@ -126,7 +126,7 @@ test_return_t replication_get_test(memcached_st *memc)
   for (uint32_t host= 0; host < memcached_server_count(memc); ++host)
   {
     memcached_st *memc_clone= memcached_clone(NULL, memc);
-    org::libmemcached::Instance* instance= (org::libmemcached::Instance*)memcached_server_instance_by_position(memc_clone, host);
+    memcached_instance_st* instance= (memcached_instance_st*)memcached_server_instance_by_position(memc_clone, host);
 
     instance->port(0);
 
@@ -188,7 +188,7 @@ test_return_t replication_mget_test(memcached_st *memc)
   for (uint32_t host= 0; host < memcached_server_count(memc_clone); host++)
   {
     memcached_st *new_clone= memcached_clone(NULL, memc);
-    memcached_server_instance_st instance= memcached_server_instance_by_position(new_clone, host);
+    const memcached_instance_st * instance= memcached_server_instance_by_position(new_clone, host);
     ((memcached_server_write_instance_st)instance)->port(0);
 
     for (int x= 'a'; x <= 'z'; ++x)
diff --git a/tests/libmemcached-1.0/stat.cc b/tests/libmemcached-1.0/stat.cc
index 5305eeac..f2847bdb 100644
--- a/tests/libmemcached-1.0/stat.cc
+++ b/tests/libmemcached-1.0/stat.cc
@@ -48,7 +48,7 @@ using namespace libtest;
 
 #include "tests/libmemcached-1.0/stat.h"
 
-static memcached_return_t item_counter(memcached_server_instance_st ,
+static memcached_return_t item_counter(const memcached_instance_st * ,
                                        const char *key, size_t key_length,
                                        const char *value, size_t, // value_length,
                                        void *context)
diff --git a/tests/libmemcached-1.0/touch.cc b/tests/libmemcached-1.0/touch.cc
index 4f5385ec..092a182a 100644
--- a/tests/libmemcached-1.0/touch.cc
+++ b/tests/libmemcached-1.0/touch.cc
@@ -48,14 +48,13 @@ using namespace libtest;
 static test_return_t pre_touch(memcached_st *memc)
 {
   test_compare(MEMCACHED_SUCCESS, memcached_version(memc));
-  test_skip(true, libmemcached_util_version_check(memc, 1, 4, 8));
+  test_skip(true, libmemcached_util_version_check(memc, 1, 4, 15));
 
   return TEST_SUCCESS;
 }
 
 test_return_t test_memcached_touch(memcached_st *memc)
 {
-
   test_skip(TEST_SUCCESS, pre_touch(memc));
 
   size_t len;
@@ -85,21 +84,20 @@ test_return_t test_memcached_touch(memcached_st *memc)
     free(value);
   }
 
-  test_compare(MEMCACHED_SUCCESS,
-               memcached_touch(memc, test_literal_param(__func__), 60 *60));
+  rc= memcached_touch(memc, test_literal_param(__func__), 60 *60);
+  ASSERT_EQ_(MEMCACHED_SUCCESS, rc, "%s", memcached_last_error_message(memc));
 
   rc= memcached_touch(memc, test_literal_param(__func__), 60 *60 *24 *60);
-  test_compare(MEMCACHED_SUCCESS, rc);
+  ASSERT_EQ_(MEMCACHED_SUCCESS, rc, "%s", memcached_last_error_message(memc));
 
-  test_compare(MEMCACHED_NOTFOUND,
-               memcached_exist(memc, test_literal_param(__func__)));
+  rc= memcached_exist(memc, test_literal_param(__func__));
+  ASSERT_EQ_(MEMCACHED_NOTFOUND, rc, "%s", memcached_last_error_message(memc));
 
   return TEST_SUCCESS;
 }
 
 test_return_t test_memcached_touch_by_key(memcached_st *memc)
 {
-
   test_skip(TEST_SUCCESS, pre_touch(memc));
 
   size_t len;
@@ -132,19 +130,20 @@ test_return_t test_memcached_touch_by_key(memcached_st *memc)
     free(value);
   }
 
-  test_compare(MEMCACHED_SUCCESS,
-               memcached_touch_by_key(memc,
-                                      test_literal_param("grouping_key"),
-                                      test_literal_param(__func__),
-                                      60 *60));
+  rc= memcached_touch_by_key(memc,
+                             test_literal_param("grouping_key"),
+                             test_literal_param(__func__),
+                             60 *60);
+  ASSERT_EQ_(MEMCACHED_SUCCESS, rc, "%s", memcached_last_error_message(memc));
 
-  test_compare(MEMCACHED_SUCCESS,
-               memcached_touch_by_key(memc,
-                                      test_literal_param("grouping_key"),
-                                      test_literal_param(__func__),
-                                      60 *60 *24 *60));
-  test_compare(MEMCACHED_NOTFOUND,
-               memcached_exist_by_key(memc, test_literal_param("grouping_key"),test_literal_param(__func__)));
+  rc= memcached_touch_by_key(memc,
+                             test_literal_param("grouping_key"),
+                             test_literal_param(__func__),
+                             60 *60 *24 *60);
+  ASSERT_EQ_(MEMCACHED_SUCCESS, rc, "%s", memcached_last_error_message(memc));
+
+  rc= memcached_exist_by_key(memc, test_literal_param("grouping_key"),test_literal_param(__func__));
+  ASSERT_EQ_(MEMCACHED_NOTFOUND, rc, "%s", memcached_last_error_message(memc));
 
   return TEST_SUCCESS;
 }
diff --git a/tests/mem_udp.cc b/tests/mem_udp.cc
index dc2d10f5..41fc910b 100644
--- a/tests/mem_udp.cc
+++ b/tests/mem_udp.cc
@@ -106,9 +106,9 @@ static void get_udp_request_ids(memcached_st *memc, Expected &ids)
 {
   for (uint32_t x= 0; x < memcached_server_count(memc); x++)
   {
-    memcached_server_instance_st instance= memcached_server_instance_by_position(memc, x);
+    const memcached_instance_st * instance= memcached_server_instance_by_position(memc, x);
 
-    ids.push_back(get_udp_datagram_request_id((struct udp_datagram_header_st *) ((memcached_server_instance_st )instance)->write_buffer));
+    ids.push_back(get_udp_datagram_request_id((struct udp_datagram_header_st *) ((const memcached_instance_st * )instance)->write_buffer));
   }
 }
 
@@ -173,7 +173,7 @@ static test_return_t add_tcp_server_udp_client_test(memcached_st *memc)
   (void)memc;
 #if 0
   memcached_server_st server;
-  memcached_server_instance_st instance=
+  const memcached_instance_st * instance=
     memcached_server_instance_by_position(memc, 0);
   memcached_server_clone(&server, &memc->hosts[0]);
   test_true(memcached_server_remove(&(memc->hosts[0])) == MEMCACHED_SUCCESS);
@@ -188,7 +188,7 @@ static test_return_t add_udp_server_tcp_client_test(memcached_st *memc)
   (void)memc;
 #if 0
   memcached_server_st server;
-  memcached_server_instance_st instance=
+  const memcached_instance_st * instance=
     memcached_server_instance_by_position(memc, 0);
   memcached_server_clone(&server, &memc->hosts[0]);
   test_true(memcached_server_remove(&(memc->hosts[0])) == MEMCACHED_SUCCESS);
@@ -284,7 +284,7 @@ static test_return_t udp_set_test(memcached_st *memc)
     get_udp_request_ids(memc, expected_ids);
     unsigned int server_key= memcached_generate_hash(memc, test_literal_param("foo"));
     test_true(server_key < memcached_server_count(memc));
-    memcached_server_instance_st instance= memcached_server_instance_by_position(memc, server_key);
+    const memcached_instance_st * instance= memcached_server_instance_by_position(memc, server_key);
     size_t init_offset= instance->write_buffer_offset;
 
     test_compare_hint(MEMCACHED_SUCCESS, 
@@ -349,7 +349,7 @@ static test_return_t udp_delete_test(memcached_st *memc)
     get_udp_request_ids(memc, expected_ids);
 
     unsigned int server_key= memcached_generate_hash(memc, test_literal_param("foo"));
-    memcached_server_instance_st instance= memcached_server_instance_by_position(memc, server_key);
+    const memcached_instance_st * instance= memcached_server_instance_by_position(memc, server_key);
     size_t init_offset= instance->write_buffer_offset;
 
     test_compare(MEMCACHED_SUCCESS,
@@ -483,7 +483,7 @@ static test_return_t udp_get_test(memcached_st *memc)
   size_t vlen;
   Expected expected_ids;
   get_udp_request_ids(memc, expected_ids);
-  test_null(memcached_get(memc, test_literal_param("foo"), &vlen, (uint32_t)0, &rc));
+  test_null(memcached_get(memc, test_literal_param("foo"), &vlen, NULL, &rc));
   test_compare(MEMCACHED_NOT_SUPPORTED, rc);
 
   return post_udp_op_check(memc, expected_ids);
diff --git a/tests/memping.cc b/tests/memping.cc
new file mode 100644
index 00000000..6161611d
--- /dev/null
+++ b/tests/memping.cc
@@ -0,0 +1,121 @@
+/*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ * 
+ *  Test memping
+ *
+ *  Copyright (C) 2011-2013 Data Differential, http://datadifferential.com/
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions are
+ *  met:
+ *
+ *      * Redistributions of source code must retain the above copyright
+ *  notice, this list of conditions and the following disclaimer.
+ *
+ *      * Redistributions in binary form must reproduce the above
+ *  copyright notice, this list of conditions and the following disclaimer
+ *  in the documentation and/or other materials provided with the
+ *  distribution.
+ *
+ *      * The names of its contributors may not be used to endorse or
+ *  promote products derived from this software without specific prior
+ *  written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+
+/*
+  Test that we are cycling the servers we are creating during testing.
+*/
+
+#include <mem_config.h>
+
+#include <libtest/test.hpp>
+#include <libmemcached-1.2/memcached.h>
+
+using namespace libtest;
+
+#ifndef __INTEL_COMPILER
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif
+
+static std::string executable("clients/memping");
+
+static test_return_t help_test(void *)
+{
+  const char *args[]= { "--help", 0 };
+
+  test_compare(EXIT_SUCCESS, exec_cmdline(executable, args, true));
+
+  return TEST_SUCCESS;
+}
+
+static test_return_t ping_TEST(void *)
+{
+  char buffer[1024];
+  snprintf(buffer, sizeof(buffer), "--server=localhost:%d", int(default_port()));
+  const char *args[]= { buffer, 0 };
+
+  test_compare(EXIT_SUCCESS, exec_cmdline(executable, args, true));
+
+  return TEST_SUCCESS;
+}
+
+static test_return_t NOT_FOUND_TEST(void *)
+{
+  char buffer[1024];
+  snprintf(buffer, sizeof(buffer), "--server=nonexist.libmemcached.org:%d", int(default_port()));
+  const char *args[]= { buffer, 0 };
+
+  test_compare(EXIT_FAILURE, exec_cmdline(executable, args, true));
+
+  return TEST_SUCCESS;
+}
+
+test_st memping_TESTS[] ={
+  {"--help", true, help_test },
+  {"ping(FOUND)", true, ping_TEST },
+  {"ping(NOT_FOUND)", true, NOT_FOUND_TEST },
+  {0, 0, 0}
+};
+
+collection_st collection[] ={
+  {"memping", 0, 0, memping_TESTS },
+  {0, 0, 0, 0}
+};
+
+static void *world_create(server_startup_st& servers, test_return_t& error)
+{
+  if (libtest::has_memcached() == false)
+  {
+    error= TEST_SKIPPED;
+    return NULL;
+  }
+
+  if (server_startup(servers, "memcached", libtest::default_port(), NULL) == false)
+  {
+    error= TEST_FAILURE;
+  }
+
+  return &servers;
+}
+
+
+void get_world(libtest::Framework* world)
+{
+  world->collections(collection);
+  world->create(world_create);
+}
+
+
diff --git a/tests/print.h b/tests/print.h
index 7460dc3b..f5fcf899 100644
--- a/tests/print.h
+++ b/tests/print.h
@@ -38,11 +38,11 @@
 #pragma once
 
 memcached_return_t server_print_callback(const memcached_st *ptr,
-                                         memcached_server_instance_st server,
+                                         const memcached_instance_st *server,
                                          void *context);
 
 memcached_return_t server_print_version_callback(const memcached_st *ptr,
-                                                 memcached_server_instance_st server,
+                                                 const memcached_server_st *server,
                                                  void *context);
 
 const char * print_version(memcached_st *memc);