Merge lp:~brianaker/libmemcached/feature-server_timeout into lp:libmemcached

[Brian Aker]

[lp:~brianaker/libmemcached/feature-server_timeout]

1182. By Brian Aker on 2014-02-05

Fix issue where we missed MEMCACHED_BEHAVIOR_SERVER_TIMEOUT_LIMIT from a switch/case.

=== removed file '.quickly'
--- .quickly	2012-05-05 22:11:48 +0000
+++ .quickly	1970-01-01 00:00:00 +0000
@@ -1,5 +0,0 @@
-project = libmemcached
-version = 0.4.2
-template = pandora-build
-project-type = library
-pandora-version = 0.175

=== modified file 'ChangeLog'
--- ChangeLog	2013-05-04 09:20:42 +0000
+++ ChangeLog	2014-02-05 00:01:58 +0000
@@ -2,7 +2,11 @@
 * Enable MEMCACHED_BEHAVIOR_VERIFY_KEY by default
 
 1.0.18
+<<<<<<< TREE
 *
+=======
+* MEMCACHED_BEHAVIOR_RETRY_TIMEOUT can now be set to zero.
+>>>>>>> MERGE-SOURCE
 
 1.0.17 Tue Apr  2 14:02:01 HST 2013
 * Remove c++ namespace that was being exposed (the API should be plug compatible)..

=== added file 'GNUmakefile'
--- GNUmakefile	1970-01-01 00:00:00 +0000
+++ GNUmakefile	2014-02-05 00:01:58 +0000
@@ -0,0 +1,36 @@
+# -*-Makefile-*-
+#
+_bootstrap_Makefile := $(wildcard [M]akefile)
+_bootstrap_config-status := $(wildcard config.status)
+
+ALL_RECURSIVE_TARGETS=
+
+ifneq ($(_bootstrap_Makefile),)
+  include Makefile
+else
+  ifneq ($(_bt_config-status),)
+    $(srcdir)/config.status
+    $(MAKE) $(AM_MAKEFLAGS) configure
+  endif
+
+.DEFAULT_GOAL:= basic_build
+srcdir= .
+
+configure: bootstrap.sh
+	@$(srcdir)/bootstrap.sh -a
+
+Makefile: configure
+	@$(srcdir)/bootstrap.sh -c
+
+.PHONY: basic_build
+basic_build: Makefile
+	@$(MAKE) $(AM_MAKEFLAGS)
+endif
+
+ALL_RECURSIVE_TARGETS+= $(AM_RECURSIVE_TARGETS)
+
+ifneq ($(word 2, $(MAKECMDGOALS)), )
+ifneq ($(filter $(ALL_RECURSIVE_TARGETS), $(MAKECMDGOALS)), )
+.NOTPARALLEL:
+endif
+endif

=== modified file 'Makefile.am'
--- Makefile.am	2013-05-04 09:20:42 +0000
+++ Makefile.am	2014-02-05 00:01:58 +0000
@@ -31,7 +31,6 @@
 
 DISTCLEANFILES+= aminclude.am
 
-EXTRA_DIST+= .quickly
 EXTRA_DIST+= README.FIRST
 EXTRA_DIST+= README.win32
 
@@ -137,5 +136,7 @@
 	-rm -f m4/ltsugar.m4
 	-rm -f m4/ltversion.m4
 	-rm -f m4/lt~obsolete.m4
+	-rm -f m4/test-driver
 	-rmdir build-aux
 	-rm -rf ${top_builddir}/html
+	-rm -f bootstrap

=== modified file 'bootstrap.sh'
--- bootstrap.sh	2013-11-04 17:14:31 +0000
+++ bootstrap.sh	2014-02-05 00:01:58 +0000
@@ -38,7 +38,7 @@
 #   LIBTOOLIZE
 #   MAKE
 #   PREFIX
-#   TESTS_ENVIRONMENT
+#   LOG_COMPILER
 #   VERBOSE
 #   WARNINGS
 #
@@ -486,8 +486,8 @@
     die "OLD_MAKE($OLD_MAKE) was set on push, programmer error!"
   fi
 
-  if [[ -n "$OLD_TESTS_ENVIRONMENT" ]]; then
-    die "OLD_TESTS_ENVIRONMENT($OLD_TESTS_ENVIRONMENT) was set on push, programmer error!"
+  if [[ -n "$OLD_LOG_COMPILER" ]]; then
+    die "OLD_LOG_COMPILER($OLD_LOG_COMPILER) was set on push, programmer error!"
   fi
 
   if [[ -n "$CONFIGURE" ]]; then
@@ -502,8 +502,8 @@
     OLD_MAKE=$MAKE
   fi
 
-  if [[ -n "$TESTS_ENVIRONMENT" ]]; then
-    OLD_TESTS_ENVIRONMENT=$TESTS_ENVIRONMENT
+  if [[ -n "$LOG_COMPILER" ]]; then
+    OLD_LOG_COMPILER=$LOG_COMPILER
   fi
 }
 
@@ -525,15 +525,15 @@
     MAKE=$OLD_MAKE
   fi
 
-  if [[ -n "$OLD_TESTS_ENVIRONMENT" ]]; then
-    TESTS_ENVIRONMENT=$OLD_TESTS_ENVIRONMENT
+  if [[ -n "$OLD_LOG_COMPILER" ]]; then
+    LOG_COMPILER=$OLD_LOG_COMPILER
   fi
 
   OLD_CONFIGURE=
   OLD_CONFIGURE_ARG=
   OLD_PREFIX=
   OLD_MAKE=
-  OLD_TESTS_ENVIRONMENT=
+  OLD_LOG_COMPILER=
 
   export -n CC CXX
 }
@@ -567,9 +567,9 @@
   # If we don't have a configure, then most likely we will be missing libtool
   assert_file 'configure'
   if [[ -x 'libtool' ]]; then
-    TESTS_ENVIRONMENT="./libtool --mode=execute $VALGRIND_COMMAND"
+    LOG_COMPILER="./libtool --mode=execute $VALGRIND_COMMAND"
   else
-    TESTS_ENVIRONMENT="$VALGRIND_COMMAND"
+    LOG_COMPILER="$VALGRIND_COMMAND"
   fi
 
   make_target 'all'
@@ -703,11 +703,11 @@
     else
       if [[ -n "$DISPLAY" ]]; then
         if command_exists 'wine'; then
-          TESTS_ENVIRONMENT='wine'
+          LOG_COMPILER='wine'
         fi
       fi
 
-      if [[ -n "$TESTS_ENVIRONMENT" ]]; then
+      if [[ -n "$LOG_COMPILER" ]]; then
         make_target 'check' 'warn' || warn "$MAKE check failed"
         ret=$?
       fi
@@ -935,9 +935,9 @@
     # If we don't have a configure, then most likely we will be missing libtool
     assert_file 'configure'
     if [[ -f 'libtool' ]]; then
-      TESTS_ENVIRONMENT="./libtool --mode=execute $GDB_COMMAND"
+      LOG_COMPILER="./libtool --mode=execute $GDB_COMMAND"
     else
-      TESTS_ENVIRONMENT="$GDB_COMMAND"
+      LOG_COMPILER="$GDB_COMMAND"
     fi
 
     make_target 'check'
@@ -974,9 +974,9 @@
     run_configure
   fi
 
-  if [ -n "$TESTS_ENVIRONMENT" ]; then
+  if [ -n "$LOG_COMPILER" ]; then
     if $verbose; then
-      echo "TESTS_ENVIRONMENT=$TESTS_ENVIRONMENT"
+      echo "LOG_COMPILER=$LOG_COMPILER"
     fi
   fi
 
@@ -1386,16 +1386,16 @@
     echo "MAKE=$MAKE"
   fi
 
-  if [[ -n "$MAKE_TARGET" ]]; then
-    echo "MAKE_TARGET=$MAKE_TARGET"
+  if [[ -n "$BOOTSTRAP_TARGET" ]]; then
+    echo "BOOTSTRAP_TARGET=$BOOTSTRAP_TARGET"
   fi
 
   if [[ -n "$PREFIX" ]]; then
     echo "PREFIX=$PREFIX"
   fi
 
-  if [[ -n "$TESTS_ENVIRONMENT" ]]; then
-    echo "TESTS_ENVIRONMENT=$TESTS_ENVIRONMENT"
+  if [[ -n "$LOG_COMPILER" ]]; then
+    echo "LOG_COMPILER=$LOG_COMPILER"
   fi
 
   if [[ -n "$VCS_CHECKOUT" ]]; then
