Initial import

11 files changed, 5836 insertions, 0 deletions

diff --git a/m4/.cvsignore b/m4/.cvsignore
new file mode 100644
index 0000000..38066dd
--- /dev/null
+++ b/m4/.cvsignore
@@ -0,0 +1,5 @@
+libtool.m4
+ltoptions.m4
+ltsugar.m4
+ltversion.m4
+lt~obsolete.m4
diff --git a/m4/CVS/Entries b/m4/CVS/Entries
new file mode 100644
index 0000000..f5469cd
--- /dev/null
+++ b/m4/CVS/Entries
@@ -0,0 +1,8 @@
+/.cvsignore/1.1/Fri Feb 13 06:34:44 2009//
+/cares-compilers.m4/1.63/Mon Nov 16 23:01:37 2009//
+/cares-confopts.m4/1.8/Sat Oct 31 04:16:40 2009//
+/cares-functions.m4/1.39/Mon Nov 16 01:56:16 2009//
+/cares-override.m4/1.3/Mon Oct 19 04:11:54 2009//
+/cares-reentrant.m4/1.5/Sat Nov 14 18:51:37 2009//
+/cares-system.m4/1.3/Mon Oct 19 04:13:12 2009//
+D
diff --git a/m4/CVS/Repository b/m4/CVS/Repository
new file mode 100644
index 0000000..c363eba
--- /dev/null
+++ b/m4/CVS/Repository
@@ -0,0 +1 @@
+curl/ares/m4
diff --git a/m4/CVS/Root b/m4/CVS/Root
new file mode 100644
index 0000000..2b0bfa7
--- /dev/null
+++ b/m4/CVS/Root
@@ -0,0 +1 @@
+:pserver:anonymous@cool.haxx.se:/cvsroot/curl
diff --git a/m4/CVS/Template b/m4/CVS/Template
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/m4/CVS/Template
diff --git a/m4/cares-compilers.m4 b/m4/cares-compilers.m4
new file mode 100644
index 0000000..74950c7
--- /dev/null
+++ b/m4/cares-compilers.m4
@@ -0,0 +1,1470 @@
+#***************************************************************************
+# $Id: cares-compilers.m4,v 1.63 2009-11-16 23:01:37 yangtse Exp $
+#
+# Copyright (C) 2009 by Daniel Stenberg et al
+#
+# Permission to use, copy, modify, and distribute this software and its
+# documentation for any purpose and without fee is hereby granted, provided
+# that the above copyright notice appear in all copies and that both that
+# copyright notice and this permission notice appear in supporting
+# documentation, and that the name of M.I.T. not be used in advertising or
+# publicity pertaining to distribution of the software without specific,
+# written prior permission.  M.I.T. makes no representations about the
+# suitability of this software for any purpose.  It is provided "as is"
+# without express or implied warranty.
+#
+#***************************************************************************
+
+# File version for 'aclocal' use. Keep it a single number.
+# serial 63
+
+
+dnl CARES_CHECK_COMPILER
+dnl -------------------------------------------------
+dnl Verify if the C compiler being used is known.
+
+AC_DEFUN([CARES_CHECK_COMPILER], [
+  AC_BEFORE([$0],[CARES_CHECK_NO_UNDEFINED])dnl
+  #
+  compiler_id="unknown"
+  compiler_num="0"
+  #
+  flags_dbg_all="unknown"
+  flags_dbg_yes="unknown"
+  flags_dbg_off="unknown"
+  flags_opt_all="unknown"
+  flags_opt_yes="unknown"
+  flags_opt_off="unknown"
+  #
+  CARES_CHECK_COMPILER_DEC_C
+  CARES_CHECK_COMPILER_HPUX_C
+  CARES_CHECK_COMPILER_IBM_C
+  CARES_CHECK_COMPILER_INTEL_C
+  CARES_CHECK_COMPILER_GNU_C
+  CARES_CHECK_COMPILER_LCC
+  CARES_CHECK_COMPILER_SGI_MIPSPRO_C
+  CARES_CHECK_COMPILER_SGI_MIPS_C
+  CARES_CHECK_COMPILER_SUNPRO_C
+  CARES_CHECK_COMPILER_TINY_C
+  CARES_CHECK_COMPILER_WATCOM_C
+  #
+  if test "$compiler_id" = "unknown"; then
+  cat <<_EOF 1>&2
+***
+*** Warning: This configure script does not have information about the
+*** compiler you are using, relative to the flags required to enable or
+*** disable generation of debug info, optimization options or warnings.
+***
+*** Whatever settings are present in CFLAGS will be used for this run.
+***
+*** If you wish to help the c-ares project to better support your compiler
+*** you can report this and the required info on the c-ares development
+*** mailing list: http://cool.haxx.se/mailman/listinfo/c-ares/
+***
+_EOF
+  fi
+])
+
+
+dnl CARES_CHECK_COMPILER_DEC_C
+dnl -------------------------------------------------
+dnl Verify if compiler being used is DEC C.
+
+AC_DEFUN([CARES_CHECK_COMPILER_DEC_C], [
+  AC_MSG_CHECKING([if compiler is DEC/Compaq/HP C])
+  CURL_CHECK_DEF([__DECC], [], [silent])
+  CURL_CHECK_DEF([__DECC_VER], [], [silent])
+  if test "$curl_cv_have_def___DECC" = "yes" &&
+    test "$curl_cv_have_def___DECC_VER" = "yes"; then
+    AC_MSG_RESULT([yes])
+    compiler_id="DEC_C"
+    flags_dbg_all="-g -g0 -g1 -g2 -g3"
+    flags_dbg_yes="-g2"
+    flags_dbg_off="-g0"
+    flags_opt_all="-O -O0 -O1 -O2 -O3 -O4"
+    flags_opt_yes="-O1"
+    flags_opt_off="-O0"
+  else
+    AC_MSG_RESULT([no])
+  fi
+])
+
+
+dnl CARES_CHECK_COMPILER_GNU_C
+dnl -------------------------------------------------
+dnl Verify if compiler being used is GNU C.
+
+AC_DEFUN([CARES_CHECK_COMPILER_GNU_C], [
+  AC_REQUIRE([CARES_CHECK_COMPILER_INTEL_C])dnl
+  AC_MSG_CHECKING([if compiler is GNU C])
+  CURL_CHECK_DEF([__GNUC__], [], [silent])
+  if test "$curl_cv_have_def___GNUC__" = "yes" &&
+    test "$compiler_id" = "unknown"; then
+    AC_MSG_RESULT([yes])
+    compiler_id="GNU_C"
+    gccver=`$CC -dumpversion`
+    gccvhi=`echo $gccver | cut -d . -f1`
+    gccvlo=`echo $gccver | cut -d . -f2`
+    compiler_num=`(expr $gccvhi "*" 100 + $gccvlo) 2>/dev/null`
+    flags_dbg_all="-g -g0 -g1 -g2 -g3"
+    flags_dbg_all="$flags_dbg_all -ggdb"
+    flags_dbg_all="$flags_dbg_all -gstabs"
+    flags_dbg_all="$flags_dbg_all -gstabs+"
+    flags_dbg_all="$flags_dbg_all -gcoff"
+    flags_dbg_all="$flags_dbg_all -gxcoff"
+    flags_dbg_all="$flags_dbg_all -gdwarf-2"
+    flags_dbg_all="$flags_dbg_all -gvms"
+    flags_dbg_yes="-g"
+    flags_dbg_off="-g0"
+    flags_opt_all="-O -O0 -O1 -O2 -O3 -Os"
+    flags_opt_yes="-O2"
+    flags_opt_off="-O0"
+  else
+    AC_MSG_RESULT([no])
+  fi
+])
+
+
+dnl CARES_CHECK_COMPILER_HPUX_C
+dnl -------------------------------------------------
+dnl Verify if compiler being used is HP-UX C.
+
+AC_DEFUN([CARES_CHECK_COMPILER_HPUX_C], [
+  AC_MSG_CHECKING([if compiler is HP-UX C])
+  CURL_CHECK_DEF([__HP_cc], [], [silent])
+  if test "$curl_cv_have_def___HP_cc" = "yes"; then
+    AC_MSG_RESULT([yes])
+    compiler_id="HP_UX_C"
+    flags_dbg_all="-g -s"
+    flags_dbg_yes="-g"
+    flags_dbg_off="-s"
+    flags_opt_all="-O +O0 +O1 +O2 +O3 +O4"
+    flags_opt_yes="+O2"
+    flags_opt_off="+O0"
+  else
+    AC_MSG_RESULT([no])
+  fi
+])
+
+
+dnl CARES_CHECK_COMPILER_IBM_C
+dnl -------------------------------------------------
+dnl Verify if compiler being used is IBM C.
+
+AC_DEFUN([CARES_CHECK_COMPILER_IBM_C], [
+  AC_MSG_CHECKING([if compiler is IBM C])
+  CURL_CHECK_DEF([__IBMC__], [], [silent])
+  if test "$curl_cv_have_def___IBMC__" = "yes"; then
+    AC_MSG_RESULT([yes])
+    compiler_id="IBM_C"
+    flags_dbg_all="-g -g0 -g1 -g2 -g3"
+    flags_dbg_yes="-g"
+    flags_dbg_off=""
+    flags_opt_all="-O -O0 -O1 -O2 -O3 -O4 -O5"
+    flags_opt_all="$flags_opt_all -qnooptimize"
+    flags_opt_all="$flags_opt_all -qoptimize=0"
+    flags_opt_all="$flags_opt_all -qoptimize=1"
+    flags_opt_all="$flags_opt_all -qoptimize=2"
+    flags_opt_all="$flags_opt_all -qoptimize=3"
+    flags_opt_all="$flags_opt_all -qoptimize=4"
+    flags_opt_all="$flags_opt_all -qoptimize=5"
+    flags_opt_yes="-O2"
+    flags_opt_off="-qnooptimize"
+  else
+    AC_MSG_RESULT([no])
+  fi
+])
+
+
+dnl CARES_CHECK_COMPILER_INTEL_C
+dnl -------------------------------------------------
+dnl Verify if compiler being used is Intel C.
+
+AC_DEFUN([CARES_CHECK_COMPILER_INTEL_C], [
+  AC_BEFORE([$0],[CARES_CHECK_COMPILER_GNU_C])dnl
+  AC_MSG_CHECKING([if compiler is Intel C])
+  CURL_CHECK_DEF([__INTEL_COMPILER], [], [silent])
+  if test "$curl_cv_have_def___INTEL_COMPILER" = "yes"; then
+    AC_MSG_RESULT([yes])
+    compiler_num="$curl_cv_def___INTEL_COMPILER"
+    CURL_CHECK_DEF([__unix__], [], [silent])
+    if test "$curl_cv_have_def___unix__" = "yes"; then
+      compiler_id="INTEL_UNIX_C"
+      flags_dbg_all="-g -g0"
+      flags_dbg_yes="-g"
+      flags_dbg_off="-g0"
+      flags_opt_all="-O -O0 -O1 -O2 -O3 -Os"
+      flags_opt_yes="-O2"
+      flags_opt_off="-O0"
+    else
+      compiler_id="INTEL_WINDOWS_C"
+      flags_dbg_all="/ZI /Zi /zI /zi /ZD /Zd /zD /zd /Z7 /z7 /Oy /Oy-"
+      flags_dbg_all="$flags_dbg_all /debug"
+      flags_dbg_all="$flags_dbg_all /debug:none"
+      flags_dbg_all="$flags_dbg_all /debug:minimal"
+      flags_dbg_all="$flags_dbg_all /debug:partial"
+      flags_dbg_all="$flags_dbg_all /debug:full"
+      flags_dbg_all="$flags_dbg_all /debug:semantic_stepping"
+      flags_dbg_all="$flags_dbg_all /debug:extended"
+      flags_dbg_yes="/Zi /Oy-"
+      flags_dbg_off="/debug:none /Oy-"
+      flags_opt_all="/O /O0 /O1 /O2 /O3 /Od /Og /Og- /Oi /Oi-"
+      flags_opt_yes="/O2"
+      flags_opt_off="/Od"
+    fi
+  else
+    AC_MSG_RESULT([no])
+  fi
+])
+
+
+dnl CARES_CHECK_COMPILER_LCC
+dnl -------------------------------------------------
+dnl Verify if compiler being used is LCC.
+
+AC_DEFUN([CARES_CHECK_COMPILER_LCC], [
+  AC_MSG_CHECKING([if compiler is LCC])
+  CURL_CHECK_DEF([__LCC__], [], [silent])
+  if test "$curl_cv_have_def___LCC__" = "yes"; then
+    AC_MSG_RESULT([yes])
+    compiler_id="LCC"
+    flags_dbg_all="-g"
+    flags_dbg_yes="-g"
+    flags_dbg_off=""
+    flags_opt_all=""
+    flags_opt_yes=""
+    flags_opt_off=""
+  else
+    AC_MSG_RESULT([no])
+  fi
+])
+
+
+dnl CARES_CHECK_COMPILER_SGI_MIPS_C
+dnl -------------------------------------------------
+dnl Verify if compiler being used is SGI MIPS C.
+
+AC_DEFUN([CARES_CHECK_COMPILER_SGI_MIPS_C], [
+  AC_REQUIRE([CARES_CHECK_COMPILER_SGI_MIPSPRO_C])dnl
+  AC_MSG_CHECKING([if compiler is SGI MIPS C])
+  CURL_CHECK_DEF([__GNUC__], [], [silent])
+  CURL_CHECK_DEF([__sgi], [], [silent])
+  if test "$curl_cv_have_def___GNUC__" = "no" &&
+    test "$curl_cv_have_def___sgi" = "yes" &&
+    test "$compiler_id" = "unknown"; then
+    AC_MSG_RESULT([yes])
+    compiler_id="SGI_MIPS_C"
+    flags_dbg_all="-g -g0 -g1 -g2 -g3"
+    flags_dbg_yes="-g"
+    flags_dbg_off="-g0"
+    flags_opt_all="-O -O0 -O1 -O2 -O3 -Ofast"
+    flags_opt_yes="-O2"
+    flags_opt_off="-O0"
+  else
+    AC_MSG_RESULT([no])
+  fi
+])
+
+
+dnl CARES_CHECK_COMPILER_SGI_MIPSPRO_C
+dnl -------------------------------------------------
+dnl Verify if compiler being used is SGI MIPSpro C.
+
+AC_DEFUN([CARES_CHECK_COMPILER_SGI_MIPSPRO_C], [
+  AC_BEFORE([$0],[CARES_CHECK_COMPILER_SGI_MIPS_C])dnl
+  AC_MSG_CHECKING([if compiler is SGI MIPSpro C])
+  CURL_CHECK_DEF([__GNUC__], [], [silent])
+  CURL_CHECK_DEF([_COMPILER_VERSION], [], [silent])
+  CURL_CHECK_DEF([_SGI_COMPILER_VERSION], [], [silent])
+  if test "$curl_cv_have_def___GNUC__" = "no" &&
+    (test "$curl_cv_have_def__SGI_COMPILER_VERSION" = "yes" ||
+     test "$curl_cv_have_def__COMPILER_VERSION" = "yes"); then
+    AC_MSG_RESULT([yes])
+    compiler_id="SGI_MIPSPRO_C"
+    flags_dbg_all="-g -g0 -g1 -g2 -g3"
+    flags_dbg_yes="-g"
+    flags_dbg_off="-g0"
+    flags_opt_all="-O -O0 -O1 -O2 -O3 -Ofast"
+    flags_opt_yes="-O2"
+    flags_opt_off="-O0"
+  else
+    AC_MSG_RESULT([no])
+  fi
+])
+
+
+dnl CARES_CHECK_COMPILER_SUNPRO_C
+dnl -------------------------------------------------
+dnl Verify if compiler being used is SunPro C.
+
+AC_DEFUN([CARES_CHECK_COMPILER_SUNPRO_C], [
+  AC_MSG_CHECKING([if compiler is SunPro C])
+  CURL_CHECK_DEF([__SUNPRO_C], [], [silent])
+  if test "$curl_cv_have_def___SUNPRO_C" = "yes"; then
+    AC_MSG_RESULT([yes])
+    compiler_id="SUNPRO_C"
+    flags_dbg_all="-g -s"
+    flags_dbg_yes="-g"
+    flags_dbg_off="-s"
+    flags_opt_all="-O -xO -xO1 -xO2 -xO3 -xO4 -xO5"
+    flags_opt_yes="-xO2"
+    flags_opt_off=""
+  else
+    AC_MSG_RESULT([no])
+  fi
+])
+
+
+dnl CARES_CHECK_COMPILER_TINY_C
+dnl -------------------------------------------------
+dnl Verify if compiler being used is Tiny C.
+
+AC_DEFUN([CARES_CHECK_COMPILER_TINY_C], [
+  AC_MSG_CHECKING([if compiler is Tiny C])
+  CURL_CHECK_DEF([__TINYC__], [], [silent])
+  if test "$curl_cv_have_def___TINYC__" = "yes"; then
+    AC_MSG_RESULT([yes])
+    compiler_id="TINY_C"
+    flags_dbg_all="-g -b"
+    flags_dbg_yes="-g"
+    flags_dbg_off=""
+    flags_opt_all=""
+    flags_opt_yes=""
+    flags_opt_off=""
+  else
+    AC_MSG_RESULT([no])
+  fi
+])
+
+
+dnl CARES_CHECK_COMPILER_WATCOM_C
+dnl -------------------------------------------------
+dnl Verify if compiler being used is Watcom C.
+
+AC_DEFUN([CARES_CHECK_COMPILER_WATCOM_C], [
+  AC_MSG_CHECKING([if compiler is Watcom C])
+  CURL_CHECK_DEF([__WATCOMC__], [], [silent])
+  if test "$curl_cv_have_def___WATCOMC__" = "yes"; then
+    AC_MSG_RESULT([yes])
+    CURL_CHECK_DEF([__UNIX__], [], [silent])
+    if test "$curl_cv_have_def___UNIX__" = "yes"; then
+      compiler_id="WATCOM_UNIX_C"
+      flags_dbg_all="-g1 -g1+ -g2 -g3"
+      flags_dbg_yes="-g2"
+      flags_dbg_off=""
+      flags_opt_all="-O0 -O1 -O2 -O3"
+      flags_opt_yes="-O2"
+      flags_opt_off="-O0"
+    else
+      compiler_id="WATCOM_WINDOWS_C"
+      flags_dbg_all=""
+      flags_dbg_yes=""
+      flags_dbg_off=""
+      flags_opt_all=""
+      flags_opt_yes=""
+      flags_opt_off=""
+    fi
+  else
+    AC_MSG_RESULT([no])
+  fi
+])
+
+
+dnl CARES_CONVERT_INCLUDE_TO_ISYSTEM
+dnl -------------------------------------------------
+dnl Changes standard include paths present in CFLAGS
+dnl and CPPFLAGS into isystem include paths. This is
+dnl done to prevent GNUC from generating warnings on
+dnl headers from these locations, although on ancient
+dnl GNUC versions these warnings are not silenced.
+
+AC_DEFUN([CARES_CONVERT_INCLUDE_TO_ISYSTEM], [
+  AC_REQUIRE([CARES_SHFUNC_SQUEEZE])dnl
+  tmp_has_include="no"
+  tmp_chg_FLAGS="$CFLAGS"
+  for word1 in $tmp_chg_FLAGS; do
+    case "$word1" in
+      -I*)
+        tmp_has_include="yes"
+        ;;
+    esac
+  done
+  if test "$tmp_has_include" = "yes"; then
+    tmp_chg_FLAGS=`echo "$tmp_chg_FLAGS" | "$SED" 's/^-I/ -isystem /g'`
+    tmp_chg_FLAGS=`echo "$tmp_chg_FLAGS" | "$SED" 's/ -I/ -isystem /g'`
+    CFLAGS="$tmp_chg_FLAGS"
+    squeeze CFLAGS
+  fi
+  tmp_has_include="no"
+  tmp_chg_FLAGS="$CPPFLAGS"
+  for word1 in $tmp_chg_FLAGS; do
+    case "$word1" in
+      -I*)
+        tmp_has_include="yes"
+        ;;
+    esac
+  done
+  if test "$tmp_has_include" = "yes"; then
+    tmp_chg_FLAGS=`echo "$tmp_chg_FLAGS" | "$SED" 's/^-I/ -isystem /g'`
+    tmp_chg_FLAGS=`echo "$tmp_chg_FLAGS" | "$SED" 's/ -I/ -isystem /g'`
+    CPPFLAGS="$tmp_chg_FLAGS"
+    squeeze CPPFLAGS
+  fi
+])
+
+
+dnl CARES_COMPILER_WORKS_IFELSE ([ACTION-IF-WORKS], [ACTION-IF-NOT-WORKS])
+dnl -------------------------------------------------
+dnl Verify if the C compiler seems to work with the
+dnl settings that are 'active' at the time the test
+dnl is performed.
+
+AC_DEFUN([CARES_COMPILER_WORKS_IFELSE], [
+  dnl compilation capability verification
+  tmp_compiler_works="unknown"
+  AC_COMPILE_IFELSE([
+    AC_LANG_PROGRAM([[
+    ]],[[
+      int i = 1;
+      return i;
+    ]])
+  ],[
+    tmp_compiler_works="yes"
+  ],[
+    tmp_compiler_works="no"
+    echo " " >&6
+    sed 's/^/cc-fail: /' conftest.err >&6
+    echo " " >&6
+  ])
+  dnl linking capability verification
+  if test "$tmp_compiler_works" = "yes"; then
+    AC_LINK_IFELSE([
+      AC_LANG_PROGRAM([[
+      ]],[[
+        int i = 1;
+        return i;
+      ]])
+    ],[
+      tmp_compiler_works="yes"
+    ],[
+      tmp_compiler_works="no"
+      echo " " >&6
+      sed 's/^/link-fail: /' conftest.err >&6
+      echo " " >&6
+    ])
+  fi
+  dnl only do runtime verification when not cross-compiling
+  if test "x$cross_compiling" != "xyes" &&
+    test "$tmp_compiler_works" = "yes"; then
+    AC_RUN_IFELSE([
+      AC_LANG_PROGRAM([[
+#       ifdef __STDC__
+#         include <stdlib.h>
+#       endif
+      ]],[[
+        int i = 0;
+        exit(i);
+      ]])
+    ],[
+      tmp_compiler_works="yes"
+    ],[
+      tmp_compiler_works="no"
+      echo " " >&6
+      echo "run-fail: test program exited with status $ac_status" >&6
+      echo " " >&6
+    ])
+  fi
+  dnl branch upon test result
+  if test "$tmp_compiler_works" = "yes"; then
+  ifelse($1,,:,[$1])
+  ifelse($2,,,[else
+    $2])
+  fi
+])
+
+
+dnl CARES_SET_COMPILER_BASIC_OPTS
+dnl -------------------------------------------------
+dnl Sets compiler specific options/flags which do not
+dnl depend on configure's debug, optimize or warnings
+dnl options.
+
+AC_DEFUN([CARES_SET_COMPILER_BASIC_OPTS], [
+  AC_REQUIRE([CARES_CHECK_COMPILER])dnl
+  AC_REQUIRE([CARES_SHFUNC_SQUEEZE])dnl
+  #
+  if test "$compiler_id" != "unknown"; then
+    #
+    if test "$compiler_id" = "GNU_C"; then
+      CARES_CONVERT_INCLUDE_TO_ISYSTEM
+    fi
+    #
+    tmp_save_CPPFLAGS="$CPPFLAGS"
+    tmp_save_CFLAGS="$CFLAGS"
+    tmp_CPPFLAGS=""
+    tmp_CFLAGS=""
+    #
+    case "$compiler_id" in
+        #
+      DEC_C)
+        #
+        dnl Select strict ANSI C compiler mode
+        tmp_CFLAGS="$tmp_CFLAGS -std1"
+        dnl Turn off optimizer ANSI C aliasing rules
+        tmp_CFLAGS="$tmp_CFLAGS -noansi_alias"
+        dnl Generate warnings for missing function prototypes
+        tmp_CFLAGS="$tmp_CFLAGS -warnprotos"
+        dnl Change some warnings into fatal errors
+        tmp_CFLAGS="$tmp_CFLAGS -msg_fatal toofewargs,toomanyargs"
+        ;;
+        #
+      GNU_C)
+        #
+        dnl Placeholder
+        tmp_CFLAGS="$tmp_CFLAGS"
+        ;;
+        #
+      HP_UX_C)
+        #
+        dnl Disallow run-time dereferencing of null pointers
+        tmp_CFLAGS="$tmp_CFLAGS -z"
+        dnl Disable some remarks
+        dnl #4227: padding struct with n bytes to align member
+        dnl #4255: padding size of struct with n bytes to alignment boundary
+        tmp_CFLAGS="$tmp_CFLAGS +W 4227,4255"
+        ;;
+        #
+      IBM_C)
+        #
+        dnl Ensure that compiler optimizations are always thread-safe.
+        tmp_CFLAGS="$tmp_CFLAGS -qthreaded"
+        dnl Disable type based strict aliasing optimizations, using worst
+        dnl case aliasing assumptions when compiling. Type based aliasing
+        dnl would restrict the lvalues that could be safely used to access
+        dnl a data object.
+        tmp_CFLAGS="$tmp_CFLAGS -qnoansialias"
+        dnl Force compiler to stop after the compilation phase, without
+        dnl generating an object code file when compilation has errors.
+        tmp_CFLAGS="$tmp_CFLAGS -qhalt=e"
+        ;;
+        #
+      INTEL_UNIX_C)
+        #
+        dnl On unix this compiler uses gcc's header files, so
+        dnl we select ANSI C89 dialect plus GNU extensions.
+        tmp_CFLAGS="$tmp_CFLAGS -std=gnu89"
+        dnl Change some warnings into errors
+        dnl #140: too many arguments in function call
+        dnl #147: declaration is incompatible with 'previous one'
+        dnl #165: too few arguments in function call
+        dnl #266: function declared implicitly
+        tmp_CPPFLAGS="$tmp_CPPFLAGS -we 140,147,165,266"
+        dnl Disable some remarks
+        dnl #279: controlling expression is constant
+        dnl #981: operands are evaluated in unspecified order
+        dnl #1469: "cc" clobber ignored
+        tmp_CPPFLAGS="$tmp_CPPFLAGS -wd 279,981,1469"
+        ;;
+        #
+      INTEL_WINDOWS_C)
+        #
+        dnl Placeholder
+        tmp_CFLAGS="$tmp_CFLAGS"
+        ;;
+        #
+      LCC)
+        #
+        dnl Disallow run-time dereferencing of null pointers
+        tmp_CFLAGS="$tmp_CFLAGS -n"
+        ;;
+        #
+      SGI_MIPS_C)
+        #
+        dnl Placeholder
+        tmp_CFLAGS="$tmp_CFLAGS"
+        ;;
+        #
+      SGI_MIPSPRO_C)
+        #
+        dnl Placeholder
+        tmp_CFLAGS="$tmp_CFLAGS"
+        ;;
+        #
+      SUNPRO_C)
+        #
+        dnl Placeholder
+        tmp_CFLAGS="$tmp_CFLAGS"
+        ;;
+        #
+      TINY_C)
+        #
+        dnl Placeholder
+        tmp_CFLAGS="$tmp_CFLAGS"
+        ;;
+        #
+      WATCOM_UNIX_C)
+        #
+        dnl Placeholder
+        tmp_CFLAGS="$tmp_CFLAGS"
+        ;;
+        #
+      WATCOM_WINDOWS_C)
+        #
+        dnl Placeholder
+        tmp_CFLAGS="$tmp_CFLAGS"
+        ;;
+        #
+    esac
+    #
+    squeeze tmp_CPPFLAGS
+    squeeze tmp_CFLAGS
+    #
+    if test ! -z "$tmp_CFLAGS" || test ! -z "$tmp_CPPFLAGS"; then
+      AC_MSG_CHECKING([if compiler accepts some basic options])
+      CPPFLAGS="$tmp_save_CPPFLAGS $tmp_CPPFLAGS"
+      CFLAGS="$tmp_save_CFLAGS $tmp_CFLAGS"
+      squeeze CPPFLAGS
+      squeeze CFLAGS
+      CARES_COMPILER_WORKS_IFELSE([
+        AC_MSG_RESULT([yes])
+        AC_MSG_NOTICE([compiler options added: $tmp_CFLAGS $tmp_CPPFLAGS])
+      ],[
+        AC_MSG_RESULT([no])
+        AC_MSG_WARN([compiler options rejected: $tmp_CFLAGS $tmp_CPPFLAGS])
+        dnl restore initial settings
+        CPPFLAGS="$tmp_save_CPPFLAGS"
+        CFLAGS="$tmp_save_CFLAGS"
+      ])
+    fi
+    #
+  fi
+])
+
+
+dnl CARES_SET_COMPILER_DEBUG_OPTS
+dnl -------------------------------------------------
+dnl Sets compiler specific options/flags which depend
+dnl on configure's debug option.
+
+AC_DEFUN([CARES_SET_COMPILER_DEBUG_OPTS], [
+  AC_REQUIRE([CARES_CHECK_OPTION_DEBUG])dnl
+  AC_REQUIRE([CARES_CHECK_COMPILER])dnl
+  AC_REQUIRE([CARES_SHFUNC_SQUEEZE])dnl
+  #
+  if test "$compiler_id" != "unknown"; then
+    #
+    tmp_save_CFLAGS="$CFLAGS"
+    tmp_save_CPPFLAGS="$CPPFLAGS"
+    #
+    tmp_options=""
+    tmp_CFLAGS="$CFLAGS"
+    tmp_CPPFLAGS="$CPPFLAGS"
+    CARES_VAR_STRIP([tmp_CFLAGS],[$flags_dbg_all])
+    CARES_VAR_STRIP([tmp_CPPFLAGS],[$flags_dbg_all])
+    #
+    if test "$want_debug" = "yes"; then
+      AC_MSG_CHECKING([if compiler accepts debug enabling options])
+      tmp_options="$flags_dbg_yes"
+    fi
+    if test "$want_debug" = "no"; then
+      AC_MSG_CHECKING([if compiler accepts debug disabling options])
+      tmp_options="$flags_dbg_off"
+    fi
+    #
+    CPPFLAGS="$tmp_CPPFLAGS"
+    CFLAGS="$tmp_CFLAGS $tmp_options"
+    squeeze CPPFLAGS
+    squeeze CFLAGS
+    CARES_COMPILER_WORKS_IFELSE([
+      AC_MSG_RESULT([yes])
+      AC_MSG_NOTICE([compiler options added: $tmp_options])
+    ],[
+      AC_MSG_RESULT([no])
+      AC_MSG_WARN([compiler options rejected: $tmp_options])
+      dnl restore initial settings
+      CPPFLAGS="$tmp_save_CPPFLAGS"
+      CFLAGS="$tmp_save_CFLAGS"
+    ])
+    #
+  fi
+])
+
+
+dnl CARES_SET_COMPILER_OPTIMIZE_OPTS
+dnl -------------------------------------------------
+dnl Sets compiler specific options/flags which depend
+dnl on configure's optimize option.
+
+AC_DEFUN([CARES_SET_COMPILER_OPTIMIZE_OPTS], [
+  AC_REQUIRE([CARES_CHECK_OPTION_OPTIMIZE])dnl
+  AC_REQUIRE([CARES_CHECK_COMPILER])dnl
+  AC_REQUIRE([CARES_SHFUNC_SQUEEZE])dnl
+  #
+  if test "$compiler_id" != "unknown"; then
+    #
+    tmp_save_CFLAGS="$CFLAGS"
+    tmp_save_CPPFLAGS="$CPPFLAGS"
+    #
+    tmp_options=""
+    tmp_CFLAGS="$CFLAGS"
+    tmp_CPPFLAGS="$CPPFLAGS"
+    honor_optimize_option="yes"
+    #
+    dnl If optimization request setting has not been explicitly specified,
+    dnl it has been derived from the debug setting and initially assumed.
+    dnl This initially assumed optimizer setting will finally be ignored
+    dnl if CFLAGS or CPPFLAGS already hold optimizer flags. This implies
+    dnl that an initially assumed optimizer setting might not be honored.
+    #
+    if test "$want_optimize" = "assume_no" ||
+       test "$want_optimize" = "assume_yes"; then
+      AC_MSG_CHECKING([if compiler optimizer assumed setting might be used])
+      CARES_VAR_MATCH_IFELSE([tmp_CFLAGS],[$flags_opt_all],[
+        honor_optimize_option="no"
+      ])
+      CARES_VAR_MATCH_IFELSE([tmp_CPPFLAGS],[$flags_opt_all],[
+        honor_optimize_option="no"
+      ])
+      AC_MSG_RESULT([$honor_optimize_option])
+      if test "$honor_optimize_option" = "yes"; then
+        if test "$want_optimize" = "assume_yes"; then
+          want_optimize="yes"
+        fi
+        if test "$want_optimize" = "assume_no"; then
+          want_optimize="no"
+        fi
+      fi
+    fi
+    #
+    if test "$honor_optimize_option" = "yes"; then
+      CARES_VAR_STRIP([tmp_CFLAGS],[$flags_opt_all])
+      CARES_VAR_STRIP([tmp_CPPFLAGS],[$flags_opt_all])
+      if test "$want_optimize" = "yes"; then
+        AC_MSG_CHECKING([if compiler accepts optimizer enabling options])
+        tmp_options="$flags_opt_yes"
+      fi
+      if test "$want_optimize" = "no"; then
+        AC_MSG_CHECKING([if compiler accepts optimizer disabling options])
+        tmp_options="$flags_opt_off"
+      fi
+      CPPFLAGS="$tmp_CPPFLAGS"
+      CFLAGS="$tmp_CFLAGS $tmp_options"
+      squeeze CPPFLAGS
+      squeeze CFLAGS
+      CARES_COMPILER_WORKS_IFELSE([
+        AC_MSG_RESULT([yes])
+        AC_MSG_NOTICE([compiler options added: $tmp_options])
+      ],[
+        AC_MSG_RESULT([no])
+        AC_MSG_WARN([compiler options rejected: $tmp_options])
+        dnl restore initial settings
+        CPPFLAGS="$tmp_save_CPPFLAGS"
+        CFLAGS="$tmp_save_CFLAGS"
+      ])
+    fi
+    #
+  fi
+])
+
+
+dnl CARES_SET_COMPILER_WARNING_OPTS
+dnl -------------------------------------------------
+dnl Sets compiler options/flags which depend on
+dnl configure's warnings given option.
+
+AC_DEFUN([CARES_SET_COMPILER_WARNING_OPTS], [
+  AC_REQUIRE([CARES_CHECK_OPTION_WARNINGS])dnl
+  AC_REQUIRE([CARES_CHECK_COMPILER])dnl
+  AC_REQUIRE([CARES_SHFUNC_SQUEEZE])dnl
+  #
+  if test "$compiler_id" != "unknown"; then
+    #
+    tmp_save_CPPFLAGS="$CPPFLAGS"
+    tmp_save_CFLAGS="$CFLAGS"
+    tmp_CPPFLAGS=""
+    tmp_CFLAGS=""
+    #
+    case "$compiler_id" in
+        #
+      DEC_C)
+        #
+        if test "$want_warnings" = "yes"; then
+          dnl Select a higher warning level than default level2
+          tmp_CFLAGS="$tmp_CFLAGS -msg_enable level3"
+        fi
+        ;;
+        #
+      GNU_C)
+        #
+        if test "$want_warnings" = "yes"; then
+          #
+          dnl Do not enable -pedantic when cross-compiling with a gcc older
+          dnl than 3.0, to avoid warnings from third party system headers.
+          if test "x$cross_compiling" != "xyes" ||
+            test "$compiler_num" -ge "300"; then
+            tmp_CFLAGS="$tmp_CFLAGS -pedantic"
+          fi
+          #
+          dnl Set of options we believe *ALL* gcc versions support:
+          tmp_CFLAGS="$tmp_CFLAGS -Wall -W"
+          #
+          dnl Only gcc 1.4 or later
+          if test "$compiler_num" -ge "104"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wpointer-arith -Wwrite-strings"
+            dnl If not cross-compiling with a gcc older than 3.0
+            if test "x$cross_compiling" != "xyes" ||
+              test "$compiler_num" -ge "300"; then
+              tmp_CFLAGS="$tmp_CFLAGS -Wunused -Wshadow"
+            fi
+          fi
+          #
+          dnl Only gcc 2.7 or later
+          if test "$compiler_num" -ge "207"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Winline -Wnested-externs"
+            dnl If not cross-compiling with a gcc older than 3.0
+            if test "x$cross_compiling" != "xyes" ||
+              test "$compiler_num" -ge "300"; then
+              tmp_CFLAGS="$tmp_CFLAGS -Wmissing-declarations"
+              tmp_CFLAGS="$tmp_CFLAGS -Wmissing-prototypes"
+            fi
+          fi
+          #
+          dnl Only gcc 2.95 or later
+          if test "$compiler_num" -ge "295"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wno-long-long"
+          fi
+          #
+          dnl Only gcc 2.96 or later
+          if test "$compiler_num" -ge "296"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wfloat-equal"
+            tmp_CFLAGS="$tmp_CFLAGS -Wno-multichar -Wsign-compare"
+            dnl -Wundef used only if gcc is 2.96 or later since we get
+            dnl lots of "`_POSIX_C_SOURCE' is not defined" in system
+            dnl headers with gcc 2.95.4 on FreeBSD 4.9
+            tmp_CFLAGS="$tmp_CFLAGS -Wundef"
+          fi
+          #
+          dnl Only gcc 2.97 or later
+          if test "$compiler_num" -ge "297"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wno-format-nonliteral"
+          fi
+          #
+          dnl Only gcc 3.0 or later
+          if test "$compiler_num" -ge "300"; then
+            dnl -Wunreachable-code seems totally unreliable on my gcc 3.3.2 on
+            dnl on i686-Linux as it gives us heaps with false positives.
+            dnl Also, on gcc 4.0.X it is totally unbearable and complains all
+            dnl over making it unusable for generic purposes. Let's not use it.
+            tmp_CFLAGS="$tmp_CFLAGS"
+          fi
+          #
+          dnl Only gcc 3.3 or later
+          if test "$compiler_num" -ge "303"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wendif-labels -Wstrict-prototypes"
+          fi
+          #
+          dnl Only gcc 3.4 or later
+          if test "$compiler_num" -ge "304"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wdeclaration-after-statement"
+          fi
+          #
+          dnl Only gcc 4.3 or later
+          if test "$compiler_num" -ge "403"; then
+            tmp_CFLAGS="$tmp_CFLAGS -Wtype-limits -Wold-style-declaration"
+            tmp_CFLAGS="$tmp_CFLAGS -Wmissing-parameter-type -Wempty-body"
+            tmp_CFLAGS="$tmp_CFLAGS -Wclobbered -Wignored-qualifiers"
+          fi
+          #
+        fi
+        #
+        dnl Do not issue warnings for code in system include paths.
+        if test "$compiler_num" -ge "300"; then
+          tmp_CFLAGS="$tmp_CFLAGS -Wno-system-headers"
+        else
+          dnl When cross-compiling with a gcc older than 3.0, disable
+          dnl some warnings triggered on third party system headers.
+          if test "x$cross_compiling" = "xyes"; then
+            if test "$compiler_num" -ge "104"; then
+              dnl gcc 1.4 or later
+              tmp_CFLAGS="$tmp_CFLAGS -Wno-unused -Wno-shadow"
+            fi
+            if test "$compiler_num" -ge "207"; then
+              dnl gcc 2.7 or later
+              tmp_CFLAGS="$tmp_CFLAGS -Wno-missing-declarations"
+              tmp_CFLAGS="$tmp_CFLAGS -Wno-missing-prototypes"
+            fi
+          fi
+        fi
+        ;;
+        #
+      HP_UX_C)
+        #
+        if test "$want_warnings" = "yes"; then
+          dnl Issue all warnings
+          tmp_CFLAGS="$tmp_CFLAGS +w1"
+        fi
+        ;;
+        #
+      IBM_C)
+        #
+        dnl Placeholder
+        tmp_CFLAGS="$tmp_CFLAGS"
+        ;;
+        #
+      INTEL_UNIX_C)
+        #
+        if test "$want_warnings" = "yes"; then
+          if test "$compiler_num" -gt "600"; then
+            dnl Show errors, warnings, and remarks
+            tmp_CPPFLAGS="$tmp_CPPFLAGS -Wall -w2"
+            dnl Perform extra compile-time code checking
+            tmp_CPPFLAGS="$tmp_CPPFLAGS -Wcheck"
+            dnl Warn on nested comments
+            tmp_CPPFLAGS="$tmp_CPPFLAGS -Wcomment"
+            dnl Show warnings relative to deprecated features
+            tmp_CPPFLAGS="$tmp_CPPFLAGS -Wdeprecated"
+            dnl Enable warnings for missing prototypes
+            tmp_CPPFLAGS="$tmp_CPPFLAGS -Wmissing-prototypes"
+            dnl Enable warnings for 64-bit portability issues
+            tmp_CPPFLAGS="$tmp_CPPFLAGS -Wp64"
+            dnl Enable warnings for questionable pointer arithmetic
+            tmp_CPPFLAGS="$tmp_CPPFLAGS -Wpointer-arith"
+            dnl Check for function return typw issues
+            tmp_CPPFLAGS="$tmp_CPPFLAGS -Wreturn-type"
+            dnl Warn on variable declarations hiding a previous one
+            tmp_CPPFLAGS="$tmp_CPPFLAGS -Wshadow"
+            dnl Warn when a variable is used before initialized
+            tmp_CPPFLAGS="$tmp_CPPFLAGS -Wuninitialized"
+            dnl Warn if a declared function is not used
+            tmp_CPPFLAGS="$tmp_CPPFLAGS -Wunused-function"
+          fi
+        fi
+        dnl Disable using EBP register in optimizations
+        tmp_CFLAGS="$tmp_CFLAGS -fno-omit-frame-pointer"
+        dnl Disable use of ANSI C aliasing rules in optimizations
+        tmp_CFLAGS="$tmp_CFLAGS -no-ansi-alias"
+        dnl Value-safe optimizations on floating-point data
+        tmp_CFLAGS="$tmp_CFLAGS -fp-model precise"
+        dnl Only icc 10.0 or later
+        if test "$compiler_num" -ge "1000"; then
+          dnl Disable vectorizer diagnostic information
+          tmp_CFLAGS="$tmp_CFLAGS -vec-report0"
+        fi
+        ;;
+        #
+      INTEL_WINDOWS_C)
+        #
+        dnl Placeholder
+        tmp_CFLAGS="$tmp_CFLAGS"
+        ;;
+        #
+      LCC)
+        #
+        if test "$want_warnings" = "yes"; then
+          dnl Highest warning level is double -A, next is single -A.
+          dnl Due to the big number of warnings these trigger on third
+          dnl party header files it is impractical for us to use any of
+          dnl them here. If you want them simply define it in CPPFLAGS.
+          tmp_CFLAGS="$tmp_CFLAGS"
+        fi
+        ;;
+        #
+      SGI_MIPS_C)
+        #
+        if test "$want_warnings" = "yes"; then
+          dnl Perform stricter semantic and lint-like checks
+          tmp_CFLAGS="$tmp_CFLAGS -fullwarn"
+        fi
+        ;;
+        #
+      SGI_MIPSPRO_C)
+        #
+        if test "$want_warnings" = "yes"; then
+          dnl Perform stricter semantic and lint-like checks
+          tmp_CFLAGS="$tmp_CFLAGS -fullwarn"
+          dnl Disable some remarks
+          dnl #1209: controlling expression is constant
+          tmp_CFLAGS="$tmp_CFLAGS -woff 1209"
+        fi
+        ;;
+        #
+      SUNPRO_C)
+        #
+        if test "$want_warnings" = "yes"; then
+          dnl Perform stricter semantic and lint-like checks
+          tmp_CFLAGS="$tmp_CFLAGS -v"
+        fi
+        ;;
+        #
+      TINY_C)
+        #
+        if test "$want_warnings" = "yes"; then
+          dnl Activate all warnings
+          tmp_CFLAGS="$tmp_CFLAGS -Wall"
+          dnl Make string constants be of type const char *
+          tmp_CFLAGS="$tmp_CFLAGS -Wwrite-strings"
+          dnl Warn use of unsupported GCC features ignored by TCC
+          tmp_CFLAGS="$tmp_CFLAGS -Wunsupported"
+        fi
+        ;;
+        #
+      WATCOM_UNIX_C)
+        #
+        if test "$want_warnings" = "yes"; then
+          dnl Issue all warnings
+          tmp_CFLAGS="$tmp_CFLAGS -Wall -Wextra"
+        fi
+        ;;
+        #
+      WATCOM_WINDOWS_C)
+        #
+        dnl Placeholder
+        tmp_CFLAGS="$tmp_CFLAGS"
+        ;;
+        #
+    esac
+    #
+    squeeze tmp_CPPFLAGS
+    squeeze tmp_CFLAGS
+    #
+    if test ! -z "$tmp_CFLAGS" || test ! -z "$tmp_CPPFLAGS"; then
+      AC_MSG_CHECKING([if compiler accepts strict warning options])
+      CPPFLAGS="$tmp_save_CPPFLAGS $tmp_CPPFLAGS"
+      CFLAGS="$tmp_save_CFLAGS $tmp_CFLAGS"
+      squeeze CPPFLAGS
+      squeeze CFLAGS
+      CARES_COMPILER_WORKS_IFELSE([
+        AC_MSG_RESULT([yes])
+        AC_MSG_NOTICE([compiler options added: $tmp_CFLAGS $tmp_CPPFLAGS])
+      ],[
+        AC_MSG_RESULT([no])
+        AC_MSG_WARN([compiler options rejected: $tmp_CFLAGS $tmp_CPPFLAGS])
+        dnl restore initial settings
+        CPPFLAGS="$tmp_save_CPPFLAGS"
+        CFLAGS="$tmp_save_CFLAGS"
+      ])
+    fi
+    #
+  fi
+])
+
+
+dnl CARES_SHFUNC_SQUEEZE
+dnl -------------------------------------------------
+dnl Declares a shell function squeeze() which removes
+dnl redundant whitespace out of a shell variable.
+
+AC_DEFUN([CARES_SHFUNC_SQUEEZE], [
+squeeze() {
+  _sqz_result=""
+  eval _sqz_input=\[$][$]1
+  for _sqz_token in $_sqz_input; do
+    if test -z "$_sqz_result"; then
+      _sqz_result="$_sqz_token"
+    else
+      _sqz_result="$_sqz_result $_sqz_token"
+    fi
+  done
+  eval [$]1=\$_sqz_result
+  return 0
+}
+])
+
+
+dnl CARES_CHECK_CURLDEBUG
+dnl -------------------------------------------------
+dnl Settings which depend on configure's curldebug given
+dnl option, and other additional configure pre-requisites.
+dnl Using the curl debug memory tracking feature in c-ares
+dnl is a hack that actually can only be used/enabled when
+dnl c-ares is built directly in curl's CVS tree, as a static
+dnl library or as a shared one on those systems on which
+dnl shared libraries support undefined symbols, along with
+dnl an equally configured libcurl.
+
+AC_DEFUN([CARES_CHECK_CURLDEBUG], [
+  AC_REQUIRE([CARES_SHFUNC_SQUEEZE])dnl
+  cares_builddir=`pwd`
+  supports_curldebug="unknown"
+  if test "$want_curldebug" = "yes"; then
+    if test "x$enable_shared" != "xno" &&
+      test "x$enable_shared" != "xyes"; then
+      AC_MSG_WARN([unknown enable_shared setting.])
+      supports_curldebug="no"
+    fi
+    if test "x$enable_static" != "xno" &&
+      test "x$enable_static" != "xyes"; then
+      AC_MSG_WARN([unknown enable_static setting.])
+      supports_curldebug="no"
+    fi
+    if test "$supports_curldebug" != "no"; then
+      if test "$enable_shared" = "yes" &&
+        test "$need_no_undefined" = "yes"; then
+        supports_curldebug="no"
+        AC_MSG_WARN([shared library does not support undefined symbols.])
+      fi
+      if test ! -f "$srcdir/../include/curl/curlbuild.h.dist"; then
+        AC_MSG_WARN([c-ares source not embedded in curl's CVS tree.])
+        supports_curldebug="no"
+      elif test ! -f "$srcdir/../include/curl/Makefile.in"; then
+        AC_MSG_WARN([curl's buildconf has not been run.])
+        supports_curldebug="no"
+      elif test ! -f "$cares_builddir/../libcurl.pc" ||
+        test ! -f "$cares_builddir/../include/curl/curlbuild.h"; then
+        AC_MSG_WARN([curl's configure has not been run.])
+        supports_curldebug="no"
+      elif test ! -f "$cares_builddir/../lib/curl_config.h"; then
+        AC_MSG_WARN([libcurl's curl_config.h is missing.])
+        supports_curldebug="no"
+      elif test ! -f "$cares_builddir/../config.status"; then
+        AC_MSG_WARN([curl's config.status is missing.])
+        supports_curldebug="no"
+      fi
+      if test "$supports_curldebug" != "no"; then
+        grep '^#define USE_ARES' "$cares_builddir/../lib/curl_config.h" >/dev/null
+        if test "$?" -ne "0"; then
+          AC_MSG_WARN([libcurl configured without c-ares support.])
+          supports_curldebug="no"
+        fi
+      fi
+      if test "$supports_curldebug" != "no"; then
+        grep 'CPPFLAGS.*CURLDEBUG' "$cares_builddir/../config.status" >/dev/null
+        if test "$?" -ne "0"; then
+          AC_MSG_WARN([libcurl configured without curldebug support.])
+          supports_curldebug="no"
+        fi
+      fi
+    fi
+  fi
+  #
+  if test "$want_curldebug" = "yes"; then
+    AC_MSG_CHECKING([if curl debug memory tracking can be enabled])
+    test "$supports_curldebug" = "no" || supports_curldebug="yes"
+    AC_MSG_RESULT([$supports_curldebug])
+    if test "$supports_curldebug" = "no"; then
+      AC_MSG_WARN([cannot enable curl debug memory tracking.])
+      want_curldebug="no"
+    fi
+  fi
+  #
+  if test "$want_curldebug" = "yes"; then
+    dnl TODO: Verify if the BUILDING_LIBCURL definition is still required.
+    AC_DEFINE(BUILDING_LIBCURL, 1, [when building as static part of libcurl])
+    CPPFLAGS="$CPPFLAGS -DCURLDEBUG"
+    squeeze CPPFLAGS
+  fi
+  #
+  if test "$want_debug" = "yes"; then
+    CPPFLAGS="$CPPFLAGS -DDEBUGBUILD"
+    squeeze CPPFLAGS
+  fi
+])
+
+
+dnl CARES_CHECK_NO_UNDEFINED
+dnl -------------------------------------------------
+dnl Checks if the -no-undefined flag must be used when
+dnl building shared libraries. This is required on all
+dnl systems on which shared libraries should not have
+dnl references to undefined symbols. This check should
+dnl not be done before AC-PROG-LIBTOOL.
+
+AC_DEFUN([CARES_CHECK_NO_UNDEFINED], [
+  AC_BEFORE([$0],[CARES_CHECK_CURLDEBUG])dnl
+  AC_MSG_CHECKING([if shared libraries need -no-undefined])
+  need_no_undefined="no"
+  case $host in
+    *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-cegcc* | *-*-aix*)
+      need_no_undefined="yes"
+      ;;
+  esac
+  if test "x$allow_undefined" = "xno"; then
+    need_no_undefined="yes"
+  elif test "x$allow_undefined_flag" = "xunsupported"; then
+    need_no_undefined="yes"
+  fi
+  AC_MSG_RESULT($need_no_undefined)
+])
+
+
+dnl CARES_CHECK_PROG_CC
+dnl -------------------------------------------------
+dnl Check for compiler program, preventing CFLAGS and
+dnl CPPFLAGS from being unexpectedly changed.
+
+AC_DEFUN([CARES_CHECK_PROG_CC], [
+  ac_save_CFLAGS="$CFLAGS"
+  ac_save_CPPFLAGS="$CPPFLAGS"
+  AC_PROG_CC
+  CFLAGS="$ac_save_CFLAGS"
+  CPPFLAGS="$ac_save_CPPFLAGS"
+])
+
+
+dnl CARES_CHECK_COMPILER_HALT_ON_ERROR
+dnl -------------------------------------------------
+dnl Verifies if the compiler actually halts after the
+dnl compilation phase without generating any object
+dnl code file, when the source compiles with errors.
+
+AC_DEFUN([CARES_CHECK_COMPILER_HALT_ON_ERROR], [
+  AC_MSG_CHECKING([if compiler halts on compilation errors])
+  AC_COMPILE_IFELSE([
+    AC_LANG_PROGRAM([[
+    ]],[[
+      force compilation error
+    ]])
+  ],[
+    AC_MSG_RESULT([no])
+    AC_MSG_ERROR([compiler does not halt on compilation errors.])
+  ],[
+    AC_MSG_RESULT([yes])
+  ])
+])
+
+
+dnl CARES_CHECK_COMPILER_ARRAY_SIZE_NEGATIVE
+dnl -------------------------------------------------
+dnl Verifies if the compiler actually halts after the
+dnl compilation phase without generating any object
+dnl code file, when the source code tries to define a
+dnl type for a constant array with negative dimension.
+
+AC_DEFUN([CARES_CHECK_COMPILER_ARRAY_SIZE_NEGATIVE], [
+  AC_REQUIRE([CARES_CHECK_COMPILER_HALT_ON_ERROR])dnl
+  AC_MSG_CHECKING([if compiler halts on negative sized arrays])
+  AC_COMPILE_IFELSE([
+    AC_LANG_PROGRAM([[
+      typedef char bad_t[sizeof(char) == sizeof(int) ? -1 : -1 ];
+    ]],[[
+      bad_t dummy;
+    ]])
+  ],[
+    AC_MSG_RESULT([no])
+    AC_MSG_ERROR([compiler does not halt on negative sized arrays.])
+  ],[
+    AC_MSG_RESULT([yes])
+  ])
+])
+
+
+dnl CARES_CHECK_COMPILER_STRUCT_MEMBER_SIZE
+dnl -------------------------------------------------
+dnl Verifies if the compiler is capable of handling the
+dnl size of a struct member, struct which is a function
+dnl result, as a compilation-time condition inside the
+dnl type definition of a constant array.
+
+AC_DEFUN([CARES_CHECK_COMPILER_STRUCT_MEMBER_SIZE], [
+  AC_REQUIRE([CARES_CHECK_COMPILER_ARRAY_SIZE_NEGATIVE])dnl
+  AC_MSG_CHECKING([if compiler struct member size checking works])
+  tst_compiler_check_one_works="unknown"
+  AC_COMPILE_IFELSE([
+    AC_LANG_PROGRAM([[
+      struct mystruct {
+        int  mi;
+        char mc;
+        struct mystruct *next;
+      };
+      struct mystruct myfunc();
+      typedef char good_t1[sizeof(myfunc().mi) == sizeof(int)  ? 1 : -1 ];
+      typedef char good_t2[sizeof(myfunc().mc) == sizeof(char) ? 1 : -1 ];
+    ]],[[
+      good_t1 dummy1;
+      good_t2 dummy2;
+    ]])
+  ],[
+    tst_compiler_check_one_works="yes"
+  ],[
+    tst_compiler_check_one_works="no"
+    sed 's/^/cc-src: /' conftest.$ac_ext >&6
+    sed 's/^/cc-err: /' conftest.err >&6
+  ])
+  tst_compiler_check_two_works="unknown"
+  AC_COMPILE_IFELSE([
+    AC_LANG_PROGRAM([[
+      struct mystruct {
+        int  mi;
+        char mc;
+        struct mystruct *next;
+      };
+      struct mystruct myfunc();
+      typedef char bad_t1[sizeof(myfunc().mi) != sizeof(int)  ? 1 : -1 ];
+      typedef char bad_t2[sizeof(myfunc().mc) != sizeof(char) ? 1 : -1 ];
+    ]],[[
+      bad_t1 dummy1;
+      bad_t2 dummy2;
+    ]])
+  ],[
+    tst_compiler_check_two_works="no"
+  ],[
+    tst_compiler_check_two_works="yes"
+  ])
+  if test "$tst_compiler_check_one_works" = "yes" &&
+    test "$tst_compiler_check_two_works" = "yes"; then
+    AC_MSG_RESULT([yes])
+  else
+    AC_MSG_RESULT([no])
+    AC_MSG_ERROR([compiler fails struct member size checking.])
+  fi
+])
+
+
+dnl CARES_CHECK_COMPILER_SYMBOL_HIDING
+dnl -------------------------------------------------
+dnl Verify if compiler supports hiding library internal symbols, setting
+dnl shell variable supports_symbol_hiding value as appropriate, as well as
+dnl variables symbol_hiding_CFLAGS and symbol_hiding_EXTERN when supported.
+
+AC_DEFUN([CARES_CHECK_COMPILER_SYMBOL_HIDING], [
+  AC_REQUIRE([CARES_CHECK_COMPILER])dnl
+  AC_BEFORE([$0],[CARES_CONFIGURE_SYMBOL_HIDING])dnl
+  AC_MSG_CHECKING([if compiler supports hiding library internal symbols])
+  supports_symbol_hiding="no"
+  symbol_hiding_CFLAGS=""
+  symbol_hiding_EXTERN=""
+  tmp_CFLAGS=""
+  tmp_EXTERN=""
+  case "$compiler_id" in
+    GNU_C)
+      dnl Only gcc 3.4 or later
+      if test "$compiler_num" -ge "304"; then
+        if $CC --help --verbose 2>&1 | grep fvisibility= > /dev/null ; then
+          tmp_EXTERN="__attribute__ ((visibility (\"default\")))"
+          tmp_CFLAGS="-fvisibility=hidden"
+          supports_symbol_hiding="yes"
+        fi
+      fi
+      ;;
+    INTEL_UNIX_C)
+      dnl Only icc 9.0 or later
+      if test "$compiler_num" -ge "900"; then
+        if $CC --help --verbose 2>&1 | grep fvisibility= > /dev/null ; then
+          tmp_save_CFLAGS="$CFLAGS"
+          CFLAGS="$CFLAGS -fvisibility=hidden"
+          AC_LINK_IFELSE([
+            AC_LANG_PROGRAM([[
+#             include <stdio.h>
+            ]],[[
+              printf("icc fvisibility bug test");
+            ]])
+          ],[
+            tmp_EXTERN="__attribute__ ((visibility (\"default\")))"
+            tmp_CFLAGS="-fvisibility=hidden"
+            supports_symbol_hiding="yes"
+          ])
+          CFLAGS="$tmp_save_CFLAGS"
+        fi
+      fi
+      ;;
+    SUNPRO_C)
+      if $CC 2>&1 | grep flags >/dev/null && $CC -flags | grep xldscope= >/dev/null ; then
+        tmp_EXTERN="__global"
+        tmp_CFLAGS="-xldscope=hidden"
+        supports_symbol_hiding="yes"
+      fi
+      ;;
+  esac
+  if test "$supports_symbol_hiding" = "yes"; then
+    tmp_save_CFLAGS="$CFLAGS"
+    CFLAGS="$tmp_save_CFLAGS $tmp_CFLAGS"
+    squeeze CFLAGS
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $tmp_EXTERN char *dummy(char *buff);
+        char *dummy(char *buff)
+        {
+         if(buff)
+           return ++buff;
+         else
+           return buff;
+        }
+      ]],[[
+        char b[16];
+        char *r = dummy(&b);
+        if(r)
+          return (int)*r;
+      ]])
+    ],[
+      supports_symbol_hiding="yes"
+    ],[
+      supports_symbol_hiding="no"
+      echo " " >&6
+      sed 's/^/cc-src: /' conftest.$ac_ext >&6
+      sed 's/^/cc-err: /' conftest.err >&6
+      echo " " >&6
+    ])
+    CFLAGS="$tmp_save_CFLAGS"
+  fi
+  if test "$supports_symbol_hiding" = "yes"; then
+    AC_MSG_RESULT([yes])
+    symbol_hiding_CFLAGS="$tmp_CFLAGS"
+    symbol_hiding_EXTERN="$tmp_EXTERN"
+  else
+    AC_MSG_RESULT([no])
+  fi
+])
+
+
+dnl CARES_VAR_MATCH (VARNAME, VALUE)
+dnl -------------------------------------------------
+dnl Verifies if shell variable VARNAME contains VALUE.
+dnl Contents of variable VARNAME and VALUE are handled
+dnl as whitespace separated lists of words. If at least
+dnl one word of VALUE is present in VARNAME the match
+dnl is considered positive, otherwise false.
+
+AC_DEFUN([CARES_VAR_MATCH], [
+  ac_var_match_word="no"
+  for word1 in $[$1]; do
+    for word2 in [$2]; do
+      if test "$word1" = "$word2"; then
+        ac_var_match_word="yes"
+      fi
+    done
+  done
+])
+
+
+dnl CARES_VAR_MATCH_IFELSE (VARNAME, VALUE,
+dnl                        [ACTION-IF-MATCH], [ACTION-IF-NOT-MATCH])
+dnl -------------------------------------------------
+dnl This performs a CURL_VAR_MATCH check and executes
+dnl first branch if the match is positive, otherwise
+dnl the second branch is executed.
+
+AC_DEFUN([CARES_VAR_MATCH_IFELSE], [
+  CARES_VAR_MATCH([$1],[$2])
+  if test "$ac_var_match_word" = "yes"; then
+  ifelse($3,,:,[$3])
+  ifelse($4,,,[else
+    $4])
+  fi
+])
+
+
+dnl CARES_VAR_STRIP (VARNAME, VALUE)
+dnl -------------------------------------------------
+dnl Contents of variable VARNAME and VALUE are handled
+dnl as whitespace separated lists of words. Each word
+dnl from VALUE is removed from VARNAME when present.
+
+AC_DEFUN([CARES_VAR_STRIP], [
+  AC_REQUIRE([CARES_SHFUNC_SQUEEZE])dnl
+  ac_var_stripped=""
+  for word1 in $[$1]; do
+    ac_var_strip_word="no"
+    for word2 in [$2]; do
+      if test "$word1" = "$word2"; then
+        ac_var_strip_word="yes"
+      fi
+    done
+    if test "$ac_var_strip_word" = "no"; then
+      ac_var_stripped="$ac_var_stripped $word1"
+    fi
+  done
+  dnl squeeze whitespace out of result
+  [$1]="$ac_var_stripped"
+  squeeze [$1]
+])
+
diff --git a/m4/cares-confopts.m4 b/m4/cares-confopts.m4
new file mode 100644
index 0000000..3ea9708
--- /dev/null
+++ b/m4/cares-confopts.m4
@@ -0,0 +1,320 @@
+#***************************************************************************
+# $Id: cares-confopts.m4,v 1.8 2009-10-31 04:16:40 yangtse Exp $
+#
+# Copyright (C) 2008 - 2009 by Daniel Stenberg et al
+#
+# Permission to use, copy, modify, and distribute this software and its
+# documentation for any purpose and without fee is hereby granted, provided
+# that the above copyright notice appear in all copies and that both that
+# copyright notice and this permission notice appear in supporting
+# documentation, and that the name of M.I.T. not be used in advertising or
+# publicity pertaining to distribution of the software without specific,
+# written prior permission.  M.I.T. makes no representations about the
+# suitability of this software for any purpose.  It is provided "as is"
+# without express or implied warranty.
+#
+#***************************************************************************
+
+# File version for 'aclocal' use. Keep it a single number.
+# serial 8
+
+
+dnl CARES_CHECK_OPTION_CURLDEBUG
+dnl -------------------------------------------------
+dnl Verify if configure has been invoked with option
+dnl --enable-curldebug or --disable-curldebug, and set
+dnl shell variable want_curldebug value as appropriate.
+
+AC_DEFUN([CARES_CHECK_OPTION_CURLDEBUG], [
+  AC_BEFORE([$0],[CARES_CHECK_CURLDEBUG])dnl
+  AC_MSG_CHECKING([whether to enable curl debug memory tracking])
+  OPT_CURLDEBUG_BUILD="default"
+  AC_ARG_ENABLE(curldebug,
+AC_HELP_STRING([--enable-curldebug],[Enable curl debug memory tracking])
+AC_HELP_STRING([--disable-curldebug],[Disable curl debug memory tracking]),
+  OPT_CURLDEBUG_BUILD=$enableval)
+  case "$OPT_CURLDEBUG_BUILD" in
+    no)
+      dnl --disable-curldebug option used
+      want_curldebug="no"
+      ;;
+    default)
+      dnl configure option not specified
+      want_curldebug="no"
+      ;;
+    *)
+      dnl --enable-curldebug option used.
+      dnl The use of this option value is a request to enable curl's
+      dnl debug memory tracking for the c-ares library. This is a big
+      dnl hack that can only be done when a whole bunch of requisites
+      dnl are simultaneously satisfied. Later on, these requisites are
+      dnl verified and if they are not fully satisfied the option will
+      dnl be ignored and act as if --disable-curldebug had been given
+      dnl setting shell variable want_curldebug to 'no'.
+      want_curldebug="yes"
+      ;;
+  esac
+  AC_MSG_RESULT([$want_curldebug])
+])
+
+
+dnl CARES_CHECK_OPTION_DEBUG
+dnl -------------------------------------------------
+dnl Verify if configure has been invoked with option
+dnl --enable-debug or --disable-debug, and set shell
+dnl variable want_debug value as appropriate.
+
+AC_DEFUN([CARES_CHECK_OPTION_DEBUG], [
+  AC_BEFORE([$0],[CARES_CHECK_OPTION_WARNINGS])dnl
+  AC_BEFORE([$0],[CARES_CHECK_OPTION_CURLDEBUG])dnl
+  AC_BEFORE([$0],[CARES_CHECK_PROG_CC])dnl
+  AC_MSG_CHECKING([whether to enable debug build options])
+  OPT_DEBUG_BUILD="default"
+  AC_ARG_ENABLE(debug,
+AC_HELP_STRING([--enable-debug],[Enable debug build options])
+AC_HELP_STRING([--disable-debug],[Disable debug build options]),
+  OPT_DEBUG_BUILD=$enableval)
+  case "$OPT_DEBUG_BUILD" in
+    no)
+      dnl --disable-debug option used
+      want_debug="no"
+      ;;
+    default)
+      dnl configure option not specified
+      want_debug="no"
+      ;;
+    *)
+      dnl --enable-debug option used
+      want_debug="yes"
+      ;;
+  esac
+  AC_MSG_RESULT([$want_debug])
+])
+
+
+dnl CARES_CHECK_OPTION_NONBLOCKING
+dnl -------------------------------------------------
+dnl Verify if configure has been invoked with option
+dnl --enable-nonblocking or --disable-nonblocking, and
+dnl set shell variable want_nonblocking as appropriate.
+
+AC_DEFUN([CARES_CHECK_OPTION_NONBLOCKING], [
+  AC_BEFORE([$0],[CARES_CHECK_NONBLOCKING_SOCKET])dnl
+  AC_MSG_CHECKING([whether to enable non-blocking communications])
+  OPT_NONBLOCKING="default"
+  AC_ARG_ENABLE(nonblocking,
+AC_HELP_STRING([--enable-nonblocking],[Enable non-blocking communications])
+AC_HELP_STRING([--disable-nonblocking],[Disable non-blocking communications]),
+  OPT_NONBLOCKING=$enableval)
+  case "$OPT_NONBLOCKING" in
+    no)
+      dnl --disable-nonblocking option used
+      want_nonblocking="no"
+      ;;
+    default)
+      dnl configure option not specified
+      want_nonblocking="yes"
+      ;;
+    *)
+      dnl --enable-nonblocking option used
+      want_nonblocking="yes"
+      ;;
+  esac
+  AC_MSG_RESULT([$want_nonblocking])
+])
+
+
+dnl CARES_CHECK_OPTION_OPTIMIZE
+dnl -------------------------------------------------
+dnl Verify if configure has been invoked with option
+dnl --enable-optimize or --disable-optimize, and set
+dnl shell variable want_optimize value as appropriate.
+
+AC_DEFUN([CARES_CHECK_OPTION_OPTIMIZE], [
+  AC_REQUIRE([CARES_CHECK_OPTION_DEBUG])dnl
+  AC_BEFORE([$0],[CARES_CHECK_PROG_CC])dnl
+  AC_MSG_CHECKING([whether to enable compiler optimizer])
+  OPT_COMPILER_OPTIMIZE="default"
+  AC_ARG_ENABLE(optimize,
+AC_HELP_STRING([--enable-optimize(=OPT)],[Enable compiler optimizations (default=-O2)])
+AC_HELP_STRING([--disable-optimize],[Disable compiler optimizations]),
+  OPT_COMPILER_OPTIMIZE=$enableval)
+  case "$OPT_COMPILER_OPTIMIZE" in
+    no)
+      dnl --disable-optimize option used. We will handle this as
+      dnl a request to disable compiler optimizations if possible.
+      dnl If the compiler is known CFLAGS and CPPFLAGS will be
+      dnl overridden, otherwise this can not be honored.
+      want_optimize="no"
+      AC_MSG_RESULT([no])
+      ;;
+    default)
+      dnl configure's optimize option not specified. Initially we will
+      dnl handle this as a a request contrary to configure's setting
+      dnl for --enable-debug. IOW, initially, for debug-enabled builds
+      dnl this will be handled as a request to disable optimizations if
+      dnl possible, and for debug-disabled builds this will be handled
+      dnl initially as a request to enable optimizations if possible.
+      dnl Finally, if the compiler is known and CFLAGS and CPPFLAGS do
+      dnl not have any optimizer flag the request will be honored, in
+      dnl any other case the request can not be honored.
+      dnl IOW, existing optimizer flags defined in CFLAGS or CPPFLAGS
+      dnl will always take precedence over any initial assumption.
+      if test "$want_debug" = "yes"; then
+        want_optimize="assume_no"
+        AC_MSG_RESULT([not specified (assuming no)])
+      else
+        want_optimize="assume_yes"
+        AC_MSG_RESULT([not specified (assuming yes)])
+      fi
+      ;;
+    *)
+      dnl --enable-optimize option used. We will handle this as
+      dnl a request to enable compiler optimizations if possible.
+      dnl If the compiler is known CFLAGS and CPPFLAGS will be
+      dnl overridden, otherwise this can not be honored.
+      want_optimize="yes"
+      AC_MSG_RESULT([yes])
+      ;;
+  esac
+])
+
+
+dnl CARES_CHECK_OPTION_SYMBOL_HIDING
+dnl -------------------------------------------------
+dnl Verify if configure has been invoked with option
+dnl --enable-symbol-hiding or --disable-symbol-hiding,
+dnl setting shell variable want_symbol_hiding value.
+
+AC_DEFUN([CARES_CHECK_OPTION_SYMBOL_HIDING], [
+  AC_BEFORE([$0],[CARES_CHECK_COMPILER_SYMBOL_HIDING])dnl
+  AC_MSG_CHECKING([whether to enable hiding of library internal symbols])
+  OPT_SYMBOL_HIDING="default"
+  AC_ARG_ENABLE(symbol-hiding,
+AC_HELP_STRING([--enable-symbol-hiding],[Enable hiding of library internal symbols])
+AC_HELP_STRING([--disable-symbol-hiding],[Disable hiding of library internal symbols]),
+  OPT_SYMBOL_HIDING=$enableval)
+  case "$OPT_SYMBOL_HIDING" in
+    no)
+      dnl --disable-symbol-hiding option used.
+      dnl This is an indication to not attempt hiding of library internal
+      dnl symbols. Default symbol visibility will be used, which normally
+      dnl exposes all library internal symbols.
+      want_symbol_hiding="no"
+      AC_MSG_RESULT([no])
+      ;;
+    default)
+      dnl configure's symbol-hiding option not specified.
+      dnl Handle this as if --enable-symbol-hiding option was given.
+      want_symbol_hiding="yes"
+      AC_MSG_RESULT([yes])
+      ;;
+    *)
+      dnl --enable-symbol-hiding option used.
+      dnl This is an indication to attempt hiding of library internal
+      dnl symbols. This is only supported on some compilers/linkers.
+      want_symbol_hiding="yes"
+      AC_MSG_RESULT([yes])
+      ;;
+  esac
+])
+
+
+dnl CARES_CHECK_OPTION_WARNINGS
+dnl -------------------------------------------------
+dnl Verify if configure has been invoked with option
+dnl --enable-warnings or --disable-warnings, and set
+dnl shell variable want_warnings as appropriate.
+
+AC_DEFUN([CARES_CHECK_OPTION_WARNINGS], [
+  AC_REQUIRE([CARES_CHECK_OPTION_DEBUG])dnl
+  AC_BEFORE([$0],[CARES_CHECK_PROG_CC])dnl
+  AC_MSG_CHECKING([whether to enable strict compiler warnings])
+  OPT_COMPILER_WARNINGS="default"
+  AC_ARG_ENABLE(warnings,
+AC_HELP_STRING([--enable-warnings],[Enable strict compiler warnings])
+AC_HELP_STRING([--disable-warnings],[Disable strict compiler warnings]),
+  OPT_COMPILER_WARNINGS=$enableval)
+  case "$OPT_COMPILER_WARNINGS" in
+    no)
+      dnl --disable-warnings option used
+      want_warnings="no"
+      ;;
+    default)
+      dnl configure option not specified, so
+      dnl use same setting as --enable-debug
+      want_warnings="$want_debug"
+      ;;
+    *)
+      dnl --enable-warnings option used
+      want_warnings="yes"
+      ;;
+  esac
+  AC_MSG_RESULT([$want_warnings])
+])
+
+
+dnl CARES_CHECK_NONBLOCKING_SOCKET
+dnl -------------------------------------------------
+dnl Check for how to set a socket into non-blocking state.
+
+AC_DEFUN([CARES_CHECK_NONBLOCKING_SOCKET], [
+  AC_REQUIRE([CARES_CHECK_OPTION_NONBLOCKING])dnl
+  AC_REQUIRE([CARES_CHECK_FUNC_FCNTL])dnl
+  AC_REQUIRE([CARES_CHECK_FUNC_IOCTL])dnl
+  AC_REQUIRE([CARES_CHECK_FUNC_IOCTLSOCKET])dnl
+  AC_REQUIRE([CARES_CHECK_FUNC_IOCTLSOCKET_CAMEL])dnl
+  AC_REQUIRE([CARES_CHECK_FUNC_SETSOCKOPT])dnl
+  #
+  tst_method="unknown"
+  if test "$want_nonblocking" = "yes"; then
+    AC_MSG_CHECKING([how to set a socket into non-blocking mode])
+    if test "x$ac_cv_func_fcntl_o_nonblock" = "xyes"; then
+      tst_method="fcntl O_NONBLOCK"
+    elif test "x$ac_cv_func_ioctl_fionbio" = "xyes"; then
+      tst_method="ioctl FIONBIO"
+    elif test "x$ac_cv_func_ioctlsocket_fionbio" = "xyes"; then
+      tst_method="ioctlsocket FIONBIO"
+    elif test "x$ac_cv_func_ioctlsocket_camel_fionbio" = "xyes"; then
+      tst_method="IoctlSocket FIONBIO"
+    elif test "x$ac_cv_func_setsockopt_so_nonblock" = "xyes"; then
+      tst_method="setsockopt SO_NONBLOCK"
+    fi
+    AC_MSG_RESULT([$tst_method])
+    if test "$tst_method" = "unknown"; then
+      AC_MSG_WARN([cannot determine non-blocking socket method.])
+    fi
+  fi
+  if test "$tst_method" = "unknown"; then
+    AC_DEFINE_UNQUOTED(USE_BLOCKING_SOCKETS, 1,
+      [Define to disable non-blocking sockets.])
+    AC_MSG_WARN([non-blocking sockets disabled.])
+  fi
+])
+
+
+dnl CARES_CONFIGURE_SYMBOL_HIDING
+dnl -------------------------------------------------
+dnl Depending on --enable-symbol-hiding or --disable-symbol-hiding
+dnl configure option, and compiler capability to actually honor such
+dnl option, this will modify compiler flags as appropriate and also
+dnl provide needed definitions for configuration file.
+dnl This macro should not be used until all compilation tests have
+dnl been done to prevent interferences on other tests.
+
+AC_DEFUN([CARES_CONFIGURE_SYMBOL_HIDING], [
+  AC_MSG_CHECKING([whether hiding of library internal symbols will actually happen])
+  if test x"$ac_cv_native_windows" != "xyes" &&
+    test "$want_symbol_hiding" = "yes" &&
+    test "$supports_symbol_hiding" = "yes"; then
+    CFLAGS="$CFLAGS $symbol_hiding_CFLAGS"
+    AC_DEFINE_UNQUOTED(CARES_SYMBOL_HIDING, 1,
+      [Define to 1 to enable hiding of library internal symbols.])
+    AC_DEFINE_UNQUOTED(CARES_SYMBOL_SCOPE_EXTERN, $symbol_hiding_EXTERN,
+      [Definition to make a library symbol externally visible.])
+    AC_MSG_RESULT([yes])
+  else
+    AC_MSG_RESULT([no])
+  fi
+])
+
diff --git a/m4/cares-functions.m4 b/m4/cares-functions.m4
new file mode 100644
index 0000000..5d052d0
--- /dev/null
+++ b/m4/cares-functions.m4
@@ -0,0 +1,3235 @@
+#***************************************************************************
+# $Id: cares-functions.m4,v 1.39 2009-11-16 01:56:16 yangtse Exp $
+#
+# Copyright (C) 2008 - 2009 by Daniel Stenberg et al
+#
+# Permission to use, copy, modify, and distribute this software and its
+# documentation for any purpose and without fee is hereby granted, provided
+# that the above copyright notice appear in all copies and that both that
+# copyright notice and this permission notice appear in supporting
+# documentation, and that the name of M.I.T. not be used in advertising or
+# publicity pertaining to distribution of the software without specific,
+# written prior permission.  M.I.T. makes no representations about the
+# suitability of this software for any purpose.  It is provided "as is"
+# without express or implied warranty.
+#
+#***************************************************************************
+
+# File version for 'aclocal' use. Keep it a single number.
+# serial 39
+
+
+dnl CARES_INCLUDES_ARPA_INET
+dnl -------------------------------------------------
+dnl Set up variable with list of headers that must be
+dnl included when arpa/inet.h is to be included.
+
+AC_DEFUN([CARES_INCLUDES_ARPA_INET], [
+cares_includes_arpa_inet="\
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#  include <sys/socket.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#  include <netinet/in.h>
+#endif
+#ifdef HAVE_ARPA_INET_H
+#  include <arpa/inet.h>
+#endif
+/* includes end */"
+  AC_CHECK_HEADERS(
+    sys/types.h sys/socket.h netinet/in.h arpa/inet.h,
+    [], [], [$cares_includes_arpa_inet])
+])
+
+
+dnl CARES_INCLUDES_FCNTL
+dnl -------------------------------------------------
+dnl Set up variable with list of headers that must be
+dnl included when fcntl.h is to be included.
+
+AC_DEFUN([CARES_INCLUDES_FCNTL], [
+cares_includes_fcntl="\
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#  include <unistd.h>
+#endif
+#ifdef HAVE_FCNTL_H
+#  include <fcntl.h>
+#endif
+/* includes end */"
+  AC_CHECK_HEADERS(
+    sys/types.h unistd.h fcntl.h,
+    [], [], [$cares_includes_fcntl])
+])
+
+
+dnl CARES_INCLUDES_NETDB
+dnl -------------------------------------------------
+dnl Set up variable with list of headers that must be
+dnl included when netdb.h is to be included.
+
+AC_DEFUN([CARES_INCLUDES_NETDB], [
+cares_includes_netdb="\
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_NETDB_H
+#  include <netdb.h>
+#endif
+/* includes end */"
+  AC_CHECK_HEADERS(
+    sys/types.h netdb.h,
+    [], [], [$cares_includes_netdb])
+])
+
+
+dnl CARES_INCLUDES_SOCKET
+dnl -------------------------------------------------
+dnl Set up variable with list of headers that must be
+dnl included when socket.h is to be included.
+
+AC_DEFUN([CARES_INCLUDES_SOCKET], [
+cares_includes_socket="\
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_SOCKET_H
+#  include <socket.h>
+#endif
+/* includes end */"
+  AC_CHECK_HEADERS(
+    sys/types.h socket.h,
+    [], [], [$cares_includes_socket])
+])
+
+
+dnl CARES_INCLUDES_STDLIB
+dnl -------------------------------------------------
+dnl Set up variable with list of headers that must be
+dnl included when stdlib.h is to be included.
+
+AC_DEFUN([CARES_INCLUDES_STDLIB], [
+cares_includes_stdlib="\
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_STDLIB_H
+#  include <stdlib.h>
+#endif
+/* includes end */"
+  AC_CHECK_HEADERS(
+    sys/types.h stdlib.h,
+    [], [], [$cares_includes_stdlib])
+])
+
+
+dnl CARES_INCLUDES_STRING
+dnl -------------------------------------------------
+dnl Set up variable with list of headers that must be
+dnl included when string(s).h is to be included.
+
+AC_DEFUN([CARES_INCLUDES_STRING], [
+cares_includes_string="\
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_STRING_H
+#  include <string.h>
+#endif
+#ifdef HAVE_STRINGS_H
+#  include <strings.h>
+#endif
+/* includes end */"
+  AC_CHECK_HEADERS(
+    sys/types.h string.h strings.h,
+    [], [], [$cares_includes_string])
+])
+
+
+dnl CARES_INCLUDES_STROPTS
+dnl -------------------------------------------------
+dnl Set up variable with list of headers that must be
+dnl included when stropts.h is to be included.
+
+AC_DEFUN([CARES_INCLUDES_STROPTS], [
+cares_includes_stropts="\
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#  include <unistd.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#  include <sys/socket.h>
+#endif
+#ifdef HAVE_SYS_IOCTL_H
+#  include <sys/ioctl.h>
+#endif
+#ifdef HAVE_STROPTS_H
+#  include <stropts.h>
+#endif
+/* includes end */"
+  AC_CHECK_HEADERS(
+    sys/types.h unistd.h sys/socket.h sys/ioctl.h stropts.h,
+    [], [], [$cares_includes_stropts])
+])
+
+
+dnl CARES_INCLUDES_SYS_SOCKET
+dnl -------------------------------------------------
+dnl Set up variable with list of headers that must be
+dnl included when sys/socket.h is to be included.
+
+AC_DEFUN([CARES_INCLUDES_SYS_SOCKET], [
+cares_includes_sys_socket="\
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#  include <sys/socket.h>
+#endif
+/* includes end */"
+  AC_CHECK_HEADERS(
+    sys/types.h sys/socket.h,
+    [], [], [$cares_includes_sys_socket])
+])
+
+
+dnl CARES_INCLUDES_SYS_TYPES
+dnl -------------------------------------------------
+dnl Set up variable with list of headers that must be
+dnl included when sys/types.h is to be included.
+
+AC_DEFUN([CARES_INCLUDES_SYS_TYPES], [
+cares_includes_sys_types="\
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+/* includes end */"
+  AC_CHECK_HEADERS(
+    sys/types.h,
+    [], [], [$cares_includes_sys_types])
+])
+
+
+dnl CARES_INCLUDES_SYS_UIO
+dnl -------------------------------------------------
+dnl Set up variable with list of headers that must be
+dnl included when sys/uio.h is to be included.
+
+AC_DEFUN([CARES_INCLUDES_SYS_UIO], [
+cares_includes_sys_uio="\
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_UIO_H
+#  include <sys/uio.h>
+#endif
+/* includes end */"
+  AC_CHECK_HEADERS(
+    sys/types.h sys/uio.h,
+    [], [], [$cares_includes_sys_uio])
+])
+
+
+dnl CARES_INCLUDES_UNISTD
+dnl -------------------------------------------------
+dnl Set up variable with list of headers that must be
+dnl included when unistd.h is to be included.
+
+AC_DEFUN([CARES_INCLUDES_UNISTD], [
+cares_includes_unistd="\
+/* includes start */
+#ifdef HAVE_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#  include <unistd.h>
+#endif
+/* includes end */"
+  AC_CHECK_HEADERS(
+    sys/types.h unistd.h,
+    [], [], [$cares_includes_unistd])
+])
+
+
+dnl CARES_INCLUDES_WINSOCK2
+dnl -------------------------------------------------
+dnl Set up variable with list of headers that must be
+dnl included when winsock(2).h is to be included.
+
+AC_DEFUN([CARES_INCLUDES_WINSOCK2], [
+cares_includes_winsock2="\
+/* includes start */
+#ifdef HAVE_WINDOWS_H
+#  ifndef WIN32_LEAN_AND_MEAN
+#    define WIN32_LEAN_AND_MEAN
+#  endif
+#  include <windows.h>
+#  ifdef HAVE_WINSOCK2_H
+#    include <winsock2.h>
+#  else
+#    ifdef HAVE_WINSOCK_H
+#      include <winsock.h>
+#    endif
+#  endif
+#endif
+/* includes end */"
+  CURL_CHECK_HEADER_WINDOWS
+  CURL_CHECK_HEADER_WINSOCK
+  CURL_CHECK_HEADER_WINSOCK2
+])
+
+
+dnl CARES_INCLUDES_WS2TCPIP
+dnl -------------------------------------------------
+dnl Set up variable with list of headers that must be
+dnl included when ws2tcpip.h is to be included.
+
+AC_DEFUN([CARES_INCLUDES_WS2TCPIP], [
+cares_includes_ws2tcpip="\
+/* includes start */
+#ifdef HAVE_WINDOWS_H
+#  ifndef WIN32_LEAN_AND_MEAN
+#    define WIN32_LEAN_AND_MEAN
+#  endif
+#  include <windows.h>
+#  ifdef HAVE_WINSOCK2_H
+#    include <winsock2.h>
+#    ifdef HAVE_WS2TCPIP_H
+#       include <ws2tcpip.h>
+#    endif
+#  endif
+#endif
+/* includes end */"
+  CURL_CHECK_HEADER_WINDOWS
+  CURL_CHECK_HEADER_WINSOCK2
+  CURL_CHECK_HEADER_WS2TCPIP
+])
+
+
+dnl CARES_PREPROCESS_CALLCONV
+dnl -------------------------------------------------
+dnl Set up variable with a preprocessor block which
+dnl defines function calling convention.
+
+AC_DEFUN([CARES_PREPROCESS_CALLCONV], [
+cares_preprocess_callconv="\
+/* preprocess start */
+#ifdef HAVE_WINDOWS_H
+#  define FUNCALLCONV __stdcall
+#else
+#  define FUNCALLCONV
+#endif
+/* preprocess end */"
+])
+
+
+dnl CARES_CHECK_FUNC_CLOSESOCKET
+dnl -------------------------------------------------
+dnl Verify if closesocket is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_closesocket, then
+dnl HAVE_CLOSESOCKET will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_CLOSESOCKET], [
+  AC_REQUIRE([CARES_INCLUDES_WINSOCK2])dnl
+  AC_REQUIRE([CARES_INCLUDES_SOCKET])dnl
+  #
+  tst_links_closesocket="unknown"
+  tst_proto_closesocket="unknown"
+  tst_compi_closesocket="unknown"
+  tst_allow_closesocket="unknown"
+  #
+  AC_MSG_CHECKING([if closesocket can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_PROGRAM([[
+      $cares_includes_winsock2
+      $cares_includes_socket
+    ]],[[
+      if(0 != closesocket(0))
+        return 1;
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_closesocket="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_closesocket="no"
+  ])
+  #
+  if test "$tst_links_closesocket" = "yes"; then
+    AC_MSG_CHECKING([if closesocket is prototyped])
+    AC_EGREP_CPP([closesocket],[
+      $cares_includes_winsock2
+      $cares_includes_socket
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_closesocket="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_closesocket="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_closesocket" = "yes"; then
+    AC_MSG_CHECKING([if closesocket is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_winsock2
+        $cares_includes_socket
+      ]],[[
+        if(0 != closesocket(0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_closesocket="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_closesocket="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_closesocket" = "yes"; then
+    AC_MSG_CHECKING([if closesocket usage allowed])
+    if test "x$cares_disallow_closesocket" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_closesocket="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_closesocket="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if closesocket might be used])
+  if test "$tst_links_closesocket" = "yes" &&
+     test "$tst_proto_closesocket" = "yes" &&
+     test "$tst_compi_closesocket" = "yes" &&
+     test "$tst_allow_closesocket" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_CLOSESOCKET, 1,
+      [Define to 1 if you have the closesocket function.])
+    ac_cv_func_closesocket="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_closesocket="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_CLOSESOCKET_CAMEL
+dnl -------------------------------------------------
+dnl Verify if CloseSocket is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_closesocket_camel,
+dnl then HAVE_CLOSESOCKET_CAMEL will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_CLOSESOCKET_CAMEL], [
+  AC_REQUIRE([CARES_INCLUDES_SYS_SOCKET])dnl
+  #
+  tst_links_closesocket_camel="unknown"
+  tst_proto_closesocket_camel="unknown"
+  tst_compi_closesocket_camel="unknown"
+  tst_allow_closesocket_camel="unknown"
+  #
+  AC_MSG_CHECKING([if CloseSocket can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_PROGRAM([[
+      $cares_includes_sys_socket
+    ]],[[
+      if(0 != CloseSocket(0))
+        return 1;
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_closesocket_camel="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_closesocket_camel="no"
+  ])
+  #
+  if test "$tst_links_closesocket_camel" = "yes"; then
+    AC_MSG_CHECKING([if CloseSocket is prototyped])
+    AC_EGREP_CPP([CloseSocket],[
+      $cares_includes_sys_socket
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_closesocket_camel="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_closesocket_camel="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_closesocket_camel" = "yes"; then
+    AC_MSG_CHECKING([if CloseSocket is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_sys_socket
+      ]],[[
+        if(0 != CloseSocket(0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_closesocket_camel="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_closesocket_camel="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_closesocket_camel" = "yes"; then
+    AC_MSG_CHECKING([if CloseSocket usage allowed])
+    if test "x$cares_disallow_closesocket_camel" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_closesocket_camel="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_closesocket_camel="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if CloseSocket might be used])
+  if test "$tst_links_closesocket_camel" = "yes" &&
+     test "$tst_proto_closesocket_camel" = "yes" &&
+     test "$tst_compi_closesocket_camel" = "yes" &&
+     test "$tst_allow_closesocket_camel" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_CLOSESOCKET_CAMEL, 1,
+      [Define to 1 if you have the CloseSocket camel case function.])
+    ac_cv_func_closesocket_camel="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_closesocket_camel="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_CONNECT
+dnl -------------------------------------------------
+dnl Verify if connect is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_connect, then
+dnl HAVE_CONNECT will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_CONNECT], [
+  AC_REQUIRE([CARES_INCLUDES_WINSOCK2])dnl
+  AC_REQUIRE([CARES_INCLUDES_SYS_SOCKET])dnl
+  AC_REQUIRE([CARES_INCLUDES_SOCKET])dnl
+  #
+  tst_links_connect="unknown"
+  tst_proto_connect="unknown"
+  tst_compi_connect="unknown"
+  tst_allow_connect="unknown"
+  #
+  AC_MSG_CHECKING([if connect can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_PROGRAM([[
+      $cares_includes_winsock2
+      $cares_includes_sys_socket
+      $cares_includes_socket
+    ]],[[
+      if(0 != connect(0, 0, 0))
+        return 1;
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_connect="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_connect="no"
+  ])
+  #
+  if test "$tst_links_connect" = "yes"; then
+    AC_MSG_CHECKING([if connect is prototyped])
+    AC_EGREP_CPP([connect],[
+      $cares_includes_winsock2
+      $cares_includes_sys_socket
+      $cares_includes_socket
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_connect="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_connect="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_connect" = "yes"; then
+    AC_MSG_CHECKING([if connect is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_winsock2
+        $cares_includes_sys_socket
+        $cares_includes_socket
+      ]],[[
+        if(0 != connect(0, 0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_connect="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_connect="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_connect" = "yes"; then
+    AC_MSG_CHECKING([if connect usage allowed])
+    if test "x$cares_disallow_connect" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_connect="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_connect="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if connect might be used])
+  if test "$tst_links_connect" = "yes" &&
+     test "$tst_proto_connect" = "yes" &&
+     test "$tst_compi_connect" = "yes" &&
+     test "$tst_allow_connect" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_CONNECT, 1,
+      [Define to 1 if you have the connect function.])
+    ac_cv_func_connect="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_connect="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_FCNTL
+dnl -------------------------------------------------
+dnl Verify if fcntl is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_fcntl, then
+dnl HAVE_FCNTL will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_FCNTL], [
+  AC_REQUIRE([CARES_INCLUDES_FCNTL])dnl
+  #
+  tst_links_fcntl="unknown"
+  tst_proto_fcntl="unknown"
+  tst_compi_fcntl="unknown"
+  tst_allow_fcntl="unknown"
+  #
+  AC_MSG_CHECKING([if fcntl can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([fcntl])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_fcntl="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_fcntl="no"
+  ])
+  #
+  if test "$tst_links_fcntl" = "yes"; then
+    AC_MSG_CHECKING([if fcntl is prototyped])
+    AC_EGREP_CPP([fcntl],[
+      $cares_includes_fcntl
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_fcntl="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_fcntl="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_fcntl" = "yes"; then
+    AC_MSG_CHECKING([if fcntl is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_fcntl
+      ]],[[
+        if(0 != fcntl(0, 0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_fcntl="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_fcntl="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_fcntl" = "yes"; then
+    AC_MSG_CHECKING([if fcntl usage allowed])
+    if test "x$cares_disallow_fcntl" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_fcntl="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_fcntl="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if fcntl might be used])
+  if test "$tst_links_fcntl" = "yes" &&
+     test "$tst_proto_fcntl" = "yes" &&
+     test "$tst_compi_fcntl" = "yes" &&
+     test "$tst_allow_fcntl" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_FCNTL, 1,
+      [Define to 1 if you have the fcntl function.])
+    ac_cv_func_fcntl="yes"
+    CARES_CHECK_FUNC_FCNTL_O_NONBLOCK
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_fcntl="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_FCNTL_O_NONBLOCK
+dnl -------------------------------------------------
+dnl Verify if fcntl with status flag O_NONBLOCK is
+dnl available, can be compiled, and seems to work. If
+dnl all of these are true, then HAVE_FCNTL_O_NONBLOCK
+dnl will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_FCNTL_O_NONBLOCK], [
+  #
+  tst_compi_fcntl_o_nonblock="unknown"
+  tst_allow_fcntl_o_nonblock="unknown"
+  #
+  case $host_os in
+    sunos4* | aix3* | beos*)
+      dnl O_NONBLOCK does not work on these platforms
+      cares_disallow_fcntl_o_nonblock="yes"
+      ;;
+  esac
+  #
+  if test "$ac_cv_func_fcntl" = "yes"; then
+    AC_MSG_CHECKING([if fcntl O_NONBLOCK is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_fcntl
+      ]],[[
+        int flags = 0;
+        if(0 != fcntl(0, F_SETFL, flags | O_NONBLOCK))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_fcntl_o_nonblock="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_fcntl_o_nonblock="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_fcntl_o_nonblock" = "yes"; then
+    AC_MSG_CHECKING([if fcntl O_NONBLOCK usage allowed])
+    if test "x$cares_disallow_fcntl_o_nonblock" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_fcntl_o_nonblock="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_fcntl_o_nonblock="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if fcntl O_NONBLOCK might be used])
+  if test "$tst_compi_fcntl_o_nonblock" = "yes" &&
+     test "$tst_allow_fcntl_o_nonblock" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_FCNTL_O_NONBLOCK, 1,
+      [Define to 1 if you have a working fcntl O_NONBLOCK function.])
+    ac_cv_func_fcntl_o_nonblock="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_fcntl_o_nonblock="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_FREEADDRINFO
+dnl -------------------------------------------------
+dnl Verify if freeaddrinfo is available, prototyped,
+dnl and can be compiled. If all of these are true,
+dnl and usage has not been previously disallowed with
+dnl shell variable cares_disallow_freeaddrinfo, then
+dnl HAVE_FREEADDRINFO will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_FREEADDRINFO], [
+  AC_REQUIRE([CARES_INCLUDES_WS2TCPIP])dnl
+  AC_REQUIRE([CARES_INCLUDES_SYS_SOCKET])dnl
+  AC_REQUIRE([CARES_INCLUDES_NETDB])dnl
+  #
+  tst_links_freeaddrinfo="unknown"
+  tst_proto_freeaddrinfo="unknown"
+  tst_compi_freeaddrinfo="unknown"
+  tst_allow_freeaddrinfo="unknown"
+  #
+  AC_MSG_CHECKING([if freeaddrinfo can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_PROGRAM([[
+      $cares_includes_ws2tcpip
+      $cares_includes_sys_socket
+      $cares_includes_netdb
+    ]],[[
+      freeaddrinfo(0);
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_freeaddrinfo="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_freeaddrinfo="no"
+  ])
+  #
+  if test "$tst_links_freeaddrinfo" = "yes"; then
+    AC_MSG_CHECKING([if freeaddrinfo is prototyped])
+    AC_EGREP_CPP([freeaddrinfo],[
+      $cares_includes_ws2tcpip
+      $cares_includes_sys_socket
+      $cares_includes_netdb
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_freeaddrinfo="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_freeaddrinfo="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_freeaddrinfo" = "yes"; then
+    AC_MSG_CHECKING([if freeaddrinfo is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_ws2tcpip
+        $cares_includes_sys_socket
+        $cares_includes_netdb
+      ]],[[
+        freeaddrinfo(0);
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_freeaddrinfo="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_freeaddrinfo="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_freeaddrinfo" = "yes"; then
+    AC_MSG_CHECKING([if freeaddrinfo usage allowed])
+    if test "x$cares_disallow_freeaddrinfo" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_freeaddrinfo="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_freeaddrinfo="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if freeaddrinfo might be used])
+  if test "$tst_links_freeaddrinfo" = "yes" &&
+     test "$tst_proto_freeaddrinfo" = "yes" &&
+     test "$tst_compi_freeaddrinfo" = "yes" &&
+     test "$tst_allow_freeaddrinfo" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_FREEADDRINFO, 1,
+      [Define to 1 if you have the freeaddrinfo function.])
+    ac_cv_func_freeaddrinfo="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_freeaddrinfo="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_GETADDRINFO
+dnl -------------------------------------------------
+dnl Verify if getaddrinfo is available, prototyped, can
+dnl be compiled and seems to work. If all of these are
+dnl true, and usage has not been previously disallowed
+dnl with shell variable cares_disallow_getaddrinfo, then
+dnl HAVE_GETADDRINFO will be defined. Additionally when
+dnl HAVE_GETADDRINFO gets defined this will also attempt
+dnl to find out if getaddrinfo happens to be threadsafe,
+dnl defining HAVE_GETADDRINFO_THREADSAFE when true.
+
+AC_DEFUN([CARES_CHECK_FUNC_GETADDRINFO], [
+  AC_REQUIRE([CARES_INCLUDES_WS2TCPIP])dnl
+  AC_REQUIRE([CARES_INCLUDES_STDLIB])dnl
+  AC_REQUIRE([CARES_INCLUDES_STRING])dnl
+  AC_REQUIRE([CARES_INCLUDES_SYS_SOCKET])dnl
+  AC_REQUIRE([CARES_INCLUDES_NETDB])dnl
+  #
+  tst_links_getaddrinfo="unknown"
+  tst_proto_getaddrinfo="unknown"
+  tst_compi_getaddrinfo="unknown"
+  tst_works_getaddrinfo="unknown"
+  tst_allow_getaddrinfo="unknown"
+  tst_tsafe_getaddrinfo="unknown"
+  #
+  AC_MSG_CHECKING([if getaddrinfo can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_PROGRAM([[
+      $cares_includes_ws2tcpip
+      $cares_includes_sys_socket
+      $cares_includes_netdb
+    ]],[[
+      if(0 != getaddrinfo(0, 0, 0, 0))
+        return 1;
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_getaddrinfo="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_getaddrinfo="no"
+  ])
+  #
+  if test "$tst_links_getaddrinfo" = "yes"; then
+    AC_MSG_CHECKING([if getaddrinfo is prototyped])
+    AC_EGREP_CPP([getaddrinfo],[
+      $cares_includes_ws2tcpip
+      $cares_includes_sys_socket
+      $cares_includes_netdb
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_getaddrinfo="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_getaddrinfo="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_getaddrinfo" = "yes"; then
+    AC_MSG_CHECKING([if getaddrinfo is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_ws2tcpip
+        $cares_includes_sys_socket
+        $cares_includes_netdb
+      ]],[[
+        if(0 != getaddrinfo(0, 0, 0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_getaddrinfo="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_getaddrinfo="no"
+    ])
+  fi
+  #
+  dnl only do runtime verification when not cross-compiling
+  if test "x$cross_compiling" != "xyes" &&
+    test "$tst_compi_getaddrinfo" = "yes"; then
+    AC_MSG_CHECKING([if getaddrinfo seems to work])
+    AC_RUN_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_ws2tcpip
+        $cares_includes_stdlib
+        $cares_includes_string
+        $cares_includes_sys_socket
+        $cares_includes_netdb
+      ]],[[
+        struct addrinfo hints;
+        struct addrinfo *ai = 0;
+        int error;
+
+        memset(&hints, 0, sizeof(hints));
+        hints.ai_flags = AI_NUMERICHOST;
+        hints.ai_family = AF_UNSPEC;
+        hints.ai_socktype = SOCK_STREAM;
+        error = getaddrinfo("127.0.0.1", 0, &hints, &ai);
+        if(error || !ai)
+          exit(1); /* fail */
+        else
+          exit(0);
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_works_getaddrinfo="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_works_getaddrinfo="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_getaddrinfo" = "yes" &&
+    test "$tst_works_getaddrinfo" != "no"; then
+    AC_MSG_CHECKING([if getaddrinfo usage allowed])
+    if test "x$cares_disallow_getaddrinfo" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_getaddrinfo="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_getaddrinfo="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if getaddrinfo might be used])
+  if test "$tst_links_getaddrinfo" = "yes" &&
+     test "$tst_proto_getaddrinfo" = "yes" &&
+     test "$tst_compi_getaddrinfo" = "yes" &&
+     test "$tst_allow_getaddrinfo" = "yes" &&
+     test "$tst_works_getaddrinfo" != "no"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_GETADDRINFO, 1,
+      [Define to 1 if you have a working getaddrinfo function.])
+    ac_cv_func_getaddrinfo="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_getaddrinfo="no"
+    ac_cv_func_getaddrinfo_threadsafe="no"
+  fi
+  #
+  if test "$ac_cv_func_getaddrinfo" = "yes"; then
+    AC_MSG_CHECKING([if getaddrinfo is threadsafe])
+    case $host_os in
+      aix[[1234]].* | aix5.[[01]].*)
+        dnl aix 5.1 and older
+        tst_tsafe_getaddrinfo="no"
+        ;;
+      aix*)
+        dnl aix 5.2 and newer
+        tst_tsafe_getaddrinfo="yes"
+        ;;
+      darwin[[12345]].*)
+        dnl darwin 5.0 and mac os x 10.1.X and older
+        tst_tsafe_getaddrinfo="no"
+        ;;
+      darwin*)
+        dnl darwin 6.0 and mac os x 10.2.X and newer
+        tst_tsafe_getaddrinfo="yes"
+        ;;
+      freebsd[[1234]].* | freebsd5.[[1234]]*)
+        dnl freebsd 5.4 and older
+        tst_tsafe_getaddrinfo="no"
+        ;;
+      freebsd*)
+        dnl freebsd 5.5 and newer
+        tst_tsafe_getaddrinfo="yes"
+        ;;
+      hpux[[123456789]].* | hpux10.* | hpux11.0* | hpux11.10*)
+        dnl hpux 11.10 and older
+        tst_tsafe_getaddrinfo="no"
+        ;;
+      hpux*)
+        dnl hpux 11.11 and newer
+        tst_tsafe_getaddrinfo="yes"
+        ;;
+      netbsd[[123]].*)
+        dnl netbsd 3.X and older
+        tst_tsafe_getaddrinfo="no"
+        ;;
+      netbsd*)
+        dnl netbsd 4.X and newer
+        tst_tsafe_getaddrinfo="yes"
+        ;;
+      *bsd*)
+        dnl All other bsd's
+        tst_tsafe_getaddrinfo="no"
+        ;;
+      solaris2*)
+        dnl solaris which have it
+        tst_tsafe_getaddrinfo="yes"
+        ;;
+    esac
+    if test "$tst_tsafe_getaddrinfo" = "unknown"; then
+      CURL_CHECK_DEF_CC([h_errno], [
+        $cares_includes_ws2tcpip
+        $cares_includes_sys_socket
+        $cares_includes_netdb
+        ], [silent])
+      if test "$curl_cv_have_def_h_errno" = "no"; then
+        tst_tsafe_getaddrinfo="no"
+      fi
+    fi
+    if test "$tst_tsafe_getaddrinfo" = "unknown"; then
+      tst_tsafe_getaddrinfo="yes"
+    fi
+    AC_MSG_RESULT([$tst_tsafe_getaddrinfo])
+    if test "$tst_tsafe_getaddrinfo" = "yes"; then
+      AC_DEFINE_UNQUOTED(HAVE_GETADDRINFO_THREADSAFE, 1,
+        [Define to 1 if the getaddrinfo function is threadsafe.])
+      ac_cv_func_getaddrinfo_threadsafe="yes"
+    else
+      ac_cv_func_getaddrinfo_threadsafe="no"
+    fi
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_GETHOSTBYADDR
+dnl -------------------------------------------------
+dnl Verify if gethostbyaddr is available, prototyped,
+dnl and can be compiled. If all of these are true,
+dnl and usage has not been previously disallowed with
+dnl shell variable cares_disallow_gethostbyaddr, then
+dnl HAVE_GETHOSTBYADDR will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_GETHOSTBYADDR], [
+  AC_REQUIRE([CARES_INCLUDES_WINSOCK2])dnl
+  AC_REQUIRE([CARES_INCLUDES_NETDB])dnl
+  #
+  tst_links_gethostbyaddr="unknown"
+  tst_proto_gethostbyaddr="unknown"
+  tst_compi_gethostbyaddr="unknown"
+  tst_allow_gethostbyaddr="unknown"
+  #
+  AC_MSG_CHECKING([if gethostbyaddr can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_PROGRAM([[
+      $cares_includes_winsock2
+      $cares_includes_netdb
+    ]],[[
+      if(0 != gethostbyaddr(0, 0, 0))
+        return 1;
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_gethostbyaddr="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_gethostbyaddr="no"
+  ])
+  #
+  if test "$tst_links_gethostbyaddr" = "yes"; then
+    AC_MSG_CHECKING([if gethostbyaddr is prototyped])
+    AC_EGREP_CPP([gethostbyaddr],[
+      $cares_includes_winsock2
+      $cares_includes_netdb
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_gethostbyaddr="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_gethostbyaddr="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_gethostbyaddr" = "yes"; then
+    AC_MSG_CHECKING([if gethostbyaddr is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_winsock2
+        $cares_includes_netdb
+      ]],[[
+        if(0 != gethostbyaddr(0, 0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_gethostbyaddr="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_gethostbyaddr="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_gethostbyaddr" = "yes"; then
+    AC_MSG_CHECKING([if gethostbyaddr usage allowed])
+    if test "x$cares_disallow_gethostbyaddr" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_gethostbyaddr="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_gethostbyaddr="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if gethostbyaddr might be used])
+  if test "$tst_links_gethostbyaddr" = "yes" &&
+     test "$tst_proto_gethostbyaddr" = "yes" &&
+     test "$tst_compi_gethostbyaddr" = "yes" &&
+     test "$tst_allow_gethostbyaddr" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_GETHOSTBYADDR, 1,
+      [Define to 1 if you have the gethostbyaddr function.])
+    ac_cv_func_gethostbyaddr="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_gethostbyaddr="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_GETHOSTBYNAME
+dnl -------------------------------------------------
+dnl Verify if gethostbyname is available, prototyped,
+dnl and can be compiled. If all of these are true,
+dnl and usage has not been previously disallowed with
+dnl shell variable cares_disallow_gethostbyname, then
+dnl HAVE_GETHOSTBYNAME will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_GETHOSTBYNAME], [
+  AC_REQUIRE([CARES_INCLUDES_WINSOCK2])dnl
+  AC_REQUIRE([CARES_INCLUDES_NETDB])dnl
+  #
+  tst_links_gethostbyname="unknown"
+  tst_proto_gethostbyname="unknown"
+  tst_compi_gethostbyname="unknown"
+  tst_allow_gethostbyname="unknown"
+  #
+  AC_MSG_CHECKING([if gethostbyname can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_PROGRAM([[
+      $cares_includes_winsock2
+      $cares_includes_netdb
+    ]],[[
+      if(0 != gethostbyname(0))
+        return 1;
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_gethostbyname="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_gethostbyname="no"
+  ])
+  #
+  if test "$tst_links_gethostbyname" = "yes"; then
+    AC_MSG_CHECKING([if gethostbyname is prototyped])
+    AC_EGREP_CPP([gethostbyname],[
+      $cares_includes_winsock2
+      $cares_includes_netdb
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_gethostbyname="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_gethostbyname="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_gethostbyname" = "yes"; then
+    AC_MSG_CHECKING([if gethostbyname is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_winsock2
+        $cares_includes_netdb
+      ]],[[
+        if(0 != gethostbyname(0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_gethostbyname="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_gethostbyname="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_gethostbyname" = "yes"; then
+    AC_MSG_CHECKING([if gethostbyname usage allowed])
+    if test "x$cares_disallow_gethostbyname" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_gethostbyname="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_gethostbyname="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if gethostbyname might be used])
+  if test "$tst_links_gethostbyname" = "yes" &&
+     test "$tst_proto_gethostbyname" = "yes" &&
+     test "$tst_compi_gethostbyname" = "yes" &&
+     test "$tst_allow_gethostbyname" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_GETHOSTBYNAME, 1,
+      [Define to 1 if you have the gethostbyname function.])
+    ac_cv_func_gethostbyname="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_gethostbyname="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_GETHOSTNAME
+dnl -------------------------------------------------
+dnl Verify if gethostname is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_gethostname, then
+dnl HAVE_GETHOSTNAME will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_GETHOSTNAME], [
+  AC_REQUIRE([CARES_INCLUDES_WINSOCK2])dnl
+  AC_REQUIRE([CARES_INCLUDES_UNISTD])dnl
+  #
+  tst_links_gethostname="unknown"
+  tst_proto_gethostname="unknown"
+  tst_compi_gethostname="unknown"
+  tst_allow_gethostname="unknown"
+  #
+  AC_MSG_CHECKING([if gethostname can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_PROGRAM([[
+      $cares_includes_winsock2
+      $cares_includes_unistd
+    ]],[[
+      if(0 != gethostname(0, 0))
+        return 1;
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_gethostname="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_gethostname="no"
+  ])
+  #
+  if test "$tst_links_gethostname" = "yes"; then
+    AC_MSG_CHECKING([if gethostname is prototyped])
+    AC_EGREP_CPP([gethostname],[
+      $cares_includes_winsock2
+      $cares_includes_unistd
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_gethostname="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_gethostname="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_gethostname" = "yes"; then
+    AC_MSG_CHECKING([if gethostname is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_winsock2
+        $cares_includes_unistd
+      ]],[[
+        if(0 != gethostname(0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_gethostname="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_gethostname="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_gethostname" = "yes"; then
+    AC_MSG_CHECKING([if gethostname usage allowed])
+    if test "x$cares_disallow_gethostname" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_gethostname="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_gethostname="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if gethostname might be used])
+  if test "$tst_links_gethostname" = "yes" &&
+     test "$tst_proto_gethostname" = "yes" &&
+     test "$tst_compi_gethostname" = "yes" &&
+     test "$tst_allow_gethostname" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_GETHOSTNAME, 1,
+      [Define to 1 if you have the gethostname function.])
+    ac_cv_func_gethostname="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_gethostname="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_GETSERVBYPORT_R
+dnl -------------------------------------------------
+dnl Verify if getservbyport_r is available, prototyped,
+dnl and can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_getservbyport_r, then
+dnl HAVE_GETSERVBYPORT_R will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_GETSERVBYPORT_R], [
+  AC_REQUIRE([CARES_INCLUDES_NETDB])dnl
+  #
+  tst_links_getservbyport_r="unknown"
+  tst_proto_getservbyport_r="unknown"
+  tst_compi_getservbyport_r="unknown"
+  tst_allow_getservbyport_r="unknown"
+  tst_nargs_getservbyport_r="unknown"
+  #
+  AC_MSG_CHECKING([if getservbyport_r can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([getservbyport_r])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_getservbyport_r="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_getservbyport_r="no"
+  ])
+  #
+  if test "$tst_links_getservbyport_r" = "yes"; then
+    AC_MSG_CHECKING([if getservbyport_r is prototyped])
+    AC_EGREP_CPP([getservbyport_r],[
+      $cares_includes_netdb
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_getservbyport_r="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_getservbyport_r="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_getservbyport_r" = "yes"; then
+    if test "$tst_nargs_getservbyport_r" = "unknown"; then
+      AC_MSG_CHECKING([if getservbyport_r takes 4 args.])
+      AC_COMPILE_IFELSE([
+        AC_LANG_PROGRAM([[
+          $cares_includes_netdb
+        ]],[[
+          if(0 != getservbyport_r(0, 0, 0, 0))
+            return 1;
+        ]])
+      ],[
+        AC_MSG_RESULT([yes])
+        tst_compi_getservbyport_r="yes"
+        tst_nargs_getservbyport_r="4"
+      ],[
+        AC_MSG_RESULT([no])
+        tst_compi_getservbyport_r="no"
+      ])
+    fi
+    if test "$tst_nargs_getservbyport_r" = "unknown"; then
+      AC_MSG_CHECKING([if getservbyport_r takes 5 args.])
+      AC_COMPILE_IFELSE([
+        AC_LANG_PROGRAM([[
+          $cares_includes_netdb
+        ]],[[
+          if(0 != getservbyport_r(0, 0, 0, 0, 0))
+            return 1;
+        ]])
+      ],[
+        AC_MSG_RESULT([yes])
+        tst_compi_getservbyport_r="yes"
+        tst_nargs_getservbyport_r="5"
+      ],[
+        AC_MSG_RESULT([no])
+        tst_compi_getservbyport_r="no"
+      ])
+    fi
+    if test "$tst_nargs_getservbyport_r" = "unknown"; then
+      AC_MSG_CHECKING([if getservbyport_r takes 6 args.])
+      AC_COMPILE_IFELSE([
+        AC_LANG_PROGRAM([[
+          $cares_includes_netdb
+        ]],[[
+          if(0 != getservbyport_r(0, 0, 0, 0, 0, 0))
+            return 1;
+        ]])
+      ],[
+        AC_MSG_RESULT([yes])
+        tst_compi_getservbyport_r="yes"
+        tst_nargs_getservbyport_r="6"
+      ],[
+        AC_MSG_RESULT([no])
+        tst_compi_getservbyport_r="no"
+      ])
+    fi
+    AC_MSG_CHECKING([if getservbyport_r is compilable])
+    if test "$tst_compi_getservbyport_r" = "yes"; then
+      AC_MSG_RESULT([yes])
+    else
+      AC_MSG_RESULT([no])
+    fi
+  fi
+  #
+  if test "$tst_compi_getservbyport_r" = "yes"; then
+    AC_MSG_CHECKING([if getservbyport_r usage allowed])
+    if test "x$cares_disallow_getservbyport_r" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_getservbyport_r="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_getservbyport_r="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if getservbyport_r might be used])
+  if test "$tst_links_getservbyport_r" = "yes" &&
+     test "$tst_proto_getservbyport_r" = "yes" &&
+     test "$tst_compi_getservbyport_r" = "yes" &&
+     test "$tst_allow_getservbyport_r" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_GETSERVBYPORT_R, 1,
+      [Define to 1 if you have the getservbyport_r function.])
+    AC_DEFINE_UNQUOTED(GETSERVBYPORT_R_ARGS, $tst_nargs_getservbyport_r,
+      [Specifies the number of arguments to getservbyport_r])
+    if test "$tst_nargs_getservbyport_r" -eq "4"; then
+      AC_DEFINE(GETSERVBYPORT_R_BUFSIZE, sizeof(struct servent_data),
+        [Specifies the size of the buffer to pass to getservbyport_r])
+    else
+      AC_DEFINE(GETSERVBYPORT_R_BUFSIZE, 4096,
+        [Specifies the size of the buffer to pass to getservbyport_r])
+    fi
+    ac_cv_func_getservbyport_r="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_getservbyport_r="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_INET_NTOP
+dnl -------------------------------------------------
+dnl Verify if inet_ntop is available, prototyped, can
+dnl be compiled and seems to work. If all of these are
+dnl true, and usage has not been previously disallowed
+dnl with shell variable cares_disallow_inet_ntop, then
+dnl HAVE_INET_NTOP will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_INET_NTOP], [
+  AC_REQUIRE([CARES_INCLUDES_STDLIB])dnl
+  AC_REQUIRE([CARES_INCLUDES_ARPA_INET])dnl
+  AC_REQUIRE([CARES_INCLUDES_STRING])dnl
+  #
+  tst_links_inet_ntop="unknown"
+  tst_proto_inet_ntop="unknown"
+  tst_compi_inet_ntop="unknown"
+  tst_works_inet_ntop="unknown"
+  tst_allow_inet_ntop="unknown"
+  #
+  AC_MSG_CHECKING([if inet_ntop can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([inet_ntop])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_inet_ntop="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_inet_ntop="no"
+  ])
+  #
+  if test "$tst_links_inet_ntop" = "yes"; then
+    AC_MSG_CHECKING([if inet_ntop is prototyped])
+    AC_EGREP_CPP([inet_ntop],[
+      $cares_includes_arpa_inet
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_inet_ntop="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_inet_ntop="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_inet_ntop" = "yes"; then
+    AC_MSG_CHECKING([if inet_ntop is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_arpa_inet
+      ]],[[
+        if(0 != inet_ntop(0, 0, 0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_inet_ntop="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_inet_ntop="no"
+    ])
+  fi
+  #
+  dnl only do runtime verification when not cross-compiling
+  if test "x$cross_compiling" != "xyes" &&
+    test "$tst_compi_inet_ntop" = "yes"; then
+    AC_MSG_CHECKING([if inet_ntop seems to work])
+    AC_RUN_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_stdlib
+        $cares_includes_arpa_inet
+        $cares_includes_string
+      ]],[[
+        char ipv6res[sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255")];
+        char ipv4res[sizeof "255.255.255.255"];
+        unsigned char ipv6a[26];
+        unsigned char ipv4a[5];
+        char *ipv6ptr = 0;
+        char *ipv4ptr = 0;
+        /* - */
+        ipv4res[0] = '\0';
+        ipv4a[0] = 0xc0;
+        ipv4a[1] = 0xa8;
+        ipv4a[2] = 0x64;
+        ipv4a[3] = 0x01;
+        ipv4a[4] = 0x01;
+        /* - */
+        ipv4ptr = inet_ntop(AF_INET, ipv4a, ipv4res, sizeof(ipv4res));
+        if(!ipv4ptr)
+          exit(1); /* fail */
+        if(ipv4ptr != ipv4res)
+          exit(1); /* fail */
+        if(!ipv4ptr[0])
+          exit(1); /* fail */
+        if(memcmp(ipv4res, "192.168.100.1", 13) != 0)
+          exit(1); /* fail */
+        /* - */
+        ipv6res[0] = '\0';
+        memset(ipv6a, 0, sizeof(ipv6a));
+        ipv6a[0] = 0xfe;
+        ipv6a[1] = 0x80;
+        ipv6a[8] = 0x02;
+        ipv6a[9] = 0x14;
+        ipv6a[10] = 0x4f;
+        ipv6a[11] = 0xff;
+        ipv6a[12] = 0xfe;
+        ipv6a[13] = 0x0b;
+        ipv6a[14] = 0x76;
+        ipv6a[15] = 0xc8;
+        ipv6a[25] = 0x01;
+        /* - */
+        ipv6ptr = inet_ntop(AF_INET6, ipv6a, ipv6res, sizeof(ipv6res));
+        if(!ipv6ptr)
+          exit(1); /* fail */
+        if(ipv6ptr != ipv6res)
+          exit(1); /* fail */
+        if(!ipv6ptr[0])
+          exit(1); /* fail */
+        if(memcmp(ipv6res, "fe80::214:4fff:fe0b:76c8", 24) != 0)
+          exit(1); /* fail */
+        /* - */
+        exit(0);
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_works_inet_ntop="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_works_inet_ntop="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_inet_ntop" = "yes" &&
+    test "$tst_works_inet_ntop" != "no"; then
+    AC_MSG_CHECKING([if inet_ntop usage allowed])
+    if test "x$cares_disallow_inet_ntop" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_inet_ntop="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_inet_ntop="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if inet_ntop might be used])
+  if test "$tst_links_inet_ntop" = "yes" &&
+     test "$tst_proto_inet_ntop" = "yes" &&
+     test "$tst_compi_inet_ntop" = "yes" &&
+     test "$tst_allow_inet_ntop" = "yes" &&
+     test "$tst_works_inet_ntop" != "no"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_INET_NTOP, 1,
+      [Define to 1 if you have a IPv6 capable working inet_ntop function.])
+    ac_cv_func_inet_ntop="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_inet_ntop="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_INET_PTON
+dnl -------------------------------------------------
+dnl Verify if inet_pton is available, prototyped, can
+dnl be compiled and seems to work. If all of these are
+dnl true, and usage has not been previously disallowed
+dnl with shell variable cares_disallow_inet_pton, then
+dnl HAVE_INET_PTON will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_INET_PTON], [
+  AC_REQUIRE([CARES_INCLUDES_STDLIB])dnl
+  AC_REQUIRE([CARES_INCLUDES_ARPA_INET])dnl
+  AC_REQUIRE([CARES_INCLUDES_STRING])dnl
+  #
+  tst_links_inet_pton="unknown"
+  tst_proto_inet_pton="unknown"
+  tst_compi_inet_pton="unknown"
+  tst_works_inet_pton="unknown"
+  tst_allow_inet_pton="unknown"
+  #
+  AC_MSG_CHECKING([if inet_pton can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([inet_pton])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_inet_pton="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_inet_pton="no"
+  ])
+  #
+  if test "$tst_links_inet_pton" = "yes"; then
+    AC_MSG_CHECKING([if inet_pton is prototyped])
+    AC_EGREP_CPP([inet_pton],[
+      $cares_includes_arpa_inet
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_inet_pton="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_inet_pton="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_inet_pton" = "yes"; then
+    AC_MSG_CHECKING([if inet_pton is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_arpa_inet
+      ]],[[
+        if(0 != inet_pton(0, 0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_inet_pton="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_inet_pton="no"
+    ])
+  fi
+  #
+  dnl only do runtime verification when not cross-compiling
+  if test "x$cross_compiling" != "xyes" &&
+    test "$tst_compi_inet_pton" = "yes"; then
+    AC_MSG_CHECKING([if inet_pton seems to work])
+    AC_RUN_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_stdlib
+        $cares_includes_arpa_inet
+        $cares_includes_string
+      ]],[[
+        unsigned char ipv6a[16+1];
+        unsigned char ipv4a[4+1];
+        const char *ipv6src = "fe80::214:4fff:fe0b:76c8";
+        const char *ipv4src = "192.168.100.1";
+        /* - */
+        memset(ipv4a, 1, sizeof(ipv4a));
+        if(1 != inet_pton(AF_INET, ipv4src, ipv4a))
+          exit(1); /* fail */
+        /* - */
+        if( (ipv4a[0] != 0xc0) ||
+            (ipv4a[1] != 0xa8) ||
+            (ipv4a[2] != 0x64) ||
+            (ipv4a[3] != 0x01) ||
+            (ipv4a[4] != 0x01) )
+          exit(1); /* fail */
+        /* - */
+        memset(ipv6a, 1, sizeof(ipv6a));
+        if(1 != inet_pton(AF_INET6, ipv6src, ipv6a))
+          exit(1); /* fail */
+        /* - */
+        if( (ipv6a[0]  != 0xfe) ||
+            (ipv6a[1]  != 0x80) ||
+            (ipv6a[8]  != 0x02) ||
+            (ipv6a[9]  != 0x14) ||
+            (ipv6a[10] != 0x4f) ||
+            (ipv6a[11] != 0xff) ||
+            (ipv6a[12] != 0xfe) ||
+            (ipv6a[13] != 0x0b) ||
+            (ipv6a[14] != 0x76) ||
+            (ipv6a[15] != 0xc8) ||
+            (ipv6a[16] != 0x01) )
+          exit(1); /* fail */
+        /* - */
+        if( (ipv6a[2]  != 0x0) ||
+            (ipv6a[3]  != 0x0) ||
+            (ipv6a[4]  != 0x0) ||
+            (ipv6a[5]  != 0x0) ||
+            (ipv6a[6]  != 0x0) ||
+            (ipv6a[7]  != 0x0) )
+          exit(1); /* fail */
+        /* - */
+        exit(0);
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_works_inet_pton="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_works_inet_pton="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_inet_pton" = "yes" &&
+    test "$tst_works_inet_pton" != "no"; then
+    AC_MSG_CHECKING([if inet_pton usage allowed])
+    if test "x$cares_disallow_inet_pton" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_inet_pton="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_inet_pton="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if inet_pton might be used])
+  if test "$tst_links_inet_pton" = "yes" &&
+     test "$tst_proto_inet_pton" = "yes" &&
+     test "$tst_compi_inet_pton" = "yes" &&
+     test "$tst_allow_inet_pton" = "yes" &&
+     test "$tst_works_inet_pton" != "no"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_INET_PTON, 1,
+      [Define to 1 if you have a IPv6 capable working inet_pton function.])
+    ac_cv_func_inet_pton="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_inet_pton="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_IOCTL
+dnl -------------------------------------------------
+dnl Verify if ioctl is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_ioctl, then
+dnl HAVE_IOCTL will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_IOCTL], [
+  AC_REQUIRE([CARES_INCLUDES_STROPTS])dnl
+  #
+  tst_links_ioctl="unknown"
+  tst_proto_ioctl="unknown"
+  tst_compi_ioctl="unknown"
+  tst_allow_ioctl="unknown"
+  #
+  AC_MSG_CHECKING([if ioctl can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([ioctl])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_ioctl="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_ioctl="no"
+  ])
+  #
+  if test "$tst_links_ioctl" = "yes"; then
+    AC_MSG_CHECKING([if ioctl is prototyped])
+    AC_EGREP_CPP([ioctl],[
+      $cares_includes_stropts
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_ioctl="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_ioctl="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_ioctl" = "yes"; then
+    AC_MSG_CHECKING([if ioctl is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_stropts
+      ]],[[
+        if(0 != ioctl(0, 0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_ioctl="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_ioctl="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_ioctl" = "yes"; then
+    AC_MSG_CHECKING([if ioctl usage allowed])
+    if test "x$cares_disallow_ioctl" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_ioctl="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_ioctl="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if ioctl might be used])
+  if test "$tst_links_ioctl" = "yes" &&
+     test "$tst_proto_ioctl" = "yes" &&
+     test "$tst_compi_ioctl" = "yes" &&
+     test "$tst_allow_ioctl" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_IOCTL, 1,
+      [Define to 1 if you have the ioctl function.])
+    ac_cv_func_ioctl="yes"
+    CARES_CHECK_FUNC_IOCTL_FIONBIO
+    CARES_CHECK_FUNC_IOCTL_SIOCGIFADDR
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_ioctl="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_IOCTL_FIONBIO
+dnl -------------------------------------------------
+dnl Verify if ioctl with the FIONBIO command is
+dnl available, can be compiled, and seems to work. If
+dnl all of these are true, then HAVE_IOCTL_FIONBIO
+dnl will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_IOCTL_FIONBIO], [
+  #
+  tst_compi_ioctl_fionbio="unknown"
+  tst_allow_ioctl_fionbio="unknown"
+  #
+  if test "$ac_cv_func_ioctl" = "yes"; then
+    AC_MSG_CHECKING([if ioctl FIONBIO is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_stropts
+      ]],[[
+        int flags = 0;
+        if(0 != ioctl(0, FIONBIO, &flags))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_ioctl_fionbio="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_ioctl_fionbio="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_ioctl_fionbio" = "yes"; then
+    AC_MSG_CHECKING([if ioctl FIONBIO usage allowed])
+    if test "x$cares_disallow_ioctl_fionbio" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_ioctl_fionbio="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_ioctl_fionbio="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if ioctl FIONBIO might be used])
+  if test "$tst_compi_ioctl_fionbio" = "yes" &&
+     test "$tst_allow_ioctl_fionbio" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_IOCTL_FIONBIO, 1,
+      [Define to 1 if you have a working ioctl FIONBIO function.])
+    ac_cv_func_ioctl_fionbio="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_ioctl_fionbio="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_IOCTL_SIOCGIFADDR
+dnl -------------------------------------------------
+dnl Verify if ioctl with the SIOCGIFADDR command is available,
+dnl struct ifreq is defined, they can be compiled, and seem to
+dnl work. If all of these are true, then HAVE_IOCTL_SIOCGIFADDR
+dnl will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_IOCTL_SIOCGIFADDR], [
+  #
+  tst_compi_ioctl_siocgifaddr="unknown"
+  tst_allow_ioctl_siocgifaddr="unknown"
+  #
+  if test "$ac_cv_func_ioctl" = "yes"; then
+    AC_MSG_CHECKING([if ioctl SIOCGIFADDR is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_stropts
+        #include <net/if.h>
+      ]],[[
+        struct ifreq ifr;
+        if(0 != ioctl(0, SIOCGIFADDR, &ifr))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_ioctl_siocgifaddr="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_ioctl_siocgifaddr="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_ioctl_siocgifaddr" = "yes"; then
+    AC_MSG_CHECKING([if ioctl SIOCGIFADDR usage allowed])
+    if test "x$cares_disallow_ioctl_siocgifaddr" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_ioctl_siocgifaddr="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_ioctl_siocgifaddr="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if ioctl SIOCGIFADDR might be used])
+  if test "$tst_compi_ioctl_siocgifaddr" = "yes" &&
+     test "$tst_allow_ioctl_siocgifaddr" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_IOCTL_SIOCGIFADDR, 1,
+      [Define to 1 if you have a working ioctl SIOCGIFADDR function.])
+    ac_cv_func_ioctl_siocgifaddr="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_ioctl_siocgifaddr="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_IOCTLSOCKET
+dnl -------------------------------------------------
+dnl Verify if ioctlsocket is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_ioctlsocket, then
+dnl HAVE_IOCTLSOCKET will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_IOCTLSOCKET], [
+  AC_REQUIRE([CARES_INCLUDES_WINSOCK2])dnl
+  #
+  tst_links_ioctlsocket="unknown"
+  tst_proto_ioctlsocket="unknown"
+  tst_compi_ioctlsocket="unknown"
+  tst_allow_ioctlsocket="unknown"
+  #
+  AC_MSG_CHECKING([if ioctlsocket can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_PROGRAM([[
+      $cares_includes_winsock2
+    ]],[[
+      if(0 != ioctlsocket(0, 0, 0))
+        return 1;
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_ioctlsocket="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_ioctlsocket="no"
+  ])
+  #
+  if test "$tst_links_ioctlsocket" = "yes"; then
+    AC_MSG_CHECKING([if ioctlsocket is prototyped])
+    AC_EGREP_CPP([ioctlsocket],[
+      $cares_includes_winsock2
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_ioctlsocket="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_ioctlsocket="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_ioctlsocket" = "yes"; then
+    AC_MSG_CHECKING([if ioctlsocket is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_winsock2
+      ]],[[
+        if(0 != ioctlsocket(0, 0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_ioctlsocket="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_ioctlsocket="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_ioctlsocket" = "yes"; then
+    AC_MSG_CHECKING([if ioctlsocket usage allowed])
+    if test "x$cares_disallow_ioctlsocket" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_ioctlsocket="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_ioctlsocket="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if ioctlsocket might be used])
+  if test "$tst_links_ioctlsocket" = "yes" &&
+     test "$tst_proto_ioctlsocket" = "yes" &&
+     test "$tst_compi_ioctlsocket" = "yes" &&
+     test "$tst_allow_ioctlsocket" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_IOCTLSOCKET, 1,
+      [Define to 1 if you have the ioctlsocket function.])
+    ac_cv_func_ioctlsocket="yes"
+    CARES_CHECK_FUNC_IOCTLSOCKET_FIONBIO
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_ioctlsocket="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_IOCTLSOCKET_FIONBIO
+dnl -------------------------------------------------
+dnl Verify if ioctlsocket with the FIONBIO command is
+dnl available, can be compiled, and seems to work. If
+dnl all of these are true, then HAVE_IOCTLSOCKET_FIONBIO
+dnl will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_IOCTLSOCKET_FIONBIO], [
+  #
+  tst_compi_ioctlsocket_fionbio="unknown"
+  tst_allow_ioctlsocket_fionbio="unknown"
+  #
+  if test "$ac_cv_func_ioctlsocket" = "yes"; then
+    AC_MSG_CHECKING([if ioctlsocket FIONBIO is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_winsock2
+      ]],[[
+        int flags = 0;
+        if(0 != ioctlsocket(0, FIONBIO, &flags))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_ioctlsocket_fionbio="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_ioctlsocket_fionbio="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_ioctlsocket_fionbio" = "yes"; then
+    AC_MSG_CHECKING([if ioctlsocket FIONBIO usage allowed])
+    if test "x$cares_disallow_ioctlsocket_fionbio" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_ioctlsocket_fionbio="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_ioctlsocket_fionbio="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if ioctlsocket FIONBIO might be used])
+  if test "$tst_compi_ioctlsocket_fionbio" = "yes" &&
+     test "$tst_allow_ioctlsocket_fionbio" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_IOCTLSOCKET_FIONBIO, 1,
+      [Define to 1 if you have a working ioctlsocket FIONBIO function.])
+    ac_cv_func_ioctlsocket_fionbio="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_ioctlsocket_fionbio="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_IOCTLSOCKET_CAMEL
+dnl -------------------------------------------------
+dnl Verify if IoctlSocket is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_ioctlsocket_camel,
+dnl then HAVE_IOCTLSOCKET_CAMEL will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_IOCTLSOCKET_CAMEL], [
+  AC_REQUIRE([CARES_INCLUDES_STROPTS])dnl
+  #
+  tst_links_ioctlsocket_camel="unknown"
+  tst_proto_ioctlsocket_camel="unknown"
+  tst_compi_ioctlsocket_camel="unknown"
+  tst_allow_ioctlsocket_camel="unknown"
+  #
+  AC_MSG_CHECKING([if IoctlSocket can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([IoctlSocket])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_ioctlsocket_camel="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_ioctlsocket_camel="no"
+  ])
+  #
+  if test "$tst_links_ioctlsocket_camel" = "yes"; then
+    AC_MSG_CHECKING([if IoctlSocket is prototyped])
+    AC_EGREP_CPP([IoctlSocket],[
+      $cares_includes_stropts
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_ioctlsocket_camel="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_ioctlsocket_camel="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_ioctlsocket_camel" = "yes"; then
+    AC_MSG_CHECKING([if IoctlSocket is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_stropts
+      ]],[[
+        if(0 != IoctlSocket(0, 0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_ioctlsocket_camel="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_ioctlsocket_camel="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_ioctlsocket_camel" = "yes"; then
+    AC_MSG_CHECKING([if IoctlSocket usage allowed])
+    if test "x$cares_disallow_ioctlsocket_camel" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_ioctlsocket_camel="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_ioctlsocket_camel="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if IoctlSocket might be used])
+  if test "$tst_links_ioctlsocket_camel" = "yes" &&
+     test "$tst_proto_ioctlsocket_camel" = "yes" &&
+     test "$tst_compi_ioctlsocket_camel" = "yes" &&
+     test "$tst_allow_ioctlsocket_camel" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_IOCTLSOCKET_CAMEL, 1,
+      [Define to 1 if you have the IoctlSocket camel case function.])
+    ac_cv_func_ioctlsocket_camel="yes"
+    CARES_CHECK_FUNC_IOCTLSOCKET_CAMEL_FIONBIO
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_ioctlsocket_camel="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_IOCTLSOCKET_CAMEL_FIONBIO
+dnl -------------------------------------------------
+dnl Verify if IoctlSocket with FIONBIO command is available,
+dnl can be compiled, and seems to work. If all of these are
+dnl true, then HAVE_IOCTLSOCKET_CAMEL_FIONBIO will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_IOCTLSOCKET_CAMEL_FIONBIO], [
+  #
+  tst_compi_ioctlsocket_camel_fionbio="unknown"
+  tst_allow_ioctlsocket_camel_fionbio="unknown"
+  #
+  if test "$ac_cv_func_ioctlsocket_camel" = "yes"; then
+    AC_MSG_CHECKING([if IoctlSocket FIONBIO is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_stropts
+      ]],[[
+        long flags = 0;
+        if(0 != ioctlsocket(0, FIONBIO, &flags))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_ioctlsocket_camel_fionbio="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_ioctlsocket_camel_fionbio="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_ioctlsocket_camel_fionbio" = "yes"; then
+    AC_MSG_CHECKING([if IoctlSocket FIONBIO usage allowed])
+    if test "x$cares_disallow_ioctlsocket_camel_fionbio" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_ioctlsocket_camel_fionbio="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_ioctlsocket_camel_fionbio="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if IoctlSocket FIONBIO might be used])
+  if test "$tst_compi_ioctlsocket_camel_fionbio" = "yes" &&
+     test "$tst_allow_ioctlsocket_camel_fionbio" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_IOCTLSOCKET_CAMEL_FIONBIO, 1,
+      [Define to 1 if you have a working IoctlSocket camel case FIONBIO function.])
+    ac_cv_func_ioctlsocket_camel_fionbio="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_ioctlsocket_camel_fionbio="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_SETSOCKOPT
+dnl -------------------------------------------------
+dnl Verify if setsockopt is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_setsockopt, then
+dnl HAVE_SETSOCKOPT will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_SETSOCKOPT], [
+  AC_REQUIRE([CARES_INCLUDES_WINSOCK2])dnl
+  AC_REQUIRE([CARES_INCLUDES_SYS_SOCKET])dnl
+  #
+  tst_links_setsockopt="unknown"
+  tst_proto_setsockopt="unknown"
+  tst_compi_setsockopt="unknown"
+  tst_allow_setsockopt="unknown"
+  #
+  AC_MSG_CHECKING([if setsockopt can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_PROGRAM([[
+      $cares_includes_winsock2
+      $cares_includes_sys_socket
+    ]],[[
+      if(0 != setsockopt(0, 0, 0, 0, 0))
+        return 1;
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_setsockopt="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_setsockopt="no"
+  ])
+  #
+  if test "$tst_links_setsockopt" = "yes"; then
+    AC_MSG_CHECKING([if setsockopt is prototyped])
+    AC_EGREP_CPP([setsockopt],[
+      $cares_includes_winsock2
+      $cares_includes_sys_socket
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_setsockopt="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_setsockopt="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_setsockopt" = "yes"; then
+    AC_MSG_CHECKING([if setsockopt is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_winsock2
+        $cares_includes_sys_socket
+      ]],[[
+        if(0 != setsockopt(0, 0, 0, 0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_setsockopt="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_setsockopt="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_setsockopt" = "yes"; then
+    AC_MSG_CHECKING([if setsockopt usage allowed])
+    if test "x$cares_disallow_setsockopt" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_setsockopt="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_setsockopt="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if setsockopt might be used])
+  if test "$tst_links_setsockopt" = "yes" &&
+     test "$tst_proto_setsockopt" = "yes" &&
+     test "$tst_compi_setsockopt" = "yes" &&
+     test "$tst_allow_setsockopt" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_SETSOCKOPT, 1,
+      [Define to 1 if you have the setsockopt function.])
+    ac_cv_func_setsockopt="yes"
+    CARES_CHECK_FUNC_SETSOCKOPT_SO_NONBLOCK
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_setsockopt="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_SETSOCKOPT_SO_NONBLOCK
+dnl -------------------------------------------------
+dnl Verify if setsockopt with the SO_NONBLOCK command is
+dnl available, can be compiled, and seems to work. If
+dnl all of these are true, then HAVE_SETSOCKOPT_SO_NONBLOCK
+dnl will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_SETSOCKOPT_SO_NONBLOCK], [
+  #
+  tst_compi_setsockopt_so_nonblock="unknown"
+  tst_allow_setsockopt_so_nonblock="unknown"
+  #
+  if test "$ac_cv_func_setsockopt" = "yes"; then
+    AC_MSG_CHECKING([if setsockopt SO_NONBLOCK is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_winsock2
+        $cares_includes_sys_socket
+      ]],[[
+        if(0 != setsockopt(0, SOL_SOCKET, SO_NONBLOCK, 0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_setsockopt_so_nonblock="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_setsockopt_so_nonblock="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_setsockopt_so_nonblock" = "yes"; then
+    AC_MSG_CHECKING([if setsockopt SO_NONBLOCK usage allowed])
+    if test "x$cares_disallow_setsockopt_so_nonblock" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_setsockopt_so_nonblock="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_setsockopt_so_nonblock="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if setsockopt SO_NONBLOCK might be used])
+  if test "$tst_compi_setsockopt_so_nonblock" = "yes" &&
+     test "$tst_allow_setsockopt_so_nonblock" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_SETSOCKOPT_SO_NONBLOCK, 1,
+      [Define to 1 if you have a working setsockopt SO_NONBLOCK function.])
+    ac_cv_func_setsockopt_so_nonblock="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_setsockopt_so_nonblock="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_SOCKET
+dnl -------------------------------------------------
+dnl Verify if socket is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_socket, then
+dnl HAVE_SOCKET will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_SOCKET], [
+  AC_REQUIRE([CARES_INCLUDES_WINSOCK2])dnl
+  AC_REQUIRE([CARES_INCLUDES_SYS_SOCKET])dnl
+  AC_REQUIRE([CARES_INCLUDES_SOCKET])dnl
+  #
+  tst_links_socket="unknown"
+  tst_proto_socket="unknown"
+  tst_compi_socket="unknown"
+  tst_allow_socket="unknown"
+  #
+  AC_MSG_CHECKING([if socket can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_PROGRAM([[
+      $cares_includes_winsock2
+      $cares_includes_sys_socket
+      $cares_includes_socket
+    ]],[[
+      if(0 != socket(0, 0, 0))
+        return 1;
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_socket="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_socket="no"
+  ])
+  #
+  if test "$tst_links_socket" = "yes"; then
+    AC_MSG_CHECKING([if socket is prototyped])
+    AC_EGREP_CPP([socket],[
+      $cares_includes_winsock2
+      $cares_includes_sys_socket
+      $cares_includes_socket
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_socket="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_socket="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_socket" = "yes"; then
+    AC_MSG_CHECKING([if socket is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_winsock2
+        $cares_includes_sys_socket
+        $cares_includes_socket
+      ]],[[
+        if(0 != socket(0, 0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_socket="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_socket="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_socket" = "yes"; then
+    AC_MSG_CHECKING([if socket usage allowed])
+    if test "x$cares_disallow_socket" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_socket="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_socket="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if socket might be used])
+  if test "$tst_links_socket" = "yes" &&
+     test "$tst_proto_socket" = "yes" &&
+     test "$tst_compi_socket" = "yes" &&
+     test "$tst_allow_socket" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_SOCKET, 1,
+      [Define to 1 if you have the socket function.])
+    ac_cv_func_socket="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_socket="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_STRCASECMP
+dnl -------------------------------------------------
+dnl Verify if strcasecmp is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_strcasecmp, then
+dnl HAVE_STRCASECMP will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_STRCASECMP], [
+  AC_REQUIRE([CARES_INCLUDES_STRING])dnl
+  #
+  tst_links_strcasecmp="unknown"
+  tst_proto_strcasecmp="unknown"
+  tst_compi_strcasecmp="unknown"
+  tst_allow_strcasecmp="unknown"
+  #
+  AC_MSG_CHECKING([if strcasecmp can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([strcasecmp])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_strcasecmp="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_strcasecmp="no"
+  ])
+  #
+  if test "$tst_links_strcasecmp" = "yes"; then
+    AC_MSG_CHECKING([if strcasecmp is prototyped])
+    AC_EGREP_CPP([strcasecmp],[
+      $cares_includes_string
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_strcasecmp="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_strcasecmp="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_strcasecmp" = "yes"; then
+    AC_MSG_CHECKING([if strcasecmp is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_string
+      ]],[[
+        if(0 != strcasecmp(0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_strcasecmp="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_strcasecmp="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_strcasecmp" = "yes"; then
+    AC_MSG_CHECKING([if strcasecmp usage allowed])
+    if test "x$cares_disallow_strcasecmp" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_strcasecmp="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_strcasecmp="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if strcasecmp might be used])
+  if test "$tst_links_strcasecmp" = "yes" &&
+     test "$tst_proto_strcasecmp" = "yes" &&
+     test "$tst_compi_strcasecmp" = "yes" &&
+     test "$tst_allow_strcasecmp" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_STRCASECMP, 1,
+      [Define to 1 if you have the strcasecmp function.])
+    ac_cv_func_strcasecmp="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_strcasecmp="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_STRCMPI
+dnl -------------------------------------------------
+dnl Verify if strcmpi is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_strcmpi, then
+dnl HAVE_STRCMPI will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_STRCMPI], [
+  AC_REQUIRE([CARES_INCLUDES_STRING])dnl
+  #
+  tst_links_strcmpi="unknown"
+  tst_proto_strcmpi="unknown"
+  tst_compi_strcmpi="unknown"
+  tst_allow_strcmpi="unknown"
+  #
+  AC_MSG_CHECKING([if strcmpi can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([strcmpi])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_strcmpi="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_strcmpi="no"
+  ])
+  #
+  if test "$tst_links_strcmpi" = "yes"; then
+    AC_MSG_CHECKING([if strcmpi is prototyped])
+    AC_EGREP_CPP([strcmpi],[
+      $cares_includes_string
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_strcmpi="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_strcmpi="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_strcmpi" = "yes"; then
+    AC_MSG_CHECKING([if strcmpi is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_string
+      ]],[[
+        if(0 != strcmpi(0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_strcmpi="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_strcmpi="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_strcmpi" = "yes"; then
+    AC_MSG_CHECKING([if strcmpi usage allowed])
+    if test "x$cares_disallow_strcmpi" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_strcmpi="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_strcmpi="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if strcmpi might be used])
+  if test "$tst_links_strcmpi" = "yes" &&
+     test "$tst_proto_strcmpi" = "yes" &&
+     test "$tst_compi_strcmpi" = "yes" &&
+     test "$tst_allow_strcmpi" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_STRCMPI, 1,
+      [Define to 1 if you have the strcmpi function.])
+    ac_cv_func_strcmpi="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_strcmpi="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_STRDUP
+dnl -------------------------------------------------
+dnl Verify if strdup is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_strdup, then
+dnl HAVE_STRDUP will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_STRDUP], [
+  AC_REQUIRE([CARES_INCLUDES_STRING])dnl
+  #
+  tst_links_strdup="unknown"
+  tst_proto_strdup="unknown"
+  tst_compi_strdup="unknown"
+  tst_allow_strdup="unknown"
+  #
+  AC_MSG_CHECKING([if strdup can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([strdup])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_strdup="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_strdup="no"
+  ])
+  #
+  if test "$tst_links_strdup" = "yes"; then
+    AC_MSG_CHECKING([if strdup is prototyped])
+    AC_EGREP_CPP([strdup],[
+      $cares_includes_string
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_strdup="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_strdup="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_strdup" = "yes"; then
+    AC_MSG_CHECKING([if strdup is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_string
+      ]],[[
+        if(0 != strdup(0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_strdup="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_strdup="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_strdup" = "yes"; then
+    AC_MSG_CHECKING([if strdup usage allowed])
+    if test "x$cares_disallow_strdup" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_strdup="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_strdup="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if strdup might be used])
+  if test "$tst_links_strdup" = "yes" &&
+     test "$tst_proto_strdup" = "yes" &&
+     test "$tst_compi_strdup" = "yes" &&
+     test "$tst_allow_strdup" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_STRDUP, 1,
+      [Define to 1 if you have the strdup function.])
+    ac_cv_func_strdup="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_strdup="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_STRICMP
+dnl -------------------------------------------------
+dnl Verify if stricmp is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_stricmp, then
+dnl HAVE_STRICMP will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_STRICMP], [
+  AC_REQUIRE([CARES_INCLUDES_STRING])dnl
+  #
+  tst_links_stricmp="unknown"
+  tst_proto_stricmp="unknown"
+  tst_compi_stricmp="unknown"
+  tst_allow_stricmp="unknown"
+  #
+  AC_MSG_CHECKING([if stricmp can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([stricmp])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_stricmp="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_stricmp="no"
+  ])
+  #
+  if test "$tst_links_stricmp" = "yes"; then
+    AC_MSG_CHECKING([if stricmp is prototyped])
+    AC_EGREP_CPP([stricmp],[
+      $cares_includes_string
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_stricmp="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_stricmp="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_stricmp" = "yes"; then
+    AC_MSG_CHECKING([if stricmp is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_string
+      ]],[[
+        if(0 != stricmp(0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_stricmp="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_stricmp="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_stricmp" = "yes"; then
+    AC_MSG_CHECKING([if stricmp usage allowed])
+    if test "x$cares_disallow_stricmp" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_stricmp="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_stricmp="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if stricmp might be used])
+  if test "$tst_links_stricmp" = "yes" &&
+     test "$tst_proto_stricmp" = "yes" &&
+     test "$tst_compi_stricmp" = "yes" &&
+     test "$tst_allow_stricmp" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_STRICMP, 1,
+      [Define to 1 if you have the stricmp function.])
+    ac_cv_func_stricmp="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_stricmp="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_STRNCASECMP
+dnl -------------------------------------------------
+dnl Verify if strncasecmp is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_strncasecmp, then
+dnl HAVE_STRNCASECMP will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_STRNCASECMP], [
+  AC_REQUIRE([CARES_INCLUDES_STRING])dnl
+  #
+  tst_links_strncasecmp="unknown"
+  tst_proto_strncasecmp="unknown"
+  tst_compi_strncasecmp="unknown"
+  tst_allow_strncasecmp="unknown"
+  #
+  AC_MSG_CHECKING([if strncasecmp can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([strncasecmp])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_strncasecmp="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_strncasecmp="no"
+  ])
+  #
+  if test "$tst_links_strncasecmp" = "yes"; then
+    AC_MSG_CHECKING([if strncasecmp is prototyped])
+    AC_EGREP_CPP([strncasecmp],[
+      $cares_includes_string
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_strncasecmp="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_strncasecmp="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_strncasecmp" = "yes"; then
+    AC_MSG_CHECKING([if strncasecmp is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_string
+      ]],[[
+        if(0 != strncasecmp(0, 0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_strncasecmp="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_strncasecmp="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_strncasecmp" = "yes"; then
+    AC_MSG_CHECKING([if strncasecmp usage allowed])
+    if test "x$cares_disallow_strncasecmp" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_strncasecmp="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_strncasecmp="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if strncasecmp might be used])
+  if test "$tst_links_strncasecmp" = "yes" &&
+     test "$tst_proto_strncasecmp" = "yes" &&
+     test "$tst_compi_strncasecmp" = "yes" &&
+     test "$tst_allow_strncasecmp" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_STRNCASECMP, 1,
+      [Define to 1 if you have the strncasecmp function.])
+    ac_cv_func_strncasecmp="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_strncasecmp="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_STRNCMPI
+dnl -------------------------------------------------
+dnl Verify if strncmpi is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_strncmpi, then
+dnl HAVE_STRNCMPI will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_STRNCMPI], [
+  AC_REQUIRE([CARES_INCLUDES_STRING])dnl
+  #
+  tst_links_strncmpi="unknown"
+  tst_proto_strncmpi="unknown"
+  tst_compi_strncmpi="unknown"
+  tst_allow_strncmpi="unknown"
+  #
+  AC_MSG_CHECKING([if strncmpi can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([strncmpi])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_strncmpi="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_strncmpi="no"
+  ])
+  #
+  if test "$tst_links_strncmpi" = "yes"; then
+    AC_MSG_CHECKING([if strncmpi is prototyped])
+    AC_EGREP_CPP([strncmpi],[
+      $cares_includes_string
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_strncmpi="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_strncmpi="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_strncmpi" = "yes"; then
+    AC_MSG_CHECKING([if strncmpi is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_string
+      ]],[[
+        if(0 != strncmpi(0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_strncmpi="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_strncmpi="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_strncmpi" = "yes"; then
+    AC_MSG_CHECKING([if strncmpi usage allowed])
+    if test "x$cares_disallow_strncmpi" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_strncmpi="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_strncmpi="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if strncmpi might be used])
+  if test "$tst_links_strncmpi" = "yes" &&
+     test "$tst_proto_strncmpi" = "yes" &&
+     test "$tst_compi_strncmpi" = "yes" &&
+     test "$tst_allow_strncmpi" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_STRNCMPI, 1,
+      [Define to 1 if you have the strncmpi function.])
+    ac_cv_func_strncmpi="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_strncmpi="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_STRNICMP
+dnl -------------------------------------------------
+dnl Verify if strnicmp is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_strnicmp, then
+dnl HAVE_STRNICMP will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_STRNICMP], [
+  AC_REQUIRE([CARES_INCLUDES_STRING])dnl
+  #
+  tst_links_strnicmp="unknown"
+  tst_proto_strnicmp="unknown"
+  tst_compi_strnicmp="unknown"
+  tst_allow_strnicmp="unknown"
+  #
+  AC_MSG_CHECKING([if strnicmp can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([strnicmp])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_strnicmp="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_strnicmp="no"
+  ])
+  #
+  if test "$tst_links_strnicmp" = "yes"; then
+    AC_MSG_CHECKING([if strnicmp is prototyped])
+    AC_EGREP_CPP([strnicmp],[
+      $cares_includes_string
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_strnicmp="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_strnicmp="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_strnicmp" = "yes"; then
+    AC_MSG_CHECKING([if strnicmp is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_string
+      ]],[[
+        if(0 != strnicmp(0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_strnicmp="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_strnicmp="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_strnicmp" = "yes"; then
+    AC_MSG_CHECKING([if strnicmp usage allowed])
+    if test "x$cares_disallow_strnicmp" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_strnicmp="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_strnicmp="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if strnicmp might be used])
+  if test "$tst_links_strnicmp" = "yes" &&
+     test "$tst_proto_strnicmp" = "yes" &&
+     test "$tst_compi_strnicmp" = "yes" &&
+     test "$tst_allow_strnicmp" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_STRNICMP, 1,
+      [Define to 1 if you have the strnicmp function.])
+    ac_cv_func_strnicmp="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_strnicmp="no"
+  fi
+])
+
+
+dnl CARES_CHECK_FUNC_WRITEV
+dnl -------------------------------------------------
+dnl Verify if writev is available, prototyped, and
+dnl can be compiled. If all of these are true, and
+dnl usage has not been previously disallowed with
+dnl shell variable cares_disallow_writev, then
+dnl HAVE_WRITEV will be defined.
+
+AC_DEFUN([CARES_CHECK_FUNC_WRITEV], [
+  AC_REQUIRE([CARES_INCLUDES_SYS_UIO])dnl
+  #
+  tst_links_writev="unknown"
+  tst_proto_writev="unknown"
+  tst_compi_writev="unknown"
+  tst_allow_writev="unknown"
+  #
+  AC_MSG_CHECKING([if writev can be linked])
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([writev])
+  ],[
+    AC_MSG_RESULT([yes])
+    tst_links_writev="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tst_links_writev="no"
+  ])
+  #
+  if test "$tst_links_writev" = "yes"; then
+    AC_MSG_CHECKING([if writev is prototyped])
+    AC_EGREP_CPP([writev],[
+      $cares_includes_sys_uio
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_proto_writev="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_proto_writev="no"
+    ])
+  fi
+  #
+  if test "$tst_proto_writev" = "yes"; then
+    AC_MSG_CHECKING([if writev is compilable])
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+        $cares_includes_sys_uio
+      ]],[[
+        if(0 != writev(0, 0, 0))
+          return 1;
+      ]])
+    ],[
+      AC_MSG_RESULT([yes])
+      tst_compi_writev="yes"
+    ],[
+      AC_MSG_RESULT([no])
+      tst_compi_writev="no"
+    ])
+  fi
+  #
+  if test "$tst_compi_writev" = "yes"; then
+    AC_MSG_CHECKING([if writev usage allowed])
+    if test "x$cares_disallow_writev" != "xyes"; then
+      AC_MSG_RESULT([yes])
+      tst_allow_writev="yes"
+    else
+      AC_MSG_RESULT([no])
+      tst_allow_writev="no"
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if writev might be used])
+  if test "$tst_links_writev" = "yes" &&
+     test "$tst_proto_writev" = "yes" &&
+     test "$tst_compi_writev" = "yes" &&
+     test "$tst_allow_writev" = "yes"; then
+    AC_MSG_RESULT([yes])
+    AC_DEFINE_UNQUOTED(HAVE_WRITEV, 1,
+      [Define to 1 if you have the writev function.])
+    ac_cv_func_writev="yes"
+  else
+    AC_MSG_RESULT([no])
+    ac_cv_func_writev="no"
+  fi
+])
diff --git a/m4/cares-override.m4 b/m4/cares-override.m4
new file mode 100644
index 0000000..ba45cdf
--- /dev/null
+++ b/m4/cares-override.m4
@@ -0,0 +1,102 @@
+#***************************************************************************
+# $Id: cares-override.m4,v 1.3 2009-10-19 04:11:54 yangtse Exp $
+#***************************************************************************
+
+# File version for 'aclocal' use. Keep it a single number.
+# serial 3
+
+dnl CARES_OVERRIDE_AUTOCONF
+dnl -------------------------------------------------
+dnl Placing a call to this macro in configure.ac after
+dnl the one to AC_INIT will make macros in this file
+dnl visible to the rest of the compilation overriding
+dnl those from Autoconf.
+
+AC_DEFUN([CARES_OVERRIDE_AUTOCONF], [
+AC_BEFORE([$0],[AC_PROG_LIBTOOL])
+# using cares-override.m4
+])
+
+dnl Override some Libtool tests
+dnl -------------------------------------------------
+dnl This is done to prevent Libtool 1.5.X from doing
+dnl unnecesary C++, Fortran and Java tests and reduce
+dnl resulting configure script by nearly 300 Kb.
+
+m4_define([AC_LIBTOOL_LANG_CXX_CONFIG],[:])
+m4_define([AC_LIBTOOL_LANG_F77_CONFIG],[:])
+m4_define([AC_LIBTOOL_LANG_GCJ_CONFIG],[:])
+
+dnl Override Autoconf's AC_LANG_PROGRAM (C)
+dnl -------------------------------------------------
+dnl This is done to prevent compiler warning
+dnl 'function declaration isn't a prototype'
+dnl in function main. This requires at least
+dnl a c89 compiler and does not suport K&R.
+
+m4_define([AC_LANG_PROGRAM(C)],
+[$1
+int main (void)
+{
+$2
+ ;
+ return 0;
+}])
+
+dnl Override Autoconf's AC_LANG_CALL (C)
+dnl -------------------------------------------------
+dnl This is a backport of Autoconf's 2.60 with the
+dnl embedded comments that hit the resulting script
+dnl removed. This is done to reduce configure size
+dnl and use fixed macro across Autoconf versions.
+
+m4_define([AC_LANG_CALL(C)],
+[AC_LANG_PROGRAM([$1
+m4_if([$2], [main], ,
+[
+#ifdef __cplusplus
+extern "C"
+#endif
+char $2 ();])], [return $2 ();])])
+
+dnl Override Autoconf's AC_LANG_FUNC_LINK_TRY (C)
+dnl -------------------------------------------------
+dnl This is a backport of Autoconf's 2.60 with the
+dnl embedded comments that hit the resulting script
+dnl removed. This is done to reduce configure size
+dnl and use fixed macro across Autoconf versions.
+
+m4_define([AC_LANG_FUNC_LINK_TRY(C)],
+[AC_LANG_PROGRAM(
+[
+#define $1 innocuous_$1
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+#undef $1
+#ifdef __cplusplus
+extern "C"
+#endif
+char $1 ();
+#if defined __stub_$1 || defined __stub___$1
+choke me
+#endif
+], [return $1 ();])])
+
+dnl Override Autoconf's PATH_SEPARATOR check
+dnl -------------------------------------------------
+dnl This is done to ensure that the same check is
+dnl used across different Autoconf versions and to
+dnl allow us to use this macro early enough in the
+dnl configure script.
+
+m4_defun([_AS_PATH_SEPARATOR_PREPARE],
+[CARES_CHECK_PATH_SEPARATOR
+m4_define([$0],[])])
+
+m4_defun([_LT_AC_LIBTOOL_SYS_PATH_SEPARATOR],
+[CARES_CHECK_PATH_SEPARATOR
+m4_define([$0],[])])
+
diff --git a/m4/cares-reentrant.m4 b/m4/cares-reentrant.m4
new file mode 100644
index 0000000..e91e523
--- /dev/null
+++ b/m4/cares-reentrant.m4
@@ -0,0 +1,611 @@
+#***************************************************************************
+# $Id: cares-reentrant.m4,v 1.5 2009-11-14 18:51:37 yangtse Exp $
+#
+# Copyright (C) 2008 - 2009 by Daniel Stenberg et al
+#
+# Permission to use, copy, modify, and distribute this software and its
+# documentation for any purpose and without fee is hereby granted, provided
+# that the above copyright notice appear in all copies and that both that
+# copyright notice and this permission notice appear in supporting
+# documentation, and that the name of M.I.T. not be used in advertising or
+# publicity pertaining to distribution of the software without specific,
+# written prior permission.  M.I.T. makes no representations about the
+# suitability of this software for any purpose.  It is provided "as is"
+# without express or implied warranty.
+#
+#***************************************************************************
+
+# File version for 'aclocal' use. Keep it a single number.
+# serial 4
+
+dnl Note 1
+dnl ------
+dnl None of the CARES_CHECK_NEED_REENTRANT_* macros shall use HAVE_FOO_H to
+dnl conditionally include header files. These macros are used early in the
+dnl configure process much before header file availability is known.
+
+
+dnl CARES_CHECK_NEED_REENTRANT_ERRNO
+dnl -------------------------------------------------
+dnl Checks if the preprocessor _REENTRANT definition
+dnl makes errno available as a preprocessor macro.
+
+AC_DEFUN([CARES_CHECK_NEED_REENTRANT_ERRNO], [
+  AC_COMPILE_IFELSE([
+    AC_LANG_PROGRAM([[
+#include <errno.h>
+    ]],[[
+      if(0 != errno)
+        return 1;
+    ]])
+  ],[
+    tmp_errno="yes"
+  ],[
+    tmp_errno="no"
+  ])
+  if test "$tmp_errno" = "yes"; then
+    AC_COMPILE_IFELSE([
+      AC_LANG_PROGRAM([[
+#include <errno.h>
+      ]],[[
+#ifdef errno
+        int dummy=1;
+#else
+        force compilation error
+#endif
+      ]])
+    ],[
+      tmp_errno="errno_macro_defined"
+    ],[
+      AC_COMPILE_IFELSE([
+        AC_LANG_PROGRAM([[
+#define _REENTRANT
+#include <errno.h>
+        ]],[[
+#ifdef errno
+          int dummy=1;
+#else
+          force compilation error
+#endif
+        ]])
+      ],[
+        tmp_errno="errno_macro_needs_reentrant"
+        tmp_need_reentrant="yes"
+      ])
+    ])
+  fi
+])
+
+
+dnl CARES_CHECK_NEED_REENTRANT_GMTIME_R
+dnl -------------------------------------------------
+dnl Checks if the preprocessor _REENTRANT definition
+dnl makes function gmtime_r compiler visible.
+
+AC_DEFUN([CARES_CHECK_NEED_REENTRANT_GMTIME_R], [
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([gmtime_r])
+  ],[
+    tmp_gmtime_r="yes"
+  ],[
+    tmp_gmtime_r="no"
+  ])
+  if test "$tmp_gmtime_r" = "yes"; then
+    AC_EGREP_CPP([gmtime_r],[
+#include <sys/types.h>
+#include <time.h>
+    ],[
+      tmp_gmtime_r="proto_declared"
+    ],[
+      AC_EGREP_CPP([gmtime_r],[
+#define _REENTRANT
+#include <sys/types.h>
+#include <time.h>
+      ],[
+        tmp_gmtime_r="proto_needs_reentrant"
+        tmp_need_reentrant="yes"
+      ])
+    ])
+  fi
+])
+
+
+dnl CARES_CHECK_NEED_REENTRANT_LOCALTIME_R
+dnl -------------------------------------------------
+dnl Checks if the preprocessor _REENTRANT definition
+dnl makes function localtime_r compiler visible.
+
+AC_DEFUN([CARES_CHECK_NEED_REENTRANT_LOCALTIME_R], [
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([localtime_r])
+  ],[
+    tmp_localtime_r="yes"
+  ],[
+    tmp_localtime_r="no"
+  ])
+  if test "$tmp_localtime_r" = "yes"; then
+    AC_EGREP_CPP([localtime_r],[
+#include <sys/types.h>
+#include <time.h>
+    ],[
+      tmp_localtime_r="proto_declared"
+    ],[
+      AC_EGREP_CPP([localtime_r],[
+#define _REENTRANT
+#include <sys/types.h>
+#include <time.h>
+      ],[
+        tmp_localtime_r="proto_needs_reentrant"
+        tmp_need_reentrant="yes"
+      ])
+    ])
+  fi
+])
+
+
+dnl CARES_CHECK_NEED_REENTRANT_STRERROR_R
+dnl -------------------------------------------------
+dnl Checks if the preprocessor _REENTRANT definition
+dnl makes function strerror_r compiler visible.
+
+AC_DEFUN([CARES_CHECK_NEED_REENTRANT_STRERROR_R], [
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([strerror_r])
+  ],[
+    tmp_strerror_r="yes"
+  ],[
+    tmp_strerror_r="no"
+  ])
+  if test "$tmp_strerror_r" = "yes"; then
+    AC_EGREP_CPP([strerror_r],[
+#include <sys/types.h>
+#include <string.h>
+    ],[
+      tmp_strerror_r="proto_declared"
+    ],[
+      AC_EGREP_CPP([strerror_r],[
+#define _REENTRANT
+#include <sys/types.h>
+#include <string.h>
+      ],[
+        tmp_strerror_r="proto_needs_reentrant"
+        tmp_need_reentrant="yes"
+      ])
+    ])
+  fi
+])
+
+
+dnl CARES_CHECK_NEED_REENTRANT_STRTOK_R
+dnl -------------------------------------------------
+dnl Checks if the preprocessor _REENTRANT definition
+dnl makes function strtok_r compiler visible.
+
+AC_DEFUN([CARES_CHECK_NEED_REENTRANT_STRTOK_R], [
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([strtok_r])
+  ],[
+    tmp_strtok_r="yes"
+  ],[
+    tmp_strtok_r="no"
+  ])
+  if test "$tmp_strtok_r" = "yes"; then
+    AC_EGREP_CPP([strtok_r],[
+#include <sys/types.h>
+#include <string.h>
+    ],[
+      tmp_strtok_r="proto_declared"
+    ],[
+      AC_EGREP_CPP([strtok_r],[
+#define _REENTRANT
+#include <sys/types.h>
+#include <string.h>
+      ],[
+        tmp_strtok_r="proto_needs_reentrant"
+        tmp_need_reentrant="yes"
+      ])
+    ])
+  fi
+])
+
+
+dnl CARES_CHECK_NEED_REENTRANT_INET_NTOA_R
+dnl -------------------------------------------------
+dnl Checks if the preprocessor _REENTRANT definition
+dnl makes function inet_ntoa_r compiler visible.
+
+AC_DEFUN([CARES_CHECK_NEED_REENTRANT_INET_NTOA_R], [
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([inet_ntoa_r])
+  ],[
+    tmp_inet_ntoa_r="yes"
+  ],[
+    tmp_inet_ntoa_r="no"
+  ])
+  if test "$tmp_inet_ntoa_r" = "yes"; then
+    AC_EGREP_CPP([inet_ntoa_r],[
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+    ],[
+      tmp_inet_ntoa_r="proto_declared"
+    ],[
+      AC_EGREP_CPP([inet_ntoa_r],[
+#define _REENTRANT
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+      ],[
+        tmp_inet_ntoa_r="proto_needs_reentrant"
+        tmp_need_reentrant="yes"
+      ])
+    ])
+  fi
+])
+
+
+dnl CARES_CHECK_NEED_REENTRANT_GETHOSTBYADDR_R
+dnl -------------------------------------------------
+dnl Checks if the preprocessor _REENTRANT definition
+dnl makes function gethostbyaddr_r compiler visible.
+
+AC_DEFUN([CARES_CHECK_NEED_REENTRANT_GETHOSTBYADDR_R], [
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([gethostbyaddr_r])
+  ],[
+    tmp_gethostbyaddr_r="yes"
+  ],[
+    tmp_gethostbyaddr_r="no"
+  ])
+  if test "$tmp_gethostbyaddr_r" = "yes"; then
+    AC_EGREP_CPP([gethostbyaddr_r],[
+#include <sys/types.h>
+#include <netdb.h>
+    ],[
+      tmp_gethostbyaddr_r="proto_declared"
+    ],[
+      AC_EGREP_CPP([gethostbyaddr_r],[
+#define _REENTRANT
+#include <sys/types.h>
+#include <netdb.h>
+      ],[
+        tmp_gethostbyaddr_r="proto_needs_reentrant"
+        tmp_need_reentrant="yes"
+      ])
+    ])
+  fi
+])
+
+
+dnl CARES_CHECK_NEED_REENTRANT_GETHOSTBYNAME_R
+dnl -------------------------------------------------
+dnl Checks if the preprocessor _REENTRANT definition
+dnl makes function gethostbyname_r compiler visible.
+
+AC_DEFUN([CARES_CHECK_NEED_REENTRANT_GETHOSTBYNAME_R], [
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([gethostbyname_r])
+  ],[
+    tmp_gethostbyname_r="yes"
+  ],[
+    tmp_gethostbyname_r="no"
+  ])
+  if test "$tmp_gethostbyname_r" = "yes"; then
+    AC_EGREP_CPP([gethostbyname_r],[
+#include <sys/types.h>
+#include <netdb.h>
+    ],[
+      tmp_gethostbyname_r="proto_declared"
+    ],[
+      AC_EGREP_CPP([gethostbyname_r],[
+#define _REENTRANT
+#include <sys/types.h>
+#include <netdb.h>
+      ],[
+        tmp_gethostbyname_r="proto_needs_reentrant"
+        tmp_need_reentrant="yes"
+      ])
+    ])
+  fi
+])
+
+
+dnl CARES_CHECK_NEED_REENTRANT_GETPROTOBYNAME_R
+dnl -------------------------------------------------
+dnl Checks if the preprocessor _REENTRANT definition
+dnl makes function getprotobyname_r compiler visible.
+
+AC_DEFUN([CARES_CHECK_NEED_REENTRANT_GETPROTOBYNAME_R], [
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([getprotobyname_r])
+  ],[
+    tmp_getprotobyname_r="yes"
+  ],[
+    tmp_getprotobyname_r="no"
+  ])
+  if test "$tmp_getprotobyname_r" = "yes"; then
+    AC_EGREP_CPP([getprotobyname_r],[
+#include <sys/types.h>
+#include <netdb.h>
+    ],[
+      tmp_getprotobyname_r="proto_declared"
+    ],[
+      AC_EGREP_CPP([getprotobyname_r],[
+#define _REENTRANT
+#include <sys/types.h>
+#include <netdb.h>
+      ],[
+        tmp_getprotobyname_r="proto_needs_reentrant"
+        tmp_need_reentrant="yes"
+      ])
+    ])
+  fi
+])
+
+
+dnl CARES_CHECK_NEED_REENTRANT_GETSERVBYPORT_R
+dnl -------------------------------------------------
+dnl Checks if the preprocessor _REENTRANT definition
+dnl makes function getservbyport_r compiler visible.
+
+AC_DEFUN([CARES_CHECK_NEED_REENTRANT_GETSERVBYPORT_R], [
+  AC_LINK_IFELSE([
+    AC_LANG_FUNC_LINK_TRY([getservbyport_r])
+  ],[
+    tmp_getservbyport_r="yes"
+  ],[
+    tmp_getservbyport_r="no"
+  ])
+  if test "$tmp_getservbyport_r" = "yes"; then
+    AC_EGREP_CPP([getservbyport_r],[
+#include <sys/types.h>
+#include <netdb.h>
+    ],[
+      tmp_getservbyport_r="proto_declared"
+    ],[
+      AC_EGREP_CPP([getservbyport_r],[
+#define _REENTRANT
+#include <sys/types.h>
+#include <netdb.h>
+      ],[
+        tmp_getservbyport_r="proto_needs_reentrant"
+        tmp_need_reentrant="yes"
+      ])
+    ])
+  fi
+])
+
+
+dnl CARES_CHECK_NEED_REENTRANT_FUNCTIONS_R
+dnl -------------------------------------------------
+dnl Checks if the preprocessor _REENTRANT definition
+dnl makes several _r functions compiler visible.
+dnl Internal macro for CARES_CONFIGURE_REENTRANT.
+
+AC_DEFUN([CARES_CHECK_NEED_REENTRANT_FUNCTIONS_R], [
+  if test "$tmp_need_reentrant" = "no"; then
+    CARES_CHECK_NEED_REENTRANT_GMTIME_R
+  fi
+  if test "$tmp_need_reentrant" = "no"; then
+    CARES_CHECK_NEED_REENTRANT_LOCALTIME_R
+  fi
+  if test "$tmp_need_reentrant" = "no"; then
+    CARES_CHECK_NEED_REENTRANT_STRERROR_R
+  fi
+  if test "$tmp_need_reentrant" = "no"; then
+    CARES_CHECK_NEED_REENTRANT_STRTOK_R
+  fi
+  if test "$tmp_need_reentrant" = "no"; then
+    CARES_CHECK_NEED_REENTRANT_INET_NTOA_R
+  fi
+  if test "$tmp_need_reentrant" = "no"; then
+    CARES_CHECK_NEED_REENTRANT_GETHOSTBYADDR_R
+  fi
+  if test "$tmp_need_reentrant" = "no"; then
+    CARES_CHECK_NEED_REENTRANT_GETHOSTBYNAME_R
+  fi
+  if test "$tmp_need_reentrant" = "no"; then
+    CARES_CHECK_NEED_REENTRANT_GETPROTOBYNAME_R
+  fi
+  if test "$tmp_need_reentrant" = "no"; then
+    CARES_CHECK_NEED_REENTRANT_GETSERVBYPORT_R
+  fi
+])
+
+
+dnl CARES_CHECK_NEED_REENTRANT_SYSTEM
+dnl -------------------------------------------------
+dnl Checks if the preprocessor _REENTRANT definition
+dnl must be unconditionally done for this platform.
+dnl Internal macro for CARES_CONFIGURE_REENTRANT.
+
+AC_DEFUN([CARES_CHECK_NEED_REENTRANT_SYSTEM], [
+  case $host_os in
+    solaris*)
+      tmp_need_reentrant="yes"
+      ;;
+    *)
+      tmp_need_reentrant="no"
+      ;;
+  esac
+])
+
+
+dnl CARES_CHECK_NEED_THREAD_SAFE_SYSTEM
+dnl -------------------------------------------------
+dnl Checks if the preprocessor _THREAD_SAFE definition
+dnl must be unconditionally done for this platform.
+dnl Internal macro for CARES_CONFIGURE_THREAD_SAFE.
+
+AC_DEFUN([CARES_CHECK_NEED_THREAD_SAFE_SYSTEM], [
+  case $host_os in
+    aix[[123]].* | aix4.[[012]].*)
+      dnl aix 4.2 and older
+      tmp_need_thread_safe="no"
+      ;;
+    aix*)
+      dnl AIX 4.3 and newer
+      tmp_need_thread_safe="yes"
+      ;;
+    *)
+      tmp_need_thread_safe="no"
+      ;;
+  esac
+])
+
+
+dnl CARES_CONFIGURE_FROM_NOW_ON_WITH_REENTRANT
+dnl -------------------------------------------------
+dnl This macro ensures that configuration tests done
+dnl after this will execute with preprocessor symbol
+dnl _REENTRANT defined. This macro also ensures that
+dnl the generated config file defines NEED_REENTRANT
+dnl and that in turn setup.h will define _REENTRANT.
+dnl Internal macro for CARES_CONFIGURE_REENTRANT.
+
+AC_DEFUN([CARES_CONFIGURE_FROM_NOW_ON_WITH_REENTRANT], [
+AC_DEFINE(NEED_REENTRANT, 1,
+  [Define to 1 if _REENTRANT preprocessor symbol must be defined.])
+cat >>confdefs.h <<_EOF
+#ifndef _REENTRANT
+#  define _REENTRANT
+#endif
+_EOF
+])
+
+
+dnl CARES_CONFIGURE_FROM_NOW_ON_WITH_THREAD_SAFE
+dnl -------------------------------------------------
+dnl This macro ensures that configuration tests done
+dnl after this will execute with preprocessor symbol
+dnl _THREAD_SAFE defined. This macro also ensures that
+dnl the generated config file defines NEED_THREAD_SAFE
+dnl and that in turn setup.h will define _THREAD_SAFE.
+dnl Internal macro for CARES_CONFIGURE_THREAD_SAFE.
+
+AC_DEFUN([CARES_CONFIGURE_FROM_NOW_ON_WITH_THREAD_SAFE], [
+AC_DEFINE(NEED_THREAD_SAFE, 1,
+  [Define to 1 if _THREAD_SAFE preprocessor symbol must be defined.])
+cat >>confdefs.h <<_EOF
+#ifndef _THREAD_SAFE
+#  define _THREAD_SAFE
+#endif
+_EOF
+])
+
+
+dnl CARES_CONFIGURE_REENTRANT
+dnl -------------------------------------------------
+dnl This first checks if the preprocessor _REENTRANT
+dnl symbol is already defined. If it isn't currently
+dnl defined a set of checks are performed to verify
+dnl if its definition is required to make visible to
+dnl the compiler a set of *_r functions. Finally, if
+dnl _REENTRANT is already defined or needed it takes
+dnl care of making adjustments necessary to ensure
+dnl that it is defined equally for further configure
+dnl tests and generated config file.
+
+AC_DEFUN([CARES_CONFIGURE_REENTRANT], [
+  AC_PREREQ([2.50])dnl
+  #
+  AC_MSG_CHECKING([if _REENTRANT is already defined])
+  AC_COMPILE_IFELSE([
+    AC_LANG_PROGRAM([[
+    ]],[[
+#ifdef _REENTRANT
+      int dummy=1;
+#else
+      force compilation error
+#endif
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    tmp_reentrant_initially_defined="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tmp_reentrant_initially_defined="no"
+  ])
+  #
+  if test "$tmp_reentrant_initially_defined" = "no"; then
+    AC_MSG_CHECKING([if _REENTRANT is actually needed])
+    CARES_CHECK_NEED_REENTRANT_SYSTEM
+    if test "$tmp_need_reentrant" = "no"; then
+      CARES_CHECK_NEED_REENTRANT_ERRNO
+    fi
+    if test "$tmp_need_reentrant" = "no"; then
+      CARES_CHECK_NEED_REENTRANT_FUNCTIONS_R
+    fi
+    if test "$tmp_need_reentrant" = "yes"; then
+      AC_MSG_RESULT([yes])
+    else
+      AC_MSG_RESULT([no])
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if _REENTRANT is onwards defined])
+  if test "$tmp_reentrant_initially_defined" = "yes" ||
+    test "$tmp_need_reentrant" = "yes"; then
+    CARES_CONFIGURE_FROM_NOW_ON_WITH_REENTRANT
+    AC_MSG_RESULT([yes])
+  else
+    AC_MSG_RESULT([no])
+  fi
+  #
+])
+
+
+dnl CARES_CONFIGURE_THREAD_SAFE
+dnl -------------------------------------------------
+dnl This first checks if the preprocessor _THREAD_SAFE
+dnl symbol is already defined. If it isn't currently
+dnl defined a set of checks are performed to verify
+dnl if its definition is required. Finally, if
+dnl _THREAD_SAFE is already defined or needed it takes
+dnl care of making adjustments necessary to ensure
+dnl that it is defined equally for further configure
+dnl tests and generated config file.
+
+AC_DEFUN([CARES_CONFIGURE_THREAD_SAFE], [
+  AC_PREREQ([2.50])dnl
+  #
+  AC_MSG_CHECKING([if _THREAD_SAFE is already defined])
+  AC_COMPILE_IFELSE([
+    AC_LANG_PROGRAM([[
+    ]],[[
+#ifdef _THREAD_SAFE
+      int dummy=1;
+#else
+      force compilation error
+#endif
+    ]])
+  ],[
+    AC_MSG_RESULT([yes])
+    tmp_thread_safe_initially_defined="yes"
+  ],[
+    AC_MSG_RESULT([no])
+    tmp_thread_safe_initially_defined="no"
+  ])
+  #
+  if test "$tmp_thread_safe_initially_defined" = "no"; then
+    AC_MSG_CHECKING([if _THREAD_SAFE is actually needed])
+    CARES_CHECK_NEED_THREAD_SAFE_SYSTEM
+    if test "$tmp_need_thread_safe" = "yes"; then
+      AC_MSG_RESULT([yes])
+    else
+      AC_MSG_RESULT([no])
+    fi
+  fi
+  #
+  AC_MSG_CHECKING([if _THREAD_SAFE is onwards defined])
+  if test "$tmp_thread_safe_initially_defined" = "yes" ||
+    test "$tmp_need_thread_safe" = "yes"; then
+    CARES_CONFIGURE_FROM_NOW_ON_WITH_THREAD_SAFE
+    AC_MSG_RESULT([yes])
+  else
+    AC_MSG_RESULT([no])
+  fi
+  #
+])
diff --git a/m4/cares-system.m4 b/m4/cares-system.m4
new file mode 100644
index 0000000..19ea5d4
--- /dev/null
+++ b/m4/cares-system.m4
@@ -0,0 +1,83 @@
+#***************************************************************************
+# $Id: cares-system.m4,v 1.3 2009-10-19 04:13:12 yangtse Exp $
+#
+# Copyright (C) 2008 - 2009 by Daniel Stenberg et al
+#
+# Permission to use, copy, modify, and distribute this software and its
+# documentation for any purpose and without fee is hereby granted, provided
+# that the above copyright notice appear in all copies and that both that
+# copyright notice and this permission notice appear in supporting
+# documentation, and that the name of M.I.T. not be used in advertising or
+# publicity pertaining to distribution of the software without specific,
+# written prior permission.  M.I.T. makes no representations about the
+# suitability of this software for any purpose.  It is provided "as is"
+# without express or implied warranty.
+#
+#***************************************************************************
+
+# File version for 'aclocal' use. Keep it a single number.
+# serial 3
+
+
+dnl CARES_CHECK_PATH_SEPARATOR
+dnl -------------------------------------------------
+dnl Check and compute the path separator for us. This
+dnl path separator is the symbol used to diferentiate
+dnl or separate paths inside the PATH environment var.
+
+AC_DEFUN([CARES_CHECK_PATH_SEPARATOR], [
+  if test -z "$cares_cv_PATH_SEPARATOR"; then
+    if test -z "$PATH"; then
+      AC_MSG_ERROR([PATH not set. Cannot continue without PATH being set.])
+    fi
+    dnl Directory count in PATH when using a colon separator.
+    tst_dirs_col=0
+    tst_save_IFS=$IFS; IFS=':'
+    for tst_dir in $PATH; do
+      IFS=$tst_save_IFS
+      test -d "$tst_dir" && tst_dirs_col=`expr $tst_dirs_col + 1`
+    done
+    IFS=$tst_save_IFS
+    dnl Directory count in PATH when using a semicolon separator.
+    tst_dirs_sem=0
+    tst_save_IFS=$IFS; IFS=';'
+    for tst_dir in $PATH; do
+      IFS=$tst_save_IFS
+      test -d "$tst_dir" && tst_dirs_sem=`expr $tst_dirs_sem + 1`
+    done
+    IFS=$tst_save_IFS
+    if test $tst_dirs_sem -eq $tst_dirs_col; then
+      dnl When both counting methods give the same result we do not want to
+      dnl chose one over the other, and consider auto-detection not possible.
+      if test -z "$PATH_SEPARATOR"; then
+        dnl Stop dead until user provides PATH_SEPARATOR definition.
+        AC_MSG_ERROR([PATH_SEPARATOR not set. Cannot continue without it.])
+      fi
+    else
+      dnl Separator with the greater directory count is the auto-detected one.
+      if test $tst_dirs_sem -gt $tst_dirs_col; then
+        tst_auto_separator=';'
+      else
+        tst_auto_separator=':'
+      fi
+      if test -z "$PATH_SEPARATOR"; then
+        dnl Simply use the auto-detected one when not already set.
+        PATH_SEPARATOR="$tst_auto_separator"
+      fi
+    fi
+    cares_cv_PATH_SEPARATOR="$PATH_SEPARATOR"
+  fi
+  AC_SUBST([PATH_SEPARATOR])
+  AC_SUBST([PATH])
+])
+
+
+dnl CARES_CHECK_PATH_SEPARATOR_REQUIRED
+dnl -------------------------------------------------
+dnl Use this to ensure that the path separator check
+dnl macro is only expanded and included once.
+
+AC_DEFUN([CARES_CHECK_PATH_SEPARATOR_REQUIRED], [
+  AC_REQUIRE([CARES_CHECK_PATH_SEPARATOR])dnl
+])
+