summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--ChangeLog3
-rw-r--r--Makefile.am12
-rwxr-xr-xbootstrap.sh354
-rw-r--r--libmemcached-1.2/platform.h6
-rw-r--r--libmemcached/common.h4
-rw-r--r--libmemcached/connect.cc5
-rw-r--r--libmemcached/do.cc3
-rw-r--r--libmemcached/error.cc20
-rw-r--r--libmemcached/include.am7
-rw-r--r--libmemcached/instance.cc21
-rw-r--r--libmemcached/instance.hpp7
-rw-r--r--libmemcached/io.cc317
-rw-r--r--libmemcached/io.hpp2
-rw-r--r--libmemcached/quit.cc154
-rw-r--r--libmemcached/socket.hpp2
-rw-r--r--libtest/cmdline.h8
-rw-r--r--libtest/fatal.hpp2
-rw-r--r--libtest/server.cc6
-rw-r--r--libtest/server.h4
-rw-r--r--libtest/server_container.cc4
-rw-r--r--libtest/server_container.h2
-rw-r--r--libtest/timer.hpp3
-rw-r--r--libtest/wait.h3
-rw-r--r--m4/ax_cxx_gcc_abi_demangle.m47
-rw-r--r--m4/ax_harden_compiler_flags.m442
-rw-r--r--m4/ax_platform.m420
-rw-r--r--m4/ax_prog_sphinx_build.m46
-rw-r--r--m4/socket_send_flags.m491
28 files changed, 722 insertions, 393 deletions
diff --git a/ChangeLog b/ChangeLog
index 54b12a1f..39426bd7 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,8 @@
1.1.0
* Enable MEMCACHED_BEHAVIOR_VERIFY_KEY by default
+* Added support to do two part shutdown of socket.
+
+
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 111b9c34..38394908 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -6,6 +6,7 @@ ACLOCAL_AMFLAGS = -I m4 -I libtest/m4
SUFFIXES =
.PHONY =
TESTS =
+XFAIL_TESTS =
CLEANFILES =
DISTCLEANFILES =
bin_PROGRAMS =
@@ -35,6 +36,14 @@ EXTRA_DIST+= README.win32
aclocaldir= $(datadir)/aclocal
dist_aclocal_DATA=
+# Build targets for Windows
+if BUILD_WIN32
+include libhashkit-1.0/include.am
+include libhashkit/include.am
+include libmemcached/include.am
+include libmemcached-1.0/include.am
+else
+
include libtest/include.am
include libhashkit-1.0/include.am
@@ -56,8 +65,11 @@ include util/include.am
include win32/include.am
include m4/include.am
+endif
+TESTS += ${bin_PROGRAMS}
TESTS += ${check_PROGRAMS}
+XFAIL_TESTS += ${bin_PROGRAMS}
merge-clean:
@find ./ | $(GREP) \.gcda | xargs rm -f
diff --git a/bootstrap.sh b/bootstrap.sh
index b548686f..ca36e37c 100755
--- a/bootstrap.sh
+++ b/bootstrap.sh
@@ -45,8 +45,24 @@
command_not_found_handle ()
{
- echo "Command not found: '$@'"
- exit 127
+ warn "$@: command not found"
+
+ #if $DEBUG; then
+ echo ""
+ echo "Stack trace:"
+ local frame=0
+ while caller $frame; do
+ ((frame++));
+ done
+ echo ""
+ #fi
+
+ return 127
+}
+
+function error ()
+{
+ echo "$BASH_SOURCE:$BASH_LINENO: $@" >&2
}
function die ()
@@ -55,6 +71,12 @@ function die ()
exit 1;
}
+function warn ()
+{
+ echo "$BASH_SOURCE:$BASH_LINENO: $@"
+ #echo "$BASH_SOURCE:$BASH_LINENO: $@" >&1
+}
+
function nassert ()
{
local param_name=\$"$1"
@@ -77,7 +99,7 @@ function assert ()
fi
}
-assert_file ()
+function assert_file ()
{
if [ ! -f "$1" ]; then
echo "$BASH_SOURCE:$BASH_LINENO: assert($1) does not exist: $2" >&2
@@ -85,7 +107,7 @@ assert_file ()
fi
}
-assert_no_file ()
+function assert_no_file ()
{
if [ -f "$1" ]; then
echo "$BASH_SOURCE:$BASH_LINENO: assert($1) file exists: $2" >&2
@@ -93,7 +115,15 @@ assert_no_file ()
fi
}
-assert_exec_file ()
+function assert_no_directory ()
+{
+ if [ -d "$1" ]; then
+ echo "$BASH_SOURCE:$BASH_LINENO: assert($1) directory exists: $2" >&2
+ exit 1;
+ fi
+}
+
+function assert_exec_file ()
{
if [ ! -f "$1" ]; then
echo "$BASH_SOURCE:$BASH_LINENO: assert($1) does not exist: $2" >&2
@@ -106,12 +136,12 @@ assert_exec_file ()
fi
}
-command_exists ()
+function command_exists ()
{
type "$1" &> /dev/null ;
}
-rebuild_host_os ()
+function rebuild_host_os ()
{
HOST_OS="${UNAME_MACHINE_ARCH}-${VENDOR}-${VENDOR_DISTRIBUTION}-${VENDOR_RELEASE}-${UNAME_KERNEL}-${UNAME_KERNEL_RELEASE}"
if [ -z "$1" ]; then
@@ -122,7 +152,7 @@ rebuild_host_os ()
}
# Valid values are: darwin,fedora,rhel,ubuntu
-set_VENDOR_DISTRIBUTION ()
+function set_VENDOR_DISTRIBUTION ()
{
local dist=`echo "$1" | tr '[A-Z]' '[a-z]'`
case "$dist" in
@@ -147,7 +177,7 @@ set_VENDOR_DISTRIBUTION ()
esac
}
-set_VENDOR_RELEASE ()
+function set_VENDOR_RELEASE ()
{
local release=`echo "$1" | tr '[A-Z]' '[a-z]'`
case "$VENDOR_DISTRIBUTION" in
@@ -177,7 +207,7 @@ set_VENDOR_RELEASE ()
# Valid values are: apple, redhat, centos, canonical
-set_VENDOR ()
+function set_VENDOR ()
{
local vendor=`echo "$1" | tr '[A-Z]' '[a-z]'`
@@ -206,7 +236,7 @@ set_VENDOR ()
set_VENDOR_RELEASE $3
}
-determine_target_platform ()
+function determine_target_platform ()
{
UNAME_MACHINE_ARCH=`(uname -m) 2>/dev/null` || UNAME_MACHINE_ARCH=unknown
UNAME_KERNEL=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown
@@ -242,7 +272,7 @@ determine_target_platform ()
rebuild_host_os
}
-run_configure ()
+function run_configure ()
{
# We will run autoreconf if we are required
run_autoreconf_if_required
@@ -252,6 +282,10 @@ run_configure ()
die "Programmer error, we entered run_configure with a stacked directory"
fi
+ if ! command_exists "$CONFIGURE"; then
+ die "$CONFIGURE does not exist"
+ fi
+
local BUILD_DIR="$1"
if [[ -n "$BUILD_DIR" ]]; then
rm -r -f $BUILD_DIR
@@ -260,40 +294,52 @@ run_configure ()
fi
# Arguments for configure
- local CONFIGURE_ARG=
+ local BUILD_CONFIGURE_ARG=
# Set ENV DEBUG in order to enable debugging
if $DEBUG; then
- CONFIGURE_ARG='--enable-debug'
+ BUILD_CONFIGURE_ARG='--enable-debug'
fi
# Set ENV ASSERT in order to enable assert
if [[ -n "$ASSERT" ]]; then
local ASSERT_ARG=
ASSERT_ARG='--enable-assert'
- CONFIGURE_ARG="$ASSERT_ARG $CONFIGURE_ARG"
+ BUILD_CONFIGURE_ARG="$ASSERT_ARG $BUILD_CONFIGURE_ARG"
+ fi
+
+ if [[ -n "$CONFIGURE_ARG" ]]; then
+ BUILD_CONFIGURE_ARG= "$BUILD_CONFIGURE_ARG $CONFIGURE_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 $CONFIGURE_ARG || die "Cannot execute CC=clang CXX=clang++ configure $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 $PREFIX_ARG"
+ ret=$?
;;
rhel-5*)
- command_exists gcc44 || die "Could not locate gcc44"
- CC=gcc44 CXX=gcc44 $top_srcdir/configure $CONFIGURE_ARG $PREFIX_ARG || die "Cannot execute CC=gcc44 CXX=gcc44 configure $CONFIGURE_ARG $PREFIX_ARG"
+ 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"
+ ret=$?
;;
*)
- $top_srcdir/configure $CONFIGURE_ARG $PREFIX_ARG || die "Cannot execute configure $CONFIGURE_ARG $PREFIX_ARG"
+ $CONFIGURE $BUILD_CONFIGURE_ARG $PREFIX_ARG
+ ret=$?
;;
esac
+ if [ $ret -ne 0 ]; then
+ die "Could not execute $CONFIGURE $BUILD_CONFIGURE_ARG $PREFIX_ARG"
+ fi
+
if [ ! -f 'Makefile' ]; then
- die "Programmer error, configure was run but no Makefile existed afterward"
+ die "Programmer error, configure was run but no Makefile existed after $CONFIGURE was run"
fi
}
-setup_gdb_command () {
+function setup_gdb_command () {
GDB_TMPFILE=$(mktemp /tmp/gdb.XXXXXXXXXX)
echo 'set logging overwrite on' > $GDB_TMPFILE
echo 'set logging on' >> $GDB_TMPFILE
@@ -304,15 +350,79 @@ setup_gdb_command () {
GDB_COMMAND="gdb -f -batch -x $GDB_TMPFILE"
}
-setup_valgrind_command () {
+function setup_valgrind_command () {
VALGRIND_PROGRAM=`type -p valgrind`
if [[ -n "$VALGRIND_PROGRAM" ]]; then
VALGRIND_COMMAND="$VALGRIND_PROGRAM --error-exitcode=1 --leak-check=yes --show-reachable=yes --track-fds=yes --malloc-fill=A5 --free-fill=DE"
fi
}
-push_PREFIX_ARG ()
+function save_BUILD ()
+{
+ if [[ -n "$OLD_CONFIGURE" ]]; then
+ die "OLD_CONFIGURE($OLD_CONFIGURE) was set on push, programmer error!"
+ fi
+
+ if [[ -n "$OLD_CONFIGURE_ARG" ]]; then
+ die "OLD_CONFIGURE_ARG($OLD_CONFIGURE_ARG) was set on push, programmer error!"
+ fi
+
+ if [[ -n "$OLD_MAKE" ]]; then
+ 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!"
+ fi
+
+ if [[ -n "$CONFIGURE" ]]; then
+ OLD_CONFIGURE=$CONFIGURE
+ fi
+
+ if [[ -n "$CONFIGURE_ARG" ]]; then
+ OLD_CONFIGURE_ARG=$CONFIGURE_ARG
+ fi
+
+ if [[ -n "$MAKE" ]]; then
+ OLD_MAKE=$MAKE
+ fi
+
+ if [[ -n "$TESTS_ENVIRONMENT" ]]; then
+ OLD_TESTS_ENVIRONMENT=$TESTS_ENVIRONMENT
+ fi
+}
+
+function restore_BUILD ()
{
+ if [[ -n "$OLD_CONFIGURE" ]]; then
+ CONFIGURE=$OLD_CONFIGURE
+ fi
+
+ if [[ -n "$OLD_CONFIGURE_ARG" ]]; then
+ CONFIGURE_ARG=$OLD_CONFIGURE_ARG
+ fi
+
+ if [[ -n "$OLD_MAKE" ]]; then
+ MAKE=$OLD_MAKE
+ fi
+
+ if [[ -n "$OLD_TESTS_ENVIRONMENT" ]]; then
+ TESTS_ENVIRONMENT=$OLD_TESTS_ENVIRONMENT
+ fi
+
+ OLD_CONFIGURE=
+ OLD_CONFIGURE_ARG=
+ OLD_MAKE=
+ OLD_TESTS_ENVIRONMENT=
+ echo "reset happened"
+}
+
+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=
@@ -323,17 +433,17 @@ push_PREFIX_ARG ()
fi
}
-pop_PREFIX_ARG ()
+function pop_PREFIX_ARG ()
{
if [[ -n "$OLD_PREFIX_ARG" ]]; then
- PREFIX_ARG=$OLD_TESTS_ENVIRONMENT
+ PREFIX_ARG=$OLD_PREFIX_ARG
OLD_PREFIX_ARG=
else
PREFIX_ARG=
fi
}
-push_TESTS_ENVIRONMENT ()
+function push_TESTS_ENVIRONMENT ()
{
if [[ -n "$OLD_TESTS_ENVIRONMENT" ]]; then
die "OLD_TESTS_ENVIRONMENT was set on push, programmer error!"
@@ -345,7 +455,7 @@ push_TESTS_ENVIRONMENT ()
fi
}
-pop_TESTS_ENVIRONMENT ()
+function pop_TESTS_ENVIRONMENT ()
{
TESTS_ENVIRONMENT=
if [[ -n "$OLD_TESTS_ENVIRONMENT" ]]; then
@@ -498,24 +608,84 @@ function make_for_snapshot ()
snapshot_check
}
-function make_for_mingw32 ()
+function check_mingw ()
{
- # Make sure it is clean
- if [ -f Makefile -o -f configure ]; then
- make_maintainer_clean
+ command_exists 'mingw64-configure'
+ ret=$?
+ if [ "$ret" -ne 0 ]; then
+ return 1
fi
- assert_no_file 'Makefile'
- if command_exists mingw32-configure; then
- run_autoreconf
+ command_exists 'mingw64-make'
+ ret=$?
+ if [ "$ret" -ne 0 ]; then
+ return 1
+ fi
+
+ return 0
+}
- mingw32-configure || die 'mingw32-configure failed'
+function make_skeleton_mingw ()
+{
+ run_configure
+ ret=$?
+
+ if [ $ret -eq 0 ]; then
assert_file 'Makefile'
- if command_exists mingw32-make; then
- mingw32-make || die 'mingw32-make failed'
+ make_target 'all' 'warn'
+ ret=$?
+ if [ $ret -ne 0 ]; then
+ warn "$MAKE failed"
+ else
+ if [[ -n "$DISPLAY" ]]; then
+ if command_exists 'wine'; then
+ TESTS_ENVIRONMENT='wine'
+ fi
+ elif command_exists 'wineconsole'; then
+ TESTS_ENVIRONMENT='wineconsole --backend=curses'
+ fi
+
+ if [[ -n "$TESTS_ENVIRONMENT" ]]; then
+ make_target 'check' 'warn' || warn "$MAKE check failed"
+ ret=$?
+ fi
+ fi
+
+ if $jenkins_build_environment; then
+ make_target 'clean' 'warn'
fi
fi
+
+ return $ret
+}
+
+function make_for_mingw ()
+{
+ check_mingw
+ if ! check_mingw; then
+ die 'mingw64 tools were not found'
+ fi
+
+ # Make sure it is clean
+ if [ -f Makefile -o -f configure ]; then
+ make_maintainer_clean
+ fi
+
+ run_autoreconf
+
+ save_BUILD
+
+ CONFIGURE='mingw64-configure'
+ MAKE='mingw64-make'
+ CONFIGURE_ARGS='--enable-static'
+
+ make_skeleton_mingw
+ ret=$?
+
+ restore_BUILD
+
+ return $ret
}
# If we are locally testing, we should make sure the environment is setup correctly
@@ -540,7 +710,11 @@ function make_universe ()
make_valgrind
make_gdb
make_rpm
- make_for_mingw32
+
+ if [ check_mingw -eq 0 ]; then
+ make_for_mingw
+ fi
+
make_distcheck
make_install_system
}
@@ -631,11 +805,18 @@ function self_test ()
eval "./bootstrap.sh maintainer-clean" || die "failed 'maintainer-clean'"
}
-function make_gdb ()
+function make_install_html ()
{
run_configure_if_required
+ assert_file 'configure'
- if command_exists gdb; then
+ make_target 'install-html'
+}
+
+function make_gdb ()
+{
+ if command_exists 'gdb'; then
+ run_configure_if_required
push_TESTS_ENVIRONMENT
@@ -652,7 +833,7 @@ function make_gdb ()
TESTS_ENVIRONMENT="$GDB_COMMAND"
fi
- make_target check
+ make_target 'check'
if [ -f 'gdb.txt' ]; then
rm 'gdb.txt'
@@ -663,6 +844,10 @@ function make_gdb ()
if [ -f '.gdb_history' ]; then
rm '.gdb_history'
fi
+
+ if $jenkins_build_environment; then
+ make_target 'clean'
+ fi
else
echo 'gdb was not present'
return 1
@@ -692,11 +877,19 @@ function make_target ()
die "MAKE was not set"
fi
- if [ -n "$2" ]; then
- run $MAKE $1 || return 1
- else
- run $MAKE $1 || die "Cannot execute $MAKE $1"
+ # $2 represents error or warn
+ run $MAKE $1
+ ret=$?
+
+ if [ $ret -ne 0 ]; then
+ if [ -n "$2" ]; then
+ warn "Cannot execute $MAKE $1: $ret"
+ else
+ die "Cannot execute $MAKE $1: $ret"
+ fi
fi
+
+ return $ret
}
function make_distcheck ()
@@ -706,9 +899,16 @@ function make_distcheck ()
function make_rpm ()
{
- if [ -f 'rpm.am' -o -d 'rpm' ]; then
- run_configure_if_required
- make_target 'rpm'
+ if command_exists 'rpmbuild'; then
+ if [ -f 'rpm.am' -o -d 'rpm' ]; then
+ run_configure_if_required
+ make_target 'rpm'
+
+ if $jenkins_build_environment; then
+ make_target 'clean'
+ fi
+
+ fi
fi
}
@@ -716,6 +916,11 @@ function make_maintainer_clean ()
{
run_configure_if_required
make_target 'maintainer-clean' 'no_error'
+
+ # Lets make sure we really cleaned up the environment
+ assert_no_file 'Makefile'
+ assert_no_file 'configure'
+ assert_no_directory 'autom4te.cache'
}
function make_check ()
@@ -777,10 +982,14 @@ function run ()
echo "\`$@' $ARGS"
fi
+ if [ -z "$1" ]; then
+ return 127;
+ fi
+
eval $@ $ARGS
}
-parse_command_line_options ()
+function parse_command_line_options ()
{
local SHORTOPTS=':apcmt:dvh'
@@ -838,7 +1047,7 @@ parse_command_line_options ()
fi
}
-determine_vcs ()
+function determine_vcs ()
{
if [[ -d '.git' ]]; then
VCS_CHECKOUT=git
@@ -868,10 +1077,10 @@ function autoreconf_setup ()
{
# Set ENV MAKE in order to override "make"
if [[ -z "$MAKE" ]]; then
- if command_exists gmake; then
+ if command_exists 'gmake'; then
MAKE=`type -p gmake`
else
- if command_exists make; then
+ if command_exists 'make'; then
MAKE=`type -p make`
fi
fi
@@ -980,7 +1189,7 @@ function autoreconf_setup ()
run $AUTORECONF '--help' &> /dev/null || die "Failed to run AUTORECONF:$AUTORECONF"
}
-print_setup ()
+function print_setup ()
{
saved_debug_status=$DEBUG
if $DEBUG; then
@@ -1059,7 +1268,7 @@ print_setup ()
fi
}
-make_clean_option ()
+function make_clean_option ()
{
run_configure_if_required
@@ -1072,7 +1281,7 @@ make_clean_option ()
fi
}
-make_for_autoreconf ()
+function make_for_autoreconf ()
{
if [ -f 'Makefile' ]; then
make_maintainer_clean
@@ -1083,7 +1292,7 @@ make_for_autoreconf ()
assert_no_file 'Makefile'
}
-check_make_target()
+function check_make_target()
{
case $1 in
'self')
@@ -1190,6 +1399,9 @@ function bootstrap ()
'gdb')
make_gdb
;;
+ 'install-html')
+ make_install_html
+ ;;
'clean_op')
make_clean_option
;;
@@ -1206,7 +1418,17 @@ function bootstrap ()
make_default
;;
'mingw')
- make_for_mingw32
+ check_mingw
+ if ! check_mingw; then
+ die "mingw was not found"
+ fi
+
+ make_for_mingw
+ check_ret=$?
+
+ if ! make_for_mingw; then
+ die "Failed to build mingw: $?"
+ fi
;;
'snapshot')
make_for_snapshot
@@ -1231,13 +1453,14 @@ function bootstrap ()
done
}
-main ()
+function main ()
{
# Variables we export
declare -x VCS_CHECKOUT=
# Variables we control globally
local MAKE_TARGET=
+ local CONFIGURE=
# Options for getopt
local AUTORECONF_OPTION=false
@@ -1249,12 +1472,23 @@ main ()
local TARGET_OPTION_ARG=
local VERBOSE_OPTION=false
+ local OLD_CONFIGURE=
+ local OLD_CONFIGURE_ARG=
+ local OLD_MAKE=
+ local OLD_TESTS_ENVIRONMENT=
+
# If we call autoreconf on the platform or not
local AUTORECONF_REBUILD_HOST=false
local AUTORECONF_REBUILD=false
local -r top_srcdir=`pwd`
+ # Default configure
+ if [ -z "$CONFIGURE" ]; then
+ CONFIGURE="$top_srcdir/configure"
+ fi
+
+
# Variables for determine_target_platform () and rebuild_host_os ()
# UNAME_MACHINE_ARCH= uname -m
# VENDOR= apple, redhat, centos, canonical
@@ -1337,7 +1571,7 @@ function merge ()
fi
}
-enable_debug ()
+function enable_debug ()
{
if ! $DEBUG; then
local caller_loc=`caller`
@@ -1363,7 +1597,7 @@ function usage ()
EOF
}
-disable_debug ()
+function disable_debug ()
{
set +x
DEBUG=true
diff --git a/libmemcached-1.2/platform.h b/libmemcached-1.2/platform.h
index 01ce276c..9cbc705f 100644
--- a/libmemcached-1.2/platform.h
+++ b/libmemcached-1.2/platform.h
@@ -42,7 +42,11 @@
# include <winsock2.h>
# include <ws2tcpip.h>
-typedef short in_port_t;
+#ifndef HAVE_IN_PORT_T
+typedef int in_port_t;
+# define HAVE_IN_PORT_T 1
+#endif
+
typedef SOCKET memcached_socket_t;
#else
diff --git a/libmemcached/common.h b/libmemcached/common.h
index b10cc54d..5bd33db8 100644
--- a/libmemcached/common.h
+++ b/libmemcached/common.h
@@ -107,6 +107,10 @@
# include <dlfcn.h>
#endif
+#if defined(WIN32) || defined(__MINGW32__)
+# include "libmemcached/windows.hpp"
+#endif
+
#include <libmemcached-1.2/memcached.h>
#include <libmemcached/watchpoint.h>
#include <libmemcached/is.h>
diff --git a/libmemcached/connect.cc b/libmemcached/connect.cc
index d6dca966..d2580b5e 100644
--- a/libmemcached/connect.cc
+++ b/libmemcached/connect.cc
@@ -357,6 +357,8 @@ static bool set_socket_options(org::libmemcached::Instance* server)
#endif
+#if defined(_WIN32)
+#else
#if defined(SO_NOSIGPIPE)
if (SO_NOSIGPIPE)
{
@@ -373,7 +375,8 @@ static bool set_socket_options(org::libmemcached::Instance* server)
#endif
}
}
-#endif
+#endif // SO_NOSIGPIPE
+#endif // _WIN32
if (server->root->flags.no_block)
{
diff --git a/libmemcached/do.cc b/libmemcached/do.cc
index ef63927b..c9d8e7e5 100644
--- a/libmemcached/do.cc
+++ b/libmemcached/do.cc
@@ -57,6 +57,9 @@ static memcached_return_t _vdo_udp(org::libmemcached::Instance* instance,
return MEMCACHED_SUCCESS;
#else
+ (void)instance;
+ (void)vector;
+ (void)count;
return MEMCACHED_FAILURE;
#endif
}
diff --git a/libmemcached/error.cc b/libmemcached/error.cc
index 625c3e70..4c6bfc06 100644
--- a/libmemcached/error.cc
+++ b/libmemcached/error.cc
@@ -153,37 +153,37 @@ static void _set(memcached_st& memc, memcached_string_t *str, memcached_return_t
if (str and str->size and local_errno)
{
- error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%lu) %s(%s), %.*s -> %s",
- long(error->root),
+ error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %s(%s), %.*s -> %s",
+ error->root,
memcached_strerror(&memc, rc),
errmsg_ptr,
memcached_string_printf(*str), at);
}
else if (local_errno)
{
- error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%lu) %s(%s) -> %s",
- long(error->root),
+ error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %s(%s) -> %s",
+ error->root,
memcached_strerror(&memc, rc),
errmsg_ptr,
at);
}
else if (rc == MEMCACHED_PARSE_ERROR and str and str->size)
{
- error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%lu) %.*s -> %s",
- long(error->root),
+ error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %.*s -> %s",
+ error->root,
int(str->size), str->c_str, at);
}
else if (str and str->size)
{
- error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%lu) %s, %.*s -> %s",
- long(error->root),
+ error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %s, %.*s -> %s",
+ error->root,
memcached_strerror(&memc, rc),
int(str->size), str->c_str, at);
}
else
{
- error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%lu) %s -> %s",
- long(error->root),
+ error->size= (int)snprintf(error->message, MAX_ERROR_LENGTH, "(%p) %s -> %s",
+ error->root,
memcached_strerror(&memc, rc), at);
}
diff --git a/libmemcached/include.am b/libmemcached/include.am
index 6d085895..a09a0066 100644
--- a/libmemcached/include.am
+++ b/libmemcached/include.am
@@ -54,6 +54,13 @@ libmemcached_libmemcached_la_LDFLAGS=
libmemcached_libmemcached_la_CFLAGS= -DBUILDING_LIBMEMCACHED
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
+endif
+
libmemcached_libmemcached_la_SOURCES+= libmemcached/instance.cc
libmemcached_libmemcached_la_SOURCES+= ${libhashkit_libhashkit_la_SOURCES}
libmemcached_libmemcached_la_SOURCES+= libmemcached/allocators.cc
diff --git a/libmemcached/instance.cc b/libmemcached/instance.cc
index 50d6388e..faad235d 100644
--- a/libmemcached/instance.cc
+++ b/libmemcached/instance.cc
@@ -347,3 +347,24 @@ void memcached_instance_next_retry(memcached_server_instance_st self, const time
((org::libmemcached::Instance*)self)->next_retry= absolute_time;
}
}
+
+namespace org {
+namespace libmemcached {
+
+ bool Instance::valid() const
+ {
+ if (fd == INVALID_SOCKET)
+ {
+ return false;
+ }
+
+ return true;
+ }
+
+ bool Instance::is_shutting_down() const
+ {
+ return options.is_shutting_down;
+ }
+
+} // namespace libmemcached
+} // namespace org
diff --git a/libmemcached/instance.hpp b/libmemcached/instance.hpp
index 097d3500..8f66e96d 100644
--- a/libmemcached/instance.hpp
+++ b/libmemcached/instance.hpp
@@ -85,6 +85,13 @@ struct Instance {
{
}
+ bool valid() const;
+
+ bool is_shutting_down() const;
+
+ void start_close_socket();
+ void close_socket();
+
uint32_t response_count() const
{
return cursor_active_;
diff --git a/libmemcached/io.cc b/libmemcached/io.cc
index 6d9cad9a..60614f5c 100644
--- a/libmemcached/io.cc
+++ b/libmemcached/io.cc
@@ -59,34 +59,34 @@ enum memc_read_or_write {
* Try to fill the input buffer for a server with as much
* data as possible.
*
- * @param ptr the server to pack
+ * @param instance the server to pack
*/
-static bool repack_input_buffer(org::libmemcached::Instance* ptr)
+static bool repack_input_buffer(org::libmemcached::Instance* instance)
{
- if (ptr->read_ptr != ptr->read_buffer)
+ if (instance->read_ptr != instance->read_buffer)
{
/* Move all of the data to the beginning of the buffer so
** that we can fit more data into the buffer...
*/
- memmove(ptr->read_buffer, ptr->read_ptr, ptr->read_buffer_length);
- ptr->read_ptr= ptr->read_buffer;
- ptr->read_data_length= ptr->read_buffer_length;
+ memmove(instance->read_buffer, instance->read_ptr, instance->read_buffer_length);
+ instance->read_ptr= instance->read_buffer;
+ instance->read_data_length= instance->read_buffer_length;
}
/* There is room in the buffer, try to fill it! */
- if (ptr->read_buffer_length != MEMCACHED_MAX_BUFFER)
+ if (instance->read_buffer_length != MEMCACHED_MAX_BUFFER)
{
do {
/* Just try a single read to grab what's available */
ssize_t nr;
- if ((nr= ::recv(ptr->fd,
- ptr->read_ptr + ptr->read_data_length,
- MEMCACHED_MAX_BUFFER - ptr->read_data_length,
- MSG_NOSIGNAL)) <= 0)
+ if ((nr= ::recv(instance->fd,
+ instance->read_ptr + instance->read_data_length,
+ MEMCACHED_MAX_BUFFER - instance->read_data_length,
+ MSG_NOSIGNAL)) <= 0)
{
if (nr == 0)
{
- memcached_set_error(*ptr, MEMCACHED_CONNECTION_FAILURE, MEMCACHED_AT);
+ memcached_set_error(*instance, MEMCACHED_CONNECTION_FAILURE, MEMCACHED_AT);
}
else
{
@@ -105,7 +105,7 @@ static bool repack_input_buffer(org::libmemcached::Instance* ptr)
break; // No IO is fine, we can just move on
default:
- memcached_set_errno(*ptr, get_socket_errno(), MEMCACHED_AT);
+ memcached_set_errno(*instance, get_socket_errno(), MEMCACHED_AT);
}
}
@@ -113,8 +113,8 @@ static bool repack_input_buffer(org::libmemcached::Instance* ptr)
}
else // We read data, append to our read buffer
{
- ptr->read_data_length+= size_t(nr);
- ptr->read_buffer_length+= size_t(nr);
+ instance->read_data_length+= size_t(nr);
+ instance->read_buffer_length+= size_t(nr);
return true;
}
@@ -131,28 +131,28 @@ static bool repack_input_buffer(org::libmemcached::Instance* ptr)
* when the input buffer is full, so that we _know_ that we have
* at least _one_ message to process.
*
- * @param ptr the server to star processing iput messages for
+ * @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* ptr)
+static bool process_input_buffer(org::libmemcached::Instance* instance)
{
/*
** We might be able to process some of the response messages if we
** have a callback set up
*/
- if (ptr->root->callbacks != NULL)
+ if (instance->root->callbacks != NULL)
{
/*
* We might have responses... try to read them out and fire
* callbacks
*/
- memcached_callback_st cb= *ptr->root->callbacks;
+ memcached_callback_st cb= *instance->root->callbacks;
- memcached_set_processing_input((memcached_st *)ptr->root, true);
+ memcached_set_processing_input((memcached_st *)instance->root, true);
char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
- memcached_st *root= (memcached_st *)ptr->root;
- memcached_return_t error= memcached_response(ptr, buffer, sizeof(buffer), &root->result);
+ memcached_st *root= (memcached_st *)instance->root;
+ memcached_return_t error= memcached_response(instance, buffer, sizeof(buffer), &root->result);
memcached_set_processing_input(root, false);
@@ -160,7 +160,7 @@ static bool process_input_buffer(org::libmemcached::Instance* ptr)
{
for (unsigned int x= 0; x < cb.number_of_callback; x++)
{
- error= (*cb.callback[x])(ptr->root, &root->result, cb.context);
+ error= (*cb.callback[x])(instance->root, &root->result, cb.context);
if (error != MEMCACHED_SUCCESS)
{
break;
@@ -176,7 +176,7 @@ static bool process_input_buffer(org::libmemcached::Instance* ptr)
return false;
}
-static memcached_return_t io_wait(org::libmemcached::Instance* ptr,
+static memcached_return_t io_wait(org::libmemcached::Instance* instance,
const memc_read_or_write read_or_write)
{
/*
@@ -189,37 +189,37 @@ static memcached_return_t io_wait(org::libmemcached::Instance* ptr,
*/
if (read_or_write == MEM_WRITE)
{
- if (memcached_purge(ptr) == false)
+ if (memcached_purge(instance) == false)
{
return MEMCACHED_FAILURE;
}
}
struct pollfd fds;
- fds.fd= ptr->fd;
+ fds.fd= instance->fd;
fds.events= POLLIN;
fds.revents= 0;
if (read_or_write == MEM_WRITE) /* write */
{
fds.events= POLLOUT;
- ptr->io_wait_count.write++;
+ instance->io_wait_count.write++;
}
else
{
- ptr->io_wait_count.read++;
+ instance->io_wait_count.read++;
}
- if (ptr->root->poll_timeout == 0) // Mimic 0 causes timeout behavior (not all platforms do this)
+ if (instance->root->poll_timeout == 0) // Mimic 0 causes timeout behavior (not all platforms do this)
{
- ptr->io_wait_count.timeouts++;
- return memcached_set_error(*ptr, MEMCACHED_TIMEOUT, MEMCACHED_AT);
+ instance->io_wait_count.timeouts++;
+ return memcached_set_error(*instance, MEMCACHED_TIMEOUT, MEMCACHED_AT);
}
size_t loop_max= 5;
while (--loop_max) // While loop is for ERESTART or EINTR
{
- int active_fd= poll(&fds, 1, ptr->root->poll_timeout);
+ int active_fd= poll(&fds, 1, instance->root->poll_timeout);
if (active_fd >= 1)
{
@@ -231,7 +231,7 @@ static memcached_return_t io_wait(org::libmemcached::Instance* ptr,
if (fds.revents & POLLHUP)
{
- return memcached_set_error(*ptr, MEMCACHED_CONNECTION_FAILURE, MEMCACHED_AT,
+ return memcached_set_error(*instance, MEMCACHED_CONNECTION_FAILURE, MEMCACHED_AT,
memcached_literal_param("poll() detected hang up"));
}
@@ -240,7 +240,7 @@ static memcached_return_t io_wait(org::libmemcached::Instance* ptr,
int local_errno= EINVAL;
int err;
socklen_t len= sizeof (err);
- if (getsockopt(ptr->fd, SOL_SOCKET, SO_ERROR, (char*)&err, &len) == 0)
+ if (getsockopt(instance->fd, SOL_SOCKET, SO_ERROR, (char*)&err, &len) == 0)
{
if (err == 0) // treat this as EINTR
{
@@ -248,18 +248,18 @@ static memcached_return_t io_wait(org::libmemcached::Instance* ptr,
}
local_errno= err;
}
- memcached_quit_server(ptr, true);
- return memcached_set_errno(*ptr, local_errno, MEMCACHED_AT,
+ memcached_quit_server(instance, true);
+ return memcached_set_errno(*instance, local_errno, MEMCACHED_AT,
memcached_literal_param("poll() returned POLLHUP"));
}
- return memcached_set_error(*ptr, MEMCACHED_FAILURE, MEMCACHED_AT, memcached_literal_param("poll() returned a value that was not dealt with"));
+ return memcached_set_error(*instance, MEMCACHED_FAILURE, MEMCACHED_AT, memcached_literal_param("poll() returned a value that was not dealt with"));
}
if (active_fd == 0)
{
- ptr->io_wait_count.timeouts++;
- return memcached_set_error(*ptr, MEMCACHED_TIMEOUT, MEMCACHED_AT);
+ instance->io_wait_count.timeouts++;
+ return memcached_set_error(*instance, MEMCACHED_TIMEOUT, MEMCACHED_AT);
}
// Only an error should result in this code being called.
@@ -275,30 +275,30 @@ static memcached_return_t io_wait(org::libmemcached::Instance* ptr,
case EFAULT:
case ENOMEM:
- memcached_set_error(*ptr, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT);
+ memcached_set_error(*instance, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT);
case EINVAL:
- memcached_set_error(*ptr, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT, memcached_literal_param("RLIMIT_NOFILE exceeded, or if OSX the timeout value was invalid"));
+ memcached_set_error(*instance, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT, memcached_literal_param("RLIMIT_NOFILE exceeded, or if OSX the timeout value was invalid"));
default:
- memcached_set_errno(*ptr, local_errno, MEMCACHED_AT, memcached_literal_param("poll"));
+ memcached_set_errno(*instance, local_errno, MEMCACHED_AT, memcached_literal_param("poll"));
}
break;
}
- memcached_quit_server(ptr, true);
+ memcached_quit_server(instance, true);
- if (memcached_has_error(ptr))
+ if (memcached_has_error(instance))
{
- return memcached_instance_error_return(ptr);
+ return memcached_instance_error_return(instance);
}
- return memcached_set_error(*ptr, MEMCACHED_CONNECTION_FAILURE, MEMCACHED_AT,
+ return memcached_set_error(*instance, MEMCACHED_CONNECTION_FAILURE, MEMCACHED_AT,
memcached_literal_param("number of attempts to call io_wait() failed"));
}
-static bool io_flush(org::libmemcached::Instance* ptr,
+static bool io_flush(org::libmemcached::Instance* instance,
const bool with_flush,
memcached_return_t& error)
{
@@ -308,30 +308,30 @@ static bool io_flush(org::libmemcached::Instance* ptr,
** in the purge function to avoid duplicating the logic..
*/
{
- WATCHPOINT_ASSERT(ptr->fd != INVALID_SOCKET);
+ WATCHPOINT_ASSERT(instance->fd != INVALID_SOCKET);
- if (memcached_purge(ptr) == false)
+ if (memcached_purge(instance) == false)
{
return false;
}
}
- char *local_write_ptr= ptr->write_buffer;
- size_t write_length= ptr->write_buffer_offset;
+ char *local_write_ptr= instance->write_buffer;
+ size_t write_length= instance->write_buffer_offset;
error= MEMCACHED_SUCCESS;
- WATCHPOINT_ASSERT(ptr->fd != INVALID_SOCKET);
+ WATCHPOINT_ASSERT(instance->fd != INVALID_SOCKET);
/* Looking for memory overflows */
#if defined(DEBUG)
if (write_length == MEMCACHED_MAX_BUFFER)
- WATCHPOINT_ASSERT(ptr->write_buffer == local_write_ptr);
- WATCHPOINT_ASSERT((ptr->write_buffer + MEMCACHED_MAX_BUFFER) >= (local_write_ptr + write_length));
+ WATCHPOINT_ASSERT(instance->write_buffer == local_write_ptr);
+ WATCHPOINT_ASSERT((instance->write_buffer + MEMCACHED_MAX_BUFFER) >= (local_write_ptr + write_length));
#endif
while (write_length)
{
- WATCHPOINT_ASSERT(ptr->fd != INVALID_SOCKET);
+ WATCHPOINT_ASSERT(instance->fd != INVALID_SOCKET);
WATCHPOINT_ASSERT(write_length > 0);
int flags;
@@ -344,7 +344,7 @@ static bool io_flush(org::libmemcached::Instance* ptr,
flags= MSG_NOSIGNAL|MSG_MORE;
}
- ssize_t sent_length= ::send(ptr->fd, local_write_ptr, write_length, flags);
+ ssize_t sent_length= ::send(instance->fd, local_write_ptr, write_length, flags);
if (sent_length == SOCKET_ERROR)
{
@@ -368,12 +368,12 @@ static bool io_flush(org::libmemcached::Instance* ptr,
* buffer for more data and retry the write before
* waiting..
*/
- if (repack_input_buffer(ptr) or process_input_buffer(ptr))
+ if (repack_input_buffer(instance) or process_input_buffer(instance))
{
continue;
}
- memcached_return_t rc= io_wait(ptr, MEM_WRITE);
+ memcached_return_t rc= io_wait(instance, MEM_WRITE);
if (memcached_success(rc))
{
continue;
@@ -383,43 +383,43 @@ static bool io_flush(org::libmemcached::Instance* ptr,
return false;
}
- memcached_quit_server(ptr, true);
- error= memcached_set_errno(*ptr, get_socket_errno(), MEMCACHED_AT);
+ memcached_quit_server(instance, true);
+ error= memcached_set_errno(*instance, get_socket_errno(), MEMCACHED_AT);
return false;
}
case ENOTCONN:
case EPIPE:
default:
- memcached_quit_server(ptr, true);
- error= memcached_set_errno(*ptr, get_socket_errno(), MEMCACHED_AT);
- WATCHPOINT_ASSERT(ptr->fd == INVALID_SOCKET);
+ memcached_quit_server(instance, true);
+ error= memcached_set_errno(*instance, get_socket_errno(), MEMCACHED_AT);
+ WATCHPOINT_ASSERT(instance->fd == INVALID_SOCKET);
return false;
}
}
- ptr->io_bytes_sent+= uint32_t(sent_length);
+ instance->io_bytes_sent+= uint32_t(sent_length);
local_write_ptr+= sent_length;
write_length-= uint32_t(sent_length);
}
WATCHPOINT_ASSERT(write_length == 0);
- ptr->write_buffer_offset= 0;
+ instance->write_buffer_offset= 0;
return true;
}
-memcached_return_t memcached_io_wait_for_write(org::libmemcached::Instance* ptr)
+memcached_return_t memcached_io_wait_for_write(org::libmemcached::Instance* instance)
{
- return io_wait(ptr, MEM_WRITE);
+ return io_wait(instance, MEM_WRITE);
}
-static memcached_return_t _io_fill(org::libmemcached::Instance* ptr)
+static memcached_return_t _io_fill(org::libmemcached::Instance* instance)
{
ssize_t data_read;
do
{
- data_read= ::recv(ptr->fd, ptr->read_buffer, MEMCACHED_MAX_BUFFER, MSG_NOSIGNAL);
+ data_read= ::recv(instance->fd, instance->read_buffer, MEMCACHED_MAX_BUFFER, MSG_NOSIGNAL);
if (data_read == SOCKET_ERROR)
{
switch (get_socket_errno())
@@ -437,7 +437,7 @@ static memcached_return_t _io_fill(org::libmemcached::Instance* ptr)
#endif
{
memcached_return_t io_wait_ret;
- if (memcached_success(io_wait_ret= io_wait(ptr, MEM_READ)))
+ if (memcached_success(io_wait_ret= io_wait(instance, MEM_READ)))
{
continue;
}
@@ -452,17 +452,17 @@ static memcached_return_t _io_fill(org::libmemcached::Instance* ptr)
case ENOTSOCK:
WATCHPOINT_ASSERT(0);
case EBADF:
- assert_msg(ptr->fd != INVALID_SOCKET, "Programmer error, invalid socket");
+ assert_msg(instance->fd != INVALID_SOCKET, "Programmer error, invalid socket");
case EINVAL:
case EFAULT:
case ECONNREFUSED:
default:
- memcached_quit_server(ptr, true);
- memcached_set_errno(*ptr, get_socket_errno(), MEMCACHED_AT);
+ memcached_quit_server(instance, true);
+ memcached_set_errno(*instance, get_socket_errno(), MEMCACHED_AT);
break;
}
- return memcached_instance_error_return(ptr);
+ return memcached_instance_error_return(instance);
}
else if (data_read == 0)
{
@@ -475,42 +475,42 @@ static memcached_return_t _io_fill(org::libmemcached::Instance* ptr)
for blocking I/O we do not return 0 and for non-blocking case
it will return EGAIN if data is not immediatly available.
*/
- memcached_quit_server(ptr, true);
- return memcached_set_error(*ptr, MEMCACHED_CONNECTION_FAILURE, MEMCACHED_AT,
+ memcached_quit_server(instance, true);
+ return memcached_set_error(*instance, MEMCACHED_CONNECTION_FAILURE, MEMCACHED_AT,
memcached_literal_param("::rec() returned zero, server has disconnected"));
}
- ptr->io_wait_count._bytes_read+= data_read;
+ instance->io_wait_count._bytes_read+= data_read;
} while (data_read <= 0);
- ptr->io_bytes_sent= 0;
- ptr->read_data_length= (size_t) data_read;
- ptr->read_buffer_length= (size_t) data_read;
- ptr->read_ptr= ptr->read_buffer;
+ instance->io_bytes_sent= 0;
+ instance->read_data_length= (size_t) data_read;
+ instance->read_buffer_length= (size_t) data_read;
+ instance->read_ptr= instance->read_buffer;
return MEMCACHED_SUCCESS;
}
-memcached_return_t memcached_io_read(org::libmemcached::Instance* ptr,
+memcached_return_t memcached_io_read(org::libmemcached::Instance* instance,
void *buffer, size_t length, ssize_t& nread)
{
- assert(memcached_is_udp(ptr->root) == false);
- assert_msg(ptr, "Programmer error, memcached_io_read() recieved an invalid Instance"); // Programmer error
+ assert(memcached_is_udp(instance->root) == false);
+ assert_msg(instance, "Programmer error, memcached_io_read() recieved an invalid Instance"); // Programmer error
char *buffer_ptr= static_cast<char *>(buffer);
- if (ptr->fd == INVALID_SOCKET)
+ if (instance->fd == INVALID_SOCKET)
{
#if 0
- assert_msg(int(ptr->state) <= int(MEMCACHED_SERVER_STATE_ADDRINFO), "Programmer error, invalid socket state");
+ assert_msg(int(instance->state) <= int(MEMCACHED_SERVER_STATE_ADDRINFO), "Programmer error, invalid socket state");
#endif
return MEMCACHED_CONNECTION_FAILURE;
}
while (length)
{
- if (ptr->read_buffer_length == 0)
+ if (instance->read_buffer_length == 0)
{
memcached_return_t io_fill_ret;
- if (memcached_fatal(io_fill_ret= _io_fill(ptr)))
+ if (memcached_fatal(io_fill_ret= _io_fill(instance)))
{
nread= -1;
return io_fill_ret;
@@ -519,19 +519,19 @@ memcached_return_t memcached_io_read(org::libmemcached::Instance* ptr,
if (length > 1)
{
- size_t difference= (length > ptr->read_buffer_length) ? ptr->read_buffer_length : length;
+ size_t difference= (length > instance->read_buffer_length) ? instance->read_buffer_length : length;
- memcpy(buffer_ptr, ptr->read_ptr, difference);
+ memcpy(buffer_ptr, instance->read_ptr, difference);
length -= difference;
- ptr->read_ptr+= difference;
- ptr->read_buffer_length-= difference;
+ instance->read_ptr+= difference;
+ instance->read_buffer_length-= difference;
buffer_ptr+= difference;
}
else
{
- *buffer_ptr= *ptr->read_ptr;
- ptr->read_ptr++;
- ptr->read_buffer_length--;
+ *buffer_ptr= *instance->read_ptr;
+ instance->read_ptr++;
+ instance->read_buffer_length--;
buffer_ptr++;
break;
}
@@ -542,14 +542,14 @@ memcached_return_t memcached_io_read(org::libmemcached::Instance* ptr,
return MEMCACHED_SUCCESS;
}
-memcached_return_t memcached_io_slurp(org::libmemcached::Instance* ptr)
+memcached_return_t memcached_io_slurp(org::libmemcached::Instance* instance)
{
- assert_msg(ptr, "Programmer error, invalid Instance");
- assert(memcached_is_udp(ptr->root) == false);
+ assert_msg(instance, "Programmer error, invalid Instance");
+ assert(memcached_is_udp(instance->root) == false);
- if (ptr->fd == INVALID_SOCKET)
+ if (instance->fd == INVALID_SOCKET)
{
- assert_msg(int(ptr->state) <= int(MEMCACHED_SERVER_STATE_ADDRINFO), "Invalid socket state");
+ assert_msg(int(instance->state) <= int(MEMCACHED_SERVER_STATE_ADDRINFO), "Invalid socket state");
return MEMCACHED_CONNECTION_FAILURE;
}
@@ -557,7 +557,7 @@ memcached_return_t memcached_io_slurp(org::libmemcached::Instance* ptr)
char buffer[MEMCACHED_MAX_BUFFER];
do
{
- data_read= ::recv(ptr->fd, ptr->read_buffer, sizeof(buffer), MSG_NOSIGNAL);
+ data_read= ::recv(instance->fd, instance->read_buffer, sizeof(buffer), MSG_NOSIGNAL);
if (data_read == SOCKET_ERROR)
{
switch (get_socket_errno())
@@ -573,7 +573,7 @@ memcached_return_t memcached_io_slurp(org::libmemcached::Instance* ptr)
#ifdef TARGET_OS_LINUX
case ERESTART:
#endif
- if (memcached_success(io_wait(ptr, MEM_READ)))
+ if (memcached_success(io_wait(instance, MEM_READ)))
{
continue;
}
@@ -586,7 +586,7 @@ memcached_return_t memcached_io_slurp(org::libmemcached::Instance* ptr)
case ENOTSOCK:
assert(0);
case EBADF:
- assert_msg(ptr->fd != INVALID_SOCKET, "Invalid socket state");
+ assert_msg(instance->fd != INVALID_SOCKET, "Invalid socket state");
case EINVAL:
case EFAULT:
case ECONNREFUSED:
@@ -599,12 +599,12 @@ memcached_return_t memcached_io_slurp(org::libmemcached::Instance* ptr)
return MEMCACHED_CONNECTION_FAILURE;
}
-static bool _io_write(org::libmemcached::Instance* ptr,
+static bool _io_write(org::libmemcached::Instance* instance,
const void *buffer, size_t length, bool with_flush,
size_t& written)
{
- assert(ptr->fd != INVALID_SOCKET);
- assert(memcached_is_udp(ptr->root) == false);
+ assert(instance->fd != INVALID_SOCKET);
+ assert(memcached_is_udp(instance->root) == false);
const char *buffer_ptr= static_cast<const char *>(buffer);
@@ -614,21 +614,21 @@ static bool _io_write(org::libmemcached::Instance* ptr,
{
char *write_ptr;
size_t buffer_end= MEMCACHED_MAX_BUFFER;
- size_t should_write= buffer_end -ptr->write_buffer_offset;
+ size_t should_write= buffer_end -instance->write_buffer_offset;
should_write= (should_write < length) ? should_write : length;
- write_ptr= ptr->write_buffer + ptr->write_buffer_offset;
+ write_ptr= instance->write_buffer + instance->write_buffer_offset;
memcpy(write_ptr, buffer_ptr, should_write);
- ptr->write_buffer_offset+= should_write;
+ instance->write_buffer_offset+= should_write;
buffer_ptr+= should_write;
length-= should_write;
- if (ptr->write_buffer_offset == buffer_end)
+ if (instance->write_buffer_offset == buffer_end)
{
- WATCHPOINT_ASSERT(ptr->fd != INVALID_SOCKET);
+ WATCHPOINT_ASSERT(instance->fd != INVALID_SOCKET);
memcached_return_t rc;
- if (io_flush(ptr, with_flush, rc) == false)
+ if (io_flush(instance, with_flush, rc) == false)
{
written= original_length -length;
return false;
@@ -639,8 +639,8 @@ static bool _io_write(org::libmemcached::Instance* ptr,
if (with_flush)
{
memcached_return_t rc;
- WATCHPOINT_ASSERT(ptr->fd != INVALID_SOCKET);
- if (io_flush(ptr, with_flush, rc) == false)
+ WATCHPOINT_ASSERT(instance->fd != INVALID_SOCKET);
+ if (io_flush(instance, with_flush, rc) == false)
{
written= original_length -length;
return false;
@@ -652,18 +652,18 @@ static bool _io_write(org::libmemcached::Instance* ptr,
return true;
}
-bool memcached_io_write(org::libmemcached::Instance* ptr)
+bool memcached_io_write(org::libmemcached::Instance* instance)
{
size_t written;
- return _io_write(ptr, NULL, 0, true, written);
+ return _io_write(instance, NULL, 0, true, written);
}
-ssize_t memcached_io_write(org::libmemcached::Instance* ptr,
+ssize_t memcached_io_write(org::libmemcached::Instance* instance,
const void *buffer, const size_t length, const bool with_flush)
{
size_t written;
- if (_io_write(ptr, buffer, length, with_flush, written) == false)
+ if (_io_write(instance, buffer, length, with_flush, written) == false)
{
return -1;
}
@@ -671,7 +671,7 @@ ssize_t memcached_io_write(org::libmemcached::Instance* ptr,
return ssize_t(written);
}
-bool memcached_io_writev(org::libmemcached::Instance* ptr,
+bool memcached_io_writev(org::libmemcached::Instance* instance,
libmemcached_io_vector_st vector[],
const size_t number_of, const bool with_flush)
{
@@ -684,7 +684,7 @@ bool memcached_io_writev(org::libmemcached::Instance* ptr,
if (vector->length)
{
size_t written;
- if ((_io_write(ptr, vector->buffer, vector->length, false, written)) == false)
+ if ((_io_write(instance, vector->buffer, vector->length, false, written)) == false)
{
return false;
}
@@ -694,7 +694,7 @@ bool memcached_io_writev(org::libmemcached::Instance* ptr,
if (with_flush)
{
- if (memcached_io_write(ptr) == false)
+ if (memcached_io_write(instance) == false)
{
return false;
}
@@ -703,28 +703,47 @@ bool memcached_io_writev(org::libmemcached::Instance* ptr,
return (complete_total == total);
}
-
-void memcached_io_close(org::libmemcached::Instance* ptr)
+void org::libmemcached::Instance::start_close_socket()
{
- if (ptr->fd == INVALID_SOCKET)
+ if (fd != INVALID_SOCKET)
{
- return;
+ shutdown(fd, SHUT_WR);
+ options.is_shutting_down= true;
}
+}
- /* in case of death shutdown to avoid blocking at close() */
- if (shutdown(ptr->fd, SHUT_RDWR) == SOCKET_ERROR and get_socket_errno() != ENOTCONN)
+void org::libmemcached::Instance::close_socket()
+{
+ if (fd != INVALID_SOCKET)
{
- WATCHPOINT_NUMBER(ptr->fd);
- WATCHPOINT_ERRNO(get_socket_errno());
- WATCHPOINT_ASSERT(get_socket_errno());
- }
+ /* in case of death shutdown to avoid blocking at close() */
+ if (shutdown(fd, SHUT_RD) == SOCKET_ERROR and get_socket_errno() != ENOTCONN)
+ {
+ WATCHPOINT_NUMBER(fd);
+ WATCHPOINT_ERRNO(get_socket_errno());
+ WATCHPOINT_ASSERT(get_socket_errno());
+ }
- if (closesocket(ptr->fd) == SOCKET_ERROR)
- {
- WATCHPOINT_ERRNO(get_socket_errno());
+ if (closesocket(fd) == SOCKET_ERROR)
+ {
+ WATCHPOINT_ERRNO(get_socket_errno());
+ }
+ state= MEMCACHED_SERVER_STATE_NEW;
+ fd= INVALID_SOCKET;
}
- ptr->state= MEMCACHED_SERVER_STATE_NEW;
- ptr->fd= INVALID_SOCKET;
+
+ state= MEMCACHED_SERVER_STATE_NEW;
+ cursor_active_= 0;
+ io_bytes_sent= 0;
+ write_buffer_offset= size_t(root and memcached_is_udp(root) ? UDP_DATAGRAM_HEADER_LENGTH : 0);
+ read_buffer_length= 0;
+ read_ptr= read_buffer;
+ options.is_shutting_down= false;
+ memcached_server_response_reset(this);
+
+ // We reset the version so that if we end up talking to a different server
+ // we don't have stale server version information.
+ major_version= minor_version= micro_version= UINT8_MAX;
}
org::libmemcached::Instance* memcached_io_get_readable_server(memcached_st *memc, memcached_return_t&)
@@ -800,16 +819,16 @@ org::libmemcached::Instance* memcached_io_get_readable_server(memcached_st *memc
/*
Eventually we will just kill off the server with the problem.
*/
-void memcached_io_reset(org::libmemcached::Instance* ptr)
+void memcached_io_reset(org::libmemcached::Instance* instance)
{
- memcached_quit_server(ptr, true);
+ memcached_quit_server(instance, true);
}
/**
* 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* ptr,
+memcached_return_t memcached_safe_read(org::libmemcached::Instance* instance,
void *dta,
const size_t size)
{
@@ -821,7 +840,7 @@ memcached_return_t memcached_safe_read(org::libmemcached::Instance* ptr,
ssize_t nread;
memcached_return_t rc;
- while (memcached_continue(rc= memcached_io_read(ptr, data + offset, size - offset, nread))) { };
+ while (memcached_continue(rc= memcached_io_read(instance, data + offset, size - offset, nread))) { };
if (memcached_failed(rc))
{
@@ -834,7 +853,7 @@ memcached_return_t memcached_safe_read(org::libmemcached::Instance* ptr,
return MEMCACHED_SUCCESS;
}
-memcached_return_t memcached_io_readline(org::libmemcached::Instance* ptr,
+memcached_return_t memcached_io_readline(org::libmemcached::Instance* instance,
char *buffer_ptr,
size_t size,
size_t& total_nr)
@@ -844,7 +863,7 @@ memcached_return_t memcached_io_readline(org::libmemcached::Instance* ptr,
while (line_complete == false)
{
- if (ptr->read_buffer_length == 0)
+ if (instance->read_buffer_length == 0)
{
/*
* We don't have any data in the buffer, so let's fill the read
@@ -852,11 +871,11 @@ memcached_return_t memcached_io_readline(org::libmemcached::Instance* ptr,
* the logic.
*/
ssize_t nread;
- memcached_return_t rc= memcached_io_read(ptr, buffer_ptr, 1, nread);
+ memcached_return_t rc= memcached_io_read(instance, buffer_ptr, 1, nread);
if (memcached_failed(rc) and rc == MEMCACHED_IN_PROGRESS)
{
- memcached_quit_server(ptr, true);
- return memcached_set_error(*ptr, rc, MEMCACHED_AT);
+ memcached_quit_server(instance, true);
+ return memcached_set_error(*instance, rc, MEMCACHED_AT);
}
else if (memcached_failed(rc))
{
@@ -873,15 +892,15 @@ memcached_return_t memcached_io_readline(org::libmemcached::Instance* ptr,
}
/* Now let's look in the buffer and copy as we go! */
- while (ptr->read_buffer_length and total_nr < size and line_complete == false)
+ while (instance->read_buffer_length and total_nr < size and line_complete == false)
{
- *buffer_ptr = *ptr->read_ptr;
+ *buffer_ptr = *instance->read_ptr;
if (*buffer_ptr == '\n')
{
line_complete = true;
}
- --ptr->read_buffer_length;
- ++ptr->read_ptr;
+ --instance->read_buffer_length;
+ ++instance->read_ptr;
++total_nr;
++buffer_ptr;
}
diff --git a/libmemcached/io.hpp b/libmemcached/io.hpp
index ed0b82ad..bf2133e8 100644
--- a/libmemcached/io.hpp
+++ b/libmemcached/io.hpp
@@ -62,8 +62,6 @@ memcached_return_t memcached_io_readline(org::libmemcached::Instance* ptr,
size_t size,
size_t& total);
-void memcached_io_close(org::libmemcached::Instance* ptr);
-
/* Read n bytes of data from the server and store them in dta */
memcached_return_t memcached_safe_read(org::libmemcached::Instance* ptr,
void *dta,
diff --git a/libmemcached/quit.cc b/libmemcached/quit.cc
index 77924fb4..8b33255b 100644
--- a/libmemcached/quit.cc
+++ b/libmemcached/quit.cc
@@ -37,6 +37,65 @@
#include <libmemcached/common.h>
+namespace {
+ memcached_return_t send_quit_message(org::libmemcached::Instance* instance)
+ {
+ memcached_return_t rc;
+ if (instance->root->flags.binary_protocol)
+ {
+ protocol_binary_request_quit request= {}; // = {.bytes= {0}};
+
+ initialize_binary_request(instance, request.message.header);
+
+ request.message.header.request.opcode = PROTOCOL_BINARY_CMD_QUIT;
+ request.message.header.request.datatype = PROTOCOL_BINARY_RAW_BYTES;
+
+ libmemcached_io_vector_st vector[]=
+ {
+ { request.bytes, sizeof(request.bytes) }
+ };
+
+ rc= memcached_vdo(instance, vector, 1, true);
+ }
+ else
+ {
+ libmemcached_io_vector_st vector[]=
+ {
+ { memcached_literal_param("quit\r\n") }
+ };
+
+ rc= memcached_vdo(instance, vector, 1, true);
+ }
+
+ return rc;
+ }
+
+ void drain_instance(org::libmemcached::Instance* instance)
+ {
+ /* read until socket is closed, or there is an error
+ * closing the socket before all data is read
+ * results in server throwing away all data which is
+ * not read
+ *
+ * In .40 we began to only do this if we had been doing buffered
+ * requests of had replication enabled.
+ */
+ if (instance->root->flags.buffer_requests or instance->root->number_of_replicas)
+ {
+ memcached_io_slurp(instance);
+ }
+
+ /*
+ * memcached_io_read may call memcached_quit_server with io_death if
+ * it encounters problems, but we don't care about those occurences.
+ * The intention of that loop is to drain the data sent from the
+ * server to ensure that the server processed all of the data we
+ * sent to the server.
+ */
+ instance->server_failure_counter= 0;
+ }
+}
+
/*
This closes all connections (forces flush of input as well).
@@ -46,111 +105,44 @@
will force data to be completed.
*/
-void memcached_quit_server(org::libmemcached::Instance* ptr, bool io_death)
+void memcached_quit_server(org::libmemcached::Instance* instance, bool io_death)
{
- if (ptr->fd != INVALID_SOCKET)
+ if (instance->valid())
{
- if (io_death == false and memcached_is_udp(ptr->root) == false and ptr->options.is_shutting_down == false)
+ if (io_death == false and memcached_is_udp(instance->root) == false and instance->is_shutting_down() == false)
{
- ptr->options.is_shutting_down= true;
+ send_quit_message(instance);
- memcached_return_t rc;
- if (ptr->root->flags.binary_protocol)
- {
- protocol_binary_request_quit request= {}; // = {.bytes= {0}};
-
- initialize_binary_request(ptr, request.message.header);
-
- request.message.header.request.opcode = PROTOCOL_BINARY_CMD_QUIT;
- request.message.header.request.datatype = PROTOCOL_BINARY_RAW_BYTES;
-
- libmemcached_io_vector_st vector[]=
- {
- { request.bytes, sizeof(request.bytes) }
- };
-
- rc= memcached_vdo(ptr, vector, 1, true);
- }
- else
- {
- libmemcached_io_vector_st vector[]=
- {
- { memcached_literal_param("quit\r\n") }
- };
-
- rc= memcached_vdo(ptr, vector, 1, true);
- }
-
- /* read until socket is closed, or there is an error
- * closing the socket before all data is read
- * results in server throwing away all data which is
- * not read
- *
- * In .40 we began to only do this if we had been doing buffered
- * requests of had replication enabled.
- */
- if (memcached_success(rc) and (ptr->root->flags.buffer_requests or ptr->root->number_of_replicas))
- {
- if (0)
- {
- memcached_return_t rc_slurp;
- while (memcached_continue(rc_slurp= memcached_io_slurp(ptr))) {} ;
- WATCHPOINT_ASSERT(rc_slurp == MEMCACHED_CONNECTION_FAILURE);
- }
- else
- {
- memcached_io_slurp(ptr);
- }
- }
-
- /*
- * memcached_io_read may call memcached_quit_server with io_death if
- * it encounters problems, but we don't care about those occurences.
- * The intention of that loop is to drain the data sent from the
- * server to ensure that the server processed all of the data we
- * sent to the server.
- */
- ptr->server_failure_counter= 0;
+ instance->start_close_socket();
+ drain_instance(instance);
}
- memcached_io_close(ptr);
}
- ptr->state= MEMCACHED_SERVER_STATE_NEW;
- ptr->cursor_active_= 0;
- ptr->io_bytes_sent= 0;
- ptr->write_buffer_offset= size_t(ptr->root and memcached_is_udp(ptr->root) ? UDP_DATAGRAM_HEADER_LENGTH : 0);
- ptr->read_buffer_length= 0;
- ptr->read_ptr= ptr->read_buffer;
- ptr->options.is_shutting_down= false;
- memcached_server_response_reset(ptr);
-
- // We reset the version so that if we end up talking to a different server
- // we don't have stale server version information.
- ptr->major_version= ptr->minor_version= ptr->micro_version= UINT8_MAX;
+ instance->close_socket();
if (io_death)
{
- memcached_mark_server_for_timeout(ptr);
+ memcached_mark_server_for_timeout(instance);
}
}
-void send_quit(memcached_st *ptr)
+void send_quit(memcached_st *memc)
{
- for (uint32_t x= 0; x < memcached_server_count(ptr); x++)
+ for (uint32_t x= 0; x < memcached_server_count(memc); x++)
{
- org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, x);
+ org::libmemcached::Instance* instance= memcached_instance_fetch(memc, x);
memcached_quit_server(instance, false);
}
}
-void memcached_quit(memcached_st *ptr)
+void memcached_quit(memcached_st *memc)
{
memcached_return_t rc;
- if (memcached_failed(rc= initialize_query(ptr, true)))
+ if (memcached_failed(rc= initialize_query(memc, true)))
{
return;
}
- send_quit(ptr);
+ send_quit(memc);
}
diff --git a/libmemcached/socket.hpp b/libmemcached/socket.hpp
index 30e296ff..a2ee941f 100644
--- a/libmemcached/socket.hpp
+++ b/libmemcached/socket.hpp
@@ -58,7 +58,7 @@
#endif
#ifdef __cplusplus
-static inline void memcached_close_socket(int& socket_fd)
+static inline void memcached_close_socket(memcached_socket_t& socket_fd)
{
closesocket(socket_fd);
socket_fd= INVALID_SOCKET;
diff --git a/libtest/cmdline.h b/libtest/cmdline.h
index 2f639116..d150ff59 100644
--- a/libtest/cmdline.h
+++ b/libtest/cmdline.h
@@ -36,7 +36,13 @@
#pragma once
-#include <spawn.h>
+#ifdef _WIN32
+typedef int posix_spawn_file_actions_t;
+#else
+# include <spawn.h>
+#endif
+
+#include <pthread.h>
// http://www.gnu.org/software/automake/manual/automake.html#Using-the-TAP-test-protocol
#ifndef EXIT_SKIP
diff --git a/libtest/fatal.hpp b/libtest/fatal.hpp
index 8b810e7b..7e627a46 100644
--- a/libtest/fatal.hpp
+++ b/libtest/fatal.hpp
@@ -53,7 +53,7 @@ public:
// The following are just for unittesting the exception class
static bool is_disabled();
static void disable();
- static void enable();
+
static uint32_t disabled_counter();
static void increment_disabled_counter();
diff --git a/libtest/server.cc b/libtest/server.cc
index 33b20ad8..522120be 100644
--- a/libtest/server.cc
+++ b/libtest/server.cc
@@ -124,7 +124,7 @@ Server::Server(const std::string& host_arg, const in_port_t port_arg,
Server::~Server()
{
- kill();
+ murder();
}
bool Server::check()
@@ -148,7 +148,7 @@ bool Server::cycle()
while (--limit and
is_pid_valid(_app.pid()))
{
- if (kill())
+ if (murder())
{
Log << "Killed existing server," << *this;
dream(0, 50000);
@@ -498,7 +498,7 @@ bool Server::args(Application& app)
return true;
}
-bool Server::kill()
+bool Server::murder()
{
if (check_pid(_app.pid())) // If we kill it, reset
{
diff --git a/libtest/server.h b/libtest/server.h
index f5138808..5b26fcdd 100644
--- a/libtest/server.h
+++ b/libtest/server.h
@@ -41,8 +41,10 @@
#include <cassert>
#include <cstdio>
#include <cstring>
+
#include <netdb.h>
#include <netinet/in.h>
+
#include <string>
#include <unistd.h>
#include <vector>
@@ -249,7 +251,7 @@ public:
std::string log_and_pid();
- bool kill();
+ bool murder();
bool start();
bool command(libtest::Application& app);
diff --git a/libtest/server_container.cc b/libtest/server_container.cc
index 513e472c..cc1e0a56 100644
--- a/libtest/server_container.cc
+++ b/libtest/server_container.cc
@@ -103,7 +103,7 @@ bool server_startup_st::shutdown(uint32_t host_to_shutdown)
{
Server* tmp= servers[host_to_shutdown];
- if (tmp and tmp->kill() == false)
+ if (tmp and tmp->murder() == false)
{ }
else
{
@@ -139,7 +139,7 @@ bool server_startup_st::shutdown()
bool success= true;
for (std::vector<Server *>::iterator iter= servers.begin(); iter != servers.end(); ++iter)
{
- if ((*iter)->has_pid() and (*iter)->kill() == false)
+ if ((*iter)->has_pid() and (*iter)->murder() == false)
{
Error << "Unable to kill:" << *(*iter);
success= false;
diff --git a/libtest/server_container.h b/libtest/server_container.h
index 9e083365..48d90901 100644
--- a/libtest/server_container.h
+++ b/libtest/server_container.h
@@ -39,8 +39,10 @@
#include <cassert>
#include <cstdio>
#include <cstring>
+
#include <netdb.h>
#include <netinet/in.h>
+
#include <string>
#include <unistd.h>
#include <vector>
diff --git a/libtest/timer.hpp b/libtest/timer.hpp
index 28ec4741..cd34124f 100644
--- a/libtest/timer.hpp
+++ b/libtest/timer.hpp
@@ -122,6 +122,9 @@ private:
mach_port_deallocate(mach_task_self(), _clock_serv);
ts.tv_sec= _mach_timespec.tv_sec;
ts.tv_nsec= _mach_timespec.tv_nsec;
+#elif defined(_WIN32)
+ ts.tv_sec= time(NULL);
+ ts.tv_nsec= 0;
#else
clock_gettime(CLOCK_REALTIME, &ts);
#endif
diff --git a/libtest/wait.h b/libtest/wait.h
index a39a853e..5f013cd3 100644
--- a/libtest/wait.h
+++ b/libtest/wait.h
@@ -38,8 +38,9 @@
#include <unistd.h>
#include <string>
-#include <signal.h>
+#include <csignal>
+#include <sys/types.h>
#include <libtest/dream.h>
namespace libtest {
diff --git a/m4/ax_cxx_gcc_abi_demangle.m4 b/m4/ax_cxx_gcc_abi_demangle.m4
index 41ea469e..072d5db8 100644
--- a/m4/ax_cxx_gcc_abi_demangle.m4
+++ b/m4/ax_cxx_gcc_abi_demangle.m4
@@ -24,7 +24,7 @@
# and this notice are preserved. This file is offered as-is, without any
# warranty.
-#serial 9
+#serial 10
AC_DEFUN([AX_CXX_GCC_ABI_DEMANGLE],
[AC_PREREQ([2.63])dnl
@@ -38,6 +38,9 @@ AC_DEFUN([AX_CXX_GCC_ABI_DEMANGLE],
template<typename TYPE>
class A {};]],
[[A<int> instance;
+#if defined(_WIN32)
+ return EXIT_FAILURE;
+#endif
int status = 0;
char* c_name = abi::__cxa_demangle(typeid(instance).name(), 0, 0, &status);
@@ -52,6 +55,8 @@ AC_DEFUN([AX_CXX_GCC_ABI_DEMANGLE],
[ax_cv_cxx_gcc_abi_demangle=no],
[ax_cv_cxx_gcc_abi_demangle=no])
AC_LANG_POP])
+ AC_MSG_CHECKING([checking for cxx_gcc_abi_demangle])
+ AC_MSG_RESULT(["$ax_cv_cxx_gcc_abi_demangle"])
AS_IF([test "x$ax_cv_cxx_gcc_abi_demangle" = xyes],
[AC_DEFINE([HAVE_GCC_ABI_DEMANGLE],[1],[define if the compiler supports GCC C++ ABI name demangling])])
])
diff --git a/m4/ax_harden_compiler_flags.m4 b/m4/ax_harden_compiler_flags.m4
index 66de89d3..b31518aa 100644
--- a/m4/ax_harden_compiler_flags.m4
+++ b/m4/ax_harden_compiler_flags.m4
@@ -61,9 +61,10 @@ AC_DEFUN([_WARNINGS_AS_ERRORS],
])
])
+# Note: Should this be LIBS or LDFLAGS?
AC_DEFUN([_APPEND_LINK_FLAGS_ERROR],
[AC_REQUIRE([AX_APPEND_LINK_FLAGS])
- AX_APPEND_LINK_FLAGS([$1],[LIB],[-Werror])
+ AX_APPEND_LINK_FLAGS([$1],[LDFLAGS],[-Werror])
])
AC_DEFUN([_APPEND_COMPILE_FLAGS_ERROR],
@@ -75,7 +76,7 @@ AC_DEFUN([_APPEND_COMPILE_FLAGS_ERROR],
AC_DEFUN([_HARDEN_LINKER_FLAGS],
[_APPEND_LINK_FLAGS_ERROR([-z relro -z now])
- _APPEND_LINK_FLAGS_ERROR([-pie])
+ #_APPEND_LINK_FLAGS_ERROR([-pie])
AS_IF([test "x$ac_cv_warnings_as_errors" = xyes],
[AX_APPEND_LINK_FLAGS([-Werror])])
])
@@ -91,7 +92,10 @@ AC_DEFUN([_HARDEN_CC_COMPILER_FLAGS],
[_APPEND_COMPILE_FLAGS_ERROR([-g])
_APPEND_COMPILE_FLAGS_ERROR([-O2])])
- _APPEND_COMPILE_FLAGS_ERROR([-Wno-pragmas])
+ 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([-Wall])
_APPEND_COMPILE_FLAGS_ERROR([-Wextra])
_APPEND_COMPILE_FLAGS_ERROR([-Wunknown-pragmas])
@@ -148,17 +152,13 @@ AC_DEFUN([_HARDEN_CC_COMPILER_FLAGS],
AS_IF([test "x$ax_enable_debug" = xno],
[AS_IF([test "x$ac_cv_vcs_checkout" = xyes],
- [_APPEND_COMPILE_FLAGS_ERROR([-fstack-check])
- AS_IF([test "x$ac_c_gcc_recent" = xyes],
- [_APPEND_COMPILE_FLAGS_ERROR([-D_FORTIFY_SOURCE=2])
-# _APPEND_COMPILE_FLAGS_ERROR([-Wstack-protector])
- _APPEND_COMPILE_FLAGS_ERROR([-fstack-protector])
-# _APPEND_COMPILE_FLAGS_ERROR([-fstack-protector-all])
- ])])])
-
- AS_IF([test "x$ac_cv_vcs_checkout" = xyes],
- [_APPEND_COMPILE_FLAGS_ERROR([-fstack-check])],
- [_APPEND_COMPILE_FLAGS_ERROR([-Wno-pragmas])])
+ [AS_IF([test "x${target_os}" != "xmingw"],
+ [AS_IF([test "x$ac_c_gcc_recent" = xyes],
+ [_APPEND_COMPILE_FLAGS_ERROR([-D_FORTIFY_SOURCE=2])
+ #_APPEND_COMPILE_FLAGS_ERROR([-Wstack-protector])
+ #_APPEND_COMPILE_FLAGS_ERROR([-fstack-protector])
+ _APPEND_COMPILE_FLAGS_ERROR([-fstack-protector-all])
+ ])])])])
AS_IF([test "x$ac_cv_warnings_as_errors" = xyes],
[AX_APPEND_FLAG([-Werror])])
@@ -231,13 +231,13 @@ AC_DEFUN([_HARDEN_CXX_COMPILER_FLAGS],
AS_IF([test "x$ax_enable_debug" = xno],
[AS_IF([test "x$ac_cv_vcs_checkout" = xyes],
- [_APPEND_COMPILE_FLAGS_ERROR([-fstack-check])
- AS_IF([test "x$ac_c_gcc_recent" = xyes],
- [_APPEND_COMPILE_FLAGS_ERROR([-D_FORTIFY_SOURCE=2])
-# _APPEND_COMPILE_FLAGS_ERROR([-Wstack-protector])
- _APPEND_COMPILE_FLAGS_ERROR([-fstack-protector])
-# _APPEND_COMPILE_FLAGS_ERROR([-fstack-protector-all])
- ])])])
+ [AS_IF([test "x${target_os}" != "xmingw"],
+ [AS_IF([test "x$ac_c_gcc_recent" = xyes],
+ [_APPEND_COMPILE_FLAGS_ERROR([-D_FORTIFY_SOURCE=2])
+ #_APPEND_COMPILE_FLAGS_ERROR([-Wstack-protector])
+ #_APPEND_COMPILE_FLAGS_ERROR([-fstack-protector])
+ _APPEND_COMPILE_FLAGS_ERROR([-fstack-protector-all])
+ ])])])])
AS_IF([test "x$ac_cv_warnings_as_errors" = xyes],
[AX_APPEND_FLAG([-Werror])])
diff --git a/m4/ax_platform.m4 b/m4/ax_platform.m4
index bf4ff0e4..56472c72 100644
--- a/m4/ax_platform.m4
+++ b/m4/ax_platform.m4
@@ -1,5 +1,5 @@
# ===========================================================================
-# http://www.gnu.org/software/autoconf-archive/ax_count_cpus.html
+# http://
# ===========================================================================
#
# SYNOPSIS
@@ -19,7 +19,8 @@
# and this notice are preserved. This file is offered as-is, without any
# warranty.
-#serial 1
+#serial 3
+#
AC_DEFUN([AX_PLATFORM],
[AC_REQUIRE([AC_CANONICAL_HOST])
AC_REQUIRE([AC_CANONICAL_TARGET])
@@ -33,10 +34,9 @@
AC_DEFINE_UNQUOTED([TARGET_CPU],["$target_cpu"], [CPU of Target System])
AS_CASE([$target_os],
- [*mingw32*],
- [AC_DEFINE([TARGET_OS_WINDOWS], [1], [Whether we are building for Windows])
- AC_DEFINE([WINVER], [WindowsXP], [Version of Windows])
- AC_DEFINE([_WIN32_WINNT], [0x0501], [Magical number to make things work])
+ [*mingw*],
+ [TARGET_WINDOWS="true"
+ AC_DEFINE([TARGET_OS_WINDOWS], [1], [Whether we are building for Windows])
AC_DEFINE([EAI_SYSTEM], [11], [Another magical number])
AH_BOTTOM([
#ifndef HAVE_SYS_SOCKET_H
@@ -48,8 +48,12 @@
[*freebsd*],[AC_DEFINE([TARGET_OS_FREEBSD],[1],[Whether we are building for FreeBSD])
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*],[AC_DEFINE([TARGET_OS_OSX],[1],[Whether we build for OSX])],
- [*linux*],[AC_DEFINE([TARGET_OS_LINUX],[1],[Whether we build for Linux])])
+ [*darwin*],
+ [TARGET_OSX="true"
+ AC_DEFINE([TARGET_OS_OSX],[1],[Whether we build for OSX])],
+ [*linux*],
+ [TARGET_LINUX="true"
+ AC_DEFINE([TARGET_OS_LINUX],[1],[Whether we build for Linux])])
AM_CONDITIONAL([BUILD_WIN32],[test "x${TARGET_WINDOWS}" = "xtrue"])
AM_CONDITIONAL([TARGET_OSX],[test "x${TARGET_OSX}" = "xtrue"])
diff --git a/m4/ax_prog_sphinx_build.m4 b/m4/ax_prog_sphinx_build.m4
index 8b69df83..cbbf1723 100644
--- a/m4/ax_prog_sphinx_build.m4
+++ b/m4/ax_prog_sphinx_build.m4
@@ -39,7 +39,7 @@ AC_DEFUN([AX_PROG_SPHINX_BUILD],
])
])
- AM_CONDITIONAL(HAVE_DPKG_GENSYMBOLS,[test "x${DPKG_GENSYMBOLS}" != "x:"])
- AM_CONDITIONAL(HAVE_SPHINX,[test "x${SPHINXBUILD}" != "x:"])
- AM_CONDITIONAL(HAVE_RECENT_SPHINX,[test "x${ac_cv_recent_sphinx}" = "xyes"])
+ AM_CONDITIONAL([HAVE_DPKG_GENSYMBOLS],[test "x${DPKG_GENSYMBOLS}" != "x:"])
+ AM_CONDITIONAL([HAVE_SPHINX],[test "x${SPHINXBUILD}" != "x:"])
+ AM_CONDITIONAL([HAVE_RECENT_SPHINX],[test "x${ac_cv_recent_sphinx}" = "xyes"])
])
diff --git a/m4/socket_send_flags.m4 b/m4/socket_send_flags.m4
index 5c1c7470..7b739928 100644
--- a/m4/socket_send_flags.m4
+++ b/m4/socket_send_flags.m4
@@ -1,48 +1,47 @@
-dnl Copyright (C) 2012 Data Differential LLC
-dnl Copyright (C) 2011 Trond Norbye
-dnl This file is free software; Trond Norbye
-dnl gives unlimited permission to copy and/or distribute it,
-dnl with or without modifications, as long as this notice is preserved.
-dnl ---------------------------------------------------------------------------
-dnl Macro: SOCKET_SEND_FLAGS
-dnl ---------------------------------------------------------------------------
-
-AC_DEFUN([SOCKET_SEND_FLAGS],[
- AC_CACHE_CHECK([for MSG_NOSIGNAL], [ac_cv_msg_nosignal], [
- AC_LANG_PUSH([C])
- AX_SAVE_FLAGS
- CFLAGS="$CFLAGS -I${srcdir}"
-
- AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <netdb.h>], [ int flags= MSG_NOSIGNAL ])], [ac_cv_msg_nosignal="yes"])
- AC_LANG_POP
- AX_RESTORE_FLAGS
+# Copyright (C) 2012-2013 Data Differential LLC
+# Copyright (C) 2011 Trond Norbye
+# This file is free software; Trond Norbye and Data Differential
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+# ---------------------------------------------------------------------------
+# Macro: SOCKET_SEND_FLAGS
+# ---------------------------------------------------------------------------
+#
+
+#serial 2
+
+AC_DEFUN([SOCKET_SEND_FLAGS],
+ [AC_CACHE_CHECK([for MSG_NOSIGNAL],[ac_cv_msg_nosignal],
+ [AC_LANG_PUSH([C])
+ AX_SAVE_FLAGS
+ CFLAGS="$CFLAGS -I${srcdir}"
+
+ AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <netdb.h>], [int flags= MSG_NOSIGNAL])], [ac_cv_msg_nosignal="yes"])
+ AC_LANG_POP
+ AX_RESTORE_FLAGS])
+
+ AC_CACHE_CHECK([for MSG_DONTWAIT],[ac_cv_msg_dontwait],
+ [AC_LANG_PUSH([C])
+ AX_SAVE_FLAGS
+ CFLAGS="$CFLAGS -I${srcdir}"
+
+ AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <netdb.h>],[int flags= MSG_DONTWAIT])],[ac_cv_msg_dontwait="yes"])
+ AC_LANG_POP
+ AX_RESTORE_FLAGS])
+
+ AC_CACHE_CHECK([for MSG_MORE],[ac_cv_msg_more],
+ [AC_LANG_PUSH([C])
+ AX_SAVE_FLAGS
+ CFLAGS="$CFLAGS -I${srcdir}"
+ AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <netdb.h>], [int flags= MSG_MORE])], [ac_cv_msg_more="yes"])
+ AC_LANG_POP
+ AX_RESTORE_FLAGS])
+
+ AS_IF([test "x$ac_cv_msg_nosignal" = "xyes"],[AC_DEFINE([HAVE_MSG_NOSIGNAL],[1],[Define to 1 if you have a MSG_NOSIGNAL])])
+ AS_IF([test "x$ac_cv_msg_dontwait" = "xyes"],[AC_DEFINE([HAVE_MSG_DONTWAIT],[1],[Define to 1 if you have a MSG_DONTWAIT])])
+ AS_IF([test "x$ac_cv_msg_more" = "xyes"],[AC_DEFINE([HAVE_MSG_MORE],[1],[Define to 1 if you have a MSG_MORE])])
])
- AC_CACHE_CHECK([for MSG_DONTWAIT], [ac_cv_msg_dontwait], [
- AC_LANG_PUSH([C])
- AX_SAVE_FLAGS
- CFLAGS="$CFLAGS -I${srcdir}"
-
- AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <netdb.h>], [ int flags= MSG_DONTWAIT ])], [ac_cv_msg_dontwait="yes"])
- AC_LANG_POP
- AX_RESTORE_FLAGS
- ])
-
- AC_CACHE_CHECK([for MSG_MORE], [ac_cv_msg_more], [
- AC_LANG_PUSH([C])
- AX_SAVE_FLAGS
- CFLAGS="$CFLAGS -I${srcdir}"
-
- AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <netdb.h>], [ int flags= MSG_MORE ])], [ac_cv_msg_more="yes"])
- AC_LANG_POP
- AX_RESTORE_FLAGS
- ])
-
- AS_IF([test "x$ac_cv_msg_nosignal" = "xyes"],[ AC_DEFINE(HAVE_MSG_NOSIGNAL, 1, [Define to 1 if you have a MSG_NOSIGNAL])])
- AS_IF([test "x$ac_cv_msg_dontwait" = "xyes"],[ AC_DEFINE(HAVE_MSG_DONTWAIT, 1, [Define to 1 if you have a MSG_DONTWAIT])])
- AS_IF([test "x$ac_cv_msg_more" = "xyes"],[ AC_DEFINE(HAVE_MSG_MORE, 1, [Define to 1 if you have a MSG_MORE])])
-])
-
-dnl ---------------------------------------------------------------------------
-dnl End Macro: SOCKET_SEND_FLAGS
-dnl ---------------------------------------------------------------------------
+# ---------------------------------------------------------------------------
+# End Macro: SOCKET_SEND_FLAGS
+# ---------------------------------------------------------------------------
View Lorry Controller Status