@@ -1511,7 +1511,7 @@
 execute_job ()
 {
   # We should always have a target by this point
-  assert MAKE_TARGET
+  assert BOOTSTRAP_TARGET
 
   determine_target_platform
 
@@ -1535,8 +1535,8 @@
     fi
   fi
 
-  # Use OLD_TESTS_ENVIRONMENT for tracking the state of the variable
-  local OLD_TESTS_ENVIRONMENT=
+  # Use OLD_LOG_COMPILER for tracking the state of the variable
+  local OLD_LOG_COMPILER=
 
   # Set ENV PREFIX in order to set --prefix for ./configure
   if [[ -n "$PREFIX" ]]; then 
@@ -1547,17 +1547,17 @@
     make_maintainer_clean
   fi
 
-  local MAKE_TARGET_ARRAY
-  MAKE_TARGET_ARRAY=( $MAKE_TARGET )
+  local BOOTSTRAP_TARGET_ARRAY
+  BOOTSTRAP_TARGET_ARRAY=( $BOOTSTRAP_TARGET )
 
-  for target in "${MAKE_TARGET_ARRAY[@]}"
+  for target in "${BOOTSTRAP_TARGET_ARRAY[@]}"
   do
     # If we are running inside of Jenkins, we want to only run some of the possible tests
     if $jenkins_build_environment; then
       check_make_target $target
       ret=$?
       if [ $ret -ne 0 ]; then
-        die "Unknown MAKE_TARGET option: $target"
+        die "Unknown BOOTSTRAP_TARGET option: $target"
       fi
     fi
 
@@ -1663,7 +1663,7 @@
   declare -x VCS_CHECKOUT=
 
   # Variables we control globally
-  local -a MAKE_TARGET=
+  local -a BOOTSTRAP_TARGET=
   local CONFIGURE=
   local use_libtool=false
   local verbose=false
@@ -1688,7 +1688,7 @@
   local OLD_CONFIGURE_ARG=
   local OLD_PREFIX=
   local OLD_MAKE=
-  local OLD_TESTS_ENVIRONMENT=
+  local OLD_LOG_COMPILER=
 
   # If we call autoreconf on the platform or not
   local AUTORECONF_REBUILD_HOST=false
@@ -1726,47 +1726,36 @@
   local OPT_TARGET=
   parse_command_line_options "$@"
 
-  nassert MAKE_TARGET
+  nassert BOOTSTRAP_TARGET
 
   if [ -n "$OPT_TARGET" ]; then
-    MAKE_TARGET="$OPT_TARGET"
+    BOOTSTRAP_TARGET="$OPT_TARGET"
   fi
 
   # If we are running under Jenkins we predetermine what tests we will run against
-  # This MAKE_TARGET can be overridden by parse_command_line_options based MAKE_TARGET changes.
+  # This BOOTSTRAP_TARGET can be overridden by parse_command_line_options based BOOTSTRAP_TARGET changes.
   # We don't want Jenkins overriding other variables, so we NULL them.
-  if [ -z "$MAKE_TARGET" ]; then
+  if [ -z "$BOOTSTRAP_TARGET" ]; then
     if $jenkins_build_environment; then
       if [[ -n "$JENKINS_TARGET" ]]; then
-        MAKE_TARGET="$JENKINS_TARGET"
+        check_make_target $JENKINS_TARGET
+        if [ $? -eq 0 ]; then
+          BOOTSTRAP_TARGET="$JENKINS_TARGET"
+        else
+          die "label not found: $label"
+        fi
       else
-        if [[ -n "$label" ]]; then
-          check_make_target $label
-          if [ $? -eq 0 ]; then
-            MAKE_TARGET="$label"
-          fi
-        fi
-
-        if [[ -n "$LABEL" ]]; then
-          check_make_target $LABEL
-          if [ $? -eq 0 ]; then
-            MAKE_TARGET="$LABEL"
-          fi
-        fi
-
-        if [ -z "$MAKE_TARGET" ]; then
-          MAKE_TARGET='jenkins'
-        fi
+          BOOTSTRAP_TARGET='jenkins'
       fi
     fi
   fi
 
-  if [ -z "$MAKE_TARGET" ]; then
-    MAKE_TARGET="make_default"
+  if [ -z "$BOOTSTRAP_TARGET" ]; then
+    BOOTSTRAP_TARGET="make_default"
   fi
 
   # We should always have a target by this point
-  assert MAKE_TARGET
+  assert BOOTSTRAP_TARGET
 
   execute_job
   local ret=$?
@@ -1882,7 +1871,7 @@
   export LIBTOOLIZE_OPTIONS
   export MAKE
   export PREFIX_ARG
-  export TESTS_ENVIRONMENT
+  export LOG_COMPILER
   export VERBOSE
   export WARNINGS
 

=== modified file 'clients/include.am'
--- clients/include.am	2013-10-02 00:54:50 +0000
+++ clients/include.am	2014-02-05 00:01:58 +0000
@@ -102,10 +102,12 @@
 clients_memaslap_LDADD+= $(CLIENTS_LDADDS)
 clients_memaslap_LDADD+= @PTHREAD_LIBS@
 
+clients_memcapable_CXXFLAGS= @PTHREAD_CFLAGS@
 clients_memcapable_SOURCES=
 clients_memcapable_SOURCES+= clients/memcapable.cc
 clients_memcapable_SOURCES+= libmemcached/byteorder.cc
 clients_memcapable_LDADD= $(CLIENTS_LDADDS)
+clients_memcapable_LDADD+= @PTHREAD_LIBS@
 
 test-start-server:
 	clients/memflush --servers=localhost

=== modified file 'clients/memcp.cc'
--- clients/memcp.cc	2013-10-11 12:19:52 +0000
+++ clients/memcp.cc	2014-02-05 00:01:58 +0000
@@ -68,13 +68,13 @@
       or (errno != 0 && val == 0))
   {
     *error= true;
-    return EXIT_SUCCESS;
+    return 0;
   }
 
   if (endptr == nptr)
   {
     *error= true;
-    return EXIT_SUCCESS;
+    return 0;
   }
 
   *error= false;
@@ -385,10 +385,10 @@
     case OPT_EXPIRE: /* --expire */
       {
         bool strtol_error;
-        opt_expires= (time_t)strtol_wrapper(optarg, 16, &strtol_error);
+        opt_expires= (time_t)strtol_wrapper(optarg, 10, &strtol_error);
         if (strtol_error == true)
         {
-          fprintf(stderr, "Bad value passed via --flag\n");
+          fprintf(stderr, "Bad value passed via --expire\n");
           exit(1);
         }
       }

=== modified file 'configure.ac'
--- configure.ac	2013-11-04 17:14:31 +0000
+++ configure.ac	2014-02-05 00:01:58 +0000
@@ -7,18 +7,22 @@
 # the COPYING file in this directory for full text.
 
 m4_include([version.m4])
+AC_PREREQ([2.61])
 AC_INIT([libmemcached],VERSION_NUMBER,[http://libmemcached.org/])
+
+# Setup the compilers early on
+AC_PROG_CC([cc gcc clang])
+AC_PROG_CXX([c++ g++ clang++])
+
 AC_CONFIG_AUX_DIR([build-aux])
 AC_CONFIG_MACRO_DIR([m4])
 
-AC_CANONICAL_TARGET
+AC_CANONICAL_HOST
 AC_ARG_PROGRAM
 AC_USE_SYSTEM_EXTENSIONS
 
 AM_INIT_AUTOMAKE([1.11 color-tests -Wno-portability subdir-objects foreign tar-ustar])
 
-AC_PREREQ([2.61])
-
 AC_CONFIG_HEADERS([mem_config.h:mem_config.in])dnl Keep filename to 8.3 for MS-DOS.
 AC_SUBST([AUTOHEADER_FILE],[mem_config.h])
 AC_CONFIG_SRCDIR([libmemcached/memcached.cc])
@@ -47,17 +51,20 @@
 m4_include([libhashkit/include.m4])
 
 LT_PREREQ([2.2])
-LT_INIT
+LT_INIT([dlopen])
 LT_LANG([C++])
 LT_LIB_M
 
+AC_SUBST([lt_cv_dlopen_libs])
+
+
 AC_PROG_CC_C99
 AS_IF([test "x${ac_cv_prog_cc_c99}" == "xno"],[AC_MSG_ERROR([No c99 compatible compiler found])])
 
 AC_DEFUN([CHECK_CXX0X],[
           AC_LANG_PUSH([C++])
           AX_CHECK_COMPILE_FLAG([-std=c++0x],[
-                                 CXXFLAGS="$CXXFLAGS -std=c++0x"])
+                                 CXX="$CXX -std=c++0x"])
           AC_LANG_POP([C++])
           ])
 CHECK_CXX0X
@@ -65,13 +72,8 @@
 AX_ASSERT
 
 AX_PLATFORM
-
 m4_ifdef([AM_SILENT_RULES],[AM_SILENT_RULES([yes])])
 
-AX_CXX_HEADER_STDCXX_98
-AS_IF([test "x$ax_cv_cxx_stdcxx_98" = "xno"],
-      [AC_MSG_ERROR([Your system lacks a new enough C++ compiler])])
-
 AC_DEFUN([LIBMEMCACHED_PROTOCOL],
          [AC_ARG_ENABLE([libmemcachedprotocol],
                         [AS_HELP_STRING([--enable-libmemcachedprotocol],
@@ -255,9 +257,6 @@
              [AC_DEFINE([HAVE_CLOCK_GETTIME],[0],[Have clock_gettime])])
 
 
-# Check for the ability to call dlopen (used in libhostile)
-AX_DLOPEN
-
 AC_CHECK_HEADERS([atomic.h])
 AS_IF([test "x$ac_cv_header_atomic_h" = "xyes"],
       [AC_CHECK_FUNCS([atomic_add_64])
@@ -298,8 +297,10 @@
 AX_UUID_GENERATE_TIME_SAFE
 
 AC_DEFUN([CHECK_FOR_PTHREAD_AND_SASL],
-         [AX_PTHREAD(, [AC_MSG_ERROR([could not find libpthread])])
+         [AC_LANG_PUSH([C++])
+         AX_PTHREAD(, [AC_MSG_ERROR([could not find libpthread])])
          AX_PTHREAD_TIMEDJOIN_NP
+         AC_LANG_POP([C++])
 
          # The sasl functions should only be visible if we build with sasl support
          #

=== modified file 'libmemcached-1.2/defaults.h'
--- libmemcached-1.2/defaults.h	2013-05-03 08:44:02 +0000
+++ libmemcached-1.2/defaults.h	2014-02-05 00:01:58 +0000
@@ -52,5 +52,5 @@
 #define MEMCACHED_SERVER_FAILURE_LIMIT 5
 #define MEMCACHED_SERVER_FAILURE_RETRY_TIMEOUT 2
 #define MEMCACHED_SERVER_FAILURE_DEAD_TIMEOUT 0
-
+#define MEMCACHED_SERVER_TIMEOUT_LIMIT 0
 

=== modified file 'libmemcached-1.2/server.h'
--- libmemcached-1.2/server.h	2013-04-03 13:14:23 +0000
+++ libmemcached-1.2/server.h	2014-02-05 00:01:58 +0000
@@ -104,6 +104,9 @@
 in_port_t memcached_server_port(const memcached_instance_st * self);
 
 LIBMEMCACHED_API
+in_port_t memcached_server_srcport(const memcached_instance_st * self);
+
+LIBMEMCACHED_API
 void memcached_instance_next_retry(const memcached_instance_st * self, const time_t absolute_time);
 
 LIBMEMCACHED_API

=== modified file 'libmemcached-1.2/struct/memcached.h'
--- libmemcached-1.2/struct/memcached.h	2013-03-31 23:24:29 +0000
+++ libmemcached-1.2/struct/memcached.h	2014-02-05 00:01:58 +0000
@@ -79,6 +79,7 @@
   int32_t snd_timeout;
   int32_t rcv_timeout;
   uint32_t server_failure_limit;
+  uint32_t server_timeout_limit;
   uint32_t io_msg_watermark;
   uint32_t io_bytes_watermark;
   uint32_t io_key_prefetch;

=== modified file 'libmemcached-1.2/struct/server.h'
--- libmemcached-1.2/struct/server.h	2012-10-25 06:28:22 +0000
+++ libmemcached-1.2/struct/server.h	2014-02-05 00:01:58 +0000
@@ -77,6 +77,8 @@
   uint32_t request_id;
   uint32_t server_failure_counter;
   uint64_t server_failure_counter_query_id;
+  uint32_t server_timeout_counter;
+  uint64_t server_timeout_counter_query_id;
   uint32_t weight;
   uint32_t version;
   enum memcached_server_state_t state;

=== modified file 'libmemcached-1.2/types/behavior.h'
--- libmemcached-1.2/types/behavior.h	2012-01-08 00:54:08 +0000
+++ libmemcached-1.2/types/behavior.h	2014-02-05 00:01:58 +0000
@@ -76,6 +76,7 @@
   MEMCACHED_BEHAVIOR_LOAD_FROM_FILE,
   MEMCACHED_BEHAVIOR_REMOVE_FAILED_SERVERS,
   MEMCACHED_BEHAVIOR_DEAD_TIMEOUT,
+  MEMCACHED_BEHAVIOR_SERVER_TIMEOUT_LIMIT,
   MEMCACHED_BEHAVIOR_MAX
 };
 

=== modified file 'libmemcached/behavior.cc'
--- libmemcached/behavior.cc	2013-03-31 23:24:29 +0000
+++ libmemcached/behavior.cc	2014-02-05 00:01:58 +0000
@@ -116,6 +116,10 @@
     ptr->server_failure_limit= uint32_t(data);
     break;
 
+  case MEMCACHED_BEHAVIOR_SERVER_TIMEOUT_LIMIT:
+    ptr->server_timeout_limit= uint32_t(data);
+    break;
+
   case MEMCACHED_BEHAVIOR_BINARY_PROTOCOL:
     send_quit(ptr); // We need t shutdown all of the connections to make sure we do the correct protocol
     if (data)
@@ -230,11 +234,6 @@
     break;
 
   case MEMCACHED_BEHAVIOR_RETRY_TIMEOUT:
-    if (data == 0)
-    {
-      return memcached_set_error(*ptr, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT,
-                                        memcached_literal_param("MEMCACHED_BEHAVIOR_RETRY_TIMEOUT requires a value greater then zero."));
-    }
     ptr->retry_timeout= int32_t(data);
     break;
 
@@ -379,6 +378,9 @@
   case MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT:
     return ptr->server_failure_limit;
 
+  case MEMCACHED_BEHAVIOR_SERVER_TIMEOUT_LIMIT:
+    return ptr->server_timeout_limit;
+
   case MEMCACHED_BEHAVIOR_SORT_HOSTS:
     return ptr->flags.use_sort_hosts;
 
@@ -628,6 +630,7 @@
 {
   switch (flag)
   {
+  case MEMCACHED_BEHAVIOR_SERVER_TIMEOUT_LIMIT: return "MEMCACHED_BEHAVIOR_SERVER_TIMEOUT_LIMIT";
   case MEMCACHED_BEHAVIOR_NO_BLOCK: return "MEMCACHED_BEHAVIOR_NO_BLOCK";
   case MEMCACHED_BEHAVIOR_TCP_NODELAY: return "MEMCACHED_BEHAVIOR_TCP_NODELAY";
   case MEMCACHED_BEHAVIOR_HASH: return "MEMCACHED_BEHAVIOR_HASH";

=== modified file 'libmemcached/connect.cc'
--- libmemcached/connect.cc	2013-10-11 12:19:52 +0000
+++ libmemcached/connect.cc	2014-02-05 00:01:58 +0000
@@ -198,7 +198,7 @@
   struct addrinfo hints;
   memset(&hints, 0, sizeof(struct addrinfo));
 
-  hints.ai_family= AF_INET;
+  hints.ai_family= AF_UNSPEC;
   if (memcached_is_udp(server->root))
   {
     hints.ai_protocol= IPPROTO_UDP;
@@ -715,6 +715,7 @@
     if (_gettime_success and server->next_retry < curr_time.tv_sec)
     {
       server->state= MEMCACHED_SERVER_STATE_NEW;
+      server->server_timeout_counter= 0;
     }
     else
     {

=== modified file 'libmemcached/fetch.cc'
--- libmemcached/fetch.cc	2013-04-03 13:14:23 +0000
+++ libmemcached/fetch.cc	2014-02-05 00:01:58 +0000
@@ -194,7 +194,12 @@
   *error= MEMCACHED_MAXIMUM_RETURN; // We use this to see if we ever go into the loop
   memcached_instance_st *server;
   memcached_return_t read_ret= MEMCACHED_SUCCESS;
+<<<<<<< TREE
   while ((server= memcached_io_get_readable_server(memc, read_ret)))
+=======
+  bool connection_failures= false;
+  while ((server= memcached_io_get_readable_server(ptr, read_ret)))
+>>>>>>> MERGE-SOURCE
   {
     char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
     *error= memcached_response(server, buffer, sizeof(buffer), result);
@@ -203,6 +208,11 @@
     {
       continue;
     }
+    else if (*error == MEMCACHED_CONNECTION_FAILURE)
+    {
+      connection_failures= true;
+      continue;
+    }
     else if (*error == MEMCACHED_SUCCESS)
     {
       result->impl()->count++;
@@ -230,6 +240,16 @@
   {
     *error= MEMCACHED_NOTFOUND;
   }
+  else if (connection_failures)
+  {
+    /*  
+        If we have a connection failure to some servers, the caller may
+        wish to treat that differently to getting a definitive NOT_FOUND
+        from all servers, so return MEMCACHED_CONNECTION_FAILURE to allow
+        that. 
+        */
+    *error= MEMCACHED_CONNECTION_FAILURE;
+  }
   else if (*error == MEMCACHED_SUCCESS)
   {
     *error= MEMCACHED_END;

=== modified file 'libmemcached/include.am'
--- libmemcached/include.am	2013-06-12 07:11:22 +0000
+++ libmemcached/include.am	2014-02-05 00:01:58 +0000
@@ -2,7 +2,7 @@
 # included from Top Level Makefile.am
 # All paths should be given relative to the root
 
-libmemcached_libmemcached_la_SOURCES =
+libmemcached_libmemcached_la_SOURCES=
 
 include libmemcached/csl/include.am
 
@@ -53,8 +53,11 @@
 EXTRA_libmemcached_libmemcached_la_DEPENDENCIES=
 libmemcached_libmemcached_la_LIBADD=
 libmemcached_libmemcached_la_LDFLAGS=
-libmemcached_libmemcached_la_CFLAGS= -DBUILDING_LIBMEMCACHED
-libmemcached_libmemcached_la_CXXFLAGS= -DBUILDING_LIBMEMCACHED
+libmemcached_libmemcached_la_CFLAGS=
+libmemcached_libmemcached_la_CXXFLAGS=
+
+libmemcached_libmemcached_la_CFLAGS+= -DBUILDING_LIBMEMCACHED
+libmemcached_libmemcached_la_CXXFLAGS+= -DBUILDING_LIBMEMCACHED
 
 if BUILD_WIN32
 libmemcached_libmemcached_la_CFLAGS+= -DBUILDING_HASHKIT
@@ -120,9 +123,10 @@
 libmemcached/options.cc: libmemcached/csl/parser.h
 
 libmemcached_libmemcached_la_LDFLAGS+= -version-info ${MEMCACHED_LIBRARY_VERSION}
-libmemcached_libmemcached_la_LIBADD+= @DL_LIB@
+libmemcached_libmemcached_la_LIBADD+= @lt_cv_dlopen_libs@
 
 if HAVE_SASL
+libmemcached_libmemcached_la_CFLAGS+= @PTHREAD_CFLAGS@
 libmemcached_libmemcached_la_CXXFLAGS+= @PTHREAD_CFLAGS@
 libmemcached_libmemcached_la_LIBADD+= @PTHREAD_LIBS@
 libmemcached_libmemcached_la_LIBADD+= @SASL_LIB@

=== modified file 'libmemcached/instance.cc'
--- libmemcached/instance.cc	2013-03-31 23:24:29 +0000
+++ libmemcached/instance.cc	2014-02-05 00:01:58 +0000
@@ -54,6 +54,8 @@
   self->request_id= 0;
   self->server_failure_counter= 0;
   self->server_failure_counter_query_id= 0;
+  self->server_timeout_counter= 0;
+  self->server_timeout_counter_query_id= 0;
   self->weight= weight ? weight : 1; // 1 is the default weight value
   self->io_wait_count.read= 0;
   self->io_wait_count.write= 0;

=== modified file 'libmemcached/instance.hpp'
--- libmemcached/instance.hpp	2013-03-31 23:24:29 +0000
+++ libmemcached/instance.hpp	2014-02-05 00:01:58 +0000
@@ -73,6 +73,7 @@
   void mark_server_as_clean()
   {
     server_failure_counter= 0;
+    server_timeout_counter= 0;
     next_retry= 0;
   }
 
@@ -147,6 +148,8 @@
   uint32_t request_id;
   uint32_t server_failure_counter;
   uint64_t server_failure_counter_query_id;
+  uint32_t server_timeout_counter;
+  uint32_t server_timeout_counter_query_id;
   uint32_t weight;
   uint32_t version;
   enum memcached_server_state_t state;

=== modified file 'libmemcached/io.cc'
--- libmemcached/io.cc	2013-11-04 11:17:45 +0000
+++ libmemcached/io.cc	2014-02-05 00:01:58 +0000
@@ -342,6 +342,7 @@
     }
 
     ssize_t sent_length= ::send(instance->fd, local_write_ptr, write_length, flags);
+    int local_errno= get_socket_errno(); // We cache in case memcached_quit_server() modifies errno
 
     if (sent_length == SOCKET_ERROR)
     {
@@ -381,14 +382,14 @@
           }
 
           memcached_quit_server(instance, true);
-          error= memcached_set_errno(*instance, get_socket_errno(), MEMCACHED_AT);
+          error= memcached_set_errno(*instance, local_errno, MEMCACHED_AT);
           return false;
         }
       case ENOTCONN:
       case EPIPE:
       default:
         memcached_quit_server(instance, true);
-        error= memcached_set_errno(*instance, get_socket_errno(), MEMCACHED_AT);
+        error= memcached_set_errno(*instance, local_errno, MEMCACHED_AT);
         WATCHPOINT_ASSERT(instance->fd == INVALID_SOCKET);
         return false;
       }
@@ -422,6 +423,8 @@
   do
   {
     data_read= ::recv(instance->fd, instance->read_buffer, MEMCACHED_MAX_BUFFER, MSG_NOSIGNAL);
+    int local_errno= get_socket_errno(); // We cache in case memcached_quit_server() modifies errno
+
     if (data_read == SOCKET_ERROR)
     {
       switch (get_socket_errno())
@@ -460,7 +463,7 @@
       case ECONNREFUSED:
       default:
         memcached_quit_server(instance, true);
-        memcached_set_errno(*instance, get_socket_errno(), MEMCACHED_AT);
+        memcached_set_errno(*instance, local_errno, MEMCACHED_AT);
         break;
       }
 

=== modified file 'libmemcached/memcached.cc'
--- libmemcached/memcached.cc	2013-06-12 08:17:31 +0000
+++ libmemcached/memcached.cc	2014-02-05 00:01:58 +0000
@@ -87,6 +87,7 @@
   self->snd_timeout= 0;
   self->rcv_timeout= 0;
   self->server_failure_limit= MEMCACHED_SERVER_FAILURE_LIMIT;
+  self->server_timeout_limit= MEMCACHED_SERVER_TIMEOUT_LIMIT;
   self->query_id= 1; // 0 is considered invalid
 
   /* TODO, Document why we picked these defaults */
@@ -362,6 +363,7 @@
   new_clone->get_key_failure= source->get_key_failure;
   new_clone->delete_trigger= source->delete_trigger;
   new_clone->server_failure_limit= source->server_failure_limit;
+  new_clone->server_timeout_limit= source->server_timeout_limit;
   new_clone->io_msg_watermark= source->io_msg_watermark;
   new_clone->io_bytes_watermark= source->io_bytes_watermark;
   new_clone->io_key_prefetch= source->io_key_prefetch;

=== modified file 'libmemcached/quit.cc'
--- libmemcached/quit.cc	2013-03-31 23:24:29 +0000
+++ libmemcached/quit.cc	2014-02-05 00:01:58 +0000
@@ -93,6 +93,7 @@
      * sent to the server.
      */
     instance->server_failure_counter= 0;
+    instance->server_timeout_counter= 0;
   }
 }
 
@@ -120,8 +121,15 @@
 
   instance->close_socket();
 
-  if (io_death)
+  if (io_death and memcached_is_udp(instance->root))
   {
+    /*
+       If using UDP, we should stop using the server briefly on every IO
+       failure. If using TCP, it may be that the connection went down a
+       short while ago (e.g. the server failed) and we've only just
+       noticed, so we should only set the retry timeout on a connect
+       failure (which doesn't call this method).
+       */
     memcached_mark_server_for_timeout(instance);
   }
 }

=== modified file 'libmemcached/server.cc'
--- libmemcached/server.cc	2013-03-31 23:24:29 +0000
+++ libmemcached/server.cc	2014-02-05 00:01:58 +0000
@@ -54,6 +54,8 @@
   self->request_id= 0;
   self->server_failure_counter= 0;
   self->server_failure_counter_query_id= 0;
+  self->server_timeout_counter= 0;
+  self->server_timeout_counter_query_id= 0;
   self->weight= weight ? weight : 1; // 1 is the default weight value
   self->io_wait_count.read= 0;
   self->io_wait_count.write= 0;
@@ -213,6 +215,24 @@
   return self->port();
 }
 
+in_port_t memcached_server_srcport(const memcached_instance_st * self)
+{
+  WATCHPOINT_ASSERT(self);
+  if (self == NULL || self->fd == INVALID_SOCKET || (self->type != MEMCACHED_CONNECTION_TCP && self->type != MEMCACHED_CONNECTION_UDP))
+  {
+    return 0;
+  }
+
+  struct sockaddr_in sin;
+  socklen_t addrlen= sizeof(sin);
+  if (getsockname(self->fd, (struct sockaddr*)&sin, &addrlen) != -1)
+  {
+    return ntohs(sin.sin_port);
+  }
+
+  return -1;
+}
+
 uint32_t memcached_server_response_count(const memcached_instance_st * self)
 {
   WATCHPOINT_ASSERT(self);

=== modified file 'libmemcached/server.hpp'
--- libmemcached/server.hpp	2013-03-31 23:24:29 +0000
+++ libmemcached/server.hpp	2014-02-05 00:01:58 +0000
@@ -76,22 +76,31 @@
 {
   if (server->state != MEMCACHED_SERVER_STATE_IN_TIMEOUT)
   {
-    struct timeval next_time;
-    if (gettimeofday(&next_time, NULL) == 0)
-    {
-      server->next_retry= next_time.tv_sec +server->root->retry_timeout;
-    }
-    else
-    {
-      server->next_retry= 1; // Setting the value to 1 causes the timeout to occur immediatly
-    }
-
-    server->state= MEMCACHED_SERVER_STATE_IN_TIMEOUT;
-    if (server->server_failure_counter_query_id != server->root->query_id)
-    {
-      server->server_failure_counter++;
-      server->server_failure_counter_query_id= server->root->query_id;
-    }
-    set_last_disconnected_host(server);
+    if (server->server_timeout_counter_query_id != server->root->query_id)
+    {
+      server->server_timeout_counter++;
+      server->server_timeout_counter_query_id= server->root->query_id;
+    }
+
+    if (server->server_timeout_counter >= server->root->server_timeout_limit)
+    {
+      struct timeval next_time;
+      if (gettimeofday(&next_time, NULL) == 0)
+      {
+        server->next_retry= next_time.tv_sec +server->root->retry_timeout;
+      }
+      else
+      {
+        server->next_retry= 1; // Setting the value to 1 causes the timeout to occur immediatly
+      }
+
+      server->state= MEMCACHED_SERVER_STATE_IN_TIMEOUT;
+      if (server->server_failure_counter_query_id != server->root->query_id)
+      {
+        server->server_failure_counter++;
+        server->server_failure_counter_query_id= server->root->query_id;
+      }
+      set_last_disconnected_host(server);
+    }
   }
 }

=== modified file 'libmemcached/virtual_bucket.c'
--- libmemcached/virtual_bucket.c	2013-01-29 19:08:15 +0000
+++ libmemcached/virtual_bucket.c	2014-02-05 00:01:58 +0000
@@ -109,14 +109,11 @@
   {
     if (self->virtual_bucket)
     {
-      if (self->virtual_bucket)
-      {
-        uint32_t result= (uint32_t) (digest & (self->virtual_bucket->size -1));
-        return self->virtual_bucket->buckets[result].master;
-      }
-
-      return (uint32_t) (digest & (self->number_of_hosts -1));
+      uint32_t result= (uint32_t) (digest & (self->virtual_bucket->size -1));
+      return self->virtual_bucket->buckets[result].master;
     }
+
+    return (uint32_t) (digest & (self->number_of_hosts -1));
   }
 
   return 0;

=== modified file 'libtest/comparison.cc'
--- libtest/comparison.cc	2013-01-01 01:46:35 +0000
+++ libtest/comparison.cc	2014-02-05 00:01:58 +0000
@@ -51,7 +51,7 @@
 
 bool gdb_is_caller(void)
 {
-  if (bool(getenv("TESTS_ENVIRONMENT")) and strstr(getenv("TESTS_ENVIRONMENT"), "gdb"))
+  if (bool(getenv("LOG_COMPILER")) and strstr(getenv("LOG_COMPILER"), "gdb"))
   {
     return true;
   }
@@ -66,7 +66,7 @@
 
 bool helgrind_is_caller(void)
 {
-  if (bool(getenv("TESTS_ENVIRONMENT")) and strstr(getenv("TESTS_ENVIRONMENT"), "helgrind"))
+  if (bool(getenv("LOG_COMPILER")) and strstr(getenv("LOG_COMPILER"), "helgrind"))
   {
     return true;
   }

=== modified file 'libtest/formatter.cc'
--- libtest/formatter.cc	2013-01-04 01:24:50 +0000
+++ libtest/formatter.cc	2014-02-05 00:01:58 +0000
@@ -44,6 +44,56 @@
   
 namespace libtest {
 
+std::string& escape4XML(std::string const& arg, std::string& escaped_string)
+{
+  escaped_string.clear();
+
+  escaped_string+= '"';
+  for (std::string::const_iterator x= arg.begin(), end= arg.end(); x != end; ++x)
+  {
+    unsigned char c= *x;
+    if (c == '&')
+    {
+      escaped_string+= "&amp;";
+    }
+    else if (c == '>')
+    {
+      escaped_string+= "&gt;";
+    }
+    else if (c == '<')
+    {
+      escaped_string+= "&lt;";
+    }
+    else if (c == '\'')
+    {
+      escaped_string+= "&apos;";  break;
+    }
+    else if (c == '"')
+    {
+      escaped_string+= "&quot;";
+    }
+    else if (c == ' ')
+    {
+      escaped_string+= ' ';
+    }
+    else if (isalnum(c))
+    {
+      escaped_string+= c;
+    }
+    else 
+    {
+      char const* const hexdig= "0123456789ABCDEF";
+      escaped_string+= "&#x";
+      escaped_string+= hexdig[c >> 4];
+      escaped_string+= hexdig[c & 0xF];
+      escaped_string+= ';';
+    }
+  }
+  escaped_string+= '"';
+
+  return escaped_string;
+}
+
 class TestCase {
 public:
   TestCase(const std::string& arg):
@@ -110,7 +160,10 @@
 void Formatter::skipped()
 {
   current()->result(TEST_SKIPPED);
-  Out << name() << "." << current()->name() <<  "\t\t\t\t\t" << "[ " << test_strerror(current()->result()) << " ]";
+  Out << name() << "." 
+      << current()->name()
+      <<  "\t\t\t\t\t" 
+      << "[ " << test_strerror(current()->result()) << " ]";
 
   reset();
 }
@@ -120,7 +173,9 @@
   assert(current());
   current()->result(TEST_FAILURE);
 
-  Out << name() << "." << current()->name() <<  "\t\t\t\t\t" << "[ " << test_strerror(current()->result()) << " ]";
+  Out << name()
+    << "." << current()->name() <<  "\t\t\t\t\t" 
+    << "[ " << test_strerror(current()->result()) << " ]";
 
   reset();
 }
@@ -129,6 +184,7 @@
 {
   assert(current());
   current()->result(TEST_SUCCESS, timer_);
+  std::string escaped_string;
 
   Out << name() << "."
     << current()->name()
@@ -141,38 +197,50 @@
 
 void Formatter::xml(libtest::Framework& framework_, std::ofstream& output)
 {
-  output << "<testsuites name=\"" << framework_.name() << "\">" << std::endl;
+  std::string escaped_string;
+
+  output << "<testsuites name=" 
+    << escape4XML(framework_.name(), escaped_string) << ">" << std::endl;
+
   for (Suites::iterator framework_iter= framework_.suites().begin();
        framework_iter != framework_.suites().end();
        ++framework_iter)
   {
-    output << "\t<testsuite name=\"" << (*framework_iter)->name() << "\"  classname=\"\" package=\"\">" << std::endl;
+    output << "\t<testsuite name=" 
+      << escape4XML((*framework_iter)->name(), escaped_string)
+#if 0
+      << "  classname=\"\" package=\"\"" 
+#endif
+      << ">" << std::endl;
 
     for (TestCases::iterator case_iter= (*framework_iter)->formatter()->testcases().begin();
          case_iter != (*framework_iter)->formatter()->testcases().end();
          ++case_iter)
     {
-      output << "\t\t<testcase name=\"" 
-        << (*case_iter)->name() 
-        << "\" time=\"" 
+      output << "\t\t<testcase name=" 
+        << escape4XML((*case_iter)->name(), escaped_string)
+        << " time=\"" 
         << (*case_iter)->timer().elapsed_milliseconds() 
-        << "\">" 
-        << std::endl;
+        << "\""; 
 
       switch ((*case_iter)->result())
       {
         case TEST_SKIPPED:
+        output << ">" << std::endl;
         output << "\t\t <skipped/>" << std::endl;
+        output << "\t\t</testcase>" << std::endl;
         break;
 
         case TEST_FAILURE:
+        output << ">" << std::endl;
         output << "\t\t <failure message=\"\" type=\"\"/>"<< std::endl;
+        output << "\t\t</testcase>" << std::endl;
         break;
 
         case TEST_SUCCESS:
+        output << "/>" << std::endl;
         break;
       }
-      output << "\t\t</testcase>" << std::endl;
     }
     output << "\t</testsuite>" << std::endl;
   }

=== modified file 'libtest/include.am'
--- libtest/include.am	2013-06-12 07:11:22 +0000
+++ libtest/include.am	2014-02-05 00:01:58 +0000
@@ -7,7 +7,7 @@
 LIBTOOL_COMMAND= ${abs_top_builddir}/libtool --mode=execute
 VALGRIND_EXEC_COMMAND= $(LIBTOOL_COMMAND) valgrind --tool=memcheck --error-exitcode=1 --leak-check=yes --track-fds=yes --malloc-fill=A5 --free-fill=DE
 SGCHECK_EXEC_COMMAND= $(LIBTOOL_COMMAND) valgrind --tool=exp-sgcheck --error-exitcode=1
-VALGRIND_COMMAND= TESTS_ENVIRONMENT="valgrind" $(VALGRIND_EXEC_COMMAND)
+VALGRIND_COMMAND= LOG_COMPILER="valgrind" $(VALGRIND_EXEC_COMMAND)
 HELGRIND_COMMAND= $(LIBTOOL_COMMAND) valgrind --tool=helgrind --read-var-info=yes --error-exitcode=1 --read-var-info=yes
 DRD_COMMAND= $(LIBTOOL_COMMAND) valgrind --tool=drd --free-is-write=yes --error-exitcode=1
 SGCHECK_COMMAND= $(LIBTOOL_COMMAND) valgrind --tool=exp-sgcheck --error-exitcode=1
@@ -25,22 +25,22 @@
 export GDB_COMMAND
 
 valgrind:
-	@echo make check TESTS_ENVIRONMENT="\"$(VALGRIND_EXEC_COMMAND)\""
+	@echo make check LOG_COMPILER="\"$(VALGRIND_EXEC_COMMAND)\""
 
 sgcheck:
-	@echo make check TESTS_ENVIRONMENT="\"$(SGCHECK_EXEC_COMMAND)\""
+	@echo make check LOG_COMPILER="\"$(SGCHECK_EXEC_COMMAND)\""
 
 valgrind-supressions:
-	@echo make check TESTS_ENVIRONMENT="\"$(VALGRIND_SUPRESSION)\""
+	@echo make check LOG_COMPILER="\"$(VALGRIND_SUPRESSION)\""
 
 gdb:
-	@echo make check TESTS_ENVIRONMENT="\"$(GDB_COMMAND)\""
+	@echo make check LOG_COMPILER="\"$(GDB_COMMAND)\""
 
 helgrind:
-	@echo make check TESTS_ENVIRONMENT="\"$(HELGRIND_COMMAND)\""
+	@echo make check LOG_COMPILER="\"$(HELGRIND_COMMAND)\""
 
 drd:
-	@echo make check TESTS_ENVIRONMENT="\"$(DRD_COMMAND)\""
+	@echo make check LOG_COMPILER="\"$(DRD_COMMAND)\""
 
 EXTRA_DIST+= libtest/run.gdb
 EXTRA_DIST+= libtest/version.h
@@ -173,8 +173,10 @@
 # We are either building in tree, or with
 libtest_libtest_la_SOURCES+= libtest/memcached.cc
 
+if HAVE_LIBDRIZZLE
 libtest_libtest_la_LDFLAGS+= @LIBDRIZZLE_LDFLAGS@
 libtest_libtest_la_LIBADD+= @LIBDRIZZLE_LIB@
+endif
 
 libtest_libtest_la_SOURCES+= libtest/gearmand.cc
 
@@ -247,7 +249,7 @@
 libtest_backtrace_LDADD=
 libtest_backtrace_SOURCES+= libtest/backtrace_test.cc
 libtest_backtrace_SOURCES+= libmemcached/backtrace.cc
-libtest_backtrace_LDADD+= @DL_LIB@
+libtest_backtrace_LDADD+= @lt_cv_dlopen_libs@
 noinst_PROGRAMS+= libtest/backtrace
 test-backtrace: libtest/backtrace
 	@libtest/backtrace

=== modified file 'libtest/unittest.cc'
--- libtest/unittest.cc	2013-10-11 12:19:52 +0000
+++ libtest/unittest.cc	2014-02-05 00:01:58 +0000
@@ -577,7 +577,7 @@
   server_startup_st *servers= (server_startup_st*)object;
   test_true(servers);
 
-  test_skip(false, bool(getenv("TESTS_ENVIRONMENT")));
+  test_skip(false, bool(getenv("LOG_COMPILER")));
 
   if (MEMCACHED_SASL_BINARY)
   {

=== modified file 'libtest/valgrind.h'
--- libtest/valgrind.h	2013-04-15 19:09:52 +0000
+++ libtest/valgrind.h	2014-02-05 00:01:58 +0000
@@ -38,14 +38,14 @@
 
 static inline bool valgrind_is_caller(void)
 {
-  if (getenv("TESTS_ENVIRONMENT")  && strstr(getenv("TESTS_ENVIRONMENT"), "valgrind"))
+  if (getenv("LOG_COMPILER")  && strstr(getenv("LOG_COMPILER"), "valgrind"))
   {
-    if (strstr(getenv("TESTS_ENVIRONMENT"), "--tool") == NULL)
+    if (strstr(getenv("LOG_COMPILER"), "--tool") == NULL)
     {
       return true;
     }
 
-    if (strstr(getenv("TESTS_ENVIRONMENT"), "--tool=memcheck"))
+    if (strstr(getenv("LOG_COMPILER"), "--tool=memcheck"))
     {
       return true;
     }

=== modified file 'm4/ax_check_library.m4'
--- m4/ax_check_library.m4	2013-01-08 01:03:28 +0000
+++ m4/ax_check_library.m4	2014-02-05 00:01:58 +0000
@@ -87,9 +87,6 @@
 
     AS_IF([test "$]AS_TR_SH([ax_cv_have_]$1)[" = "yes"],
         [AC_DEFINE([HAVE_]$1, [1], [Define to 1 if ]$1[ is found])
-        AC_SUBST($1[_CPPFLAGS])
-        AC_SUBST($1[_LDFLAGS])
-        AC_SUBST($1[_LIB],[-l]$3)
         ifelse([$4], , :, [$4])],
         [ifelse([$5], , :, [$5])])
     ])

=== modified file 'm4/ax_compiler_vendor.m4'
--- m4/ax_compiler_vendor.m4	2012-11-04 06:54:36 +0000
+++ m4/ax_compiler_vendor.m4	2014-02-05 00:01:58 +0000
@@ -4,7 +4,7 @@
 #
 # SYNOPSIS
 #
-#   AX_COMPILER_VENDOR()
+#   AX_COMPILER_VENDOR
 #
 # DESCRIPTION
 #
@@ -44,7 +44,7 @@
 #   modified version of the Autoconf Macro, you may extend this special
 #   exception to the GPL to apply to your modified version as well.
 
-#serial 11
+#serial 12
 
 AC_DEFUN([AX_COMPILER_VENDOR],
 [AC_CACHE_CHECK([for _AC_LANG compiler vendor], ax_cv_[]_AC_LANG_ABBREV[]_compiler_vendor,
@@ -53,6 +53,7 @@
            ibm:       __xlc__,__xlC__,__IBMC__,__IBMCPP__
            pathscale: __PATHCC__,__PATHSCALE__
            clang:     __clang__
+           fujitsu:   __FUJITSU
            gnu:       __GNUC__
            sun:       __SUNPRO_C,__SUNPRO_CC
            hp:        __HP_cc,__HP_aCC

=== removed file 'm4/ax_dlopen.m4'
--- m4/ax_dlopen.m4	2013-01-08 01:03:28 +0000
+++ m4/ax_dlopen.m4	1970-01-01 00:00:00 +0000
@@ -1,10 +0,0 @@
-#serial 2
-
-AC_DEFUN([AX_DLOPEN],
-    [AS_IF([test "x$enable_shared" = xyes],
-      [AX_CHECK_LIBRARY([DL],[dlfcn.h],[dl],
-        [AC_DEFINE([HAVE_LIBDL],[1],[Have dlopen])
-        AC_CHECK_LIB([dl],[dlopen],[AC_DEFINE([HAVE_DLOPEN],[1],[Have dlopen])])
-        AC_CHECK_LIB([dl],[dladdr],[AC_DEFINE([HAVE_DLADDR],[1],[Have dladdr])])])])
-    ])
-

=== modified file 'm4/ax_harden_compiler_flags.m4'
--- m4/ax_harden_compiler_flags.m4	2013-10-11 12:19:52 +0000
+++ m4/ax_harden_compiler_flags.m4	2014-02-05 00:01:58 +0000
@@ -211,7 +211,6 @@
           _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])
           _APPEND_COMPILE_FLAGS_ERROR([-fmudflapt])
           _APPEND_COMPILE_FLAGS_ERROR([-pipe])
@@ -317,7 +316,6 @@
           _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])
           _APPEND_COMPILE_FLAGS_ERROR([-fwrapv])
           _APPEND_COMPILE_FLAGS_ERROR([-fmudflapt])
           _APPEND_COMPILE_FLAGS_ERROR([-pipe])

=== modified file 'm4/ax_pthread.m4'
--- m4/ax_pthread.m4	2013-11-04 17:14:31 +0000
+++ m4/ax_pthread.m4	2014-02-05 00:01:58 +0000
@@ -82,7 +82,7 @@
 #   modified version of the Autoconf Macro, you may extend this special
 #   exception to the GPL to apply to your modified version as well.
 
-#serial 22
+#serial 23
 
 AU_ALIAS([ACX_PTHREAD], [AX_PTHREAD])
 AC_DEFUN([AX_PTHREAD], [

=== modified file 'm4/ax_restore_flags.m4'
--- m4/ax_restore_flags.m4	2012-10-09 05:01:35 +0000
+++ m4/ax_restore_flags.m4	2014-02-05 00:01:58 +0000
@@ -4,28 +4,49 @@
 #
 # SYNOPSIS
 #
-#   AX_RESTORE_FLAGS()
+#   AX_RESTORE_FLAGS([namespace])
 #
 # DESCRIPTION
 #
-#   Restore common compilation flags from temporary variables
+#   Restore common compilation flags from temporary variables.
+#
+#   Compilation flags includes: CPPFLAGS, CFLAGS, CXXFLAGS, LDFLAGS, LIBS,
+#   OBJCFLAGS.
+#
+#   By default these flags are restored to a global (empty) namespace, but
+#   user could restore from specific NAMESPACE by using
+#   AX_RESTORE_FLAGS(NAMESPACE) macro.
+#
+#   Typical usage is like:
+#
+#     AX_SAVE_FLAGS(mypackage)
+#     CPPFLAGS="-Imypackagespath ${CPPFLAGS}"
+#     dnl ... do some detection ...
+#     AX_RESTORE_FLAGS(mypackage)
 #
 # LICENSE
 #
 #   Copyright (c) 2009 Filippo Giunchedi <[e-mail]>
+#   Copyright (c) 2011 The Board of Trustees of the Leland Stanford Junior University
+#   Copyright (c) 2011 Russ Allbery <[e-mail]>
+#   Copyright (c) 2013 Bastien ROUCARIES <[e-mail]>
 #
 #   Copying and distribution of this file, with or without modification, are
 #   permitted in any medium without royalty provided the copyright notice
 #   and this notice are preserved. This file is offered as-is, without any
 #   warranty.
 
-#serial 3
-
-AC_DEFUN([AX_RESTORE_FLAGS], [
-  CPPFLAGS="${CPPFLAGS_save}"
-  CFLAGS="${CFLAGS_save}"
-  CXXFLAGS="${CXXFLAGS_save}"
-  OBJCFLAGS="${OBJCFLAGS_save}"
-  LDFLAGS="${LDFLAGS_save}"
-  LIBS="${LIBS_save}"
+#serial 6
+
+# save one flag in name space
+AC_DEFUN([_AX_RESTORE_ONE_FLAG],[dnl
+  AS_VAR_PUSHDEF([_ax_restore_flag_var], [$2[]_$1[]_ax_save_flags])
+  AS_VAR_COPY($2[],_ax_restore_flag_var)
+  AS_VAR_POPDEF([_ax_restore_flag_var])
+])
+
+AC_DEFUN([AX_RESTORE_FLAGS], [dnl
+   m4_foreach([FLAG], dnl
+	      [_AX_SAVE_FLAGS_LIST()], dnl
+	      [_AX_RESTORE_ONE_FLAG([$1],FLAG)])
 ])

=== modified file 'm4/ax_sasl.m4'
--- m4/ax_sasl.m4	2012-12-13 02:48:43 +0000
+++ m4/ax_sasl.m4	2014-02-05 00:01:58 +0000
@@ -20,33 +20,32 @@
 #   and this notice are preserved. This file is offered as-is, without any
 #   warranty.
 
-#serial 2
+#serial 3
 
 AC_DEFUN([AX_SASL_OPTION],
-    [AC_REQUIRE([AX_SASL_CHECK])
-    AC_ARG_ENABLE([sasl],
-      [AS_HELP_STRING([--disable-sasl], [Build with sasl support @<:@default=on@:>@])],
-      [ac_enable_sasl="$enableval"],
-      [ac_enable_sasl=yes])
-
-    AS_IF([test "x${ac_enable_sasl}" = xyes],
-      [AC_MSG_CHECKING([checking to see if enabling sasl])
-      AS_IF([test "x${ax_sasl_check}" = xyes],
-        [ax_sasl_option=yes],
-        [AC_MSG_WARN([request to add sasl support failed, please see config.log])
-        ac_enable_sasl=no
-        ax_sasl_option=no])
-      AC_MSG_RESULT(["$ax_sasl_option"])
-      ])
-    AM_CONDITIONAL([HAVE_SASL],[test "x${ax_sasl_option}" = xyes])
-    ])
-
-AC_DEFUN([AX_SASL_CHECK],
-    [ax_sasl_check=no
-    AX_CHECK_LIBRARY([LIBSASL],[sasl/sasl.h],[sasl2],
-      [ax_sasl_check=yes
-      AC_SUBST([SASL_LIB],[[-lsasl2]])
-      ])
-    AC_MSG_CHECKING([checking to see if sasl works])
-    AC_MSG_RESULT(["$ax_sasl_check"])
-    ])
+         [AC_REQUIRE([AX_SASL_CHECK])
+         AC_ARG_ENABLE([sasl],
+                       [AS_HELP_STRING([--disable-sasl], [Build with sasl support @<:@default=on@:>@])],
+                       [ac_enable_sasl="$enableval"],
+                       [ac_enable_sasl=yes])
+
+         AS_IF([test "x${ac_enable_sasl}" = xyes],[
+               AC_MSG_CHECKING([checking to see if enabling sasl])
+               AS_IF([test "x${ax_sasl_check}" = xyes],[
+                     ax_sasl_option=yes],[
+                     AC_MSG_WARN([request to add sasl support failed, please see config.log])
+                     ac_enable_sasl=no
+                     ax_sasl_option=no])
+               AC_MSG_RESULT(["$ax_sasl_option"])],[
+               ax_sasl_option=no])
+         AM_CONDITIONAL([HAVE_SASL],[test "x${ax_sasl_option}" = xyes])
+         ])
+
+AC_DEFUN([AX_SASL_CHECK],[
+         AX_CHECK_LIBRARY([LIBSASL],[sasl/sasl.h],[sasl2],[
+                          ax_sasl_check=yes
+                          AC_SUBST([SASL_LIB],[[-lsasl2]])],[
+                          ax_sasl_check=no])
+         AC_MSG_CHECKING([checking to see if sasl works])
+         AC_MSG_RESULT(["$ax_sasl_check"])
+         ])

=== modified file 'm4/ax_save_flags.m4'
--- m4/ax_save_flags.m4	2012-10-09 05:01:35 +0000
+++ m4/ax_save_flags.m4	2014-02-05 00:01:58 +0000
@@ -4,28 +4,68 @@
 #
 # SYNOPSIS
 #
-#   AX_SAVE_FLAGS()
+#   AX_SAVE_FLAGS([NAMESPACE])
 #
 # DESCRIPTION
 #
-#   Save common compilation flags into temporary variables
+#   Save common compilation flags into temporary variables.
+#
+#   Compilation flags includes: CPPFLAGS, CFLAGS, CXXFLAGS, LDFLAGS, LIBS,
+#   OBJCFLAGS.
+#
+#   By default these flags are saved to a global (empty) namespace, but user
+#   could specify a specific NAMESPACE to AX_SAVE_FLAGS macro and latter
+#   restore it by using AX_RESTORE_FLAGS(NAMESPACE).
+#
+#     AX_SAVE_FLAGS(mypackage)
+#     CPPFLAGS="-Imypackagespath ${CPPFLAGS}"
+#     dnl .. do some detection ...
+#     AX_RESTORE_FLAGS(mypackage)
 #
 # LICENSE
 #
 #   Copyright (c) 2009 Filippo Giunchedi <[e-mail]>
+#   Copyright (c) 2011 The Board of Trustees of the Leland Stanford Junior University
+#   Copyright (c) 2011 Russ Allbery <[e-mail]>
+#   Copyright (c) 2013 Bastien ROUCARIES <[e-mail]>
 #
 #   Copying and distribution of this file, with or without modification, are
 #   permitted in any medium without royalty provided the copyright notice
 #   and this notice are preserved. This file is offered as-is, without any
 #   warranty.
 
-#serial 3
-
-AC_DEFUN([AX_SAVE_FLAGS], [
-  CPPFLAGS_save="${CPPFLAGS}"
-  CFLAGS_save="${CFLAGS}"
-  CXXFLAGS_save="${CXXFLAGS}"
-  OBJCFLAGS_save="${OBJCFLAGS}"
-  LDFLAGS_save="${LDFLAGS}"
-  LIBS_save="${LIBS}"
+#serial 7
+
+# list of flag to save
+AC_DEFUN([_AX_SAVE_FLAGS_LIST],[dnl
+[CCASFLAGS],dnl
+[CFLAGS],dnl
+[CPPFLAGS],dnl
+[CXXFLAGS],dnl
+[ERLCFLAGS],dnl
+[FCFLAGS],dnl
+[FCLIBS],dnl
+[FFLAGS],dnl
+[FLIBS],dnl
+[GCJFLAGS],dnl
+[JAVACFLAGS],dnl
+[LDFLAGS],dnl
+[LIBS],dnl
+[OBJCFLAGS],dnl
+[OBJCXXFLAGS],dnl
+[UPCFLAGS],dnl
+[VALAFLAGS]dnl
+])
+
+# save one flag in name space
+AC_DEFUN([_AX_SAVE_ONE_FLAG],[
+  AS_VAR_PUSHDEF([_ax_save_flag_var], [$2[]_$1[]_ax_save_flags])
+  AS_VAR_COPY(_ax_save_flag_var, $2[])
+  AS_VAR_POPDEF([_ax_save_flag_var])
+])
+
+AC_DEFUN([AX_SAVE_FLAGS],[dnl
+   m4_foreach([FLAG], dnl
+	      [_AX_SAVE_FLAGS_LIST()], dnl
+	      [_AX_SAVE_ONE_FLAG([$1],FLAG)])
 ])

=== modified file 'tests/include.am'
--- tests/include.am	2013-04-29 15:24:05 +0000
+++ tests/include.am	2014-02-05 00:01:58 +0000
@@ -27,10 +27,10 @@
 # Cycle should always run first
 tests_cycle_CFLAGS= $(AM_CFLAGS) $(NO_CONVERSION) $(NO_STRICT_ALIASING)
 tests_cycle_CXXFLAGS= $(AM_CXXFLAGS)
-tests_cycle_CXXFLAGS+= ${PTHREAD_CFLAGS}
+tests_cycle_CXXFLAGS+= @PTHREAD_CFLAGS@
 tests_cycle_SOURCES= tests/cycle.cc
 tests_cycle_LDADD= $(TESTS_LDADDS)
-tests_cycle_LDADD+= ${PTHREAD_LIBS}
+tests_cycle_LDADD+= @PTHREAD_LIBS@
 check_PROGRAMS+= tests/cycle
 noinst_PROGRAMS+= tests/cycle
 

=== modified file 'tests/libmemcached-1.0/all_tests.h'
--- tests/libmemcached-1.0/all_tests.h	2013-09-15 07:19:20 +0000
+++ tests/libmemcached-1.0/all_tests.h	2014-02-05 00:01:58 +0000
@@ -284,6 +284,7 @@
   {"lp:1021819", true, (test_callback_fn*)regression_1021819_TEST },
   {"lp:1048945", true, (test_callback_fn*)regression_1048945_TEST },
   {"lp:1067242", true, (test_callback_fn*)regression_1067242_TEST },
+  {"lp:1251482", true, (test_callback_fn*)regression_bug_1251482 },
   {0, false, (test_callback_fn*)0}
 };
 

=== modified file 'tests/libmemcached-1.0/mem_functions.cc'
--- tests/libmemcached-1.0/mem_functions.cc	2013-11-04 17:14:31 +0000
+++ tests/libmemcached-1.0/mem_functions.cc	2014-02-05 00:01:58 +0000
@@ -413,6 +413,7 @@
     test_true(memc_clone->retry_timeout == memc->retry_timeout);
     test_true(memc_clone->send_size == memc->send_size);
     test_true(memc_clone->server_failure_limit == memc->server_failure_limit);
+    test_true(memc_clone->server_timeout_limit == memc->server_timeout_limit);
     test_true(memc_clone->snd_timeout == memc->snd_timeout);
     test_true(memc_clone->user_data == memc->user_data);
 
@@ -4562,7 +4563,7 @@
 
   /* Put a retry timeout to effectively activate failure_limit effect */
   test_compare(MEMCACHED_SUCCESS,
-               memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, true));
+               memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 1));
 
   /* change behavior that triggers memcached_quit()*/
   test_compare(MEMCACHED_SUCCESS,
@@ -4844,6 +4845,28 @@
   return TEST_SUCCESS;
 }
 
+test_return_t regression_bug_1251482(memcached_st*)
+{
+  test::Memc memc("--server=localhost:5");
+
+  memcached_behavior_set(&memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 0);
+
+  for (size_t x= 4; x; --x)
+  {
+    size_t value_length;
+    memcached_return_t rc;
+    char *value= memcached_get(&memc,
+                               test_literal_param(__func__),
+                               &value_length, NULL, &rc);
+
+    test_false(value);
+    test_compare(0LLU, value_length);
+    test_compare(MEMCACHED_CONNECTION_FAILURE, rc);
+  }
+
+  return TEST_SUCCESS;
+}
+
 test_return_t regression_1009493_TEST(memcached_st*)
 {
   memcached_st* memc= memcached_create(NULL);

=== modified file 'tests/libmemcached-1.0/mem_functions.h'
--- tests/libmemcached-1.0/mem_functions.h	2013-09-15 07:19:20 +0000
+++ tests/libmemcached-1.0/mem_functions.h	2014-02-05 00:01:58 +0000
@@ -187,3 +187,4 @@
 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*);
+test_return_t regression_bug_1251482(memcached_st*);

=== modified file 'tests/libmemcached_world.h'
--- tests/libmemcached_world.h	2013-10-11 12:19:52 +0000
+++ tests/libmemcached_world.h	2014-02-05 00:01:58 +0000
@@ -50,7 +50,7 @@
     SKIP_UNLESS(libmemcached_has_feature(LIBMEMCACHED_FEATURE_HAS_SASL));
 
     // Assume we are running under valgrind, and bail
-    if (getenv("TESTS_ENVIRONMENT"))
+    if (getenv("LOG_COMPILER"))
     {
       error= TEST_SKIPPED;
       return NULL;

=== modified file 'tests/mem_udp.cc'
--- tests/mem_udp.cc	2013-04-03 13:14:23 +0000
+++ tests/mem_udp.cc	2014-02-05 00:01:58 +0000
@@ -145,7 +145,7 @@
 
 static test_return_t init_udp_valgrind(memcached_st *memc)
 {
-  if (getenv("TESTS_ENVIRONMENT"))
+  if (getenv("LOG_COMPILER"))
   {
     return TEST_SKIPPED; 
   }
@@ -157,7 +157,7 @@
 
 static test_return_t binary_init_udp(memcached_st *memc)
 {
-  if (getenv("TESTS_ENVIRONMENT"))
+  if (getenv("LOG_COMPILER"))
   {
     return TEST_SKIPPED; 
   }
@@ -269,7 +269,7 @@
 static test_return_t udp_set_test(memcached_st *memc)
 {
   // Assume we are running under valgrind, and bail 
-  if (getenv("TESTS_ENVIRONMENT"))
+  if (getenv("LOG_COMPILER"))
   {
     return TEST_SUCCESS; 
   }