From bcf8c53211f0285df3e1adae8eebecd6814ea96a Mon Sep 17 00:00:00 2001 From: Sebastian Harl Date: Tue, 3 Nov 2009 00:20:15 +0100 Subject: [PATCH] patches: Added libgnutls-config.dpatch. This patch adds support for pkg-config when checking for gnutls to configure - recent versions of gnutls no longer provide libgnutls-config which was used previously for those checks Thanks to Lucas Nussbaum and Peter Fritzsche for reporting this. Closes: #549797, #554041 --- debian/changelog | 10 +- debian/patches/00list | 1 + debian/patches/libgnutls-config.dpatch | 7424 ++++++++++++++++++++++++ 3 files changed, 7433 insertions(+), 2 deletions(-) create mode 100644 debian/patches/libgnutls-config.dpatch diff --git a/debian/changelog b/debian/changelog index d11b8ee..47cf6ea 100644 --- a/debian/changelog +++ b/debian/changelog @@ -5,8 +5,14 @@ cadaver (0.23.2-2) unstable; urgency=low build-dependency; thanks to Matthias Klose for reporting this (Closes: #553736). - Updated Standards-Version to 3.8.3 - no changes. - - -- Sebastian Harl Mon, 02 Nov 2009 23:21:44 +0100 + * patches: + - Added libgnutls-config.dpatch - this patch adds support for pkg-config + when checking for gnutls to configure - recent versions of gnutls no + longer provide libgnutls-config which was used previously for those + checks; thanks to Lucas Nussbaum and Peter Fritzsche for reporting this + (Closes: #549797, #554041). + + -- Sebastian Harl Tue, 03 Nov 2009 00:16:34 +0100 cadaver (0.23.2-1) unstable; urgency=low diff --git a/debian/patches/00list b/debian/patches/00list index cbd8881..803903c 100644 --- a/debian/patches/00list +++ b/debian/patches/00list @@ -1,2 +1,3 @@ +libgnutls-config.dpatch manpage_hyphen.dpatch diff --git a/debian/patches/libgnutls-config.dpatch b/debian/patches/libgnutls-config.dpatch new file mode 100644 index 0000000..d75bb04 --- /dev/null +++ b/debian/patches/libgnutls-config.dpatch @@ -0,0 +1,7424 @@ +#! /bin/sh /usr/share/dpatch/dpatch-run +## libgnutls-config.dpatch by Sebastian Harl +## +## DP: Support pkg-config as well when checking for gnutls. +## DP: +## DP: The latest versions of gnutls no longer ship libgnutls-config. + +@DPATCH@ + +diff a/aclocal.m4 b/aclocal.m4 +--- a/aclocal.m4 ++++ b/aclocal.m4 +@@ -1,7 +1,7 @@ +-# generated automatically by aclocal 1.10 -*- Autoconf -*- ++# generated automatically by aclocal 1.10.1 -*- Autoconf -*- + + # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, +-# 2005, 2006 Free Software Foundation, Inc. ++# 2005, 2006, 2007, 2008 Free Software Foundation, Inc. + # This file is free software; the Free Software Foundation + # gives unlimited permission to copy and/or distribute it, + # with or without modifications, as long as this notice is preserved. +@@ -2644,6 +2644,1406 @@ + | (ullmax / ull) | (ullmax % ull));]]) + ]) + ++# Copyright (C) 2001-2006 Joe Orton -*- autoconf -*- ++# ++# This file is free software; you may copy and/or distribute it with ++# or without modifications, as long as this notice is preserved. ++# This software is distributed in the hope that it will be useful, but ++# WITHOUT ANY WARRANTY, to the extent permitted by law; without even ++# the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR ++# PURPOSE. ++ ++# The above license applies to THIS FILE ONLY, the neon library code ++# itself may be copied and distributed under the terms of the GNU ++# LGPL, see COPYING.LIB for more details ++ ++# This file is part of the neon HTTP/WebDAV client library. ++# See http://www.webdav.org/neon/ for the latest version. ++# Please send any feedback to ++ ++# Tests needed for the neon-test common test code. ++ ++AC_DEFUN([NE_FORMAT_TIMET], [ ++NEON_FORMAT(time_t, [ ++#ifdef HAVE_SYS_TIME_H ++#include ++#endif]) ++]) ++ ++AC_DEFUN([NEON_TEST], [ ++ ++AC_REQUIRE([NEON_COMMON_CHECKS]) ++AC_REQUIRE([NE_FORMAT_TIMET]) ++ ++AC_REQUIRE([AC_TYPE_PID_T]) ++AC_REQUIRE([AC_HEADER_TIME]) ++ ++dnl NEON_XML_PARSER may add things (e.g. -I/usr/local/include) to ++dnl CPPFLAGS which make "gcc -Werror" fail in NEON_FORMAT; suggest ++dnl this macro is used first. ++AC_BEFORE([$0], [NEON_XML_PARSER]) ++ ++AC_CHECK_HEADERS(sys/time.h stdint.h locale.h) ++ ++AC_CHECK_FUNCS(pipe isatty usleep shutdown setlocale) ++ ++AC_REQUIRE([NE_FIND_AR]) ++ ++]) ++ ++# Copyright (C) 1998-2005, 2007 Joe Orton -*- autoconf -*- ++# ++# This file is free software; you may copy and/or distribute it with ++# or without modifications, as long as this notice is preserved. ++# This software is distributed in the hope that it will be useful, but ++# WITHOUT ANY WARRANTY, to the extent permitted by law; without even ++# the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR ++# PURPOSE. ++ ++# The above license applies to THIS FILE ONLY, the neon library code ++# itself may be copied and distributed under the terms of the GNU ++# LGPL, see COPYING.LIB for more details ++ ++# This file is part of the neon HTTP/WebDAV client library. ++# See http://www.webdav.org/neon/ for the latest version. ++# Please send any feedback to ++ ++# Check for XML parser, supporting libxml 2.x and expat 1.95.x, ++# or a bundled copy of expat. ++# * Bundled expat if a directory name argument is passed ++# -> expat dir must contain minimal expat sources, i.e. ++# xmltok, xmlparse sub-directories. See sitecopy/cadaver for ++# examples of how to do this. ++# ++# Usage: ++# NEON_XML_PARSER() ++# or ++# NEON_XML_PARSER([expat-srcdir], [expat-builddir]) ++ ++dnl Find expat: run $1 if found, else $2 ++AC_DEFUN([NE_XML_EXPAT], [ ++AC_CHECK_HEADER(expat.h, ++ [AC_CHECK_LIB(expat, XML_SetXmlDeclHandler, [ ++ AC_DEFINE(HAVE_EXPAT, 1, [Define if you have expat]) ++ neon_xml_parser_message="expat" ++ NEON_LIBS="$NEON_LIBS -lexpat" ++ neon_xml_parser=expat ++ AC_CHECK_TYPE(XML_Size, ++ [NEON_FORMAT(XML_Size, [#include ])], ++ [AC_DEFINE_UNQUOTED([NE_FMT_XML_SIZE], ["d"])], ++ [#include ]) ++ ], [$1])], [$1]) ++]) ++ ++dnl Find libxml2: run $1 if found, else $2 ++AC_DEFUN([NE_XML_LIBXML2], [ ++AC_CHECK_PROG(XML2_CONFIG, xml2-config, xml2-config) ++if test -n "$XML2_CONFIG"; then ++ neon_xml_parser_message="libxml `$XML2_CONFIG --version`" ++ AC_DEFINE(HAVE_LIBXML, 1, [Define if you have libxml]) ++ # xml2-config in some versions erroneously includes -I/include ++ # in the --cflags output. ++ CPPFLAGS="$CPPFLAGS `$XML2_CONFIG --cflags | sed 's| -I/include||g'`" ++ NEON_LIBS="$NEON_LIBS `$XML2_CONFIG --libs | sed 's|-L/usr/lib ||g'`" ++ AC_CHECK_HEADERS(libxml/xmlversion.h libxml/parser.h,,[ ++ AC_MSG_ERROR([could not find parser.h, libxml installation problem?])]) ++ neon_xml_parser=libxml2 ++else ++ $1 ++fi ++]) ++ ++dnl Configure for a bundled expat build. ++AC_DEFUN([NE_XML_BUNDLED_EXPAT], [ ++ ++AC_REQUIRE([AC_C_BIGENDIAN]) ++# Define XML_BYTE_ORDER for expat sources. ++if test $ac_cv_c_bigendian = "yes"; then ++ ne_xml_border=21 ++else ++ ne_xml_border=12 ++fi ++ ++# mini-expat doesn't pick up config.h ++CPPFLAGS="$CPPFLAGS -DXML_BYTE_ORDER=$ne_xml_border -DXML_DTD -I$1/xmlparse -I$1/xmltok" ++ ++AC_DEFINE_UNQUOTED([NE_FMT_XML_SIZE], ["d"]) ++ ++# Use the bundled expat sources ++AC_LIBOBJ($2/xmltok/xmltok) ++AC_LIBOBJ($2/xmltok/xmlrole) ++AC_LIBOBJ($2/xmlparse/xmlparse) ++AC_LIBOBJ($2/xmlparse/hashtable) ++ ++AC_DEFINE(HAVE_EXPAT) ++ ++AC_DEFINE(HAVE_XMLPARSE_H, 1, [Define if using expat which includes xmlparse.h]) ++ ++]) ++ ++AC_DEFUN([NEON_XML_PARSER], [ ++ ++dnl Switches to force choice of library ++AC_ARG_WITH([libxml2], ++AS_HELP_STRING([--with-libxml2], [force use of libxml 2.x])) ++AC_ARG_WITH([expat], ++AS_HELP_STRING([--with-expat], [force use of expat])) ++ ++dnl Flag to force choice of included expat, if available. ++ifelse($#, 2, [ ++AC_ARG_WITH([included-expat], ++AS_HELP_STRING([--with-included-expat], [use bundled expat sources]),, ++with_included_expat=no)], ++with_included_expat=no) ++ ++if test "$NEON_NEED_XML_PARSER" = "yes"; then ++ # Find an XML parser ++ neon_xml_parser=none ++ ++ # Forced choice of expat: ++ case $with_expat in ++ yes) NE_XML_EXPAT([AC_MSG_ERROR([expat library not found, cannot proceed])]) ;; ++ no) ;; ++ */libexpat.la) ++ # Special case for Subversion ++ ne_expdir=`echo $with_expat | sed 's:/libexpat.la$::'` ++ AC_DEFINE(HAVE_EXPAT) ++ AC_DEFINE_UNQUOTED([NE_FMT_XML_SIZE], ["d"]) ++ CPPFLAGS="$CPPFLAGS -I$ne_expdir" ++ if test "x${NEON_TARGET}" = "xlibneon.la"; then ++ NEON_LTLIBS=$with_expat ++ else ++ # no dependency on libexpat => crippled libneon, so do partial install ++ ALLOW_INSTALL=lib ++ fi ++ neon_xml_parser=expat ++ neon_xml_parser_message="expat in $ne_expdir" ++ ;; ++ /*) AC_MSG_ERROR([--with-expat does not take a directory argument]) ;; ++ esac ++ ++ # If expat wasn't specifically enabled and libxml was: ++ if test "${neon_xml_parser}-${with_libxml2}-${with_included_expat}" = "none-yes-no"; then ++ NE_XML_LIBXML2( ++ [AC_MSG_ERROR([libxml2.x library not found, cannot proceed])]) ++ fi ++ ++ # Otherwise, by default search for expat then libxml2: ++ if test "${neon_xml_parser}-${with_included_expat}" = "none-no"; then ++ NE_XML_EXPAT([NE_XML_LIBXML2([:])]) ++ fi ++ ++ # If an XML parser still has not been found, fail or use the bundled expat ++ if test "$neon_xml_parser" = "none"; then ++ m4_if($1, [], ++ [AC_MSG_ERROR([no XML parser was found: expat or libxml 2.x required])], ++ [# Configure the bundled copy of expat ++ NE_XML_BUNDLED_EXPAT($@) ++ neon_xml_parser_message="bundled expat in $1"]) ++ fi ++ ++ AC_MSG_NOTICE([XML parser used: $neon_xml_parser_message]) ++fi ++ ++]) ++ ++# Copyright (C) 1998-2009 Joe Orton -*- autoconf -*- ++# Copyright (C) 2004 Aleix Conchillo Flaque ++# ++# This file is free software; you may copy and/or distribute it with ++# or without modifications, as long as this notice is preserved. ++# This software is distributed in the hope that it will be useful, but ++# WITHOUT ANY WARRANTY, to the extent permitted by law; without even ++# the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR ++# PURPOSE. ++ ++# The above license applies to THIS FILE ONLY, the neon library code ++# itself may be copied and distributed under the terms of the GNU ++# LGPL, see COPYING.LIB for more details ++ ++# This file is part of the neon HTTP/WebDAV client library. ++# See http://www.webdav.org/neon/ for the latest version. ++# Please send any feedback to ++ ++# ++# Usage: ++# ++# NEON_LIBRARY ++# or NEON_BUNDLED(srcdir, [ACTIONS-IF-BUNDLED], [ACTIONS-IF-NOT_BUNDLED]) ++# or NEON_VPATH_BUNDLED(srcdir, builddir, ++# [ACTIONS-IF-BUNDLED], [ACTIONS-IF-NOT-BUNDLED]) ++# ++# where srcdir is the location of bundled neon 'src' directory. ++# If using a VPATH-enabled build, builddir is the location of the ++# build directory corresponding to srcdir. ++# ++# If a bundled build *is* being used, ACTIONS-IF-BUNDLED will be ++# evaluated. These actions should ensure that 'make' is run ++# in srcdir, and that one of NEON_NORMAL_BUILD or NEON_LIBTOOL_BUILD ++# is called. ++# ++# After calling one of the above macros, if the NEON_NEED_XML_PARSER ++# variable is set to "yes", then you must configure an XML parser ++# too. You can do this your own way, or do it easily using the ++# NEON_XML_PARSER() macro. Example usage for where we have bundled the ++# neon sources in a directory called libneon, and bundled expat ++# sources in a directory called 'expat'. ++# ++# NEON_BUNDLED(libneon, [ ++# NEON_XML_PARSER(expat) ++# NEON_NORMAL_BUILD ++# ]) ++# ++# Alternatively, for a simple standalone app with neon as a ++# dependancy, use just: ++# ++# NEON_LIBRARY ++# ++# and rely on the user installing neon correctly. ++# ++# You are free to configure an XML parser any other way you like, ++# but the end result must be, either expat or libxml will get linked ++# in, and HAVE_EXPAT or HAVE_LIBXML is defined appropriately. ++# ++# To set up the bundled build environment, call ++# ++# NEON_NORMAL_BUILD ++# or ++# NEON_LIBTOOL_BUILD ++# ++# depending on whether you are using libtool to build, or not. ++# Both these macros take an optional argument specifying the set ++# of object files you wish to build: if the argument is not given, ++# all of neon will be built. ++ ++AC_DEFUN([NEON_BUNDLED],[ ++ ++neon_bundled_srcdir=$1 ++neon_bundled_builddir=$1 ++ ++NEON_COMMON_BUNDLED([$2], [$3]) ++ ++]) ++ ++AC_DEFUN([NEON_VPATH_BUNDLED],[ ++ ++neon_bundled_srcdir=$1 ++neon_bundled_builddir=$2 ++NEON_COMMON_BUNDLED([$3], [$4]) ++ ++]) ++ ++AC_DEFUN([NEON_COMMON_BUNDLED],[ ++ ++AC_PREREQ(2.50) ++ ++AC_ARG_WITH(included-neon, ++AS_HELP_STRING([--with-included-neon], [force use of included neon library]), ++[neon_force_included="$withval"], [neon_force_included="no"]) ++ ++NEON_COMMON ++ ++# The colons are here so there is something to evaluate ++# in case the argument was not passed. ++if test "$neon_force_included" = "yes"; then ++ : ++ $1 ++else ++ : ++ $2 ++fi ++ ++]) ++ ++dnl Not got any bundled sources: ++AC_DEFUN([NEON_LIBRARY],[ ++ ++AC_PREREQ(2.50) ++neon_force_included=no ++neon_bundled_srcdir= ++neon_bundled_builddir= ++ ++NEON_COMMON ++ ++]) ++ ++AC_DEFUN([NE_DEFINE_VERSIONS], [ ++ ++NEON_VERSION="${NE_VERSION_MAJOR}.${NE_VERSION_MINOR}.${NE_VERSION_PATCH}${NE_VERSION_TAG}" ++ ++AC_DEFINE_UNQUOTED([NEON_VERSION], ["${NEON_VERSION}"], ++ [Define to be the neon version string]) ++AC_DEFINE_UNQUOTED([NE_VERSION_MAJOR], [(${NE_VERSION_MAJOR})], ++ [Define to be neon library major version]) ++AC_DEFINE_UNQUOTED([NE_VERSION_MINOR], [(${NE_VERSION_MINOR})], ++ [Define to be neon library minor version]) ++AC_DEFINE_UNQUOTED([NE_VERSION_PATCH], [(${NE_VERSION_PATCH})], ++ [Define to be neon library patch version]) ++]) ++ ++AC_DEFUN([NE_VERSIONS_BUNDLED], [ ++ ++# Define the current versions. ++NE_VERSION_MAJOR=0 ++NE_VERSION_MINOR=29 ++NE_VERSION_PATCH=0 ++NE_VERSION_TAG= ++ ++# 0.29.x is backwards-compatible to 0.27.x, so AGE=2 ++NE_LIBTOOL_VERSINFO="29:${NE_VERSION_PATCH}:2" ++ ++NE_DEFINE_VERSIONS ++ ++]) ++ ++dnl Adds an ABI variation tag which will be added to the SONAME of ++dnl a shared library. e.g. NE_ADD_ABITAG(FOO) ++AC_DEFUN([NE_ADD_ABITAG], [ ++if test "x${NE_LIBTOOL_RELEASE}y" = "xy"; then ++ NE_LIBTOOL_RELEASE="$1" ++else ++ NE_LIBTOOL_RELEASE="${NE_LIBTOOL_RELEASE}-$1" ++fi ++]) ++ ++dnl Define the minimum required versions, usage: ++dnl NE_REQUIRE_VERSIONS([major-version], [minor-versions]) ++dnl e.g. ++dnl NE_REQUIRE_VERSIONS([0], [24 25]) ++dnl to require neon 0.24.x or neon 0.25.x. ++AC_DEFUN([NE_REQUIRE_VERSIONS], [ ++m4_define([ne_require_major], [$1]) ++m4_define([ne_require_minor], [$2]) ++]) ++ ++dnl Check that the external library found in a given location ++dnl matches the min. required version (if any). Requires that ++dnl NEON_CONFIG be set the the full path of a valid neon-config ++dnl script ++dnl ++dnl Usage: ++dnl NEON_CHECK_VERSION(ACTIONS-IF-OKAY, ACTIONS-IF-FAILURE) ++dnl ++AC_DEFUN([NEON_CHECK_VERSION], [ ++m4_ifdef([ne_require_major], [ ++ # Check whether the library is of required version ++ ne_save_LIBS="$LIBS" ++ ne_save_CFLAGS="$CFLAGS" ++ CFLAGS="$CFLAGS `$NEON_CONFIG --cflags`" ++ LIBS="$LIBS `$NEON_CONFIG --libs`" ++ ne_libver=`$NEON_CONFIG --version | sed -e "s/neon //g"` ++ # Check whether it's possible to link against neon ++ AC_CACHE_CHECK([linking against neon], [ne_cv_lib_neon], ++ [AC_LINK_IFELSE( ++ [AC_LANG_PROGRAM([[#include ]], [[ne_version_match(0, 0);]])], ++ [ne_cv_lib_neon=yes], [ne_cv_lib_neon=no])]) ++ if test "$ne_cv_lib_neon" = "yes"; then ++ ne_cv_lib_neonver=no ++ for v in ne_require_minor; do ++ case $ne_libver in ++ ne_require_major.$v.*) ne_cv_lib_neonver=yes ;; ++ esac ++ done ++ fi ++ ne_goodver=$ne_cv_lib_neonver ++ LIBS=$ne_save_LIBS ++ CFLAGS=$ne_save_CFLAGS ++], [ ++ # NE_REQUIRE_VERSIONS not used; presume all versions OK! ++ ne_goodver=yes ++ ne_libver="(version unknown)" ++]) ++ ++if test "$ne_goodver" = "yes"; then ++ AC_MSG_NOTICE([using neon library $ne_libver]) ++ $1 ++else ++ AC_MSG_NOTICE([incompatible neon library version $ne_libver: wanted ne_require_major.ne_require_minor]) ++ $2 ++fi]) ++ ++dnl NEON_CHECK_SUPPORT(feature, var, name) ++AC_DEFUN([NEON_CHECK_SUPPORT], [ ++if $NEON_CONFIG --support $1 >/dev/null; then ++ NE_ENABLE_SUPPORT($2, [$3 is supported by neon]) ++else ++ NE_DISABLE_SUPPORT($2, [$3 is not supported by neon]) ++fi ++]) ++ ++dnl enable support for feature $1 with define NE_HAVE_$1, message $2 ++AC_DEFUN([NE_ENABLE_SUPPORT], [ ++NE_FLAG_$1=yes ++AC_SUBST(NE_FLAG_$1) ++AC_DEFINE([NE_HAVE_]$1, 1, [Defined if $1 is supported]) ++m4_if([$2], [], ++ [ne_$1_message="support enabled" ++ AC_MSG_NOTICE([$1 support is enabled])], ++ [ne_$1_message="$2" ++ AC_MSG_NOTICE([$2])]) ++]) ++ ++dnl Disable support for feature $1, giving message $2 ++AC_DEFUN([NE_DISABLE_SUPPORT], [ ++NE_FLAG_$1=no ++AC_SUBST(NE_FLAG_$1) ++m4_if([$2], [], ++ [ne_$1_message="not supported" ++ AC_MSG_NOTICE([$1 support is not enabled])], ++ [ne_$1_message="$2" ++ AC_MSG_NOTICE([$2])]) ++]) ++ ++AC_DEFUN([NEON_USE_EXTERNAL], [ ++# Configure to use an external neon, given a neon-config script ++# found at $NEON_CONFIG. ++neon_prefix=`$NEON_CONFIG --prefix` ++NEON_CHECK_VERSION([ ++ # Pick up CFLAGS and LIBS needed ++ CFLAGS="$CFLAGS `$NEON_CONFIG --cflags`" ++ NEON_LIBS="$NEON_LIBS `$NEON_CONFIG --libs`" ++ # Pick up library version ++ set dummy `$NEON_CONFIG --version | sed 's/\./ /g'` ++ NE_VERSION_MAJOR=[$]3; NE_VERSION_MINOR=[$]4; NE_VERSION_PATCH=[$]5 ++ NE_DEFINE_VERSIONS ++ neon_library_message="library in ${neon_prefix} (${NEON_VERSION})" ++ neon_xml_parser_message="using whatever neon uses" ++ NEON_CHECK_SUPPORT([ssl], [SSL], [SSL]) ++ NEON_CHECK_SUPPORT([zlib], [ZLIB], [zlib]) ++ NEON_CHECK_SUPPORT([ipv6], [IPV6], [IPv6]) ++ NEON_CHECK_SUPPORT([lfs], [LFS], [LFS]) ++ NEON_CHECK_SUPPORT([ts_ssl], [TS_SSL], [thread-safe SSL]) ++ neon_got_library=yes ++ if test $NE_FLAG_LFS = yes; then ++ NEON_FORMAT(off64_t) ++ AC_DEFINE_UNQUOTED([NE_FMT_NE_OFF_T], [NE_FMT_OFF64_T], ++ [Define to be printf format string for ne_off_t]) ++ else ++ AC_DEFINE_UNQUOTED([NE_FMT_NE_OFF_T], [NE_FMT_OFF_T]) ++ fi ++], [neon_got_library=no]) ++]) ++ ++AC_DEFUN([NEON_COMMON],[ ++ ++AC_REQUIRE([NEON_COMMON_CHECKS]) ++ ++AC_ARG_WITH(neon, ++[ --with-neon[[=DIR]] specify location of neon library], ++[case $withval in ++yes|no) neon_force_external=$withval; neon_ext_path= ;; ++*) neon_force_external=yes; neon_ext_path=$withval ;; ++esac;], [ ++neon_force_external=no ++neon_ext_path= ++]) ++ ++if test "$neon_force_included" = "no"; then ++ # There is no included neon source directory, or --with-included-neon ++ # wasn't given (so we're not forced to use it). ++ ++ # Default to no external neon. ++ neon_got_library=no ++ if test "x$neon_ext_path" = "x"; then ++ AC_PATH_PROG([NEON_CONFIG], neon-config, none) ++ if test "x${NEON_CONFIG}" = "xnone"; then ++ AC_MSG_NOTICE([no external neon library found]) ++ elif test -x "${NEON_CONFIG}"; then ++ NEON_USE_EXTERNAL ++ else ++ AC_MSG_NOTICE([ignoring non-executable ${NEON_CONFIG}]) ++ fi ++ else ++ AC_MSG_CHECKING([for neon library in $neon_ext_path]) ++ NEON_CONFIG="$neon_ext_path/bin/neon-config" ++ if test -x ${NEON_CONFIG}; then ++ AC_MSG_RESULT([found]) ++ NEON_USE_EXTERNAL ++ else ++ AC_MSG_RESULT([not found]) ++ # ...will fail since force_external=yes ++ fi ++ fi ++ ++ if test "$neon_got_library" = "no"; then ++ if test $neon_force_external = yes; then ++ AC_MSG_ERROR([could not use external neon library]) ++ elif test -n "$neon_bundled_srcdir"; then ++ # Couldn't find external neon, forced to use bundled sources ++ neon_force_included="yes" ++ else ++ # Couldn't find neon, and don't have bundled sources ++ AC_MSG_ERROR(could not find neon) ++ fi ++ fi ++fi ++ ++if test "$neon_force_included" = "yes"; then ++ NE_VERSIONS_BUNDLED ++ AC_MSG_NOTICE([using bundled neon ($NEON_VERSION)]) ++ NEON_BUILD_BUNDLED="yes" ++ LIBNEON_SOURCE_CHECKS ++ CFLAGS="$CFLAGS -I$neon_bundled_srcdir" ++ NEON_LIBS="-L$neon_bundled_builddir -lneon $NEON_LIBS" ++ NEON_NEED_XML_PARSER=yes ++ neon_library_message="included libneon (${NEON_VERSION})" ++else ++ # Don't need to configure an XML parser ++ NEON_NEED_XML_PARSER=no ++ NEON_BUILD_BUNDLED=no ++fi ++ ++AC_SUBST(NEON_BUILD_BUNDLED) ++ ++]) ++ ++dnl AC_SEARCH_LIBS done differently. Usage: ++dnl NE_SEARCH_LIBS(function, libnames, [extralibs], [actions-if-not-found], ++dnl [actions-if-found]) ++dnl Tries to find 'function' by linking againt `-lLIB $NEON_LIBS' for each ++dnl LIB in libnames. If link fails and 'extralibs' is given, will also ++dnl try linking against `-lLIB extralibs $NEON_LIBS`. ++dnl Once link succeeds, `-lLIB [extralibs]` is prepended to $NEON_LIBS, and ++dnl `actions-if-found' are executed, if given. ++dnl If link never succeeds, run `actions-if-not-found', if given, else ++dnl give an error and fail configure. ++AC_DEFUN([NE_SEARCH_LIBS], [ ++ ++AC_REQUIRE([NE_CHECK_OS]) ++ ++AC_CACHE_CHECK([for library containing $1], [ne_cv_libsfor_$1], [ ++AC_LINK_IFELSE( ++ [AC_LANG_PROGRAM([], [[$1();]])], ++ [ne_cv_libsfor_$1="none needed"], [ ++ne_sl_save_LIBS=$LIBS ++ne_cv_libsfor_$1="not found" ++for lib in $2; do ++ # The w32api libraries link using the stdcall calling convention. ++ case ${lib}-${ne_cv_os_uname} in ++ ws2_32-MINGW*) ne__code="__stdcall $1();" ;; ++ *) ne__code="$1();" ;; ++ esac ++ ++ LIBS="$ne_sl_save_LIBS -l$lib $NEON_LIBS" ++ AC_LINK_IFELSE([AC_LANG_PROGRAM([], [$ne__code])], ++ [ne_cv_libsfor_$1="-l$lib"; break]) ++ m4_if($3, [], [], dnl If $3 is specified, then... ++ [LIBS="$ne_sl_save_LIBS -l$lib $3 $NEON_LIBS" ++ AC_LINK_IFELSE([AC_LANG_PROGRAM([], [$ne__code])], ++ [ne_cv_libsfor_$1="-l$lib $3"; break])]) ++done ++LIBS=$ne_sl_save_LIBS])]) ++ ++if test "$ne_cv_libsfor_$1" = "not found"; then ++ m4_if([$4], [], [AC_MSG_ERROR([could not find library containing $1])], [$4]) ++elif test "$ne_cv_libsfor_$1" = "none needed"; then ++ m4_if([$5], [], [:], [$5]) ++else ++ NEON_LIBS="$ne_cv_libsfor_$1 $NEON_LIBS" ++ $5 ++fi]) ++ ++dnl Check for presence and suitability of zlib library ++AC_DEFUN([NEON_ZLIB], [ ++ ++AC_ARG_WITH(zlib, AS_HELP_STRING([--without-zlib], [disable zlib support]), ++ne_use_zlib=$withval, ne_use_zlib=yes) ++ ++if test "$ne_use_zlib" = "yes"; then ++ AC_CHECK_HEADER(zlib.h, [ ++ AC_CHECK_LIB(z, inflate, [ ++ NEON_LIBS="$NEON_LIBS -lz" ++ NE_ENABLE_SUPPORT(ZLIB, [zlib support enabled, using -lz]) ++ ], [NE_DISABLE_SUPPORT(ZLIB, [zlib library not found])]) ++ ], [NE_DISABLE_SUPPORT(ZLIB, [zlib header not found])]) ++else ++ NE_DISABLE_SUPPORT(ZLIB, [zlib not enabled]) ++fi ++]) ++ ++AC_DEFUN([NE_CHECK_OS], [ ++# Check for Darwin, which needs extra cpp and linker flags. ++AC_CACHE_CHECK([for uname], ne_cv_os_uname, [ ++ ne_cv_os_uname=`uname -s 2>/dev/null` ++]) ++ ++if test "$ne_cv_os_uname" = "Darwin"; then ++ CPPFLAGS="$CPPFLAGS -no-cpp-precomp" ++ LDFLAGS="$LDFLAGS -flat_namespace" ++ # poll has various issues in various Darwin releases ++ if test x${ac_cv_func_poll+set} != xset; then ++ ac_cv_func_poll=no ++ fi ++fi ++]) ++ ++AC_DEFUN([NEON_COMMON_CHECKS], [ ++ ++# These checks are done whether or not the bundled neon build ++# is used. ++ ++ifdef([AC_USE_SYSTEM_EXTENSIONS], ++[AC_USE_SYSTEM_EXTENSIONS], ++[AC_ISC_POSIX]) ++AC_REQUIRE([AC_PROG_CC]) ++AC_REQUIRE([AC_C_INLINE]) ++AC_REQUIRE([AC_C_CONST]) ++AC_REQUIRE([AC_TYPE_SIZE_T]) ++AC_REQUIRE([AC_TYPE_OFF_T]) ++ ++AC_REQUIRE([NE_CHECK_OS]) ++ ++AC_REQUIRE([AC_PROG_MAKE_SET]) ++ ++AC_REQUIRE([AC_HEADER_STDC]) ++ ++AC_CHECK_HEADERS([errno.h stdarg.h string.h stdlib.h]) ++ ++NEON_FORMAT(size_t,,u) dnl size_t is unsigned; use %u formats ++NEON_FORMAT(off_t) ++NEON_FORMAT(ssize_t) ++ ++]) ++ ++AC_DEFUN([NEON_FORMAT_PREP], [ ++AC_CHECK_SIZEOF(int) ++AC_CHECK_SIZEOF(long) ++AC_CHECK_SIZEOF(long long) ++if test "$GCC" = "yes"; then ++ AC_CACHE_CHECK([for gcc -Wformat -Werror sanity], ne_cv_cc_werror, [ ++ # See whether a simple test program will compile without errors. ++ ne_save_CPPFLAGS=$CPPFLAGS ++ CPPFLAGS="$CPPFLAGS -Wformat -Werror" ++ AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include ++#include ]], [[int i = 42; printf("%d", i);]])], ++ [ne_cv_cc_werror=yes], [ne_cv_cc_werror=no]) ++ CPPFLAGS=$ne_save_CPPFLAGS]) ++ ne_fmt_trycompile=$ne_cv_cc_werror ++else ++ ne_fmt_trycompile=no ++fi ++]) ++ ++dnl Check for LFS support ++AC_DEFUN([NE_LARGEFILE], [ ++dnl Need the size of off_t ++AC_REQUIRE([NEON_COMMON_CHECKS]) ++ ++if test -z "$ac_cv_sizeof_off_t"; then ++ NE_DISABLE_SUPPORT(LFS, [LFS support omitted: off_t size unknown!]) ++elif test $ac_cv_sizeof_off_t != 4; then ++ NE_DISABLE_SUPPORT(LFS, [LFS support unnecessary, off_t is not 32-bit]) ++ AC_CHECK_FUNCS([strtoll strtoq], [break]) ++elif test -z "$ac_cv_sizeof_long_long"; then ++ NE_DISABLE_SUPPORT(LFS, [LFS support omitted: long long size unknown]) ++elif test $ac_cv_sizeof_long_long != 8; then ++ NE_DISABLE_SUPPORT(LFS, [LFS support omitted: long long not 64-bit]) ++else ++ ne_save_CPPFLAGS=$CPPFLAGS ++ CPPFLAGS="$CPPFLAGS -D_LARGEFILE64_SOURCE" ++ AC_CHECK_TYPE(off64_t, [ ++ NEON_FORMAT(off64_t) ++ ne_lfsok=no ++ AC_CHECK_FUNCS([strtoll strtoq], [ne_lfsok=yes; break]) ++ AC_CHECK_FUNCS([lseek64 fstat64], [], [ne_lfsok=no; break]) ++ if test x$ne_lfsok = xyes; then ++ NE_ENABLE_SUPPORT(LFS, [LFS (large file) support enabled]) ++ NEON_CFLAGS="$NEON_CFLAGS -D_LARGEFILE64_SOURCE -DNE_LFS" ++ ne_save_CPPFLAGS="$CPPFLAGS -DNE_LFS" ++ else ++ NE_DISABLE_SUPPORT(LFS, ++ [LFS support omitted: 64-bit support functions not found]) ++ fi], [NE_DISABLE_SUPPORT(LFS, [LFS support omitted: off64_t type not found])]) ++ CPPFLAGS=$ne_save_CPPFLAGS ++fi ++if test "$NE_FLAG_LFS" = "yes"; then ++ AC_DEFINE_UNQUOTED([NE_FMT_NE_OFF_T], [NE_FMT_OFF64_T], ++ [Define to be printf format string for ne_off_t]) ++else ++ AC_DEFINE_UNQUOTED([NE_FMT_NE_OFF_T], [NE_FMT_OFF_T]) ++fi ++]) ++ ++dnl NEON_FORMAT(TYPE[, HEADERS[, [SPECIFIER]]) ++dnl ++dnl This macro finds out which modifier is needed to create a ++dnl printf format string suitable for printing integer type TYPE (which ++dnl may be an int, long, or long long). ++dnl The default specifier is 'd', if SPECIFIER is not given. ++dnl TYPE may be defined in HEADERS; sys/types.h is always used first. ++AC_DEFUN([NEON_FORMAT], [ ++ ++AC_REQUIRE([NEON_FORMAT_PREP]) ++ ++AC_CHECK_SIZEOF($1,, [AC_INCLUDES_DEFAULT ++$2]) ++ ++dnl Work out which specifier character to use ++m4_ifdef([ne_spec], [m4_undefine([ne_spec])]) ++m4_if($#, 3, [m4_define(ne_spec,$3)], [m4_define(ne_spec,d)]) ++ ++m4_ifdef([ne_cvar], [m4_undefine([ne_cvar])])dnl ++m4_define([ne_cvar], m4_translit(ne_cv_fmt_[$1], [ ], [_]))dnl ++ ++AC_CACHE_CHECK([how to print $1], [ne_cvar], [ ++ne_cvar=none ++if test $ne_fmt_trycompile = yes; then ++ oflags="$CPPFLAGS" ++ # Consider format string mismatches as errors ++ CPPFLAGS="$CPPFLAGS -Wformat -Werror" ++ dnl obscured for m4 quoting: "for str in d ld lld; do" ++ for str in ne_spec l]ne_spec[ ll]ne_spec[; do ++ AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include ++$2 ++#include ]], [[$1 i = 1; printf("%$str", i);]])], ++ [ne_cvar=$str; break]) ++ done ++ CPPFLAGS=$oflags ++else ++ # Best guess. Don't have to be too precise since we probably won't ++ # get a warning message anyway. ++ case $ac_cv_sizeof_]m4_translit($1, [ ], [_])[ in ++ $ac_cv_sizeof_int) ne_cvar="ne_spec" ;; ++ $ac_cv_sizeof_long) ne_cvar="l]ne_spec[" ;; ++ $ac_cv_sizeof_long_long) ne_cvar="ll]ne_spec[" ;; ++ esac ++fi ++]) ++ ++if test "x$ne_cvar" = "xnone"; then ++ AC_MSG_ERROR([format string for $1 not found]) ++fi ++ ++AC_DEFINE_UNQUOTED([NE_FMT_]m4_translit($1, [a-z ], [A-Z_]), "$ne_cvar", ++ [Define to be printf format string for $1]) ++]) ++ ++dnl Wrapper for AC_CHECK_FUNCS; uses libraries from $NEON_LIBS. ++AC_DEFUN([NE_CHECK_FUNCS], [ ++ne_cf_save_LIBS=$LIBS ++LIBS="$LIBS $NEON_LIBS" ++AC_CHECK_FUNCS($@) ++LIBS=$ne_cf_save_LIBS]) ++ ++dnl Checks needed when compiling the neon source. ++AC_DEFUN([LIBNEON_SOURCE_CHECKS], [ ++ ++dnl Run all the normal C language/compiler tests ++AC_REQUIRE([NEON_COMMON_CHECKS]) ++ ++dnl Needed for building the MD5 code. ++AC_REQUIRE([AC_C_BIGENDIAN]) ++dnl Is strerror_r present; if so, which variant ++AC_REQUIRE([AC_FUNC_STRERROR_R]) ++ ++AC_CHECK_HEADERS([sys/time.h limits.h sys/select.h arpa/inet.h libintl.h \ ++ signal.h sys/socket.h netinet/in.h netinet/tcp.h netdb.h sys/poll.h \ ++ sys/limits.h fcntl.h iconv.h],,, ++[AC_INCLUDES_DEFAULT ++/* netinet/tcp.h requires netinet/in.h on some platforms. */ ++#ifdef HAVE_NETINET_IN_H ++#include ++#endif]) ++ ++AC_REQUIRE([NE_SNPRINTF]) ++ ++AC_CACHE_CHECK([for timezone global], ne_cv_cc_timezone, [ ++AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include ++#include ]], ++[[time_t t = 0 - timezone; timezone = 1;]])], ++ne_cv_cc_timezone=yes, ne_cv_cc_timezone=no)]) ++ ++if test "$ne_cv_cc_timezone" = "yes"; then ++ AC_DEFINE([HAVE_TIMEZONE], 1, [Define if the timezone global is available]) ++fi ++ ++dnl Check for large file support ++NE_LARGEFILE ++ ++AC_REPLACE_FUNCS(strcasecmp) ++ ++AC_CHECK_FUNCS(signal setvbuf setsockopt stpcpy poll fcntl getsockopt) ++ ++if test "x${ac_cv_func_poll}${ac_cv_header_sys_poll_h}y" = "xyesyesy"; then ++ AC_DEFINE([NE_USE_POLL], 1, [Define if poll() should be used]) ++fi ++ ++if test "$ac_cv_func_stpcpy" = "yes"; then ++ AC_CHECK_DECLS(stpcpy) ++fi ++ ++# Modern AIXes with the "Linux-like" libc have an undeclared stpcpy ++AH_BOTTOM([#if defined(HAVE_STPCPY) && defined(HAVE_DECL_STPCPY) && !HAVE_DECL_STPCPY && !defined(stpcpy) ++char *stpcpy(char *, const char *); ++#endif]) ++ ++# Unixware 7 can only link gethostbyname with -lnsl -lsocket ++# Pick up -lsocket first, then the gethostbyname check will work. ++# Haiku requires -lnetwork for socket functions. ++NE_SEARCH_LIBS(socket, socket inet ws2_32 network) ++ ++# Enable getaddrinfo support if it, gai_strerror and inet_ntop are ++# all available. ++NE_SEARCH_LIBS(getaddrinfo, nsl,, ++ [ne_enable_gai=no], ++ [# HP-UX boxes commonly get into a state where getaddrinfo is present ++ # but borked: http://marc.theaimsgroup.com/?l=apr-dev&m=107730955207120&w=2 ++ case x`uname -sr 2>/dev/null`y in ++ xHP-UX*11.[[01]]*y) ++ AC_MSG_NOTICE([getaddrinfo support disabled on HP-UX 11.0x/11.1x]) ;; ++ *) ++ ne_enable_gai=yes ++ NE_CHECK_FUNCS(gai_strerror getnameinfo inet_ntop inet_pton,, ++ [ne_enable_gai=no; break]) ;; ++ esac ++]) ++ ++if test $ne_enable_gai = yes; then ++ NE_ENABLE_SUPPORT(IPV6, [IPv6 support is enabled]) ++ AC_DEFINE(USE_GETADDRINFO, 1, [Define if getaddrinfo() should be used]) ++ AC_CACHE_CHECK([for working AI_ADDRCONFIG], [ne_cv_gai_addrconfig], [ ++ AC_RUN_IFELSE([AC_LANG_PROGRAM([#include ], ++[struct addrinfo hints = {0}, *result; ++hints.ai_flags = AI_ADDRCONFIG; ++if (getaddrinfo("localhost", NULL, &hints, &result) != 0) return 1;])], ++ ne_cv_gai_addrconfig=yes, ne_cv_gai_addrconfig=no, ne_cv_gai_addrconfig=no)]) ++ if test $ne_cv_gai_addrconfig = yes; then ++ AC_DEFINE(USE_GAI_ADDRCONFIG, 1, [Define if getaddrinfo supports AI_ADDRCONFIG]) ++ fi ++else ++ # Checks for non-getaddrinfo() based resolver interfaces. ++ # QNX has gethostbyname in -lsocket. BeOS only has it in -lbind. ++ # CygWin/Winsock2 has it in -lws2_32, allegedly. ++ # Haiku requires -lnetwork for socket functions. ++ NE_SEARCH_LIBS(gethostbyname, socket nsl bind ws2_32 network) ++ NE_SEARCH_LIBS(hstrerror, resolv,,[:]) ++ NE_CHECK_FUNCS(hstrerror) ++ # Older Unixes don't declare h_errno. ++ AC_CHECK_DECLS(h_errno,,,[#include ]) ++ AC_CHECK_TYPE(in_addr_t,,[ ++ AC_DEFINE([in_addr_t], [unsigned int], ++ [Define if in_addr_t is not available])], [ ++#ifdef HAVE_SYS_TYPES_H ++# include ++#endif ++#ifdef HAVE_NETINET_IN_H ++# include ++#endif ++]) ++fi ++ ++AC_CHECK_TYPES(socklen_t,, ++# Linux accept(2) says this should be size_t for SunOS 5... gah. ++[AC_DEFINE([socklen_t], [int], ++ [Define if socklen_t is not available])],[ ++#ifdef HAVE_SYS_TYPES_H ++# include ++#endif ++#ifdef HAVE_SYS_SOCKET_H ++# include ++#endif ++]) ++ ++AC_CHECK_MEMBERS([struct tm.tm_gmtoff, struct tm.__tm_gmtoff],,, ++ [#include ]) ++ ++if test ${ac_cv_member_struct_tm_tm_gmtoff}${ac_cv_member_struct_tm___tm_gmtoff}${ne_cv_cc_timezone} = nonono; then ++ AC_MSG_WARN([no timezone handling in date parsing on this platform]) ++fi ++ ++ifdef([neon_no_zlib], ++ [NE_DISABLE_SUPPORT(ZLIB, [zlib not supported])], ++ [NEON_ZLIB()]) ++ ++# Conditionally enable ACL support ++AC_MSG_CHECKING([whether to enable ACL support in neon]) ++if test "x$neon_no_acl" = "xyes"; then ++ AC_MSG_RESULT(no) ++else ++ AC_MSG_RESULT(yes) ++ NEON_EXTRAOBJS="$NEON_EXTRAOBJS ne_oldacl ne_acl3744" ++fi ++ ++NEON_SSL() ++NEON_GSSAPI() ++NEON_LIBPROXY() ++ ++AC_SUBST(NEON_CFLAGS) ++AC_SUBST(NEON_LIBS) ++AC_SUBST(NEON_LTLIBS) ++ ++]) ++ ++dnl Call to put lib/snprintf.o in LIBOBJS and define HAVE_SNPRINTF_H ++dnl if snprintf isn't in libc. ++ ++AC_DEFUN([NEON_REPLACE_SNPRINTF], [ ++# Check for snprintf ++AC_CHECK_FUNC(snprintf,,[ ++ AC_DEFINE(HAVE_SNPRINTF_H, 1, [Define if need to include snprintf.h]) ++ AC_LIBOBJ(lib/snprintf)]) ++]) ++ ++dnl turn off webdav, boo hoo. ++AC_DEFUN([NEON_WITHOUT_WEBDAV], [ ++neon_no_webdav=yes ++neon_no_acl=yes ++NEON_NEED_XML_PARSER=no ++neon_xml_parser_message="none needed" ++]) ++ ++dnl Turn off zlib support ++AC_DEFUN([NEON_WITHOUT_ZLIB], [ ++define(neon_no_zlib, yes) ++]) ++ ++AC_DEFUN([NEON_WITHOUT_ACL], [ ++# Turn off ACL support ++neon_no_acl=yes ++]) ++ ++dnl Common macro to NEON_LIBTOOL_BUILD and NEON_NORMAL_BUILD ++dnl Sets NEONOBJS appropriately if it has not already been set. ++dnl ++dnl NOT FOR EXTERNAL USE: use LIBTOOL_BUILD or NORMAL_BUILD. ++dnl ++ ++AC_DEFUN([NEON_COMMON_BUILD], [ ++ ++# Using the default set of object files to build. ++# Add the extension to EXTRAOBJS ++ne="$NEON_EXTRAOBJS" ++NEON_EXTRAOBJS= ++for o in $ne; do ++ NEON_EXTRAOBJS="$NEON_EXTRAOBJS $o.$NEON_OBJEXT" ++done ++ ++# Was DAV support explicitly turned off? ++if test "x$neon_no_webdav" = "xyes"; then ++ # No WebDAV support ++ NEONOBJS="$NEONOBJS \$(NEON_BASEOBJS)" ++ NE_DISABLE_SUPPORT(DAV, [WebDAV support is not enabled]) ++ NE_ADD_ABITAG(NODAV) ++else ++ # WebDAV support ++ NEONOBJS="$NEONOBJS \$(NEON_DAVOBJS)" ++ NE_ENABLE_SUPPORT(DAV, [WebDAV support is enabled]) ++fi ++ ++AC_SUBST(NEON_TARGET) ++AC_SUBST(NEON_OBJEXT) ++AC_SUBST(NEONOBJS) ++AC_SUBST(NEON_EXTRAOBJS) ++AC_SUBST(NEON_LINK_FLAGS) ++ ++]) ++ ++# The libtoolized build case: ++AC_DEFUN([NEON_LIBTOOL_BUILD], [ ++ ++NEON_TARGET=libneon.la ++NEON_OBJEXT=lo ++ ++NEON_COMMON_BUILD($#, $*) ++ ++]) ++ ++dnl Find 'ar' and 'ranlib', fail if ar isn't found. ++AC_DEFUN([NE_FIND_AR], [ ++ ++# Search in /usr/ccs/bin for Solaris ++ne_PATH=$PATH:/usr/ccs/bin ++AC_PATH_TOOL(AR, ar, notfound, $ne_PATH) ++if test "x$AR" = "xnotfound"; then ++ AC_MSG_ERROR([could not find ar tool]) ++fi ++AC_PATH_TOOL(RANLIB, ranlib, :, $ne_PATH) ++ ++]) ++ ++# The non-libtool build case: ++AC_DEFUN([NEON_NORMAL_BUILD], [ ++ ++NEON_TARGET=libneon.a ++NEON_OBJEXT=o ++ ++AC_REQUIRE([NE_FIND_AR]) ++ ++NEON_COMMON_BUILD($#, $*) ++ ++]) ++ ++AC_DEFUN([NE_SNPRINTF], [ ++AC_CHECK_FUNCS(snprintf vsnprintf,,[ ++ ne_save_LIBS=$LIBS ++ LIBS="$LIBS -lm" # Always need -lm ++ AC_CHECK_LIB(trio, trio_vsnprintf, ++ [AC_CHECK_HEADERS(trio.h,, ++ AC_MSG_ERROR([trio installation problem? libtrio found but not trio.h])) ++ AC_MSG_NOTICE(using trio printf replacement library) ++ NEON_LIBS="$NEON_LIBS -ltrio -lm" ++ AC_DEFINE(HAVE_TRIO, 1, [Use trio printf replacement library])], ++ [AC_MSG_NOTICE([no vsnprintf/snprintf detected in C library]) ++ AC_MSG_ERROR([Install the trio library from http://daniel.haxx.se/projects/trio/])]) ++ LIBS=$ne_save_LIBS ++ break ++])]) ++ ++dnl Usage: NE_CHECK_OPENSSLVER(variable, version-string, version-hex) ++dnl Define 'variable' to 'yes' if OpenSSL version is >= version-hex ++AC_DEFUN([NE_CHECK_OPENSSLVER], [ ++AC_CACHE_CHECK([OpenSSL version is >= $2], $1, [ ++AC_EGREP_CPP(good, [#include ++#if OPENSSL_VERSION_NUMBER >= $3 ++good ++#endif], [$1=yes], [$1=no])])]) ++ ++dnl Less noisy replacement for PKG_CHECK_MODULES ++AC_DEFUN([NE_PKG_CONFIG], [ ++ ++m4_define([ne_cvar], m4_translit(ne_cv_pkg_[$2], [.-], [__]))dnl ++ ++AC_PATH_PROG(PKG_CONFIG, pkg-config, no) ++if test "$PKG_CONFIG" = "no"; then ++ : Not using pkg-config ++ $4 ++else ++ AC_CACHE_CHECK([for $2 pkg-config data], ne_cvar, ++ [if $PKG_CONFIG $2; then ++ ne_cvar=yes ++ else ++ ne_cvar=no ++ fi]) ++ ++ if test "$ne_cvar" = "yes"; then ++ $1_CFLAGS=`$PKG_CONFIG --cflags $2` ++ $1_LIBS=`$PKG_CONFIG --libs $2` ++ : Using provided pkg-config data ++ $3 ++ else ++ : No pkg-config for $2 provided ++ $4 ++ fi ++fi ++ ++m4_undefine([ne_cvar]) ++]) ++ ++dnl Check for an SSL library (GNU TLS or OpenSSL) ++AC_DEFUN([NEON_SSL], [ ++ ++AC_ARG_WITH(ssl, ++ AS_HELP_STRING([--with-ssl=openssl|gnutls], ++ [enable SSL support (default OpenSSL)])) ++ ++AC_ARG_WITH(egd, ++[[ --with-egd[=PATH] enable EGD support [using EGD socket at PATH]]]) ++ ++AC_ARG_WITH(pakchois, ++ AS_HELP_STRING([--without-pakchois], ++ [disable support for PKCS#11 using pakchois])) ++ ++case $with_ssl in ++/*) ++ AC_MSG_NOTICE([to use SSL libraries in non-standard locations, try --with-ssl --with-libs=$with_ssl]) ++ AC_MSG_ERROR([--with-ssl does not take a path argument]) ++ ;; ++yes|openssl) ++ NE_PKG_CONFIG(NE_SSL, openssl, ++ [AC_MSG_NOTICE(using SSL library configuration from pkg-config) ++ CPPFLAGS="$CPPFLAGS ${NE_SSL_CFLAGS}" ++ NEON_LIBS="$NEON_LIBS ${NE_SSL_LIBS}"], ++ [# Either OpenSSL library may require -ldl if built with dynamic engine support ++ NE_SEARCH_LIBS(RSA_new, crypto, -ldl) ++ NE_SEARCH_LIBS(SSL_library_init, ssl, -ldl)]) ++ ++ AC_CHECK_HEADERS(openssl/ssl.h openssl/opensslv.h,, ++ [AC_MSG_ERROR([OpenSSL headers not found, cannot enable SSL support])]) ++ ++ # Enable EGD support if using 0.9.7 or newer ++ NE_CHECK_OPENSSLVER(ne_cv_lib_ssl097, 0.9.7, 0x00907000L) ++ if test "$ne_cv_lib_ssl097" = "yes"; then ++ AC_MSG_NOTICE([OpenSSL >= 0.9.7; EGD support not needed in neon]) ++ NE_ENABLE_SUPPORT(SSL, [SSL support enabled, using OpenSSL (0.9.7 or later)]) ++ NE_CHECK_FUNCS(CRYPTO_set_idptr_callback SSL_SESSION_cmp) ++ else ++ # Fail if OpenSSL is older than 0.9.6 ++ NE_CHECK_OPENSSLVER(ne_cv_lib_ssl096, 0.9.6, 0x00906000L) ++ if test "$ne_cv_lib_ssl096" != "yes"; then ++ AC_MSG_ERROR([OpenSSL 0.9.6 or later is required]) ++ fi ++ NE_ENABLE_SUPPORT(SSL, [SSL support enabled, using OpenSSL (0.9.6 or later)]) ++ ++ case "$with_egd" in ++ yes|no) ne_cv_lib_sslegd=$with_egd ;; ++ /*) ne_cv_lib_sslegd=yes ++ AC_DEFINE_UNQUOTED([EGD_PATH], "$with_egd", ++ [Define to specific EGD socket path]) ;; ++ *) # Guess whether EGD support is needed ++ AC_CACHE_CHECK([whether to enable EGD support], [ne_cv_lib_sslegd], ++ [if test -r /dev/random || test -r /dev/urandom; then ++ ne_cv_lib_sslegd=no ++ else ++ ne_cv_lib_sslegd=yes ++ fi]) ++ ;; ++ esac ++ if test "$ne_cv_lib_sslegd" = "yes"; then ++ AC_MSG_NOTICE([EGD support enabled for seeding OpenSSL PRNG]) ++ AC_DEFINE([ENABLE_EGD], 1, [Define if EGD should be supported]) ++ fi ++ fi ++ ++ AC_DEFINE([HAVE_OPENSSL], 1, [Define if OpenSSL support is enabled]) ++ NEON_EXTRAOBJS="$NEON_EXTRAOBJS ne_openssl" ++ ++ AC_DEFINE([HAVE_NTLM], 1, [Define if NTLM is supported]) ++ ;; ++gnutls) ++ NE_PKG_CONFIG(NE_SSL, gnutls, ++ [AC_MSG_NOTICE(using GnuTLS configuration from pkg-config) ++ CPPFLAGS="$CPPFLAGS ${NE_SSL_CFLAGS}" ++ NEON_LIBS="$NEON_LIBS ${NE_SSL_LIBS}" ++ ++ ne_gnutls_ver=`$PKG_CONFIG --modversion gnutls` ++ ], [ ++ # Fall back on libgnutls-config script ++ AC_PATH_PROG(GNUTLS_CONFIG, libgnutls-config, no) ++ ++ if test "$GNUTLS_CONFIG" = "no"; then ++ AC_MSG_ERROR([could not find libgnutls-config in \$PATH]) ++ fi ++ ++ CPPFLAGS="$CPPFLAGS `$GNUTLS_CONFIG --cflags`" ++ NEON_LIBS="$NEON_LIBS `$GNUTLS_CONFIG --libs`" ++ ++ ne_gnutls_ver=`$GNUTLS_CONFIG --version` ++ ]) ++ ++ AC_CHECK_HEADER([gnutls/gnutls.h],, ++ [AC_MSG_ERROR([could not find gnutls/gnutls.h in include path])]) ++ ++ NE_ENABLE_SUPPORT(SSL, [SSL support enabled, using GnuTLS $ne_gnutls_ver]) ++ NEON_EXTRAOBJS="$NEON_EXTRAOBJS ne_gnutls" ++ AC_DEFINE([HAVE_GNUTLS], 1, [Define if GnuTLS support is enabled]) ++ ++ # Check for functions in later releases ++ NE_CHECK_FUNCS([gnutls_session_get_data2 gnutls_x509_dn_get_rdn_ava \ ++ gnutls_sign_callback_set \ ++ gnutls_certificate_get_x509_cas \ ++ gnutls_certificate_verify_peers2]) ++ ++ # fail if gnutls_certificate_verify_peers2 is not found ++ if test x${ac_cv_func_gnutls_certificate_verify_peers2} != xyes; then ++ AC_MSG_ERROR([GnuTLS version predates gnutls_certificate_verify_peers2, newer version required]) ++ fi ++ ++ # Check for iconv support if using the new RDN access functions: ++ if test ${ac_cv_func_gnutls_x509_dn_get_rdn_ava}X${ac_cv_header_iconv_h} = yesXyes; then ++ AC_CHECK_FUNCS(iconv) ++ fi ++ ;; ++*) # Default to off; only create crypto-enabled binaries if requested. ++ NE_DISABLE_SUPPORT(SSL, [SSL support is not enabled]) ++ NE_DISABLE_SUPPORT(TS_SSL, [Thread-safe SSL support is not enabled]) ++ NEON_EXTRAOBJS="$NEON_EXTRAOBJS ne_stubssl" ++ ;; ++esac ++AC_SUBST(NEON_SUPPORTS_SSL) ++ ++AC_ARG_WITH(ca-bundle, ++ AS_HELP_STRING(--with-ca-bundle, specify filename of an SSL CA root bundle),, ++ with_ca_bundle=no) ++ ++case ${NE_FLAG_SSL}-${with_ca_bundle} in ++*-no) ;; ++yes-*) ++ AC_DEFINE_UNQUOTED([NE_SSL_CA_BUNDLE], ["${with_ca_bundle}"], ++ [Define to be filename of an SSL CA root bundle]) ++ AC_MSG_NOTICE([Using ${with_ca_bundle} as default SSL CA bundle]) ++ ;; ++esac ++ ++AC_ARG_ENABLE(threadsafe-ssl, ++AS_HELP_STRING(--enable-threadsafe-ssl=posix, ++[enable SSL library thread-safety using POSIX threads: suitable ++CC/CFLAGS/LIBS must be used to make the POSIX library interfaces ++available]),, ++enable_threadsafe_ssl=no) ++ ++case $enable_threadsafe_ssl in ++posix|yes) ++ ne_pthr_ok=yes ++ AC_CHECK_FUNCS([pthread_mutex_init pthread_mutex_lock],,[ne_pthr_ok=no]) ++ if test "${ne_pthr_ok}" = "no"; then ++ AC_MSG_ERROR([could not find POSIX mutex interfaces; (try CC="${CC} -pthread"?)]) ++ fi ++ NE_ENABLE_SUPPORT(TS_SSL, [Thread-safe SSL supported using POSIX threads]) ++ ;; ++*) ++ NE_DISABLE_SUPPORT(TS_SSL, [Thread-safe SSL not supported]) ++ ;; ++esac ++ ++case ${with_pakchois}X${ac_cv_func_gnutls_sign_callback_set}Y${ne_cv_lib_ssl097} in ++noX*Y*) ;; ++*X*Yyes|*XyesY*) ++ # PKCS#11... ho! ++ NE_PKG_CONFIG(NE_PK11, pakchois, ++ [AC_MSG_NOTICE([[using pakchois for PKCS#11 support]]) ++ AC_DEFINE(HAVE_PAKCHOIS, 1, [Define if pakchois library supported]) ++ CPPFLAGS="$CPPFLAGS ${NE_PK11_CFLAGS}" ++ NEON_LIBS="${NEON_LIBS} ${NE_PK11_LIBS}"], ++ [AC_MSG_NOTICE([[pakchois library not found; no PKCS#11 support]])]) ++ ;; ++esac ++]) dnl -- end defun NEON_SSL ++ ++dnl Check for Kerberos installation ++AC_DEFUN([NEON_GSSAPI], [ ++AC_ARG_WITH(gssapi, AS_HELP_STRING(--without-gssapi, disable GSSAPI support)) ++if test "$with_gssapi" != "no"; then ++ AC_PATH_PROG([KRB5_CONFIG], krb5-config, none, $PATH:/usr/kerberos/bin) ++else ++ KRB5_CONFIG=none ++fi ++if test "x$KRB5_CONFIG" != "xnone"; then ++ ne_save_CPPFLAGS=$CPPFLAGS ++ ne_save_LIBS=$NEON_LIBS ++ NEON_LIBS="$NEON_LIBS `${KRB5_CONFIG} --libs gssapi`" ++ CPPFLAGS="$CPPFLAGS `${KRB5_CONFIG} --cflags gssapi`" ++ # MIT and Heimdal put gssapi.h in different places ++ AC_CHECK_HEADERS(gssapi/gssapi.h gssapi.h, [ ++ NE_CHECK_FUNCS(gss_init_sec_context, [ ++ ne_save_CPPFLAGS=$CPPFLAGS ++ ne_save_LIBS=$NEON_LIBS ++ AC_MSG_NOTICE([GSSAPI authentication support enabled]) ++ AC_DEFINE(HAVE_GSSAPI, 1, [Define if GSSAPI support is enabled]) ++ AC_CHECK_HEADERS(gssapi/gssapi_generic.h) ++ # Older versions of MIT Kerberos lack GSS_C_NT_HOSTBASED_SERVICE ++ AC_CHECK_DECL([GSS_C_NT_HOSTBASED_SERVICE],, ++ [AC_DEFINE([GSS_C_NT_HOSTBASED_SERVICE], gss_nt_service_name, ++ [Define if GSS_C_NT_HOSTBASED_SERVICE is not defined otherwise])], ++ [#ifdef HAVE_GSSAPI_GSSAPI_H ++#include ++#else ++#include ++#endif])]) ++ break ++ ]) ++ CPPFLAGS=$ne_save_CPPFLAGS ++ NEON_LIBS=$ne_save_LIBS ++fi]) ++ ++AC_DEFUN([NEON_LIBPROXY], [ ++AC_ARG_WITH(libproxy, AS_HELP_STRING(--without-libproxy, disable libproxy support)) ++if test "x$with_libproxy" != "xno"; then ++ NE_PKG_CONFIG(NE_PXY, libproxy-1.0, ++ [AC_DEFINE(HAVE_LIBPROXY, 1, [Define if libproxy is supported]) ++ CPPFLAGS="$CPPFLAGS $NE_PXY_CFLAGS" ++ NEON_LIBS="$NEON_LIBS ${NE_PXY_LIBS}" ++ NE_ENABLE_SUPPORT(LIBPXY, [libproxy support enabled])], ++ [NE_DISABLE_SUPPORT(LIBPXY, [libproxy support not enabled])]) ++else ++ NE_DISABLE_SUPPORT(LIBPXY, [libproxy support not enabled]) ++fi ++]) ++ ++dnl Adds an --enable-warnings argument to configure to allow enabling ++dnl compiler warnings ++AC_DEFUN([NEON_WARNINGS],[ ++ ++AC_REQUIRE([AC_PROG_CC]) dnl so that $GCC is set ++ ++AC_ARG_ENABLE(warnings, ++AS_HELP_STRING(--enable-warnings, [enable compiler warnings])) ++ ++if test "$enable_warnings" = "yes"; then ++ case $GCC:`uname` in ++ yes:*) ++ CFLAGS="$CFLAGS -Wall -Wmissing-declarations -Wshadow -Wreturn-type -Wsign-compare -Wundef -Wpointer-arith -Wbad-function-cast -Wformat-security" ++ if test -z "$with_ssl" -o "$with_ssl" = "no"; then ++ # OpenSSL headers fail strict prototypes checks ++ CFLAGS="$CFLAGS -Wstrict-prototypes" ++ fi ++ ;; ++ no:OSF1) CFLAGS="$CFLAGS -check -msg_disable returnchecks -msg_disable alignment -msg_disable overflow" ;; ++ no:IRIX) CFLAGS="$CFLAGS -fullwarn" ;; ++ no:UnixWare) CFLAGS="$CFLAGS -v" ;; ++ *) AC_MSG_WARN([warning flags unknown for compiler on this platform]) ;; ++ esac ++fi ++]) ++ ++dnl Adds an --disable-debug argument to configure to allow disabling ++dnl debugging messages. ++dnl Usage: ++dnl NEON_WARNINGS([actions-if-debug-enabled], [actions-if-debug-disabled]) ++dnl ++AC_DEFUN([NEON_DEBUG], [ ++ ++AC_ARG_ENABLE(debug, ++AS_HELP_STRING(--disable-debug,[disable runtime debugging messages])) ++ ++# default is to enable debugging ++case $enable_debug in ++no) AC_MSG_NOTICE([debugging is disabled]) ++$2 ;; ++*) AC_MSG_NOTICE([debugging is enabled]) ++AC_DEFINE(NE_DEBUGGING, 1, [Define to enable debugging]) ++$1 ++;; ++esac]) ++ ++dnl Macro to optionally enable socks support ++AC_DEFUN([NEON_SOCKS], [ ++]) ++ ++AC_DEFUN([NEON_WITH_LIBS], [ ++AC_ARG_WITH([libs], ++[[ --with-libs=DIR[:DIR2...] look for support libraries in DIR/{bin,lib,include}]], ++[case $with_libs in ++yes|no) AC_MSG_ERROR([--with-libs must be passed a directory argument]) ;; ++*) ne_save_IFS=$IFS; IFS=: ++ for dir in $with_libs; do ++ ne_add_CPPFLAGS="$ne_add_CPPFLAGS -I${dir}/include" ++ ne_add_LDFLAGS="$ne_add_LDFLAGS -L${dir}/lib" ++ ne_add_PATH="${ne_add_PATH}${dir}/bin:" ++ PKG_CONFIG_PATH=${PKG_CONFIG_PATH}${PKG_CONFIG_PATH+:}${dir}/lib/pkgconfig ++ done ++ IFS=$ne_save_IFS ++ CPPFLAGS="${ne_add_CPPFLAGS} $CPPFLAGS" ++ LDFLAGS="${ne_add_LDFLAGS} $LDFLAGS" ++ PATH=${ne_add_PATH}$PATH ++ export PKG_CONFIG_PATH ;; ++esac])]) ++ ++AC_DEFUN([NEON_I18N], [ ++ ++dnl Check for NLS iff libintl.h was detected. ++AC_ARG_ENABLE(nls, ++ AS_HELP_STRING(--disable-nls, [disable internationalization support]),, ++ [enable_nls=${ac_cv_header_libintl_h}]) ++ ++if test x${enable_nls} = xyes; then ++ # presume that dgettext() is available if bindtextdomain() is... ++ # checking for dgettext() itself is awkward because gcc has a ++ # builtin of that function, which confuses AC_CHECK_FUNCS et al. ++ NE_SEARCH_LIBS(bindtextdomain, intl,,[enable_nls=no]) ++ NE_CHECK_FUNCS(bind_textdomain_codeset) ++fi ++ ++if test "$enable_nls" = "no"; then ++ NE_DISABLE_SUPPORT(I18N, [Internationalization support not enabled]) ++else ++ NE_ENABLE_SUPPORT(I18N, [Internationalization support enabled]) ++ eval localedir="${datadir}/locale" ++ AC_DEFINE_UNQUOTED([LOCALEDIR], "$localedir", ++ [Define to be location of localedir]) ++fi ++ ++]) ++ + # nls.m4 serial 3 (gettext-0.15) + dnl Copyright (C) 1995-2003, 2005-2006 Free Software Foundation, Inc. + dnl This file is free software; the Free Software Foundation +@@ -3534,11 +4934,3 @@ + esac + ]) + +-m4_include([m4/neon/neon-test.m4]) +-m4_include([m4/neon/neon-xml-parser.m4]) +-m4_include([m4/neon/neon.m4]) +-m4_include([m4/inttypes.m4]) +-m4_include([m4/longlong.m4]) +-m4_include([m4/prereq.m4]) +-m4_include([m4/readline.m4]) +-m4_include([m4/strftime.m4]) +diff a/configure b/configure +--- a/configure ++++ b/configure +@@ -673,13 +673,13 @@ + NE_FLAG_ZLIB + NE_FLAG_IPV6 + NE_FLAG_LFS +-NE_FLAG_SOCKS + NE_FLAG_TS_SSL + LIBOBJS + PKG_CONFIG + GNUTLS_CONFIG + NEON_SUPPORTS_SSL + KRB5_CONFIG ++NE_FLAG_LIBPXY + NEON_CFLAGS + NEON_LIBS + NEON_LTLIBS +@@ -1334,7 +1334,6 @@ + --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no) + --enable-FEATURE[=ARG] include FEATURE [ARG=yes] + --disable-debugging disable runtime debugging messages +- --disable-readline disable readline support + --disable-netrc enable .netrc support + --enable-threadsafe-ssl=posix + enable SSL library thread-safety using POSIX +@@ -1358,8 +1357,8 @@ + --with-egd[=PATH] enable EGD support [using EGD socket at PATH] + --without-pakchois disable support for PKCS#11 using pakchois + --with-ca-bundle specify filename of an SSL CA root bundle +- --with-socks use SOCKSv5 library + --without-gssapi disable GSSAPI support ++ --without-libproxy disable libproxy support + --with-libxml2 force use of libxml 2.x + --with-expat force use of expat + --with-included-expat use bundled expat sources +@@ -4356,6 +4355,66 @@ + + fi + ++CHECK_READLINE() ++ ++# Check whether --enable-netrc was given. ++if test "${enable_netrc+set}" = set; then ++ enableval=$enable_netrc; ++else ++ enable_netrc=yes ++fi ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++# Turn off ACL support ++neon_no_acl=yes ++ ++ ++ ++ ++ ++cat >>confdefs.h <<\_ACEOF ++#define _GNU_SOURCE 1 ++_ACEOF ++ ++ ++ ++{ echo "$as_me:$LINENO: checking for AIX" >&5 ++echo $ECHO_N "checking for AIX... $ECHO_C" >&6; } ++cat >conftest.$ac_ext <<_ACEOF ++/* confdefs.h. */ ++_ACEOF ++cat confdefs.h >>conftest.$ac_ext ++cat >>conftest.$ac_ext <<_ACEOF ++/* end confdefs.h. */ ++#ifdef _AIX ++ yes ++#endif ++ ++_ACEOF ++if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | ++ $EGREP "yes" >/dev/null 2>&1; then ++ { echo "$as_me:$LINENO: result: yes" >&5 ++echo "${ECHO_T}yes" >&6; } ++cat >>confdefs.h <<\_ACEOF ++#define _ALL_SOURCE 1 ++_ACEOF ++ ++else ++ { echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6; } ++fi ++rm -f conftest* ++ ++ + # On IRIX 5.3, sys/types and inttypes.h are conflicting. + + +@@ -4425,53 +4484,35 @@ + done + + +- +- +-# Check whether --enable-readline was given. +-if test "${enable_readline+set}" = set; then +- enableval=$enable_readline; use_readline=$enableval +-else +- use_readline=yes +-fi +- +-if test "$use_readline" = "yes"; then +- { echo "$as_me:$LINENO: checking for tputs in -lcurses" >&5 +-echo $ECHO_N "checking for tputs in -lcurses... $ECHO_C" >&6; } +-if test "${ac_cv_lib_curses_tputs+set}" = set; then ++if test "${ac_cv_header_minix_config_h+set}" = set; then ++ { echo "$as_me:$LINENO: checking for minix/config.h" >&5 ++echo $ECHO_N "checking for minix/config.h... $ECHO_C" >&6; } ++if test "${ac_cv_header_minix_config_h+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 ++fi ++{ echo "$as_me:$LINENO: result: $ac_cv_header_minix_config_h" >&5 ++echo "${ECHO_T}$ac_cv_header_minix_config_h" >&6; } + else +- ac_check_lib_save_LIBS=$LIBS +-LIBS="-lcurses $LIBS" ++ # Is the header compilable? ++{ echo "$as_me:$LINENO: checking minix/config.h usability" >&5 ++echo $ECHO_N "checking minix/config.h usability... $ECHO_C" >&6; } + cat >conftest.$ac_ext <<_ACEOF + /* confdefs.h. */ + _ACEOF + cat confdefs.h >>conftest.$ac_ext + cat >>conftest.$ac_ext <<_ACEOF + /* end confdefs.h. */ +- +-/* Override any GCC internal prototype to avoid an error. +- Use char because int might match the return type of a GCC +- builtin and then its argument prototype would still apply. */ +-#ifdef __cplusplus +-extern "C" +-#endif +-char tputs (); +-int +-main () +-{ +-return tputs (); +- ; +- return 0; +-} ++$ac_includes_default ++#include + _ACEOF +-rm -f conftest.$ac_objext conftest$ac_exeext +-if { (ac_try="$ac_link" ++rm -f conftest.$ac_objext ++if { (ac_try="$ac_compile" + case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; + esac + eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_link") 2>conftest.er1 ++ (eval "$ac_compile") 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 +@@ -4480,136 +4521,152 @@ + (exit $ac_status); } && { + test -z "$ac_c_werror_flag" || + test ! -s conftest.err +- } && test -s conftest$ac_exeext && +- $as_test_x conftest$ac_exeext; then +- ac_cv_lib_curses_tputs=yes ++ } && test -s conftest.$ac_objext; then ++ ac_header_compiler=yes + else + echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + +- ac_cv_lib_curses_tputs=no ++ ac_header_compiler=no + fi + +-rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ +- conftest$ac_exeext conftest.$ac_ext +-LIBS=$ac_check_lib_save_LIBS +-fi +-{ echo "$as_me:$LINENO: result: $ac_cv_lib_curses_tputs" >&5 +-echo "${ECHO_T}$ac_cv_lib_curses_tputs" >&6; } +-if test $ac_cv_lib_curses_tputs = yes; then +- LIBS="$LIBS -lcurses" +-else ++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ++{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 ++echo "${ECHO_T}$ac_header_compiler" >&6; } + +-{ echo "$as_me:$LINENO: checking for tputs in -lncurses" >&5 +-echo $ECHO_N "checking for tputs in -lncurses... $ECHO_C" >&6; } +-if test "${ac_cv_lib_ncurses_tputs+set}" = set; then +- echo $ECHO_N "(cached) $ECHO_C" >&6 +-else +- ac_check_lib_save_LIBS=$LIBS +-LIBS="-lncurses $LIBS" ++# Is the header present? ++{ echo "$as_me:$LINENO: checking minix/config.h presence" >&5 ++echo $ECHO_N "checking minix/config.h presence... $ECHO_C" >&6; } + cat >conftest.$ac_ext <<_ACEOF + /* confdefs.h. */ + _ACEOF + cat confdefs.h >>conftest.$ac_ext + cat >>conftest.$ac_ext <<_ACEOF + /* end confdefs.h. */ +- +-/* Override any GCC internal prototype to avoid an error. +- Use char because int might match the return type of a GCC +- builtin and then its argument prototype would still apply. */ +-#ifdef __cplusplus +-extern "C" +-#endif +-char tputs (); +-int +-main () +-{ +-return tputs (); +- ; +- return 0; +-} ++#include + _ACEOF +-rm -f conftest.$ac_objext conftest$ac_exeext +-if { (ac_try="$ac_link" ++if { (ac_try="$ac_cpp conftest.$ac_ext" + case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; + esac + eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_link") 2>conftest.er1 ++ (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 +- (exit $ac_status); } && { +- test -z "$ac_c_werror_flag" || ++ (exit $ac_status); } >/dev/null && { ++ test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || + test ! -s conftest.err +- } && test -s conftest$ac_exeext && +- $as_test_x conftest$ac_exeext; then +- ac_cv_lib_ncurses_tputs=yes ++ }; then ++ ac_header_preproc=yes + else + echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + +- ac_cv_lib_ncurses_tputs=no ++ ac_header_preproc=no + fi + +-rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ +- conftest$ac_exeext conftest.$ac_ext +-LIBS=$ac_check_lib_save_LIBS ++rm -f conftest.err conftest.$ac_ext ++{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 ++echo "${ECHO_T}$ac_header_preproc" >&6; } ++ ++# So? What about this header? ++case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in ++ yes:no: ) ++ { echo "$as_me:$LINENO: WARNING: minix/config.h: accepted by the compiler, rejected by the preprocessor!" >&5 ++echo "$as_me: WARNING: minix/config.h: accepted by the compiler, rejected by the preprocessor!" >&2;} ++ { echo "$as_me:$LINENO: WARNING: minix/config.h: proceeding with the compiler's result" >&5 ++echo "$as_me: WARNING: minix/config.h: proceeding with the compiler's result" >&2;} ++ ac_header_preproc=yes ++ ;; ++ no:yes:* ) ++ { echo "$as_me:$LINENO: WARNING: minix/config.h: present but cannot be compiled" >&5 ++echo "$as_me: WARNING: minix/config.h: present but cannot be compiled" >&2;} ++ { echo "$as_me:$LINENO: WARNING: minix/config.h: check for missing prerequisite headers?" >&5 ++echo "$as_me: WARNING: minix/config.h: check for missing prerequisite headers?" >&2;} ++ { echo "$as_me:$LINENO: WARNING: minix/config.h: see the Autoconf documentation" >&5 ++echo "$as_me: WARNING: minix/config.h: see the Autoconf documentation" >&2;} ++ { echo "$as_me:$LINENO: WARNING: minix/config.h: section \"Present But Cannot Be Compiled\"" >&5 ++echo "$as_me: WARNING: minix/config.h: section \"Present But Cannot Be Compiled\"" >&2;} ++ { echo "$as_me:$LINENO: WARNING: minix/config.h: proceeding with the preprocessor's result" >&5 ++echo "$as_me: WARNING: minix/config.h: proceeding with the preprocessor's result" >&2;} ++ { echo "$as_me:$LINENO: WARNING: minix/config.h: in the future, the compiler will take precedence" >&5 ++echo "$as_me: WARNING: minix/config.h: in the future, the compiler will take precedence" >&2;} ++ ( cat <<\_ASBOX ++## --------------------------------- ## ++## Report this to cadaver@webdav.org ## ++## --------------------------------- ## ++_ASBOX ++ ) | sed "s/^/$as_me: WARNING: /" >&2 ++ ;; ++esac ++{ echo "$as_me:$LINENO: checking for minix/config.h" >&5 ++echo $ECHO_N "checking for minix/config.h... $ECHO_C" >&6; } ++if test "${ac_cv_header_minix_config_h+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ ac_cv_header_minix_config_h=$ac_header_preproc + fi +-{ echo "$as_me:$LINENO: result: $ac_cv_lib_ncurses_tputs" >&5 +-echo "${ECHO_T}$ac_cv_lib_ncurses_tputs" >&6; } +-if test $ac_cv_lib_ncurses_tputs = yes; then +- cat >>confdefs.h <<_ACEOF +-#define HAVE_LIBNCURSES 1 ++{ echo "$as_me:$LINENO: result: $ac_cv_header_minix_config_h" >&5 ++echo "${ECHO_T}$ac_cv_header_minix_config_h" >&6; } ++ ++fi ++if test $ac_cv_header_minix_config_h = yes; then ++ MINIX=yes ++else ++ MINIX= ++fi ++ ++ ++if test "$MINIX" = yes; then ++ ++cat >>confdefs.h <<\_ACEOF ++#define _POSIX_SOURCE 1 + _ACEOF + +- LIBS="-lncurses $LIBS" + +-fi ++cat >>confdefs.h <<\_ACEOF ++#define _POSIX_1_SOURCE 2 ++_ACEOF + +-fi + ++cat >>confdefs.h <<\_ACEOF ++#define _MINIX 1 ++_ACEOF ++ ++fi + +-{ echo "$as_me:$LINENO: checking for readline in -lreadline" >&5 +-echo $ECHO_N "checking for readline in -lreadline... $ECHO_C" >&6; } +-if test "${ac_cv_lib_readline_readline+set}" = set; then ++{ echo "$as_me:$LINENO: checking for inline" >&5 ++echo $ECHO_N "checking for inline... $ECHO_C" >&6; } ++if test "${ac_cv_c_inline+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 + else +- ac_check_lib_save_LIBS=$LIBS +-LIBS="-lreadline $LIBS" +-cat >conftest.$ac_ext <<_ACEOF ++ ac_cv_c_inline=no ++for ac_kw in inline __inline__ __inline; do ++ cat >conftest.$ac_ext <<_ACEOF + /* confdefs.h. */ + _ACEOF + cat confdefs.h >>conftest.$ac_ext + cat >>conftest.$ac_ext <<_ACEOF + /* end confdefs.h. */ +- +-/* Override any GCC internal prototype to avoid an error. +- Use char because int might match the return type of a GCC +- builtin and then its argument prototype would still apply. */ +-#ifdef __cplusplus +-extern "C" ++#ifndef __cplusplus ++typedef int foo_t; ++static $ac_kw foo_t static_foo () {return 0; } ++$ac_kw foo_t foo () {return 0; } + #endif +-char readline (); +-int +-main () +-{ +-return readline (); +- ; +- return 0; +-} ++ + _ACEOF +-rm -f conftest.$ac_objext conftest$ac_exeext +-if { (ac_try="$ac_link" ++rm -f conftest.$ac_objext ++if { (ac_try="$ac_compile" + case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; + esac + eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_link") 2>conftest.er1 ++ (eval "$ac_compile") 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 +@@ -4618,75 +4675,116 @@ + (exit $ac_status); } && { + test -z "$ac_c_werror_flag" || + test ! -s conftest.err +- } && test -s conftest$ac_exeext && +- $as_test_x conftest$ac_exeext; then +- ac_cv_lib_readline_readline=yes ++ } && test -s conftest.$ac_objext; then ++ ac_cv_c_inline=$ac_kw + else + echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + +- ac_cv_lib_readline_readline=no +-fi + +-rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ +- conftest$ac_exeext conftest.$ac_ext +-LIBS=$ac_check_lib_save_LIBS + fi +-{ echo "$as_me:$LINENO: result: $ac_cv_lib_readline_readline" >&5 +-echo "${ECHO_T}$ac_cv_lib_readline_readline" >&6; } +-if test $ac_cv_lib_readline_readline = yes; then +- cat >>confdefs.h <<_ACEOF +-#define HAVE_LIBREADLINE 1 +-_ACEOF + +- LIBS="-lreadline $LIBS" ++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ++ test "$ac_cv_c_inline" != no && break ++done + + fi ++{ echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5 ++echo "${ECHO_T}$ac_cv_c_inline" >&6; } + + +- { echo "$as_me:$LINENO: checking for library containing add_history" >&5 +-echo $ECHO_N "checking for library containing add_history... $ECHO_C" >&6; } +-if test "${ac_cv_search_add_history+set}" = set; then ++case $ac_cv_c_inline in ++ inline | yes) ;; ++ *) ++ case $ac_cv_c_inline in ++ no) ac_val=;; ++ *) ac_val=$ac_cv_c_inline;; ++ esac ++ cat >>confdefs.h <<_ACEOF ++#ifndef __cplusplus ++#define inline $ac_val ++#endif ++_ACEOF ++ ;; ++esac ++ ++{ echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5 ++echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6; } ++if test "${ac_cv_c_const+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 + else +- ac_func_search_save_LIBS=$LIBS +-cat >conftest.$ac_ext <<_ACEOF ++ cat >conftest.$ac_ext <<_ACEOF + /* confdefs.h. */ + _ACEOF + cat confdefs.h >>conftest.$ac_ext + cat >>conftest.$ac_ext <<_ACEOF + /* end confdefs.h. */ + +-/* Override any GCC internal prototype to avoid an error. +- Use char because int might match the return type of a GCC +- builtin and then its argument prototype would still apply. */ +-#ifdef __cplusplus +-extern "C" +-#endif +-char add_history (); + int + main () + { +-return add_history (); ++/* FIXME: Include the comments suggested by Paul. */ ++#ifndef __cplusplus ++ /* Ultrix mips cc rejects this. */ ++ typedef int charset[2]; ++ const charset cs; ++ /* SunOS 4.1.1 cc rejects this. */ ++ char const *const *pcpcc; ++ char **ppc; ++ /* NEC SVR4.0.2 mips cc rejects this. */ ++ struct point {int x, y;}; ++ static struct point const zero = {0,0}; ++ /* AIX XL C 1.02.0.0 rejects this. ++ It does not let you subtract one const X* pointer from another in ++ an arm of an if-expression whose if-part is not a constant ++ expression */ ++ const char *g = "string"; ++ pcpcc = &g + (g ? g-g : 0); ++ /* HPUX 7.0 cc rejects these. */ ++ ++pcpcc; ++ ppc = (char**) pcpcc; ++ pcpcc = (char const *const *) ppc; ++ { /* SCO 3.2v4 cc rejects this. */ ++ char *t; ++ char const *s = 0 ? (char *) 0 : (char const *) 0; ++ ++ *t++ = 0; ++ if (s) return 0; ++ } ++ { /* Someone thinks the Sun supposedly-ANSI compiler will reject this. */ ++ int x[] = {25, 17}; ++ const int *foo = &x[0]; ++ ++foo; ++ } ++ { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */ ++ typedef const int *iptr; ++ iptr p = 0; ++ ++p; ++ } ++ { /* AIX XL C 1.02.0.0 rejects this saying ++ "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */ ++ struct s { int j; const int *ap[3]; }; ++ struct s *b; b->j = 5; ++ } ++ { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */ ++ const int foo = 10; ++ if (!foo) return 0; ++ } ++ return !cs[0] && !zero.x; ++#endif ++ + ; + return 0; + } + _ACEOF +-for ac_lib in '' history; do +- if test -z "$ac_lib"; then +- ac_res="none required" +- else +- ac_res=-l$ac_lib +- LIBS="-l$ac_lib $ac_func_search_save_LIBS" +- fi +- rm -f conftest.$ac_objext conftest$ac_exeext +-if { (ac_try="$ac_link" ++rm -f conftest.$ac_objext ++if { (ac_try="$ac_compile" + case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; + esac + eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_link") 2>conftest.er1 ++ (eval "$ac_compile") 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 +@@ -4695,72 +4793,50 @@ + (exit $ac_status); } && { + test -z "$ac_c_werror_flag" || + test ! -s conftest.err +- } && test -s conftest$ac_exeext && +- $as_test_x conftest$ac_exeext; then +- ac_cv_search_add_history=$ac_res ++ } && test -s conftest.$ac_objext; then ++ ac_cv_c_const=yes + else + echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + +- ++ ac_cv_c_const=no + fi + +-rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ +- conftest$ac_exeext +- if test "${ac_cv_search_add_history+set}" = set; then +- break +-fi +-done +-if test "${ac_cv_search_add_history+set}" = set; then +- : +-else +- ac_cv_search_add_history=no +-fi +-rm conftest.$ac_ext +-LIBS=$ac_func_search_save_LIBS ++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + fi +-{ echo "$as_me:$LINENO: result: $ac_cv_search_add_history" >&5 +-echo "${ECHO_T}$ac_cv_search_add_history" >&6; } +-ac_res=$ac_cv_search_add_history +-if test "$ac_res" != no; then +- test "$ac_res" = "none required" || LIBS="$ac_res $LIBS" ++{ echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5 ++echo "${ECHO_T}$ac_cv_c_const" >&6; } ++if test $ac_cv_c_const = no; then + + cat >>confdefs.h <<\_ACEOF +-#define HAVE_ADD_HISTORY 1 ++#define const + _ACEOF + +- + fi + +- +- +- +- +- +-for ac_header in history.h readline/history.h readline.h readline/readline.h +-do +-as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` +-if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then +- { echo "$as_me:$LINENO: checking for $ac_header" >&5 +-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; } +-if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then ++{ echo "$as_me:$LINENO: checking for size_t" >&5 ++echo $ECHO_N "checking for size_t... $ECHO_C" >&6; } ++if test "${ac_cv_type_size_t+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +-fi +-ac_res=`eval echo '${'$as_ac_Header'}'` +- { echo "$as_me:$LINENO: result: $ac_res" >&5 +-echo "${ECHO_T}$ac_res" >&6; } + else +- # Is the header compilable? +-{ echo "$as_me:$LINENO: checking $ac_header usability" >&5 +-echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; } +-cat >conftest.$ac_ext <<_ACEOF ++ cat >conftest.$ac_ext <<_ACEOF + /* confdefs.h. */ + _ACEOF + cat confdefs.h >>conftest.$ac_ext + cat >>conftest.$ac_ext <<_ACEOF + /* end confdefs.h. */ + $ac_includes_default +-#include <$ac_header> ++typedef size_t ac__type_new_; ++int ++main () ++{ ++if ((ac__type_new_ *) 0) ++ return 0; ++if (sizeof (ac__type_new_)) ++ return 0; ++ ; ++ return 0; ++} + _ACEOF + rm -f conftest.$ac_objext + if { (ac_try="$ac_compile" +@@ -4779,117 +4855,118 @@ + test -z "$ac_c_werror_flag" || + test ! -s conftest.err + } && test -s conftest.$ac_objext; then +- ac_header_compiler=yes ++ ac_cv_type_size_t=yes + else + echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + +- ac_header_compiler=no ++ ac_cv_type_size_t=no + fi + + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +-{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 +-echo "${ECHO_T}$ac_header_compiler" >&6; } ++fi ++{ echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5 ++echo "${ECHO_T}$ac_cv_type_size_t" >&6; } ++if test $ac_cv_type_size_t = yes; then ++ : ++else + +-# Is the header present? +-{ echo "$as_me:$LINENO: checking $ac_header presence" >&5 +-echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; } +-cat >conftest.$ac_ext <<_ACEOF ++cat >>confdefs.h <<_ACEOF ++#define size_t unsigned int ++_ACEOF ++ ++fi ++ ++{ echo "$as_me:$LINENO: checking for off_t" >&5 ++echo $ECHO_N "checking for off_t... $ECHO_C" >&6; } ++if test "${ac_cv_type_off_t+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ cat >conftest.$ac_ext <<_ACEOF + /* confdefs.h. */ + _ACEOF + cat confdefs.h >>conftest.$ac_ext + cat >>conftest.$ac_ext <<_ACEOF + /* end confdefs.h. */ +-#include <$ac_header> ++$ac_includes_default ++typedef off_t ac__type_new_; ++int ++main () ++{ ++if ((ac__type_new_ *) 0) ++ return 0; ++if (sizeof (ac__type_new_)) ++ return 0; ++ ; ++ return 0; ++} + _ACEOF +-if { (ac_try="$ac_cpp conftest.$ac_ext" ++rm -f conftest.$ac_objext ++if { (ac_try="$ac_compile" + case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; + esac + eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1 ++ (eval "$ac_compile") 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 +- (exit $ac_status); } >/dev/null && { +- test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || ++ (exit $ac_status); } && { ++ test -z "$ac_c_werror_flag" || + test ! -s conftest.err +- }; then +- ac_header_preproc=yes ++ } && test -s conftest.$ac_objext; then ++ ac_cv_type_off_t=yes + else + echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + +- ac_header_preproc=no ++ ac_cv_type_off_t=no + fi + +-rm -f conftest.err conftest.$ac_ext +-{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 +-echo "${ECHO_T}$ac_header_preproc" >&6; } +- +-# So? What about this header? +-case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in +- yes:no: ) +- { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5 +-echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;} +- { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5 +-echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;} +- ac_header_preproc=yes +- ;; +- no:yes:* ) +- { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5 +-echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;} +- { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5 +-echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;} +- { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5 +-echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;} +- { echo "$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&5 +-echo "$as_me: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&2;} +- { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5 +-echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;} +- { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5 +-echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;} +- ( cat <<\_ASBOX +-## --------------------------------- ## +-## Report this to cadaver@webdav.org ## +-## --------------------------------- ## +-_ASBOX +- ) | sed "s/^/$as_me: WARNING: /" >&2 +- ;; +-esac +-{ echo "$as_me:$LINENO: checking for $ac_header" >&5 +-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; } +-if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then +- echo $ECHO_N "(cached) $ECHO_C" >&6 +-else +- eval "$as_ac_Header=\$ac_header_preproc" ++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + fi +-ac_res=`eval echo '${'$as_ac_Header'}'` +- { echo "$as_me:$LINENO: result: $ac_res" >&5 +-echo "${ECHO_T}$ac_res" >&6; } ++{ echo "$as_me:$LINENO: result: $ac_cv_type_off_t" >&5 ++echo "${ECHO_T}$ac_cv_type_off_t" >&6; } ++if test $ac_cv_type_off_t = yes; then ++ : ++else + +-fi +-if test `eval echo '${'$as_ac_Header'}'` = yes; then +- cat >>confdefs.h <<_ACEOF +-#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1 ++cat >>confdefs.h <<_ACEOF ++#define off_t long int + _ACEOF + + fi + +-done + ++# Check for Darwin, which needs extra cpp and linker flags. ++{ echo "$as_me:$LINENO: checking for uname" >&5 ++echo $ECHO_N "checking for uname... $ECHO_C" >&6; } ++if test "${ne_cv_os_uname+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else + +- # Check for rl_completion_matches as in readline 4.2 ++ ne_cv_os_uname=`uname -s 2>/dev/null` + +-for ac_func in rl_completion_matches +-do +-as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh` +-{ echo "$as_me:$LINENO: checking for $ac_func" >&5 +-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; } +-if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then ++fi ++{ echo "$as_me:$LINENO: result: $ne_cv_os_uname" >&5 ++echo "${ECHO_T}$ne_cv_os_uname" >&6; } ++ ++if test "$ne_cv_os_uname" = "Darwin"; then ++ CPPFLAGS="$CPPFLAGS -no-cpp-precomp" ++ LDFLAGS="$LDFLAGS -flat_namespace" ++ # poll has various issues in various Darwin releases ++ if test x${ac_cv_func_poll+set} != xset; then ++ ac_cv_func_poll=no ++ fi ++fi ++ ++ ++{ echo "$as_me:$LINENO: checking for int" >&5 ++echo $ECHO_N "checking for int... $ECHO_C" >&6; } ++if test "${ac_cv_type_int+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 + else + cat >conftest.$ac_ext <<_ACEOF +@@ -4898,53 +4975,27 @@ + cat confdefs.h >>conftest.$ac_ext + cat >>conftest.$ac_ext <<_ACEOF + /* end confdefs.h. */ +-/* Define $ac_func to an innocuous variant, in case declares $ac_func. +- For example, HP-UX 11i declares gettimeofday. */ +-#define $ac_func innocuous_$ac_func +- +-/* System header to define __stub macros and hopefully few prototypes, +- which can conflict with char $ac_func (); below. +- Prefer to if __STDC__ is defined, since +- exists even on freestanding compilers. */ +- +-#ifdef __STDC__ +-# include +-#else +-# include +-#endif +- +-#undef $ac_func +- +-/* Override any GCC internal prototype to avoid an error. +- Use char because int might match the return type of a GCC +- builtin and then its argument prototype would still apply. */ +-#ifdef __cplusplus +-extern "C" +-#endif +-char $ac_func (); +-/* The GNU C library defines this for functions which it implements +- to always fail with ENOSYS. Some functions are actually named +- something starting with __ and the normal name is an alias. */ +-#if defined __stub_$ac_func || defined __stub___$ac_func +-choke me +-#endif +- ++$ac_includes_default ++typedef int ac__type_new_; + int + main () + { +-return $ac_func (); ++if ((ac__type_new_ *) 0) ++ return 0; ++if (sizeof (ac__type_new_)) ++ return 0; + ; + return 0; + } + _ACEOF +-rm -f conftest.$ac_objext conftest$ac_exeext +-if { (ac_try="$ac_link" ++rm -f conftest.$ac_objext ++if { (ac_try="$ac_compile" + case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; + esac + eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_link") 2>conftest.er1 ++ (eval "$ac_compile") 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 +@@ -4953,80 +5004,48 @@ + (exit $ac_status); } && { + test -z "$ac_c_werror_flag" || + test ! -s conftest.err +- } && test -s conftest$ac_exeext && +- $as_test_x conftest$ac_exeext; then +- eval "$as_ac_var=yes" ++ } && test -s conftest.$ac_objext; then ++ ac_cv_type_int=yes + else + echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + +- eval "$as_ac_var=no" +-fi +- +-rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ +- conftest$ac_exeext conftest.$ac_ext +-fi +-ac_res=`eval echo '${'$as_ac_var'}'` +- { echo "$as_me:$LINENO: result: $ac_res" >&5 +-echo "${ECHO_T}$ac_res" >&6; } +-if test `eval echo '${'$as_ac_var'}'` = yes; then +- cat >>confdefs.h <<_ACEOF +-#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1 +-_ACEOF +- +-fi +-done +- +- +- msg_readline="enabled" +-else +- msg_readline="disabled" ++ ac_cv_type_int=no + fi + +- +- +-# Check whether --enable-netrc was given. +-if test "${enable_netrc+set}" = set; then +- enableval=$enable_netrc; +-else +- enable_netrc=yes ++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + fi ++{ echo "$as_me:$LINENO: result: $ac_cv_type_int" >&5 ++echo "${ECHO_T}$ac_cv_type_int" >&6; } + +- +- +- +- +- +- +- +- +- +- +-# Turn off ACL support +-neon_no_acl=yes +- +- +- +- +-{ echo "$as_me:$LINENO: checking for inline" >&5 +-echo $ECHO_N "checking for inline... $ECHO_C" >&6; } +-if test "${ac_cv_c_inline+set}" = set; then ++# The cast to long int works around a bug in the HP C Compiler ++# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects ++# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. ++# This bug is HP SR number 8606223364. ++{ echo "$as_me:$LINENO: checking size of int" >&5 ++echo $ECHO_N "checking size of int... $ECHO_C" >&6; } ++if test "${ac_cv_sizeof_int+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 + else +- ac_cv_c_inline=no +-for ac_kw in inline __inline__ __inline; do +- cat >conftest.$ac_ext <<_ACEOF ++ if test "$cross_compiling" = yes; then ++ # Depending upon the size, compute the lo and hi bounds. ++cat >conftest.$ac_ext <<_ACEOF + /* confdefs.h. */ + _ACEOF + cat confdefs.h >>conftest.$ac_ext + cat >>conftest.$ac_ext <<_ACEOF + /* end confdefs.h. */ +-#ifndef __cplusplus +-typedef int foo_t; +-static $ac_kw foo_t static_foo () {return 0; } +-$ac_kw foo_t foo () {return 0; } +-#endif ++$ac_includes_default ++ typedef int ac__type_sizeof_; ++int ++main () ++{ ++static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) >= 0)]; ++test_array [0] = 0 + ++ ; ++ return 0; ++} + _ACEOF + rm -f conftest.$ac_objext + if { (ac_try="$ac_compile" +@@ -5045,102 +5064,21 @@ + test -z "$ac_c_werror_flag" || + test ! -s conftest.err + } && test -s conftest.$ac_objext; then +- ac_cv_c_inline=$ac_kw +-else +- echo "$as_me: failed program was:" >&5 +-sed 's/^/| /' conftest.$ac_ext >&5 +- +- +-fi +- +-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +- test "$ac_cv_c_inline" != no && break +-done +- +-fi +-{ echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5 +-echo "${ECHO_T}$ac_cv_c_inline" >&6; } +- +- +-case $ac_cv_c_inline in +- inline | yes) ;; +- *) +- case $ac_cv_c_inline in +- no) ac_val=;; +- *) ac_val=$ac_cv_c_inline;; +- esac +- cat >>confdefs.h <<_ACEOF +-#ifndef __cplusplus +-#define inline $ac_val +-#endif +-_ACEOF +- ;; +-esac +- +-{ echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5 +-echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6; } +-if test "${ac_cv_c_const+set}" = set; then +- echo $ECHO_N "(cached) $ECHO_C" >&6 +-else +- cat >conftest.$ac_ext <<_ACEOF ++ ac_lo=0 ac_mid=0 ++ while :; do ++ cat >conftest.$ac_ext <<_ACEOF + /* confdefs.h. */ + _ACEOF + cat confdefs.h >>conftest.$ac_ext + cat >>conftest.$ac_ext <<_ACEOF + /* end confdefs.h. */ +- ++$ac_includes_default ++ typedef int ac__type_sizeof_; + int + main () + { +-/* FIXME: Include the comments suggested by Paul. */ +-#ifndef __cplusplus +- /* Ultrix mips cc rejects this. */ +- typedef int charset[2]; +- const charset cs; +- /* SunOS 4.1.1 cc rejects this. */ +- char const *const *pcpcc; +- char **ppc; +- /* NEC SVR4.0.2 mips cc rejects this. */ +- struct point {int x, y;}; +- static struct point const zero = {0,0}; +- /* AIX XL C 1.02.0.0 rejects this. +- It does not let you subtract one const X* pointer from another in +- an arm of an if-expression whose if-part is not a constant +- expression */ +- const char *g = "string"; +- pcpcc = &g + (g ? g-g : 0); +- /* HPUX 7.0 cc rejects these. */ +- ++pcpcc; +- ppc = (char**) pcpcc; +- pcpcc = (char const *const *) ppc; +- { /* SCO 3.2v4 cc rejects this. */ +- char *t; +- char const *s = 0 ? (char *) 0 : (char const *) 0; +- +- *t++ = 0; +- if (s) return 0; +- } +- { /* Someone thinks the Sun supposedly-ANSI compiler will reject this. */ +- int x[] = {25, 17}; +- const int *foo = &x[0]; +- ++foo; +- } +- { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */ +- typedef const int *iptr; +- iptr p = 0; +- ++p; +- } +- { /* AIX XL C 1.02.0.0 rejects this saying +- "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */ +- struct s { int j; const int *ap[3]; }; +- struct s *b; b->j = 5; +- } +- { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */ +- const int foo = 10; +- if (!foo) return 0; +- } +- return !cs[0] && !zero.x; +-#endif ++static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) <= $ac_mid)]; ++test_array [0] = 0 + + ; + return 0; +@@ -5163,46 +5101,39 @@ + test -z "$ac_c_werror_flag" || + test ! -s conftest.err + } && test -s conftest.$ac_objext; then +- ac_cv_c_const=yes ++ ac_hi=$ac_mid; break + else + echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + +- ac_cv_c_const=no ++ ac_lo=`expr $ac_mid + 1` ++ if test $ac_lo -le $ac_mid; then ++ ac_lo= ac_hi= ++ break ++ fi ++ ac_mid=`expr 2 '*' $ac_mid + 1` + fi + + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +-fi +-{ echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5 +-echo "${ECHO_T}$ac_cv_c_const" >&6; } +-if test $ac_cv_c_const = no; then +- +-cat >>confdefs.h <<\_ACEOF +-#define const +-_ACEOF +- +-fi +- +-{ echo "$as_me:$LINENO: checking for size_t" >&5 +-echo $ECHO_N "checking for size_t... $ECHO_C" >&6; } +-if test "${ac_cv_type_size_t+set}" = set; then +- echo $ECHO_N "(cached) $ECHO_C" >&6 ++ done + else +- cat >conftest.$ac_ext <<_ACEOF ++ echo "$as_me: failed program was:" >&5 ++sed 's/^/| /' conftest.$ac_ext >&5 ++ ++ cat >conftest.$ac_ext <<_ACEOF + /* confdefs.h. */ + _ACEOF + cat confdefs.h >>conftest.$ac_ext + cat >>conftest.$ac_ext <<_ACEOF + /* end confdefs.h. */ + $ac_includes_default +-typedef size_t ac__type_new_; ++ typedef int ac__type_sizeof_; + int + main () + { +-if ((ac__type_new_ *) 0) +- return 0; +-if (sizeof (ac__type_new_)) +- return 0; ++static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) < 0)]; ++test_array [0] = 0 ++ + ; + return 0; + } +@@ -5224,48 +5155,22 @@ + test -z "$ac_c_werror_flag" || + test ! -s conftest.err + } && test -s conftest.$ac_objext; then +- ac_cv_type_size_t=yes +-else +- echo "$as_me: failed program was:" >&5 +-sed 's/^/| /' conftest.$ac_ext >&5 +- +- ac_cv_type_size_t=no +-fi +- +-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +-fi +-{ echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5 +-echo "${ECHO_T}$ac_cv_type_size_t" >&6; } +-if test $ac_cv_type_size_t = yes; then +- : +-else +- +-cat >>confdefs.h <<_ACEOF +-#define size_t unsigned int +-_ACEOF +- +-fi +- +-{ echo "$as_me:$LINENO: checking for off_t" >&5 +-echo $ECHO_N "checking for off_t... $ECHO_C" >&6; } +-if test "${ac_cv_type_off_t+set}" = set; then +- echo $ECHO_N "(cached) $ECHO_C" >&6 +-else +- cat >conftest.$ac_ext <<_ACEOF ++ ac_hi=-1 ac_mid=-1 ++ while :; do ++ cat >conftest.$ac_ext <<_ACEOF + /* confdefs.h. */ + _ACEOF + cat confdefs.h >>conftest.$ac_ext + cat >>conftest.$ac_ext <<_ACEOF + /* end confdefs.h. */ + $ac_includes_default +-typedef off_t ac__type_new_; ++ typedef int ac__type_sizeof_; + int + main () + { +-if ((ac__type_new_ *) 0) +- return 0; +-if (sizeof (ac__type_new_)) +- return 0; ++static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) >= $ac_mid)]; ++test_array [0] = 0 ++ + ; + return 0; + } +@@ -5287,57 +5192,35 @@ + test -z "$ac_c_werror_flag" || + test ! -s conftest.err + } && test -s conftest.$ac_objext; then +- ac_cv_type_off_t=yes ++ ac_lo=$ac_mid; break + else + echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + +- ac_cv_type_off_t=no ++ ac_hi=`expr '(' $ac_mid ')' - 1` ++ if test $ac_mid -le $ac_hi; then ++ ac_lo= ac_hi= ++ break ++ fi ++ ac_mid=`expr 2 '*' $ac_mid` + fi + + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +-fi +-{ echo "$as_me:$LINENO: result: $ac_cv_type_off_t" >&5 +-echo "${ECHO_T}$ac_cv_type_off_t" >&6; } +-if test $ac_cv_type_off_t = yes; then +- : +-else +- +-cat >>confdefs.h <<_ACEOF +-#define off_t long int +-_ACEOF +- +-fi +- +- +-# Check for Darwin, which needs extra cpp and linker flags. +-{ echo "$as_me:$LINENO: checking for uname" >&5 +-echo $ECHO_N "checking for uname... $ECHO_C" >&6; } +-if test "${ne_cv_os_uname+set}" = set; then +- echo $ECHO_N "(cached) $ECHO_C" >&6 ++ done + else ++ echo "$as_me: failed program was:" >&5 ++sed 's/^/| /' conftest.$ac_ext >&5 + +- ne_cv_os_uname=`uname -s 2>/dev/null` +- ++ ac_lo= ac_hi= + fi +-{ echo "$as_me:$LINENO: result: $ne_cv_os_uname" >&5 +-echo "${ECHO_T}$ne_cv_os_uname" >&6; } + +-if test "$ne_cv_os_uname" = "Darwin"; then +- CPPFLAGS="$CPPFLAGS -no-cpp-precomp" +- LDFLAGS="$LDFLAGS -flat_namespace" +- # poll has various issues in various Darwin releases +- if test x${ac_cv_func_poll+set} != xset; then +- ac_cv_func_poll=no +- fi ++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + fi + +- +-{ echo "$as_me:$LINENO: checking for int" >&5 +-echo $ECHO_N "checking for int... $ECHO_C" >&6; } +-if test "${ac_cv_type_int+set}" = set; then +- echo $ECHO_N "(cached) $ECHO_C" >&6 +-else ++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ++# Binary search between lo and hi bounds. ++while test "x$ac_lo" != "x$ac_hi"; do ++ ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo` + cat >conftest.$ac_ext <<_ACEOF + /* confdefs.h. */ + _ACEOF +@@ -5345,14 +5228,13 @@ + cat >>conftest.$ac_ext <<_ACEOF + /* end confdefs.h. */ + $ac_includes_default +-typedef int ac__type_new_; ++ typedef int ac__type_sizeof_; + int + main () + { +-if ((ac__type_new_ *) 0) +- return 0; +-if (sizeof (ac__type_new_)) +- return 0; ++static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) <= $ac_mid)]; ++test_array [0] = 0 ++ + ; + return 0; + } +@@ -5374,31 +5256,30 @@ + test -z "$ac_c_werror_flag" || + test ! -s conftest.err + } && test -s conftest.$ac_objext; then +- ac_cv_type_int=yes ++ ac_hi=$ac_mid + else + echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + +- ac_cv_type_int=no ++ ac_lo=`expr '(' $ac_mid ')' + 1` + fi + + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +-fi +-{ echo "$as_me:$LINENO: result: $ac_cv_type_int" >&5 +-echo "${ECHO_T}$ac_cv_type_int" >&6; } +- +-# The cast to long int works around a bug in the HP C Compiler +-# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects +-# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. +-# This bug is HP SR number 8606223364. +-{ echo "$as_me:$LINENO: checking size of int" >&5 +-echo $ECHO_N "checking size of int... $ECHO_C" >&6; } +-if test "${ac_cv_sizeof_int+set}" = set; then +- echo $ECHO_N "(cached) $ECHO_C" >&6 ++done ++case $ac_lo in ++?*) ac_cv_sizeof_int=$ac_lo;; ++'') if test "$ac_cv_type_int" = yes; then ++ { { echo "$as_me:$LINENO: error: cannot compute sizeof (int) ++See \`config.log' for more details." >&5 ++echo "$as_me: error: cannot compute sizeof (int) ++See \`config.log' for more details." >&2;} ++ { (exit 77); exit 77; }; } ++ else ++ ac_cv_sizeof_int=0 ++ fi ;; ++esac + else +- if test "$cross_compiling" = yes; then +- # Depending upon the size, compute the lo and hi bounds. +-cat >conftest.$ac_ext <<_ACEOF ++ cat >conftest.$ac_ext <<_ACEOF + /* confdefs.h. */ + _ACEOF + cat confdefs.h >>conftest.$ac_ext +@@ -5406,311 +5287,61 @@ + /* end confdefs.h. */ + $ac_includes_default + typedef int ac__type_sizeof_; ++static long int longval () { return (long int) (sizeof (ac__type_sizeof_)); } ++static unsigned long int ulongval () { return (long int) (sizeof (ac__type_sizeof_)); } ++#include ++#include + int + main () + { +-static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) >= 0)]; +-test_array [0] = 0 ++ ++ FILE *f = fopen ("conftest.val", "w"); ++ if (! f) ++ return 1; ++ if (((long int) (sizeof (ac__type_sizeof_))) < 0) ++ { ++ long int i = longval (); ++ if (i != ((long int) (sizeof (ac__type_sizeof_)))) ++ return 1; ++ fprintf (f, "%ld\n", i); ++ } ++ else ++ { ++ unsigned long int i = ulongval (); ++ if (i != ((long int) (sizeof (ac__type_sizeof_)))) ++ return 1; ++ fprintf (f, "%lu\n", i); ++ } ++ return ferror (f) || fclose (f) != 0; + + ; + return 0; + } + _ACEOF +-rm -f conftest.$ac_objext +-if { (ac_try="$ac_compile" ++rm -f conftest$ac_exeext ++if { (ac_try="$ac_link" + case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; + esac + eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_compile") 2>conftest.er1 ++ (eval "$ac_link") 2>&5 + ac_status=$? +- grep -v '^ *+' conftest.er1 >conftest.err +- rm -f conftest.er1 +- cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 +- (exit $ac_status); } && { +- test -z "$ac_c_werror_flag" || +- test ! -s conftest.err +- } && test -s conftest.$ac_objext; then +- ac_lo=0 ac_mid=0 +- while :; do +- cat >conftest.$ac_ext <<_ACEOF +-/* confdefs.h. */ +-_ACEOF +-cat confdefs.h >>conftest.$ac_ext +-cat >>conftest.$ac_ext <<_ACEOF +-/* end confdefs.h. */ +-$ac_includes_default +- typedef int ac__type_sizeof_; +-int +-main () +-{ +-static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) <= $ac_mid)]; +-test_array [0] = 0 +- +- ; +- return 0; +-} +-_ACEOF +-rm -f conftest.$ac_objext +-if { (ac_try="$ac_compile" +-case "(($ac_try" in ++ (exit $ac_status); } && { ac_try='./conftest$ac_exeext' ++ { (case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; + esac + eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_compile") 2>conftest.er1 ++ (eval "$ac_try") 2>&5 + ac_status=$? +- grep -v '^ *+' conftest.er1 >conftest.err +- rm -f conftest.er1 +- cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 +- (exit $ac_status); } && { +- test -z "$ac_c_werror_flag" || +- test ! -s conftest.err +- } && test -s conftest.$ac_objext; then +- ac_hi=$ac_mid; break ++ (exit $ac_status); }; }; then ++ ac_cv_sizeof_int=`cat conftest.val` + else +- echo "$as_me: failed program was:" >&5 +-sed 's/^/| /' conftest.$ac_ext >&5 +- +- ac_lo=`expr $ac_mid + 1` +- if test $ac_lo -le $ac_mid; then +- ac_lo= ac_hi= +- break +- fi +- ac_mid=`expr 2 '*' $ac_mid + 1` +-fi +- +-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +- done +-else +- echo "$as_me: failed program was:" >&5 +-sed 's/^/| /' conftest.$ac_ext >&5 +- +- cat >conftest.$ac_ext <<_ACEOF +-/* confdefs.h. */ +-_ACEOF +-cat confdefs.h >>conftest.$ac_ext +-cat >>conftest.$ac_ext <<_ACEOF +-/* end confdefs.h. */ +-$ac_includes_default +- typedef int ac__type_sizeof_; +-int +-main () +-{ +-static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) < 0)]; +-test_array [0] = 0 +- +- ; +- return 0; +-} +-_ACEOF +-rm -f conftest.$ac_objext +-if { (ac_try="$ac_compile" +-case "(($ac_try" in +- *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; +- *) ac_try_echo=$ac_try;; +-esac +-eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_compile") 2>conftest.er1 +- ac_status=$? +- grep -v '^ *+' conftest.er1 >conftest.err +- rm -f conftest.er1 +- cat conftest.err >&5 +- echo "$as_me:$LINENO: \$? = $ac_status" >&5 +- (exit $ac_status); } && { +- test -z "$ac_c_werror_flag" || +- test ! -s conftest.err +- } && test -s conftest.$ac_objext; then +- ac_hi=-1 ac_mid=-1 +- while :; do +- cat >conftest.$ac_ext <<_ACEOF +-/* confdefs.h. */ +-_ACEOF +-cat confdefs.h >>conftest.$ac_ext +-cat >>conftest.$ac_ext <<_ACEOF +-/* end confdefs.h. */ +-$ac_includes_default +- typedef int ac__type_sizeof_; +-int +-main () +-{ +-static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) >= $ac_mid)]; +-test_array [0] = 0 +- +- ; +- return 0; +-} +-_ACEOF +-rm -f conftest.$ac_objext +-if { (ac_try="$ac_compile" +-case "(($ac_try" in +- *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; +- *) ac_try_echo=$ac_try;; +-esac +-eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_compile") 2>conftest.er1 +- ac_status=$? +- grep -v '^ *+' conftest.er1 >conftest.err +- rm -f conftest.er1 +- cat conftest.err >&5 +- echo "$as_me:$LINENO: \$? = $ac_status" >&5 +- (exit $ac_status); } && { +- test -z "$ac_c_werror_flag" || +- test ! -s conftest.err +- } && test -s conftest.$ac_objext; then +- ac_lo=$ac_mid; break +-else +- echo "$as_me: failed program was:" >&5 +-sed 's/^/| /' conftest.$ac_ext >&5 +- +- ac_hi=`expr '(' $ac_mid ')' - 1` +- if test $ac_mid -le $ac_hi; then +- ac_lo= ac_hi= +- break +- fi +- ac_mid=`expr 2 '*' $ac_mid` +-fi +- +-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +- done +-else +- echo "$as_me: failed program was:" >&5 +-sed 's/^/| /' conftest.$ac_ext >&5 +- +- ac_lo= ac_hi= +-fi +- +-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +-fi +- +-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +-# Binary search between lo and hi bounds. +-while test "x$ac_lo" != "x$ac_hi"; do +- ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo` +- cat >conftest.$ac_ext <<_ACEOF +-/* confdefs.h. */ +-_ACEOF +-cat confdefs.h >>conftest.$ac_ext +-cat >>conftest.$ac_ext <<_ACEOF +-/* end confdefs.h. */ +-$ac_includes_default +- typedef int ac__type_sizeof_; +-int +-main () +-{ +-static int test_array [1 - 2 * !(((long int) (sizeof (ac__type_sizeof_))) <= $ac_mid)]; +-test_array [0] = 0 +- +- ; +- return 0; +-} +-_ACEOF +-rm -f conftest.$ac_objext +-if { (ac_try="$ac_compile" +-case "(($ac_try" in +- *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; +- *) ac_try_echo=$ac_try;; +-esac +-eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_compile") 2>conftest.er1 +- ac_status=$? +- grep -v '^ *+' conftest.er1 >conftest.err +- rm -f conftest.er1 +- cat conftest.err >&5 +- echo "$as_me:$LINENO: \$? = $ac_status" >&5 +- (exit $ac_status); } && { +- test -z "$ac_c_werror_flag" || +- test ! -s conftest.err +- } && test -s conftest.$ac_objext; then +- ac_hi=$ac_mid +-else +- echo "$as_me: failed program was:" >&5 +-sed 's/^/| /' conftest.$ac_ext >&5 +- +- ac_lo=`expr '(' $ac_mid ')' + 1` +-fi +- +-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +-done +-case $ac_lo in +-?*) ac_cv_sizeof_int=$ac_lo;; +-'') if test "$ac_cv_type_int" = yes; then +- { { echo "$as_me:$LINENO: error: cannot compute sizeof (int) +-See \`config.log' for more details." >&5 +-echo "$as_me: error: cannot compute sizeof (int) +-See \`config.log' for more details." >&2;} +- { (exit 77); exit 77; }; } +- else +- ac_cv_sizeof_int=0 +- fi ;; +-esac +-else +- cat >conftest.$ac_ext <<_ACEOF +-/* confdefs.h. */ +-_ACEOF +-cat confdefs.h >>conftest.$ac_ext +-cat >>conftest.$ac_ext <<_ACEOF +-/* end confdefs.h. */ +-$ac_includes_default +- typedef int ac__type_sizeof_; +-static long int longval () { return (long int) (sizeof (ac__type_sizeof_)); } +-static unsigned long int ulongval () { return (long int) (sizeof (ac__type_sizeof_)); } +-#include +-#include +-int +-main () +-{ +- +- FILE *f = fopen ("conftest.val", "w"); +- if (! f) +- return 1; +- if (((long int) (sizeof (ac__type_sizeof_))) < 0) +- { +- long int i = longval (); +- if (i != ((long int) (sizeof (ac__type_sizeof_)))) +- return 1; +- fprintf (f, "%ld\n", i); +- } +- else +- { +- unsigned long int i = ulongval (); +- if (i != ((long int) (sizeof (ac__type_sizeof_)))) +- return 1; +- fprintf (f, "%lu\n", i); +- } +- return ferror (f) || fclose (f) != 0; +- +- ; +- return 0; +-} +-_ACEOF +-rm -f conftest$ac_exeext +-if { (ac_try="$ac_link" +-case "(($ac_try" in +- *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; +- *) ac_try_echo=$ac_try;; +-esac +-eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_link") 2>&5 +- ac_status=$? +- echo "$as_me:$LINENO: \$? = $ac_status" >&5 +- (exit $ac_status); } && { ac_try='./conftest$ac_exeext' +- { (case "(($ac_try" in +- *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; +- *) ac_try_echo=$ac_try;; +-esac +-eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_try") 2>&5 +- ac_status=$? +- echo "$as_me:$LINENO: \$? = $ac_status" >&5 +- (exit $ac_status); }; }; then +- ac_cv_sizeof_int=`cat conftest.val` +-else +- echo "$as_me: program exited with status $ac_status" >&5 +-echo "$as_me: failed program was:" >&5 ++ echo "$as_me: program exited with status $ac_status" >&5 ++echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + + ( exit $ac_status ) +@@ -6624,25 +6255,99 @@ + + + +- +- +- +- +- +- +- +-for ac_header in errno.h stdarg.h string.h stdlib.h +-do +-as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` +-if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then +- { echo "$as_me:$LINENO: checking for $ac_header" >&5 +-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; } +-if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then ++ { echo "$as_me:$LINENO: checking whether it is safe to define __EXTENSIONS__" >&5 ++echo $ECHO_N "checking whether it is safe to define __EXTENSIONS__... $ECHO_C" >&6; } ++if test "${ac_cv_safe_to_define___extensions__+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +-fi +-ac_res=`eval echo '${'$as_ac_Header'}'` +- { echo "$as_me:$LINENO: result: $ac_res" >&5 +-echo "${ECHO_T}$ac_res" >&6; } ++else ++ cat >conftest.$ac_ext <<_ACEOF ++/* confdefs.h. */ ++_ACEOF ++cat confdefs.h >>conftest.$ac_ext ++cat >>conftest.$ac_ext <<_ACEOF ++/* end confdefs.h. */ ++ ++# define __EXTENSIONS__ 1 ++ $ac_includes_default ++int ++main () ++{ ++ ++ ; ++ return 0; ++} ++_ACEOF ++rm -f conftest.$ac_objext ++if { (ac_try="$ac_compile" ++case "(($ac_try" in ++ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; ++ *) ac_try_echo=$ac_try;; ++esac ++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 ++ (eval "$ac_compile") 2>conftest.er1 ++ ac_status=$? ++ grep -v '^ *+' conftest.er1 >conftest.err ++ rm -f conftest.er1 ++ cat conftest.err >&5 ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); } && { ++ test -z "$ac_c_werror_flag" || ++ test ! -s conftest.err ++ } && test -s conftest.$ac_objext; then ++ ac_cv_safe_to_define___extensions__=yes ++else ++ echo "$as_me: failed program was:" >&5 ++sed 's/^/| /' conftest.$ac_ext >&5 ++ ++ ac_cv_safe_to_define___extensions__=no ++fi ++ ++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ++fi ++{ echo "$as_me:$LINENO: result: $ac_cv_safe_to_define___extensions__" >&5 ++echo "${ECHO_T}$ac_cv_safe_to_define___extensions__" >&6; } ++ test $ac_cv_safe_to_define___extensions__ = yes && ++ cat >>confdefs.h <<\_ACEOF ++#define __EXTENSIONS__ 1 ++_ACEOF ++ ++ cat >>confdefs.h <<\_ACEOF ++#define _POSIX_PTHREAD_SEMANTICS 1 ++_ACEOF ++ ++ cat >>confdefs.h <<\_ACEOF ++#define _TANDEM_SOURCE 1 ++_ACEOF ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++for ac_header in errno.h stdarg.h string.h stdlib.h ++do ++as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` ++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then ++ { echo "$as_me:$LINENO: checking for $ac_header" >&5 ++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; } ++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++fi ++ac_res=`eval echo '${'$as_ac_Header'}'` ++ { echo "$as_me:$LINENO: result: $ac_res" >&5 ++echo "${ECHO_T}$ac_res" >&6; } + else + # Is the header compilable? + { echo "$as_me:$LINENO: checking $ac_header usability" >&5 +@@ -9348,30 +9053,6 @@ + fi + + +-if $NEON_CONFIG --support socks >/dev/null; then +- +-NE_FLAG_SOCKS=yes +- +- +-cat >>confdefs.h <<\_ACEOF +-#define NE_HAVE_SOCKS 1 +-_ACEOF +- +-ne_SOCKS_message="SOCKSv5 is supported by neon" +- { echo "$as_me:$LINENO: SOCKSv5 is supported by neon" >&5 +-echo "$as_me: SOCKSv5 is supported by neon" >&6;} +- +-else +- +-NE_FLAG_SOCKS=no +- +-ne_SOCKS_message="SOCKSv5 is not supported by neon" +- { echo "$as_me:$LINENO: SOCKSv5 is not supported by neon" >&5 +-echo "$as_me: SOCKSv5 is not supported by neon" >&6;} +- +-fi +- +- + if $NEON_CONFIG --support ts_ssl >/dev/null; then + + NE_FLAG_TS_SSL=yes +@@ -10148,30 +9829,6 @@ + fi + + +-if $NEON_CONFIG --support socks >/dev/null; then +- +-NE_FLAG_SOCKS=yes +- +- +-cat >>confdefs.h <<\_ACEOF +-#define NE_HAVE_SOCKS 1 +-_ACEOF +- +-ne_SOCKS_message="SOCKSv5 is supported by neon" +- { echo "$as_me:$LINENO: SOCKSv5 is supported by neon" >&5 +-echo "$as_me: SOCKSv5 is supported by neon" >&6;} +- +-else +- +-NE_FLAG_SOCKS=no +- +-ne_SOCKS_message="SOCKSv5 is not supported by neon" +- { echo "$as_me:$LINENO: SOCKSv5 is not supported by neon" >&5 +-echo "$as_me: SOCKSv5 is not supported by neon" >&6;} +- +-fi +- +- + if $NEON_CONFIG --support ts_ssl >/dev/null; then + + NE_FLAG_TS_SSL=yes +@@ -10755,12 +10412,12 @@ + + # Define the current versions. + NE_VERSION_MAJOR=0 +-NE_VERSION_MINOR=28 ++NE_VERSION_MINOR=29 + NE_VERSION_PATCH=0 + NE_VERSION_TAG= + +-# 0.28.x is backwards-compatible with 0.27.x, so AGE=1 +-NE_LIBTOOL_VERSINFO="28:0:1" ++# 0.29.x is backwards-compatible to 0.27.x, so AGE=2 ++NE_LIBTOOL_VERSINFO="29:${NE_VERSION_PATCH}:2" + + + +@@ -11875,9 +11532,6 @@ + #define NE_FMT_NE_OFF_T NE_FMT_OFF64_T + _ACEOF + +- +-: Disabled for 0.28 to retain 0.27 ABI +- + else + cat >>confdefs.h <<_ACEOF + #define NE_FMT_NE_OFF_T NE_FMT_OFF_T +@@ -12175,6 +11829,7 @@ + + # Unixware 7 can only link gethostbyname with -lnsl -lsocket + # Pick up -lsocket first, then the gethostbyname check will work. ++# Haiku requires -lnetwork for socket functions. + + + +@@ -12226,7 +11881,7 @@ + + ne_sl_save_LIBS=$LIBS + ne_cv_libsfor_socket="not found" +-for lib in socket inet ws2_32; do ++for lib in socket inet ws2_32 network; do + # The w32api libraries link using the stdcall calling convention. + case ${lib}-${ne_cv_os_uname} in + ws2_32-MINGW*) ne__code="__stdcall socket();" ;; +@@ -12431,7 +12086,8 @@ + + + +-for ac_func in gai_strerror getnameinfo inet_ntop ++ ++for ac_func in gai_strerror getnameinfo inet_ntop inet_pton + do + as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh` + { echo "$as_me:$LINENO: checking for $ac_func" >&5 +@@ -12545,7 +12201,8 @@ + + + +-for ac_func in gai_strerror getnameinfo inet_ntop ++ ++for ac_func in gai_strerror getnameinfo inet_ntop inet_pton + do + as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh` + { echo "$as_me:$LINENO: checking for $ac_func" >&5 +@@ -12736,6 +12393,7 @@ + # Checks for non-getaddrinfo() based resolver interfaces. + # QNX has gethostbyname in -lsocket. BeOS only has it in -lbind. + # CygWin/Winsock2 has it in -lws2_32, allegedly. ++ # Haiku requires -lnetwork for socket functions. + + + +@@ -12787,7 +12445,7 @@ + + ne_sl_save_LIBS=$LIBS + ne_cv_libsfor_gethostbyname="not found" +-for lib in socket nsl bind ws2_32; do ++for lib in socket nsl bind ws2_32 network; do + # The w32api libraries link using the stdcall calling convention. + case ${lib}-${ne_cv_os_uname} in + ws2_32-MINGW*) ne__code="__stdcall gethostbyname();" ;; +@@ -13530,7 +13188,7 @@ + else + { echo "$as_me:$LINENO: result: yes" >&5 + echo "${ECHO_T}yes" >&6; } +- NEON_EXTRAOBJS="$NEON_EXTRAOBJS ne_acl" ++ NEON_EXTRAOBJS="$NEON_EXTRAOBJS ne_oldacl ne_acl3744" + fi + + +@@ -13567,6 +13225,7 @@ + yes|openssl) + + ++ + # Extract the first word of "pkg-config", so it can be a program name with args. + set dummy pkg-config; ac_word=$2 + { echo "$as_me:$LINENO: checking for $ac_word" >&5 +@@ -14306,6 +13965,9 @@ + + + ++ ++ ++ + for ac_header in openssl/ssl.h openssl/opensslv.h + do + as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` +@@ -14504,7 +14166,8 @@ + ne_cf_save_LIBS=$LIBS + LIBS="$LIBS $NEON_LIBS" + +-for ac_func in CRYPTO_set_idptr_callback ++ ++for ac_func in CRYPTO_set_idptr_callback SSL_SESSION_cmp + do + as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh` + { echo "$as_me:$LINENO: checking for $ac_func" >&5 +@@ -14688,9 +14351,63 @@ + _ACEOF + + NEON_EXTRAOBJS="$NEON_EXTRAOBJS ne_openssl" ++ ++ ++cat >>confdefs.h <<\_ACEOF ++#define HAVE_NTLM 1 ++_ACEOF ++ + ;; + gnutls) +- # Extract the first word of "libgnutls-config", so it can be a program name with args. ++ ++ ++ ++# Extract the first word of "pkg-config", so it can be a program name with args. ++set dummy pkg-config; ac_word=$2 ++{ echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } ++if test "${ac_cv_path_PKG_CONFIG+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ case $PKG_CONFIG in ++ [\\/]* | ?:[\\/]*) ++ ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path. ++ ;; ++ *) ++ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ++ ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++IFS=$as_save_IFS ++ ++ test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no" ++ ;; ++esac ++fi ++PKG_CONFIG=$ac_cv_path_PKG_CONFIG ++if test -n "$PKG_CONFIG"; then ++ { echo "$as_me:$LINENO: result: $PKG_CONFIG" >&5 ++echo "${ECHO_T}$PKG_CONFIG" >&6; } ++else ++ { echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6; } ++fi ++ ++ ++if test "$PKG_CONFIG" = "no"; then ++ : Not using pkg-config ++ ++ # Fall back on libgnutls-config script ++ # Extract the first word of "libgnutls-config", so it can be a program name with args. + set dummy libgnutls-config; ac_word=$2 + { echo "$as_me:$LINENO: checking for $ac_word" >&5 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } +@@ -14732,22 +14449,105 @@ + + + +- if test "$GNUTLS_CONFIG" = "no"; then +- { { echo "$as_me:$LINENO: error: could not find libgnutls-config in \$PATH" >&5 ++ if test "$GNUTLS_CONFIG" = "no"; then ++ { { echo "$as_me:$LINENO: error: could not find libgnutls-config in \$PATH" >&5 + echo "$as_me: error: could not find libgnutls-config in \$PATH" >&2;} + { (exit 1); exit 1; }; } +- fi ++ fi ++ ++ CPPFLAGS="$CPPFLAGS `$GNUTLS_CONFIG --cflags`" ++ NEON_LIBS="$NEON_LIBS `$GNUTLS_CONFIG --libs`" ++ ++ ne_gnutls_ver=`$GNUTLS_CONFIG --version` ++ ++else ++ { echo "$as_me:$LINENO: checking for gnutls pkg-config data" >&5 ++echo $ECHO_N "checking for gnutls pkg-config data... $ECHO_C" >&6; } ++if test "${ne_cv_pkg_gnutls+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if $PKG_CONFIG gnutls; then ++ ne_cv_pkg_gnutls=yes ++ else ++ ne_cv_pkg_gnutls=no ++ fi ++fi ++{ echo "$as_me:$LINENO: result: $ne_cv_pkg_gnutls" >&5 ++echo "${ECHO_T}$ne_cv_pkg_gnutls" >&6; } ++ ++ if test "$ne_cv_pkg_gnutls" = "yes"; then ++ NE_SSL_CFLAGS=`$PKG_CONFIG --cflags gnutls` ++ NE_SSL_LIBS=`$PKG_CONFIG --libs gnutls` ++ : Using provided pkg-config data ++ { echo "$as_me:$LINENO: using GnuTLS configuration from pkg-config" >&5 ++echo "$as_me: using GnuTLS configuration from pkg-config" >&6;} ++ CPPFLAGS="$CPPFLAGS ${NE_SSL_CFLAGS}" ++ NEON_LIBS="$NEON_LIBS ${NE_SSL_LIBS}" ++ ++ ne_gnutls_ver=`$PKG_CONFIG --modversion gnutls` + +- ne_gnutls_ver=`$GNUTLS_CONFIG --version` +- case $ne_gnutls_ver in +- 1.0.?|1.0.1?|1.0.20|1.0.21) +- { { echo "$as_me:$LINENO: error: GNU TLS version $ne_gnutls_ver is too old -- 1.0.22 or later required" >&5 +-echo "$as_me: error: GNU TLS version $ne_gnutls_ver is too old -- 1.0.22 or later required" >&2;} ++ else ++ : No pkg-config for gnutls provided ++ ++ # Fall back on libgnutls-config script ++ # Extract the first word of "libgnutls-config", so it can be a program name with args. ++set dummy libgnutls-config; ac_word=$2 ++{ echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } ++if test "${ac_cv_path_GNUTLS_CONFIG+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ case $GNUTLS_CONFIG in ++ [\\/]* | ?:[\\/]*) ++ ac_cv_path_GNUTLS_CONFIG="$GNUTLS_CONFIG" # Let the user override the test with a path. ++ ;; ++ *) ++ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ++ ac_cv_path_GNUTLS_CONFIG="$as_dir/$ac_word$ac_exec_ext" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++IFS=$as_save_IFS ++ ++ test -z "$ac_cv_path_GNUTLS_CONFIG" && ac_cv_path_GNUTLS_CONFIG="no" ++ ;; ++esac ++fi ++GNUTLS_CONFIG=$ac_cv_path_GNUTLS_CONFIG ++if test -n "$GNUTLS_CONFIG"; then ++ { echo "$as_me:$LINENO: result: $GNUTLS_CONFIG" >&5 ++echo "${ECHO_T}$GNUTLS_CONFIG" >&6; } ++else ++ { echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6; } ++fi ++ ++ ++ ++ if test "$GNUTLS_CONFIG" = "no"; then ++ { { echo "$as_me:$LINENO: error: could not find libgnutls-config in \$PATH" >&5 ++echo "$as_me: error: could not find libgnutls-config in \$PATH" >&2;} + { (exit 1); exit 1; }; } +- ;; +- esac ++ fi ++ ++ CPPFLAGS="$CPPFLAGS `$GNUTLS_CONFIG --cflags`" ++ NEON_LIBS="$NEON_LIBS `$GNUTLS_CONFIG --libs`" ++ ++ ne_gnutls_ver=`$GNUTLS_CONFIG --version` ++ ++ fi ++fi ++ ++ + +- CPPFLAGS="$CPPFLAGS `$GNUTLS_CONFIG --cflags`" + + if test "${ac_cv_header_gnutls_gnutls_h+set}" = set; then + { echo "$as_me:$LINENO: checking for gnutls/gnutls.h" >&5 +@@ -14902,7 +14702,6 @@ + echo "$as_me: SSL support enabled, using GnuTLS $ne_gnutls_ver" >&6;} + + NEON_EXTRAOBJS="$NEON_EXTRAOBJS ne_gnutls" +- NEON_LIBS="$NEON_LIBS `$GNUTLS_CONFIG --libs`" + + cat >>confdefs.h <<\_ACEOF + #define HAVE_GNUTLS 1 +@@ -14917,8 +14716,11 @@ + + + ++ + for ac_func in gnutls_session_get_data2 gnutls_x509_dn_get_rdn_ava \ +- gnutls_sign_callback_set ++ gnutls_sign_callback_set \ ++ gnutls_certificate_get_x509_cas \ ++ gnutls_certificate_verify_peers2 + do + as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh` + { echo "$as_me:$LINENO: checking for $ac_func" >&5 +@@ -15013,6 +14815,13 @@ + + LIBS=$ne_cf_save_LIBS + ++ # fail if gnutls_certificate_verify_peers2 is not found ++ if test x${ac_cv_func_gnutls_certificate_verify_peers2} != xyes; then ++ { { echo "$as_me:$LINENO: error: GnuTLS version predates gnutls_certificate_verify_peers2, newer version required" >&5 ++echo "$as_me: error: GnuTLS version predates gnutls_certificate_verify_peers2, newer version required" >&2;} ++ { (exit 1); exit 1; }; } ++ fi ++ + # Check for iconv support if using the new RDN access functions: + if test ${ac_cv_func_gnutls_x509_dn_get_rdn_ava}X${ac_cv_header_iconv_h} = yesXyes; then + +@@ -15110,102 +14919,14 @@ + done + + fi ++ ;; ++*) # Default to off; only create crypto-enabled binaries if requested. + +- if test x${ac_cv_func_gnutls_sign_callback_set} = xyes; then +- if test "$with_pakchois" != "no"; then +- # PKCS#11... ho! ++NE_FLAG_SSL=no + +- +-# Extract the first word of "pkg-config", so it can be a program name with args. +-set dummy pkg-config; ac_word=$2 +-{ echo "$as_me:$LINENO: checking for $ac_word" >&5 +-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } +-if test "${ac_cv_path_PKG_CONFIG+set}" = set; then +- echo $ECHO_N "(cached) $ECHO_C" >&6 +-else +- case $PKG_CONFIG in +- [\\/]* | ?:[\\/]*) +- ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path. +- ;; +- *) +- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +-for as_dir in $PATH +-do +- IFS=$as_save_IFS +- test -z "$as_dir" && as_dir=. +- for ac_exec_ext in '' $ac_executable_extensions; do +- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then +- ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext" +- echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 +- break 2 +- fi +-done +-done +-IFS=$as_save_IFS +- +- test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no" +- ;; +-esac +-fi +-PKG_CONFIG=$ac_cv_path_PKG_CONFIG +-if test -n "$PKG_CONFIG"; then +- { echo "$as_me:$LINENO: result: $PKG_CONFIG" >&5 +-echo "${ECHO_T}$PKG_CONFIG" >&6; } +-else +- { echo "$as_me:$LINENO: result: no" >&5 +-echo "${ECHO_T}no" >&6; } +-fi +- +- +-if test "$PKG_CONFIG" = "no"; then +- : Not using pkg-config +- { echo "$as_me:$LINENO: pakchois library not found; no PKCS11 support" >&5 +-echo "$as_me: pakchois library not found; no PKCS11 support" >&6;} +-else +- { echo "$as_me:$LINENO: checking for pakchois pkg-config data" >&5 +-echo $ECHO_N "checking for pakchois pkg-config data... $ECHO_C" >&6; } +-if test "${ne_cv_pkg_pakchois+set}" = set; then +- echo $ECHO_N "(cached) $ECHO_C" >&6 +-else +- if $PKG_CONFIG pakchois; then +- ne_cv_pkg_pakchois=yes +- else +- ne_cv_pkg_pakchois=no +- fi +-fi +-{ echo "$as_me:$LINENO: result: $ne_cv_pkg_pakchois" >&5 +-echo "${ECHO_T}$ne_cv_pkg_pakchois" >&6; } +- +- if test "$ne_cv_pkg_pakchois" = "yes"; then +- NE_PK11_CFLAGS=`$PKG_CONFIG --cflags pakchois` +- NE_PK11_LIBS=`$PKG_CONFIG --libs pakchois` +- : Using provided pkg-config data +- { echo "$as_me:$LINENO: using pakchois for PKCS11 support" >&5 +-echo "$as_me: using pakchois for PKCS11 support" >&6;} +- +-cat >>confdefs.h <<\_ACEOF +-#define HAVE_PAKCHOIS 1 +-_ACEOF +- +- CPPFLAGS="$CPPFLAGS ${NE_PK11_CFLAGS}" +- NEON_LIBS="${NEON_LIBS} ${NE_PK11_LIBS}" +- else +- : No pkg-config for pakchois provided +- { echo "$as_me:$LINENO: pakchois library not found; no PKCS11 support" >&5 +-echo "$as_me: pakchois library not found; no PKCS11 support" >&6;} +- fi +-fi +- fi +- fi +- +- ;; +-*) # Default to off; only create crypto-enabled binaries if requested. +- +-NE_FLAG_SSL=no +- +-ne_SSL_message="SSL support is not enabled" +- { echo "$as_me:$LINENO: SSL support is not enabled" >&5 +-echo "$as_me: SSL support is not enabled" >&6;} ++ne_SSL_message="SSL support is not enabled" ++ { echo "$as_me:$LINENO: SSL support is not enabled" >&5 ++echo "$as_me: SSL support is not enabled" >&6;} + + + NE_FLAG_TS_SSL=no +@@ -15378,21 +15099,160 @@ + ;; + esac + ++case ${with_pakchois}X${ac_cv_func_gnutls_sign_callback_set}Y${ne_cv_lib_ssl097} in ++noX*Y*) ;; ++*X*Yyes|*XyesY*) ++ # PKCS#11... ho! ++ ++ ++ ++# Extract the first word of "pkg-config", so it can be a program name with args. ++set dummy pkg-config; ac_word=$2 ++{ echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } ++if test "${ac_cv_path_PKG_CONFIG+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ case $PKG_CONFIG in ++ [\\/]* | ?:[\\/]*) ++ ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path. ++ ;; ++ *) ++ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ++ ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++IFS=$as_save_IFS ++ ++ test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no" ++ ;; ++esac ++fi ++PKG_CONFIG=$ac_cv_path_PKG_CONFIG ++if test -n "$PKG_CONFIG"; then ++ { echo "$as_me:$LINENO: result: $PKG_CONFIG" >&5 ++echo "${ECHO_T}$PKG_CONFIG" >&6; } ++else ++ { echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6; } ++fi ++ ++ ++if test "$PKG_CONFIG" = "no"; then ++ : Not using pkg-config ++ { echo "$as_me:$LINENO: pakchois library not found; no PKCS#11 support" >&5 ++echo "$as_me: pakchois library not found; no PKCS#11 support" >&6;} ++else ++ { echo "$as_me:$LINENO: checking for pakchois pkg-config data" >&5 ++echo $ECHO_N "checking for pakchois pkg-config data... $ECHO_C" >&6; } ++if test "${ne_cv_pkg_pakchois+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ if $PKG_CONFIG pakchois; then ++ ne_cv_pkg_pakchois=yes ++ else ++ ne_cv_pkg_pakchois=no ++ fi ++fi ++{ echo "$as_me:$LINENO: result: $ne_cv_pkg_pakchois" >&5 ++echo "${ECHO_T}$ne_cv_pkg_pakchois" >&6; } ++ ++ if test "$ne_cv_pkg_pakchois" = "yes"; then ++ NE_PK11_CFLAGS=`$PKG_CONFIG --cflags pakchois` ++ NE_PK11_LIBS=`$PKG_CONFIG --libs pakchois` ++ : Using provided pkg-config data ++ { echo "$as_me:$LINENO: using pakchois for PKCS#11 support" >&5 ++echo "$as_me: using pakchois for PKCS#11 support" >&6;} ++ ++cat >>confdefs.h <<\_ACEOF ++#define HAVE_PAKCHOIS 1 ++_ACEOF ++ ++ CPPFLAGS="$CPPFLAGS ${NE_PK11_CFLAGS}" ++ NEON_LIBS="${NEON_LIBS} ${NE_PK11_LIBS}" ++ else ++ : No pkg-config for pakchois provided ++ { echo "$as_me:$LINENO: pakchois library not found; no PKCS#11 support" >&5 ++echo "$as_me: pakchois library not found; no PKCS#11 support" >&6;} ++ fi ++fi ++ ++ ++ ++ ;; ++esac ++ + + ++# Check whether --with-gssapi was given. ++if test "${with_gssapi+set}" = set; then ++ withval=$with_gssapi; ++fi + ++if test "$with_gssapi" != "no"; then ++ # Extract the first word of "krb5-config", so it can be a program name with args. ++set dummy krb5-config; ac_word=$2 ++{ echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } ++if test "${ac_cv_path_KRB5_CONFIG+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ case $KRB5_CONFIG in ++ [\\/]* | ?:[\\/]*) ++ ac_cv_path_KRB5_CONFIG="$KRB5_CONFIG" # Let the user override the test with a path. ++ ;; ++ *) ++ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++as_dummy="$PATH:/usr/kerberos/bin" ++for as_dir in $as_dummy ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ++ ac_cv_path_KRB5_CONFIG="$as_dir/$ac_word$ac_exec_ext" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++IFS=$as_save_IFS + +-# Check whether --with-socks was given. +-if test "${with_socks+set}" = set; then +- withval=$with_socks; ++ test -z "$ac_cv_path_KRB5_CONFIG" && ac_cv_path_KRB5_CONFIG="none" ++ ;; ++esac ++fi ++KRB5_CONFIG=$ac_cv_path_KRB5_CONFIG ++if test -n "$KRB5_CONFIG"; then ++ { echo "$as_me:$LINENO: result: $KRB5_CONFIG" >&5 ++echo "${ECHO_T}$KRB5_CONFIG" >&6; } ++else ++ { echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6; } + fi + + +-if test "$with_socks" = "yes"; then +- ne_save_LIBS=$LIBS ++else ++ KRB5_CONFIG=none ++fi ++if test "x$KRB5_CONFIG" != "xnone"; then ++ ne_save_CPPFLAGS=$CPPFLAGS ++ ne_save_LIBS=$NEON_LIBS ++ NEON_LIBS="$NEON_LIBS `${KRB5_CONFIG} --libs gssapi`" ++ CPPFLAGS="$CPPFLAGS `${KRB5_CONFIG} --cflags gssapi`" ++ # MIT and Heimdal put gssapi.h in different places + + +-for ac_header in socks.h ++for ac_header in gssapi/gssapi.h gssapi.h + do + as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` + if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then +@@ -15531,19 +15391,41 @@ + cat >>confdefs.h <<_ACEOF + #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1 + _ACEOF +- { echo "$as_me:$LINENO: checking for connect in -lsocks5" >&5 +-echo $ECHO_N "checking for connect in -lsocks5... $ECHO_C" >&6; } +-if test "${ac_cv_lib_socks5_connect+set}" = set; then ++ ++ ++ne_cf_save_LIBS=$LIBS ++LIBS="$LIBS $NEON_LIBS" ++ ++for ac_func in gss_init_sec_context ++do ++as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh` ++{ echo "$as_me:$LINENO: checking for $ac_func" >&5 ++echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; } ++if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then + echo $ECHO_N "(cached) $ECHO_C" >&6 + else +- ac_check_lib_save_LIBS=$LIBS +-LIBS="-lsocks5 $LIBS" +-cat >conftest.$ac_ext <<_ACEOF ++ cat >conftest.$ac_ext <<_ACEOF + /* confdefs.h. */ + _ACEOF + cat confdefs.h >>conftest.$ac_ext + cat >>conftest.$ac_ext <<_ACEOF + /* end confdefs.h. */ ++/* Define $ac_func to an innocuous variant, in case declares $ac_func. ++ For example, HP-UX 11i declares gettimeofday. */ ++#define $ac_func innocuous_$ac_func ++ ++/* System header to define __stub macros and hopefully few prototypes, ++ which can conflict with char $ac_func (); below. ++ Prefer to if __STDC__ is defined, since ++ exists even on freestanding compilers. */ ++ ++#ifdef __STDC__ ++# include ++#else ++# include ++#endif ++ ++#undef $ac_func + + /* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC +@@ -15551,11 +15433,18 @@ + #ifdef __cplusplus + extern "C" + #endif +-char connect (); ++char $ac_func (); ++/* The GNU C library defines this for functions which it implements ++ to always fail with ENOSYS. Some functions are actually named ++ something starting with __ and the normal name is an alias. */ ++#if defined __stub_$ac_func || defined __stub___$ac_func ++choke me ++#endif ++ + int + main () + { +-return connect (); ++return $ac_func (); + ; + return 0; + } +@@ -15578,122 +15467,36 @@ + test ! -s conftest.err + } && test -s conftest$ac_exeext && + $as_test_x conftest$ac_exeext; then +- ac_cv_lib_socks5_connect=yes ++ eval "$as_ac_var=yes" + else + echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + +- ac_cv_lib_socks5_connect=no ++ eval "$as_ac_var=no" + fi + + rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ + conftest$ac_exeext conftest.$ac_ext +-LIBS=$ac_check_lib_save_LIBS +-fi +-{ echo "$as_me:$LINENO: result: $ac_cv_lib_socks5_connect" >&5 +-echo "${ECHO_T}$ac_cv_lib_socks5_connect" >&6; } +-if test $ac_cv_lib_socks5_connect = yes; then +- : +-else +- { { echo "$as_me:$LINENO: error: could not find libsocks5 for SOCKS support" >&5 +-echo "$as_me: error: could not find libsocks5 for SOCKS support" >&2;} +- { (exit 1); exit 1; }; } +-fi +- +-else +- { { echo "$as_me:$LINENO: error: could not find socks.h for SOCKS support" >&5 +-echo "$as_me: error: could not find socks.h for SOCKS support" >&2;} +- { (exit 1); exit 1; }; } + fi ++ac_res=`eval echo '${'$as_ac_var'}'` ++ { echo "$as_me:$LINENO: result: $ac_res" >&5 ++echo "${ECHO_T}$ac_res" >&6; } ++if test `eval echo '${'$as_ac_var'}'` = yes; then ++ cat >>confdefs.h <<_ACEOF ++#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1 ++_ACEOF + +-done +- +- +- +-NE_FLAG_SOCKS=yes +- ++ ne_save_CPPFLAGS=$CPPFLAGS ++ ne_save_LIBS=$NEON_LIBS ++ { echo "$as_me:$LINENO: GSSAPI authentication support enabled" >&5 ++echo "$as_me: GSSAPI authentication support enabled" >&6;} + + cat >>confdefs.h <<\_ACEOF +-#define NE_HAVE_SOCKS 1 ++#define HAVE_GSSAPI 1 + _ACEOF + +-ne_SOCKS_message="SOCKSv5 support is enabled" +- { echo "$as_me:$LINENO: SOCKSv5 support is enabled" >&5 +-echo "$as_me: SOCKSv5 support is enabled" >&6;} +- +- NEON_LIBS="$NEON_LIBS -lsocks5" +- LIBS=$ne_save_LIBS +-else +- +-NE_FLAG_SOCKS=no +- +-ne_SOCKS_message="SOCKSv5 support is not enabled" +- { echo "$as_me:$LINENO: SOCKSv5 support is not enabled" >&5 +-echo "$as_me: SOCKSv5 support is not enabled" >&6;} +- +-fi +- +- +-# Check whether --with-gssapi was given. +-if test "${with_gssapi+set}" = set; then +- withval=$with_gssapi; +-fi +- +-if test "$with_gssapi" != "no"; then +- # Extract the first word of "krb5-config", so it can be a program name with args. +-set dummy krb5-config; ac_word=$2 +-{ echo "$as_me:$LINENO: checking for $ac_word" >&5 +-echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } +-if test "${ac_cv_path_KRB5_CONFIG+set}" = set; then +- echo $ECHO_N "(cached) $ECHO_C" >&6 +-else +- case $KRB5_CONFIG in +- [\\/]* | ?:[\\/]*) +- ac_cv_path_KRB5_CONFIG="$KRB5_CONFIG" # Let the user override the test with a path. +- ;; +- *) +- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +-as_dummy="$PATH:/usr/kerberos/bin" +-for as_dir in $as_dummy +-do +- IFS=$as_save_IFS +- test -z "$as_dir" && as_dir=. +- for ac_exec_ext in '' $ac_executable_extensions; do +- if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then +- ac_cv_path_KRB5_CONFIG="$as_dir/$ac_word$ac_exec_ext" +- echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 +- break 2 +- fi +-done +-done +-IFS=$as_save_IFS +- +- test -z "$ac_cv_path_KRB5_CONFIG" && ac_cv_path_KRB5_CONFIG="none" +- ;; +-esac +-fi +-KRB5_CONFIG=$ac_cv_path_KRB5_CONFIG +-if test -n "$KRB5_CONFIG"; then +- { echo "$as_me:$LINENO: result: $KRB5_CONFIG" >&5 +-echo "${ECHO_T}$KRB5_CONFIG" >&6; } +-else +- { echo "$as_me:$LINENO: result: no" >&5 +-echo "${ECHO_T}no" >&6; } +-fi +- +- +-else +- KRB5_CONFIG=none +-fi +-if test "x$KRB5_CONFIG" != "xnone"; then +- ne_save_CPPFLAGS=$CPPFLAGS +- ne_save_LIBS=$NEON_LIBS +- NEON_LIBS="$NEON_LIBS `${KRB5_CONFIG} --libs gssapi`" +- CPPFLAGS="$CPPFLAGS `${KRB5_CONFIG} --cflags gssapi`" +- # MIT and Heimdal put gssapi.h in different places +- + +-for ac_header in gssapi/gssapi.h gssapi.h ++for ac_header in gssapi/gssapi_generic.h + do + as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` + if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then +@@ -15833,16 +15636,14 @@ + #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1 + _ACEOF + ++fi + +-ne_cf_save_LIBS=$LIBS +-LIBS="$LIBS $NEON_LIBS" ++done + +-for ac_func in gss_init_sec_context +-do +-as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh` +-{ echo "$as_me:$LINENO: checking for $ac_func" >&5 +-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; } +-if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then ++ # Older versions of MIT Kerberos lack GSS_C_NT_HOSTBASED_SERVICE ++ { echo "$as_me:$LINENO: checking whether GSS_C_NT_HOSTBASED_SERVICE is declared" >&5 ++echo $ECHO_N "checking whether GSS_C_NT_HOSTBASED_SERVICE is declared... $ECHO_C" >&6; } ++if test "${ac_cv_have_decl_GSS_C_NT_HOSTBASED_SERVICE+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 + else + cat >conftest.$ac_ext <<_ACEOF +@@ -15851,53 +15652,31 @@ + cat confdefs.h >>conftest.$ac_ext + cat >>conftest.$ac_ext <<_ACEOF + /* end confdefs.h. */ +-/* Define $ac_func to an innocuous variant, in case declares $ac_func. +- For example, HP-UX 11i declares gettimeofday. */ +-#define $ac_func innocuous_$ac_func +- +-/* System header to define __stub macros and hopefully few prototypes, +- which can conflict with char $ac_func (); below. +- Prefer to if __STDC__ is defined, since +- exists even on freestanding compilers. */ +- +-#ifdef __STDC__ +-# include ++#ifdef HAVE_GSSAPI_GSSAPI_H ++#include + #else +-# include +-#endif +- +-#undef $ac_func +- +-/* Override any GCC internal prototype to avoid an error. +- Use char because int might match the return type of a GCC +- builtin and then its argument prototype would still apply. */ +-#ifdef __cplusplus +-extern "C" +-#endif +-char $ac_func (); +-/* The GNU C library defines this for functions which it implements +- to always fail with ENOSYS. Some functions are actually named +- something starting with __ and the normal name is an alias. */ +-#if defined __stub_$ac_func || defined __stub___$ac_func +-choke me ++#include + #endif + + int + main () + { +-return $ac_func (); ++#ifndef GSS_C_NT_HOSTBASED_SERVICE ++ (void) GSS_C_NT_HOSTBASED_SERVICE; ++#endif ++ + ; + return 0; + } + _ACEOF +-rm -f conftest.$ac_objext conftest$ac_exeext +-if { (ac_try="$ac_link" ++rm -f conftest.$ac_objext ++if { (ac_try="$ac_compile" + case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; + esac + eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_link") 2>conftest.er1 ++ (eval "$ac_compile") 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 +@@ -15906,261 +15685,163 @@ + (exit $ac_status); } && { + test -z "$ac_c_werror_flag" || + test ! -s conftest.err +- } && test -s conftest$ac_exeext && +- $as_test_x conftest$ac_exeext; then +- eval "$as_ac_var=yes" ++ } && test -s conftest.$ac_objext; then ++ ac_cv_have_decl_GSS_C_NT_HOSTBASED_SERVICE=yes + else + echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + +- eval "$as_ac_var=no" ++ ac_cv_have_decl_GSS_C_NT_HOSTBASED_SERVICE=no + fi + +-rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ +- conftest$ac_exeext conftest.$ac_ext ++rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + fi +-ac_res=`eval echo '${'$as_ac_var'}'` +- { echo "$as_me:$LINENO: result: $ac_res" >&5 +-echo "${ECHO_T}$ac_res" >&6; } +-if test `eval echo '${'$as_ac_var'}'` = yes; then +- cat >>confdefs.h <<_ACEOF +-#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1 +-_ACEOF +- +- ne_save_CPPFLAGS=$CPPFLAGS +- ne_save_LIBS=$NEON_LIBS +- { echo "$as_me:$LINENO: GSSAPI authentication support enabled" >&5 +-echo "$as_me: GSSAPI authentication support enabled" >&6;} ++{ echo "$as_me:$LINENO: result: $ac_cv_have_decl_GSS_C_NT_HOSTBASED_SERVICE" >&5 ++echo "${ECHO_T}$ac_cv_have_decl_GSS_C_NT_HOSTBASED_SERVICE" >&6; } ++if test $ac_cv_have_decl_GSS_C_NT_HOSTBASED_SERVICE = yes; then ++ : ++else + + cat >>confdefs.h <<\_ACEOF +-#define HAVE_GSSAPI 1 ++#define GSS_C_NT_HOSTBASED_SERVICE gss_nt_service_name + _ACEOF + ++fi + +-for ac_header in gssapi/gssapi_generic.h +-do +-as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` +-if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then +- { echo "$as_me:$LINENO: checking for $ac_header" >&5 +-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; } +-if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then +- echo $ECHO_N "(cached) $ECHO_C" >&6 + fi +-ac_res=`eval echo '${'$as_ac_Header'}'` +- { echo "$as_me:$LINENO: result: $ac_res" >&5 +-echo "${ECHO_T}$ac_res" >&6; } +-else +- # Is the header compilable? +-{ echo "$as_me:$LINENO: checking $ac_header usability" >&5 +-echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; } +-cat >conftest.$ac_ext <<_ACEOF +-/* confdefs.h. */ +-_ACEOF +-cat confdefs.h >>conftest.$ac_ext +-cat >>conftest.$ac_ext <<_ACEOF +-/* end confdefs.h. */ +-$ac_includes_default +-#include <$ac_header> +-_ACEOF +-rm -f conftest.$ac_objext +-if { (ac_try="$ac_compile" +-case "(($ac_try" in +- *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; +- *) ac_try_echo=$ac_try;; +-esac +-eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_compile") 2>conftest.er1 +- ac_status=$? +- grep -v '^ *+' conftest.er1 >conftest.err +- rm -f conftest.er1 +- cat conftest.err >&5 +- echo "$as_me:$LINENO: \$? = $ac_status" >&5 +- (exit $ac_status); } && { +- test -z "$ac_c_werror_flag" || +- test ! -s conftest.err +- } && test -s conftest.$ac_objext; then +- ac_header_compiler=yes +-else +- echo "$as_me: failed program was:" >&5 +-sed 's/^/| /' conftest.$ac_ext >&5 ++done ++ ++LIBS=$ne_cf_save_LIBS ++ break + +- ac_header_compiler=no + fi + +-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +-{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 +-echo "${ECHO_T}$ac_header_compiler" >&6; } ++done + +-# Is the header present? +-{ echo "$as_me:$LINENO: checking $ac_header presence" >&5 +-echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; } +-cat >conftest.$ac_ext <<_ACEOF +-/* confdefs.h. */ +-_ACEOF +-cat confdefs.h >>conftest.$ac_ext +-cat >>conftest.$ac_ext <<_ACEOF +-/* end confdefs.h. */ +-#include <$ac_header> +-_ACEOF +-if { (ac_try="$ac_cpp conftest.$ac_ext" +-case "(($ac_try" in +- *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; +- *) ac_try_echo=$ac_try;; +-esac +-eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1 +- ac_status=$? +- grep -v '^ *+' conftest.er1 >conftest.err +- rm -f conftest.er1 +- cat conftest.err >&5 +- echo "$as_me:$LINENO: \$? = $ac_status" >&5 +- (exit $ac_status); } >/dev/null && { +- test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || +- test ! -s conftest.err +- }; then +- ac_header_preproc=yes +-else +- echo "$as_me: failed program was:" >&5 +-sed 's/^/| /' conftest.$ac_ext >&5 ++ CPPFLAGS=$ne_save_CPPFLAGS ++ NEON_LIBS=$ne_save_LIBS ++fi + +- ac_header_preproc=no ++ ++# Check whether --with-libproxy was given. ++if test "${with_libproxy+set}" = set; then ++ withval=$with_libproxy; + fi + +-rm -f conftest.err conftest.$ac_ext +-{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 +-echo "${ECHO_T}$ac_header_preproc" >&6; } ++if test "x$with_libproxy" != "xno"; then + +-# So? What about this header? +-case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in +- yes:no: ) +- { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5 +-echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;} +- { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5 +-echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;} +- ac_header_preproc=yes +- ;; +- no:yes:* ) +- { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5 +-echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;} +- { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5 +-echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;} +- { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5 +-echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;} +- { echo "$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&5 +-echo "$as_me: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&2;} +- { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5 +-echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;} +- { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5 +-echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;} +- ( cat <<\_ASBOX +-## --------------------------------- ## +-## Report this to cadaver@webdav.org ## +-## --------------------------------- ## +-_ASBOX +- ) | sed "s/^/$as_me: WARNING: /" >&2 +- ;; +-esac +-{ echo "$as_me:$LINENO: checking for $ac_header" >&5 +-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; } +-if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then ++ ++ ++# Extract the first word of "pkg-config", so it can be a program name with args. ++set dummy pkg-config; ac_word=$2 ++{ echo "$as_me:$LINENO: checking for $ac_word" >&5 ++echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } ++if test "${ac_cv_path_PKG_CONFIG+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 + else +- eval "$as_ac_Header=\$ac_header_preproc" +-fi +-ac_res=`eval echo '${'$as_ac_Header'}'` +- { echo "$as_me:$LINENO: result: $ac_res" >&5 +-echo "${ECHO_T}$ac_res" >&6; } ++ case $PKG_CONFIG in ++ [\\/]* | ?:[\\/]*) ++ ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path. ++ ;; ++ *) ++ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR ++for as_dir in $PATH ++do ++ IFS=$as_save_IFS ++ test -z "$as_dir" && as_dir=. ++ for ac_exec_ext in '' $ac_executable_extensions; do ++ if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then ++ ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext" ++ echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 ++ break 2 ++ fi ++done ++done ++IFS=$as_save_IFS + ++ test -z "$ac_cv_path_PKG_CONFIG" && ac_cv_path_PKG_CONFIG="no" ++ ;; ++esac + fi +-if test `eval echo '${'$as_ac_Header'}'` = yes; then +- cat >>confdefs.h <<_ACEOF +-#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1 +-_ACEOF +- ++PKG_CONFIG=$ac_cv_path_PKG_CONFIG ++if test -n "$PKG_CONFIG"; then ++ { echo "$as_me:$LINENO: result: $PKG_CONFIG" >&5 ++echo "${ECHO_T}$PKG_CONFIG" >&6; } ++else ++ { echo "$as_me:$LINENO: result: no" >&5 ++echo "${ECHO_T}no" >&6; } + fi + +-done + +- # Older versions of MIT Kerberos lack GSS_C_NT_HOSTBASED_SERVICE +- { echo "$as_me:$LINENO: checking whether GSS_C_NT_HOSTBASED_SERVICE is declared" >&5 +-echo $ECHO_N "checking whether GSS_C_NT_HOSTBASED_SERVICE is declared... $ECHO_C" >&6; } +-if test "${ac_cv_have_decl_GSS_C_NT_HOSTBASED_SERVICE+set}" = set; then ++if test "$PKG_CONFIG" = "no"; then ++ : Not using pkg-config ++ ++NE_FLAG_LIBPXY=no ++ ++ne_LIBPXY_message="libproxy support not enabled" ++ { echo "$as_me:$LINENO: libproxy support not enabled" >&5 ++echo "$as_me: libproxy support not enabled" >&6;} ++ ++else ++ { echo "$as_me:$LINENO: checking for libproxy-1.0 pkg-config data" >&5 ++echo $ECHO_N "checking for libproxy-1.0 pkg-config data... $ECHO_C" >&6; } ++if test "${ne_cv_pkg_libproxy_1_0+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 + else +- cat >conftest.$ac_ext <<_ACEOF +-/* confdefs.h. */ +-_ACEOF +-cat confdefs.h >>conftest.$ac_ext +-cat >>conftest.$ac_ext <<_ACEOF +-/* end confdefs.h. */ +-#ifdef HAVE_GSSAPI_GSSAPI_H +-#include +-#else +-#include +-#endif ++ if $PKG_CONFIG libproxy-1.0; then ++ ne_cv_pkg_libproxy_1_0=yes ++ else ++ ne_cv_pkg_libproxy_1_0=no ++ fi ++fi ++{ echo "$as_me:$LINENO: result: $ne_cv_pkg_libproxy_1_0" >&5 ++echo "${ECHO_T}$ne_cv_pkg_libproxy_1_0" >&6; } + +-int +-main () +-{ +-#ifndef GSS_C_NT_HOSTBASED_SERVICE +- (void) GSS_C_NT_HOSTBASED_SERVICE; +-#endif ++ if test "$ne_cv_pkg_libproxy_1_0" = "yes"; then ++ NE_PXY_CFLAGS=`$PKG_CONFIG --cflags libproxy-1.0` ++ NE_PXY_LIBS=`$PKG_CONFIG --libs libproxy-1.0` ++ : Using provided pkg-config data + +- ; +- return 0; +-} ++cat >>confdefs.h <<\_ACEOF ++#define HAVE_LIBPROXY 1 + _ACEOF +-rm -f conftest.$ac_objext +-if { (ac_try="$ac_compile" +-case "(($ac_try" in +- *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; +- *) ac_try_echo=$ac_try;; +-esac +-eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_compile") 2>conftest.er1 +- ac_status=$? +- grep -v '^ *+' conftest.er1 >conftest.err +- rm -f conftest.er1 +- cat conftest.err >&5 +- echo "$as_me:$LINENO: \$? = $ac_status" >&5 +- (exit $ac_status); } && { +- test -z "$ac_c_werror_flag" || +- test ! -s conftest.err +- } && test -s conftest.$ac_objext; then +- ac_cv_have_decl_GSS_C_NT_HOSTBASED_SERVICE=yes +-else +- echo "$as_me: failed program was:" >&5 +-sed 's/^/| /' conftest.$ac_ext >&5 + +- ac_cv_have_decl_GSS_C_NT_HOSTBASED_SERVICE=no +-fi ++ CPPFLAGS="$CPPFLAGS $NE_PXY_CFLAGS" ++ NEON_LIBS="$NEON_LIBS ${NE_PXY_LIBS}" ++ ++NE_FLAG_LIBPXY=yes + +-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +-fi +-{ echo "$as_me:$LINENO: result: $ac_cv_have_decl_GSS_C_NT_HOSTBASED_SERVICE" >&5 +-echo "${ECHO_T}$ac_cv_have_decl_GSS_C_NT_HOSTBASED_SERVICE" >&6; } +-if test $ac_cv_have_decl_GSS_C_NT_HOSTBASED_SERVICE = yes; then +- : +-else + + cat >>confdefs.h <<\_ACEOF +-#define GSS_C_NT_HOSTBASED_SERVICE gss_nt_service_name ++#define NE_HAVE_LIBPXY 1 + _ACEOF + +-fi ++ne_LIBPXY_message="libproxy support enabled" ++ { echo "$as_me:$LINENO: libproxy support enabled" >&5 ++echo "$as_me: libproxy support enabled" >&6;} + +-fi +-done ++ else ++ : No pkg-config for libproxy-1.0 provided + +-LIBS=$ne_cf_save_LIBS +- break ++NE_FLAG_LIBPXY=no ++ ++ne_LIBPXY_message="libproxy support not enabled" ++ { echo "$as_me:$LINENO: libproxy support not enabled" >&5 ++echo "$as_me: libproxy support not enabled" >&6;} + ++ fi + fi + +-done + +- CPPFLAGS=$ne_save_CPPFLAGS +- NEON_LIBS=$ne_save_LIBS ++ ++else ++ ++NE_FLAG_LIBPXY=no ++ ++ne_LIBPXY_message="libproxy support not enabled" ++ { echo "$as_me:$LINENO: libproxy support not enabled" >&5 ++echo "$as_me: libproxy support not enabled" >&6;} ++ + fi + + +@@ -16168,6 +15849,7 @@ + + + ++ + CFLAGS="$CFLAGS -I$neon_bundled_srcdir" + NEON_LIBS="-L$neon_bundled_builddir -lneon $NEON_LIBS" + NEON_NEED_XML_PARSER=yes +@@ -17019,6 +16701,10 @@ + #define HAVE_EXPAT 1 + _ACEOF + ++ cat >>confdefs.h <<_ACEOF ++#define NE_FMT_XML_SIZE "d" ++_ACEOF ++ + CPPFLAGS="$CPPFLAGS -I$ne_expdir" + if test "x${NEON_TARGET}" = "xlibneon.la"; then + NEON_LTLIBS=$with_expat +@@ -18540,7 +18226,11 @@ + echo "$as_me: WebDAV support is not enabled" >&6;} + + +-: Disabled for 0.28 to retain 0.27 ABI ++if test "x${NE_LIBTOOL_RELEASE}y" = "xy"; then ++ NE_LIBTOOL_RELEASE="NODAV" ++else ++ NE_LIBTOOL_RELEASE="${NE_LIBTOOL_RELEASE}-NODAV" ++fi + + else + # WebDAV support +@@ -19646,10 +19336,13 @@ + fi + + ++jm_PREREQ_TEMPNAME + +- { echo "$as_me:$LINENO: checking for unsigned long long" >&5 +-echo $ECHO_N "checking for unsigned long long... $ECHO_C" >&6; } +-if test "${ac_cv_type_unsigned_long_long+set}" = set; then ++ ++# Check for snprintf ++{ echo "$as_me:$LINENO: checking for snprintf" >&5 ++echo $ECHO_N "checking for snprintf... $ECHO_C" >&6; } ++if test "${ac_cv_func_snprintf+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 + else + cat >conftest.$ac_ext <<_ACEOF +@@ -19658,12 +19351,41 @@ + cat confdefs.h >>conftest.$ac_ext + cat >>conftest.$ac_ext <<_ACEOF + /* end confdefs.h. */ +-unsigned long long ull = 1; int i = 63; ++/* Define snprintf to an innocuous variant, in case declares snprintf. ++ For example, HP-UX 11i declares gettimeofday. */ ++#define snprintf innocuous_snprintf ++ ++/* System header to define __stub macros and hopefully few prototypes, ++ which can conflict with char snprintf (); below. ++ Prefer to if __STDC__ is defined, since ++ exists even on freestanding compilers. */ ++ ++#ifdef __STDC__ ++# include ++#else ++# include ++#endif ++ ++#undef snprintf ++ ++/* Override any GCC internal prototype to avoid an error. ++ Use char because int might match the return type of a GCC ++ builtin and then its argument prototype would still apply. */ ++#ifdef __cplusplus ++extern "C" ++#endif ++char snprintf (); ++/* The GNU C library defines this for functions which it implements ++ to always fail with ENOSYS. Some functions are actually named ++ something starting with __ and the normal name is an alias. */ ++#if defined __stub_snprintf || defined __stub___snprintf ++choke me ++#endif ++ + int + main () + { +-unsigned long long ullmax = (unsigned long long) -1; +- return ull << i | ull >> i | ullmax / ull | ullmax % ull; ++return snprintf (); + ; + return 0; + } +@@ -19686,100 +19408,141 @@ + test ! -s conftest.err + } && test -s conftest$ac_exeext && + $as_test_x conftest$ac_exeext; then +- ac_cv_type_unsigned_long_long=yes ++ ac_cv_func_snprintf=yes + else + echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + +- ac_cv_type_unsigned_long_long=no ++ ac_cv_func_snprintf=no + fi + + rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ + conftest$ac_exeext conftest.$ac_ext + fi +-{ echo "$as_me:$LINENO: result: $ac_cv_type_unsigned_long_long" >&5 +-echo "${ECHO_T}$ac_cv_type_unsigned_long_long" >&6; } +- if test $ac_cv_type_unsigned_long_long = yes; then ++{ echo "$as_me:$LINENO: result: $ac_cv_func_snprintf" >&5 ++echo "${ECHO_T}$ac_cv_func_snprintf" >&6; } ++if test $ac_cv_func_snprintf = yes; then ++ : ++else ++ + + cat >>confdefs.h <<\_ACEOF +-#define HAVE_UNSIGNED_LONG_LONG 1 ++#define HAVE_SNPRINTF_H 1 + _ACEOF + +- fi ++ case " $LIBOBJS " in ++ *" lib/snprintf.$ac_objext "* ) ;; ++ *) LIBOBJS="$LIBOBJS lib/snprintf.$ac_objext" ++ ;; ++esac ++ ++fi + + + +- { echo "$as_me:$LINENO: checking for uintmax_t" >&5 +-echo $ECHO_N "checking for uintmax_t... $ECHO_C" >&6; } +-if test "${ac_cv_type_uintmax_t+set}" = set; then ++{ echo "$as_me:$LINENO: checking for working POSIX fnmatch" >&5 ++echo $ECHO_N "checking for working POSIX fnmatch... $ECHO_C" >&6; } ++if test "${ac_cv_func_fnmatch_works+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 + else ++ # Some versions of Solaris, SCO, and the GNU C Library ++ # have a broken or incompatible fnmatch. ++ # So we run a test program. If we are cross-compiling, take no chance. ++ # Thanks to John Oleynick, Franc,ois Pinard, and Paul Eggert for this test. ++ if test "$cross_compiling" = yes; then ++ ac_cv_func_fnmatch_works=cross ++else + cat >conftest.$ac_ext <<_ACEOF + /* confdefs.h. */ + _ACEOF + cat confdefs.h >>conftest.$ac_ext + cat >>conftest.$ac_ext <<_ACEOF + /* end confdefs.h. */ +-$ac_includes_default +-typedef uintmax_t ac__type_new_; +-int +-main () +-{ +-if ((ac__type_new_ *) 0) +- return 0; +-if (sizeof (ac__type_new_)) +- return 0; ++#include ++# define y(a, b, c) (fnmatch (a, b, c) == 0) ++# define n(a, b, c) (fnmatch (a, b, c) == FNM_NOMATCH) ++ ++int ++main () ++{ ++return ++ (!(y ("a*", "abc", 0) ++ && n ("d*/*1", "d/s/1", FNM_PATHNAME) ++ && y ("a\\\\bc", "abc", 0) ++ && n ("a\\\\bc", "abc", FNM_NOESCAPE) ++ && y ("*x", ".x", 0) ++ && n ("*x", ".x", FNM_PERIOD) ++ && 1)); + ; + return 0; + } + _ACEOF +-rm -f conftest.$ac_objext +-if { (ac_try="$ac_compile" ++rm -f conftest$ac_exeext ++if { (ac_try="$ac_link" + case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; + esac + eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_compile") 2>conftest.er1 ++ (eval "$ac_link") 2>&5 + ac_status=$? +- grep -v '^ *+' conftest.er1 >conftest.err +- rm -f conftest.er1 +- cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 +- (exit $ac_status); } && { +- test -z "$ac_c_werror_flag" || +- test ! -s conftest.err +- } && test -s conftest.$ac_objext; then +- ac_cv_type_uintmax_t=yes ++ (exit $ac_status); } && { ac_try='./conftest$ac_exeext' ++ { (case "(($ac_try" in ++ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; ++ *) ac_try_echo=$ac_try;; ++esac ++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 ++ (eval "$ac_try") 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ ac_cv_func_fnmatch_works=yes + else +- echo "$as_me: failed program was:" >&5 ++ echo "$as_me: program exited with status $ac_status" >&5 ++echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + +- ac_cv_type_uintmax_t=no ++( exit $ac_status ) ++ac_cv_func_fnmatch_works=no ++fi ++rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext + fi + +-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ++ + fi +-{ echo "$as_me:$LINENO: result: $ac_cv_type_uintmax_t" >&5 +-echo "${ECHO_T}$ac_cv_type_uintmax_t" >&6; } +-if test $ac_cv_type_uintmax_t = yes; then +- : +-else +- test $ac_cv_type_unsigned_long_long = yes \ +- && ac_type='unsigned long long' \ +- || ac_type='unsigned long' ++{ echo "$as_me:$LINENO: result: $ac_cv_func_fnmatch_works" >&5 ++echo "${ECHO_T}$ac_cv_func_fnmatch_works" >&6; } ++if test $ac_cv_func_fnmatch_works = yes; then + +-cat >>confdefs.h <<_ACEOF +-#define uintmax_t $ac_type ++cat >>confdefs.h <<\_ACEOF ++#define HAVE_FNMATCH 1 + _ACEOF + + fi + + + +- { echo "$as_me:$LINENO: checking for ANSI C header files" >&5 +-echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6; } +-if test "${ac_cv_header_stdc+set}" = set; then ++if test $ac_cv_func_fnmatch_works = no; then ++ case " $LIBOBJS " in ++ *" lib/fnmatch.$ac_objext "* ) ;; ++ *) LIBOBJS="$LIBOBJS lib/fnmatch.$ac_objext" ++ ;; ++esac ++ ++fi ++ ++ ++ ++ ++ ++ ++ac_header_dirent=no ++for ac_hdr in dirent.h sys/ndir.h sys/dir.h ndir.h; do ++ as_ac_Header=`echo "ac_cv_header_dirent_$ac_hdr" | $as_tr_sh` ++{ echo "$as_me:$LINENO: checking for $ac_hdr that defines DIR" >&5 ++echo $ECHO_N "checking for $ac_hdr that defines DIR... $ECHO_C" >&6; } ++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then + echo $ECHO_N "(cached) $ECHO_C" >&6 + else + cat >conftest.$ac_ext <<_ACEOF +@@ -19788,15 +19551,14 @@ + cat confdefs.h >>conftest.$ac_ext + cat >>conftest.$ac_ext <<_ACEOF + /* end confdefs.h. */ +-#include +-#include +-#include +-#include ++#include ++#include <$ac_hdr> + + int + main () + { +- ++if ((DIR *) 0) ++return 0; + ; + return 0; + } +@@ -19818,178 +19580,157 @@ + test -z "$ac_c_werror_flag" || + test ! -s conftest.err + } && test -s conftest.$ac_objext; then +- ac_cv_header_stdc=yes ++ eval "$as_ac_Header=yes" + else + echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + +- ac_cv_header_stdc=no ++ eval "$as_ac_Header=no" + fi + + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +- +-if test $ac_cv_header_stdc = yes; then +- # SunOS 4.x string.h does not declare mem*, contrary to ANSI. +- cat >conftest.$ac_ext <<_ACEOF +-/* confdefs.h. */ +-_ACEOF +-cat confdefs.h >>conftest.$ac_ext +-cat >>conftest.$ac_ext <<_ACEOF +-/* end confdefs.h. */ +-#include +- +-_ACEOF +-if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | +- $EGREP "memchr" >/dev/null 2>&1; then +- : +-else +- ac_cv_header_stdc=no +-fi +-rm -f conftest* +- + fi +- +-if test $ac_cv_header_stdc = yes; then +- # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI. +- cat >conftest.$ac_ext <<_ACEOF +-/* confdefs.h. */ +-_ACEOF +-cat confdefs.h >>conftest.$ac_ext +-cat >>conftest.$ac_ext <<_ACEOF +-/* end confdefs.h. */ +-#include +- ++ac_res=`eval echo '${'$as_ac_Header'}'` ++ { echo "$as_me:$LINENO: result: $ac_res" >&5 ++echo "${ECHO_T}$ac_res" >&6; } ++if test `eval echo '${'$as_ac_Header'}'` = yes; then ++ cat >>confdefs.h <<_ACEOF ++#define `echo "HAVE_$ac_hdr" | $as_tr_cpp` 1 + _ACEOF +-if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | +- $EGREP "free" >/dev/null 2>&1; then +- : +-else +- ac_cv_header_stdc=no +-fi +-rm -f conftest* + ++ac_header_dirent=$ac_hdr; break + fi + +-if test $ac_cv_header_stdc = yes; then +- # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. +- if test "$cross_compiling" = yes; then +- : ++done ++# Two versions of opendir et al. are in -ldir and -lx on SCO Xenix. ++if test $ac_header_dirent = dirent.h; then ++ { echo "$as_me:$LINENO: checking for library containing opendir" >&5 ++echo $ECHO_N "checking for library containing opendir... $ECHO_C" >&6; } ++if test "${ac_cv_search_opendir+set}" = set; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 + else +- cat >conftest.$ac_ext <<_ACEOF ++ ac_func_search_save_LIBS=$LIBS ++cat >conftest.$ac_ext <<_ACEOF + /* confdefs.h. */ + _ACEOF + cat confdefs.h >>conftest.$ac_ext + cat >>conftest.$ac_ext <<_ACEOF + /* end confdefs.h. */ +-#include +-#include +-#if ((' ' & 0x0FF) == 0x020) +-# define ISLOWER(c) ('a' <= (c) && (c) <= 'z') +-# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) +-#else +-# define ISLOWER(c) \ +- (('a' <= (c) && (c) <= 'i') \ +- || ('j' <= (c) && (c) <= 'r') \ +- || ('s' <= (c) && (c) <= 'z')) +-# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c)) +-#endif + +-#define XOR(e, f) (((e) && !(f)) || (!(e) && (f))) ++/* Override any GCC internal prototype to avoid an error. ++ Use char because int might match the return type of a GCC ++ builtin and then its argument prototype would still apply. */ ++#ifdef __cplusplus ++extern "C" ++#endif ++char opendir (); + int + main () + { +- int i; +- for (i = 0; i < 256; i++) +- if (XOR (islower (i), ISLOWER (i)) +- || toupper (i) != TOUPPER (i)) +- return 2; ++return opendir (); ++ ; + return 0; + } + _ACEOF +-rm -f conftest$ac_exeext ++for ac_lib in '' dir; do ++ if test -z "$ac_lib"; then ++ ac_res="none required" ++ else ++ ac_res=-l$ac_lib ++ LIBS="-l$ac_lib $ac_func_search_save_LIBS" ++ fi ++ rm -f conftest.$ac_objext conftest$ac_exeext + if { (ac_try="$ac_link" + case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; + esac + eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_link") 2>&5 +- ac_status=$? +- echo "$as_me:$LINENO: \$? = $ac_status" >&5 +- (exit $ac_status); } && { ac_try='./conftest$ac_exeext' +- { (case "(($ac_try" in +- *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; +- *) ac_try_echo=$ac_try;; +-esac +-eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_try") 2>&5 ++ (eval "$ac_link") 2>conftest.er1 + ac_status=$? ++ grep -v '^ *+' conftest.er1 >conftest.err ++ rm -f conftest.er1 ++ cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 +- (exit $ac_status); }; }; then +- : ++ (exit $ac_status); } && { ++ test -z "$ac_c_werror_flag" || ++ test ! -s conftest.err ++ } && test -s conftest$ac_exeext && ++ $as_test_x conftest$ac_exeext; then ++ ac_cv_search_opendir=$ac_res + else +- echo "$as_me: program exited with status $ac_status" >&5 +-echo "$as_me: failed program was:" >&5 ++ echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + +-( exit $ac_status ) +-ac_cv_header_stdc=no +-fi +-rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +-fi + ++fi + ++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ ++ conftest$ac_exeext ++ if test "${ac_cv_search_opendir+set}" = set; then ++ break + fi ++done ++if test "${ac_cv_search_opendir+set}" = set; then ++ : ++else ++ ac_cv_search_opendir=no + fi +-{ echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5 +-echo "${ECHO_T}$ac_cv_header_stdc" >&6; } +-if test $ac_cv_header_stdc = yes; then +- +-cat >>confdefs.h <<\_ACEOF +-#define STDC_HEADERS 1 +-_ACEOF ++rm conftest.$ac_ext ++LIBS=$ac_func_search_save_LIBS ++fi ++{ echo "$as_me:$LINENO: result: $ac_cv_search_opendir" >&5 ++echo "${ECHO_T}$ac_cv_search_opendir" >&6; } ++ac_res=$ac_cv_search_opendir ++if test "$ac_res" != no; then ++ test "$ac_res" = "none required" || LIBS="$ac_res $LIBS" + + fi + +- { echo "$as_me:$LINENO: checking whether stat file-mode macros are broken" >&5 +-echo $ECHO_N "checking whether stat file-mode macros are broken... $ECHO_C" >&6; } +-if test "${ac_cv_header_stat_broken+set}" = set; then ++else ++ { echo "$as_me:$LINENO: checking for library containing opendir" >&5 ++echo $ECHO_N "checking for library containing opendir... $ECHO_C" >&6; } ++if test "${ac_cv_search_opendir+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 + else +- cat >conftest.$ac_ext <<_ACEOF ++ ac_func_search_save_LIBS=$LIBS ++cat >conftest.$ac_ext <<_ACEOF + /* confdefs.h. */ + _ACEOF + cat confdefs.h >>conftest.$ac_ext + cat >>conftest.$ac_ext <<_ACEOF + /* end confdefs.h. */ +-#include +-#include + +-#if defined S_ISBLK && defined S_IFDIR +-extern char c1[S_ISBLK (S_IFDIR) ? -1 : 1]; +-#endif +- +-#if defined S_ISBLK && defined S_IFCHR +-extern char c2[S_ISBLK (S_IFCHR) ? -1 : 1]; +-#endif +- +-#if defined S_ISLNK && defined S_IFREG +-extern char c3[S_ISLNK (S_IFREG) ? -1 : 1]; +-#endif +- +-#if defined S_ISSOCK && defined S_IFREG +-extern char c4[S_ISSOCK (S_IFREG) ? -1 : 1]; ++/* Override any GCC internal prototype to avoid an error. ++ Use char because int might match the return type of a GCC ++ builtin and then its argument prototype would still apply. */ ++#ifdef __cplusplus ++extern "C" + #endif +- ++char opendir (); ++int ++main () ++{ ++return opendir (); ++ ; ++ return 0; ++} + _ACEOF +-rm -f conftest.$ac_objext +-if { (ac_try="$ac_compile" ++for ac_lib in '' x; do ++ if test -z "$ac_lib"; then ++ ac_res="none required" ++ else ++ ac_res=-l$ac_lib ++ LIBS="-l$ac_lib $ac_func_search_save_LIBS" ++ fi ++ rm -f conftest.$ac_objext conftest$ac_exeext ++if { (ac_try="$ac_link" + case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; + esac + eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_compile") 2>conftest.er1 ++ (eval "$ac_link") 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 +@@ -19998,55 +19739,62 @@ + (exit $ac_status); } && { + test -z "$ac_c_werror_flag" || + test ! -s conftest.err +- } && test -s conftest.$ac_objext; then +- ac_cv_header_stat_broken=no ++ } && test -s conftest$ac_exeext && ++ $as_test_x conftest$ac_exeext; then ++ ac_cv_search_opendir=$ac_res + else + echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + +- ac_cv_header_stat_broken=yes +-fi + +-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + fi +-{ echo "$as_me:$LINENO: result: $ac_cv_header_stat_broken" >&5 +-echo "${ECHO_T}$ac_cv_header_stat_broken" >&6; } +-if test $ac_cv_header_stat_broken = yes; then +- +-cat >>confdefs.h <<\_ACEOF +-#define STAT_MACROS_BROKEN 1 +-_ACEOF + ++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ ++ conftest$ac_exeext ++ if test "${ac_cv_search_opendir+set}" = set; then ++ break + fi ++done ++if test "${ac_cv_search_opendir+set}" = set; then ++ : ++else ++ ac_cv_search_opendir=no ++fi ++rm conftest.$ac_ext ++LIBS=$ac_func_search_save_LIBS ++fi ++{ echo "$as_me:$LINENO: result: $ac_cv_search_opendir" >&5 ++echo "${ECHO_T}$ac_cv_search_opendir" >&6; } ++ac_res=$ac_cv_search_opendir ++if test "$ac_res" != no; then ++ test "$ac_res" = "none required" || LIBS="$ac_res $LIBS" + ++fi + ++fi + + +- +-for ac_header in fcntl.h sys/time.h stdint.h unistd.h +-do +-as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` +-if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then +- { echo "$as_me:$LINENO: checking for $ac_header" >&5 +-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; } +-if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then ++{ echo "$as_me:$LINENO: checking return type of signal handlers" >&5 ++echo $ECHO_N "checking return type of signal handlers... $ECHO_C" >&6; } ++if test "${ac_cv_type_signal+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +-fi +-ac_res=`eval echo '${'$as_ac_Header'}'` +- { echo "$as_me:$LINENO: result: $ac_res" >&5 +-echo "${ECHO_T}$ac_res" >&6; } + else +- # Is the header compilable? +-{ echo "$as_me:$LINENO: checking $ac_header usability" >&5 +-echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; } +-cat >conftest.$ac_ext <<_ACEOF ++ cat >conftest.$ac_ext <<_ACEOF + /* confdefs.h. */ + _ACEOF + cat confdefs.h >>conftest.$ac_ext + cat >>conftest.$ac_ext <<_ACEOF + /* end confdefs.h. */ +-$ac_includes_default +-#include <$ac_header> ++#include ++#include ++ ++int ++main () ++{ ++return *(signal (0, 0)) (0) == 1; ++ ; ++ return 0; ++} + _ACEOF + rm -f conftest.$ac_objext + if { (ac_try="$ac_compile" +@@ -20065,111 +19813,34 @@ + test -z "$ac_c_werror_flag" || + test ! -s conftest.err + } && test -s conftest.$ac_objext; then +- ac_header_compiler=yes ++ ac_cv_type_signal=int + else + echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + +- ac_header_compiler=no ++ ac_cv_type_signal=void + fi + + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +-{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 +-echo "${ECHO_T}$ac_header_compiler" >&6; } ++fi ++{ echo "$as_me:$LINENO: result: $ac_cv_type_signal" >&5 ++echo "${ECHO_T}$ac_cv_type_signal" >&6; } + +-# Is the header present? +-{ echo "$as_me:$LINENO: checking $ac_header presence" >&5 +-echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; } +-cat >conftest.$ac_ext <<_ACEOF +-/* confdefs.h. */ +-_ACEOF +-cat confdefs.h >>conftest.$ac_ext +-cat >>conftest.$ac_ext <<_ACEOF +-/* end confdefs.h. */ +-#include <$ac_header> ++cat >>confdefs.h <<_ACEOF ++#define RETSIGTYPE $ac_cv_type_signal + _ACEOF +-if { (ac_try="$ac_cpp conftest.$ac_ext" +-case "(($ac_try" in +- *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; +- *) ac_try_echo=$ac_try;; +-esac +-eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1 +- ac_status=$? +- grep -v '^ *+' conftest.er1 >conftest.err +- rm -f conftest.er1 +- cat conftest.err >&5 +- echo "$as_me:$LINENO: \$? = $ac_status" >&5 +- (exit $ac_status); } >/dev/null && { +- test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || +- test ! -s conftest.err +- }; then +- ac_header_preproc=yes +-else +- echo "$as_me: failed program was:" >&5 +-sed 's/^/| /' conftest.$ac_ext >&5 + +- ac_header_preproc=no +-fi + +-rm -f conftest.err conftest.$ac_ext +-{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 +-echo "${ECHO_T}$ac_header_preproc" >&6; } + +-# So? What about this header? +-case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in +- yes:no: ) +- { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5 +-echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;} +- { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5 +-echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;} +- ac_header_preproc=yes +- ;; +- no:yes:* ) +- { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5 +-echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;} +- { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5 +-echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;} +- { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5 +-echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;} +- { echo "$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&5 +-echo "$as_me: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&2;} +- { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5 +-echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;} +- { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5 +-echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;} +- ( cat <<\_ASBOX +-## --------------------------------- ## +-## Report this to cadaver@webdav.org ## +-## --------------------------------- ## +-_ASBOX +- ) | sed "s/^/$as_me: WARNING: /" >&2 +- ;; +-esac +-{ echo "$as_me:$LINENO: checking for $ac_header" >&5 +-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; } +-if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then +- echo $ECHO_N "(cached) $ECHO_C" >&6 +-else +- eval "$as_ac_Header=\$ac_header_preproc" +-fi +-ac_res=`eval echo '${'$as_ac_Header'}'` +- { echo "$as_me:$LINENO: result: $ac_res" >&5 +-echo "${ECHO_T}$ac_res" >&6; } + +-fi +-if test `eval echo '${'$as_ac_Header'}'` = yes; then +- cat >>confdefs.h <<_ACEOF +-#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1 +-_ACEOF + +-fi + +-done + + + +-for ac_func in __secure_getenv gettimeofday ++ ++ ++for ac_func in strdup strerror memcpy strcoll tcsetattr getpass stty fchmod + do + as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh` + { echo "$as_me:$LINENO: checking for $ac_func" >&5 +@@ -20262,28 +19933,40 @@ + fi + done + +- { echo "$as_me:$LINENO: checking whether getenv is declared" >&5 +-echo $ECHO_N "checking whether getenv is declared... $ECHO_C" >&6; } +-if test "${ac_cv_have_decl_getenv+set}" = set; then ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++for ac_header in sys/time.h pwd.h stdarg.h vmsdir.h memory.h alloca.h ncurses.h sgtty.h termios.h termio.h ++do ++as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` ++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then ++ { echo "$as_me:$LINENO: checking for $ac_header" >&5 ++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; } ++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then + echo $ECHO_N "(cached) $ECHO_C" >&6 ++fi ++ac_res=`eval echo '${'$as_ac_Header'}'` ++ { echo "$as_me:$LINENO: result: $ac_res" >&5 ++echo "${ECHO_T}$ac_res" >&6; } + else +- cat >conftest.$ac_ext <<_ACEOF ++ # Is the header compilable? ++{ echo "$as_me:$LINENO: checking $ac_header usability" >&5 ++echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; } ++cat >conftest.$ac_ext <<_ACEOF + /* confdefs.h. */ + _ACEOF + cat confdefs.h >>conftest.$ac_ext + cat >>conftest.$ac_ext <<_ACEOF + /* end confdefs.h. */ + $ac_includes_default +-int +-main () +-{ +-#ifndef getenv +- (void) getenv; +-#endif +- +- ; +- return 0; +-} ++#include <$ac_header> + _ACEOF + rm -f conftest.$ac_objext + if { (ac_try="$ac_compile" +@@ -20302,987 +19985,110 @@ + test -z "$ac_c_werror_flag" || + test ! -s conftest.err + } && test -s conftest.$ac_objext; then +- ac_cv_have_decl_getenv=yes ++ ac_header_compiler=yes + else + echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + +- ac_cv_have_decl_getenv=no ++ ac_header_compiler=no + fi + + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +-fi +-{ echo "$as_me:$LINENO: result: $ac_cv_have_decl_getenv" >&5 +-echo "${ECHO_T}$ac_cv_have_decl_getenv" >&6; } +-if test $ac_cv_have_decl_getenv = yes; then +- +-cat >>confdefs.h <<_ACEOF +-#define HAVE_DECL_GETENV 1 +-_ACEOF +- +- +-else +- cat >>confdefs.h <<_ACEOF +-#define HAVE_DECL_GETENV 0 +-_ACEOF +- +- +-fi +- +- +- +- +- ++{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 ++echo "${ECHO_T}$ac_header_compiler" >&6; } + +-# Check for snprintf +-{ echo "$as_me:$LINENO: checking for snprintf" >&5 +-echo $ECHO_N "checking for snprintf... $ECHO_C" >&6; } +-if test "${ac_cv_func_snprintf+set}" = set; then +- echo $ECHO_N "(cached) $ECHO_C" >&6 +-else +- cat >conftest.$ac_ext <<_ACEOF ++# Is the header present? ++{ echo "$as_me:$LINENO: checking $ac_header presence" >&5 ++echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; } ++cat >conftest.$ac_ext <<_ACEOF + /* confdefs.h. */ + _ACEOF + cat confdefs.h >>conftest.$ac_ext + cat >>conftest.$ac_ext <<_ACEOF + /* end confdefs.h. */ +-/* Define snprintf to an innocuous variant, in case declares snprintf. +- For example, HP-UX 11i declares gettimeofday. */ +-#define snprintf innocuous_snprintf +- +-/* System header to define __stub macros and hopefully few prototypes, +- which can conflict with char snprintf (); below. +- Prefer to if __STDC__ is defined, since +- exists even on freestanding compilers. */ +- +-#ifdef __STDC__ +-# include +-#else +-# include +-#endif +- +-#undef snprintf +- +-/* Override any GCC internal prototype to avoid an error. +- Use char because int might match the return type of a GCC +- builtin and then its argument prototype would still apply. */ +-#ifdef __cplusplus +-extern "C" +-#endif +-char snprintf (); +-/* The GNU C library defines this for functions which it implements +- to always fail with ENOSYS. Some functions are actually named +- something starting with __ and the normal name is an alias. */ +-#if defined __stub_snprintf || defined __stub___snprintf +-choke me +-#endif +- +-int +-main () +-{ +-return snprintf (); +- ; +- return 0; +-} +-_ACEOF +-rm -f conftest.$ac_objext conftest$ac_exeext +-if { (ac_try="$ac_link" +-case "(($ac_try" in +- *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; +- *) ac_try_echo=$ac_try;; +-esac +-eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_link") 2>conftest.er1 +- ac_status=$? +- grep -v '^ *+' conftest.er1 >conftest.err +- rm -f conftest.er1 +- cat conftest.err >&5 +- echo "$as_me:$LINENO: \$? = $ac_status" >&5 +- (exit $ac_status); } && { +- test -z "$ac_c_werror_flag" || +- test ! -s conftest.err +- } && test -s conftest$ac_exeext && +- $as_test_x conftest$ac_exeext; then +- ac_cv_func_snprintf=yes +-else +- echo "$as_me: failed program was:" >&5 +-sed 's/^/| /' conftest.$ac_ext >&5 +- +- ac_cv_func_snprintf=no +-fi +- +-rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ +- conftest$ac_exeext conftest.$ac_ext +-fi +-{ echo "$as_me:$LINENO: result: $ac_cv_func_snprintf" >&5 +-echo "${ECHO_T}$ac_cv_func_snprintf" >&6; } +-if test $ac_cv_func_snprintf = yes; then +- : +-else +- +- +-cat >>confdefs.h <<\_ACEOF +-#define HAVE_SNPRINTF_H 1 +-_ACEOF +- +- case " $LIBOBJS " in +- *" lib/snprintf.$ac_objext "* ) ;; +- *) LIBOBJS="$LIBOBJS lib/snprintf.$ac_objext" +- ;; +-esac +- +-fi +- +- +- +-{ echo "$as_me:$LINENO: checking for working POSIX fnmatch" >&5 +-echo $ECHO_N "checking for working POSIX fnmatch... $ECHO_C" >&6; } +-if test "${ac_cv_func_fnmatch_works+set}" = set; then +- echo $ECHO_N "(cached) $ECHO_C" >&6 +-else +- # Some versions of Solaris, SCO, and the GNU C Library +- # have a broken or incompatible fnmatch. +- # So we run a test program. If we are cross-compiling, take no chance. +- # Thanks to John Oleynick, Franc,ois Pinard, and Paul Eggert for this test. +- if test "$cross_compiling" = yes; then +- ac_cv_func_fnmatch_works=cross +-else +- cat >conftest.$ac_ext <<_ACEOF +-/* confdefs.h. */ +-_ACEOF +-cat confdefs.h >>conftest.$ac_ext +-cat >>conftest.$ac_ext <<_ACEOF +-/* end confdefs.h. */ +-#include +-# define y(a, b, c) (fnmatch (a, b, c) == 0) +-# define n(a, b, c) (fnmatch (a, b, c) == FNM_NOMATCH) +- +-int +-main () +-{ +-return +- (!(y ("a*", "abc", 0) +- && n ("d*/*1", "d/s/1", FNM_PATHNAME) +- && y ("a\\\\bc", "abc", 0) +- && n ("a\\\\bc", "abc", FNM_NOESCAPE) +- && y ("*x", ".x", 0) +- && n ("*x", ".x", FNM_PERIOD) +- && 1)); +- ; +- return 0; +-} +-_ACEOF +-rm -f conftest$ac_exeext +-if { (ac_try="$ac_link" +-case "(($ac_try" in +- *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; +- *) ac_try_echo=$ac_try;; +-esac +-eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_link") 2>&5 +- ac_status=$? +- echo "$as_me:$LINENO: \$? = $ac_status" >&5 +- (exit $ac_status); } && { ac_try='./conftest$ac_exeext' +- { (case "(($ac_try" in +- *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; +- *) ac_try_echo=$ac_try;; +-esac +-eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_try") 2>&5 +- ac_status=$? +- echo "$as_me:$LINENO: \$? = $ac_status" >&5 +- (exit $ac_status); }; }; then +- ac_cv_func_fnmatch_works=yes +-else +- echo "$as_me: program exited with status $ac_status" >&5 +-echo "$as_me: failed program was:" >&5 +-sed 's/^/| /' conftest.$ac_ext >&5 +- +-( exit $ac_status ) +-ac_cv_func_fnmatch_works=no +-fi +-rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +-fi +- +- +-fi +-{ echo "$as_me:$LINENO: result: $ac_cv_func_fnmatch_works" >&5 +-echo "${ECHO_T}$ac_cv_func_fnmatch_works" >&6; } +-if test $ac_cv_func_fnmatch_works = yes; then +- +-cat >>confdefs.h <<\_ACEOF +-#define HAVE_FNMATCH 1 +-_ACEOF +- +-fi +- +- +- +-if test $ac_cv_func_fnmatch_works = no; then +- case " $LIBOBJS " in +- *" lib/fnmatch.$ac_objext "* ) ;; +- *) LIBOBJS="$LIBOBJS lib/fnmatch.$ac_objext" +- ;; +-esac +- +-fi +- +- +- +- +- +- +-ac_header_dirent=no +-for ac_hdr in dirent.h sys/ndir.h sys/dir.h ndir.h; do +- as_ac_Header=`echo "ac_cv_header_dirent_$ac_hdr" | $as_tr_sh` +-{ echo "$as_me:$LINENO: checking for $ac_hdr that defines DIR" >&5 +-echo $ECHO_N "checking for $ac_hdr that defines DIR... $ECHO_C" >&6; } +-if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then +- echo $ECHO_N "(cached) $ECHO_C" >&6 +-else +- cat >conftest.$ac_ext <<_ACEOF +-/* confdefs.h. */ +-_ACEOF +-cat confdefs.h >>conftest.$ac_ext +-cat >>conftest.$ac_ext <<_ACEOF +-/* end confdefs.h. */ +-#include +-#include <$ac_hdr> +- +-int +-main () +-{ +-if ((DIR *) 0) +-return 0; +- ; +- return 0; +-} +-_ACEOF +-rm -f conftest.$ac_objext +-if { (ac_try="$ac_compile" +-case "(($ac_try" in +- *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; +- *) ac_try_echo=$ac_try;; +-esac +-eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_compile") 2>conftest.er1 +- ac_status=$? +- grep -v '^ *+' conftest.er1 >conftest.err +- rm -f conftest.er1 +- cat conftest.err >&5 +- echo "$as_me:$LINENO: \$? = $ac_status" >&5 +- (exit $ac_status); } && { +- test -z "$ac_c_werror_flag" || +- test ! -s conftest.err +- } && test -s conftest.$ac_objext; then +- eval "$as_ac_Header=yes" +-else +- echo "$as_me: failed program was:" >&5 +-sed 's/^/| /' conftest.$ac_ext >&5 +- +- eval "$as_ac_Header=no" +-fi +- +-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +-fi +-ac_res=`eval echo '${'$as_ac_Header'}'` +- { echo "$as_me:$LINENO: result: $ac_res" >&5 +-echo "${ECHO_T}$ac_res" >&6; } +-if test `eval echo '${'$as_ac_Header'}'` = yes; then +- cat >>confdefs.h <<_ACEOF +-#define `echo "HAVE_$ac_hdr" | $as_tr_cpp` 1 +-_ACEOF +- +-ac_header_dirent=$ac_hdr; break +-fi +- +-done +-# Two versions of opendir et al. are in -ldir and -lx on SCO Xenix. +-if test $ac_header_dirent = dirent.h; then +- { echo "$as_me:$LINENO: checking for library containing opendir" >&5 +-echo $ECHO_N "checking for library containing opendir... $ECHO_C" >&6; } +-if test "${ac_cv_search_opendir+set}" = set; then +- echo $ECHO_N "(cached) $ECHO_C" >&6 +-else +- ac_func_search_save_LIBS=$LIBS +-cat >conftest.$ac_ext <<_ACEOF +-/* confdefs.h. */ +-_ACEOF +-cat confdefs.h >>conftest.$ac_ext +-cat >>conftest.$ac_ext <<_ACEOF +-/* end confdefs.h. */ +- +-/* Override any GCC internal prototype to avoid an error. +- Use char because int might match the return type of a GCC +- builtin and then its argument prototype would still apply. */ +-#ifdef __cplusplus +-extern "C" +-#endif +-char opendir (); +-int +-main () +-{ +-return opendir (); +- ; +- return 0; +-} +-_ACEOF +-for ac_lib in '' dir; do +- if test -z "$ac_lib"; then +- ac_res="none required" +- else +- ac_res=-l$ac_lib +- LIBS="-l$ac_lib $ac_func_search_save_LIBS" +- fi +- rm -f conftest.$ac_objext conftest$ac_exeext +-if { (ac_try="$ac_link" +-case "(($ac_try" in +- *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; +- *) ac_try_echo=$ac_try;; +-esac +-eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_link") 2>conftest.er1 +- ac_status=$? +- grep -v '^ *+' conftest.er1 >conftest.err +- rm -f conftest.er1 +- cat conftest.err >&5 +- echo "$as_me:$LINENO: \$? = $ac_status" >&5 +- (exit $ac_status); } && { +- test -z "$ac_c_werror_flag" || +- test ! -s conftest.err +- } && test -s conftest$ac_exeext && +- $as_test_x conftest$ac_exeext; then +- ac_cv_search_opendir=$ac_res +-else +- echo "$as_me: failed program was:" >&5 +-sed 's/^/| /' conftest.$ac_ext >&5 +- +- +-fi +- +-rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ +- conftest$ac_exeext +- if test "${ac_cv_search_opendir+set}" = set; then +- break +-fi +-done +-if test "${ac_cv_search_opendir+set}" = set; then +- : +-else +- ac_cv_search_opendir=no +-fi +-rm conftest.$ac_ext +-LIBS=$ac_func_search_save_LIBS +-fi +-{ echo "$as_me:$LINENO: result: $ac_cv_search_opendir" >&5 +-echo "${ECHO_T}$ac_cv_search_opendir" >&6; } +-ac_res=$ac_cv_search_opendir +-if test "$ac_res" != no; then +- test "$ac_res" = "none required" || LIBS="$ac_res $LIBS" +- +-fi +- +-else +- { echo "$as_me:$LINENO: checking for library containing opendir" >&5 +-echo $ECHO_N "checking for library containing opendir... $ECHO_C" >&6; } +-if test "${ac_cv_search_opendir+set}" = set; then +- echo $ECHO_N "(cached) $ECHO_C" >&6 +-else +- ac_func_search_save_LIBS=$LIBS +-cat >conftest.$ac_ext <<_ACEOF +-/* confdefs.h. */ +-_ACEOF +-cat confdefs.h >>conftest.$ac_ext +-cat >>conftest.$ac_ext <<_ACEOF +-/* end confdefs.h. */ +- +-/* Override any GCC internal prototype to avoid an error. +- Use char because int might match the return type of a GCC +- builtin and then its argument prototype would still apply. */ +-#ifdef __cplusplus +-extern "C" +-#endif +-char opendir (); +-int +-main () +-{ +-return opendir (); +- ; +- return 0; +-} +-_ACEOF +-for ac_lib in '' x; do +- if test -z "$ac_lib"; then +- ac_res="none required" +- else +- ac_res=-l$ac_lib +- LIBS="-l$ac_lib $ac_func_search_save_LIBS" +- fi +- rm -f conftest.$ac_objext conftest$ac_exeext +-if { (ac_try="$ac_link" +-case "(($ac_try" in +- *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; +- *) ac_try_echo=$ac_try;; +-esac +-eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_link") 2>conftest.er1 +- ac_status=$? +- grep -v '^ *+' conftest.er1 >conftest.err +- rm -f conftest.er1 +- cat conftest.err >&5 +- echo "$as_me:$LINENO: \$? = $ac_status" >&5 +- (exit $ac_status); } && { +- test -z "$ac_c_werror_flag" || +- test ! -s conftest.err +- } && test -s conftest$ac_exeext && +- $as_test_x conftest$ac_exeext; then +- ac_cv_search_opendir=$ac_res +-else +- echo "$as_me: failed program was:" >&5 +-sed 's/^/| /' conftest.$ac_ext >&5 +- +- +-fi +- +-rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ +- conftest$ac_exeext +- if test "${ac_cv_search_opendir+set}" = set; then +- break +-fi +-done +-if test "${ac_cv_search_opendir+set}" = set; then +- : +-else +- ac_cv_search_opendir=no +-fi +-rm conftest.$ac_ext +-LIBS=$ac_func_search_save_LIBS +-fi +-{ echo "$as_me:$LINENO: result: $ac_cv_search_opendir" >&5 +-echo "${ECHO_T}$ac_cv_search_opendir" >&6; } +-ac_res=$ac_cv_search_opendir +-if test "$ac_res" != no; then +- test "$ac_res" = "none required" || LIBS="$ac_res $LIBS" +- +-fi +- +-fi +- +- +-{ echo "$as_me:$LINENO: checking return type of signal handlers" >&5 +-echo $ECHO_N "checking return type of signal handlers... $ECHO_C" >&6; } +-if test "${ac_cv_type_signal+set}" = set; then +- echo $ECHO_N "(cached) $ECHO_C" >&6 +-else +- cat >conftest.$ac_ext <<_ACEOF +-/* confdefs.h. */ +-_ACEOF +-cat confdefs.h >>conftest.$ac_ext +-cat >>conftest.$ac_ext <<_ACEOF +-/* end confdefs.h. */ +-#include +-#include +- +-int +-main () +-{ +-return *(signal (0, 0)) (0) == 1; +- ; +- return 0; +-} +-_ACEOF +-rm -f conftest.$ac_objext +-if { (ac_try="$ac_compile" +-case "(($ac_try" in +- *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; +- *) ac_try_echo=$ac_try;; +-esac +-eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_compile") 2>conftest.er1 +- ac_status=$? +- grep -v '^ *+' conftest.er1 >conftest.err +- rm -f conftest.er1 +- cat conftest.err >&5 +- echo "$as_me:$LINENO: \$? = $ac_status" >&5 +- (exit $ac_status); } && { +- test -z "$ac_c_werror_flag" || +- test ! -s conftest.err +- } && test -s conftest.$ac_objext; then +- ac_cv_type_signal=int +-else +- echo "$as_me: failed program was:" >&5 +-sed 's/^/| /' conftest.$ac_ext >&5 +- +- ac_cv_type_signal=void +-fi +- +-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +-fi +-{ echo "$as_me:$LINENO: result: $ac_cv_type_signal" >&5 +-echo "${ECHO_T}$ac_cv_type_signal" >&6; } +- +-cat >>confdefs.h <<_ACEOF +-#define RETSIGTYPE $ac_cv_type_signal +-_ACEOF +- +- +- +- +- +- +- +- +- +- +- +-for ac_func in strdup strerror memcpy strcoll tcsetattr getpass stty fchmod +-do +-as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh` +-{ echo "$as_me:$LINENO: checking for $ac_func" >&5 +-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; } +-if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then +- echo $ECHO_N "(cached) $ECHO_C" >&6 +-else +- cat >conftest.$ac_ext <<_ACEOF +-/* confdefs.h. */ +-_ACEOF +-cat confdefs.h >>conftest.$ac_ext +-cat >>conftest.$ac_ext <<_ACEOF +-/* end confdefs.h. */ +-/* Define $ac_func to an innocuous variant, in case declares $ac_func. +- For example, HP-UX 11i declares gettimeofday. */ +-#define $ac_func innocuous_$ac_func +- +-/* System header to define __stub macros and hopefully few prototypes, +- which can conflict with char $ac_func (); below. +- Prefer to if __STDC__ is defined, since +- exists even on freestanding compilers. */ +- +-#ifdef __STDC__ +-# include +-#else +-# include +-#endif +- +-#undef $ac_func +- +-/* Override any GCC internal prototype to avoid an error. +- Use char because int might match the return type of a GCC +- builtin and then its argument prototype would still apply. */ +-#ifdef __cplusplus +-extern "C" +-#endif +-char $ac_func (); +-/* The GNU C library defines this for functions which it implements +- to always fail with ENOSYS. Some functions are actually named +- something starting with __ and the normal name is an alias. */ +-#if defined __stub_$ac_func || defined __stub___$ac_func +-choke me +-#endif +- +-int +-main () +-{ +-return $ac_func (); +- ; +- return 0; +-} +-_ACEOF +-rm -f conftest.$ac_objext conftest$ac_exeext +-if { (ac_try="$ac_link" +-case "(($ac_try" in +- *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; +- *) ac_try_echo=$ac_try;; +-esac +-eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_link") 2>conftest.er1 +- ac_status=$? +- grep -v '^ *+' conftest.er1 >conftest.err +- rm -f conftest.er1 +- cat conftest.err >&5 +- echo "$as_me:$LINENO: \$? = $ac_status" >&5 +- (exit $ac_status); } && { +- test -z "$ac_c_werror_flag" || +- test ! -s conftest.err +- } && test -s conftest$ac_exeext && +- $as_test_x conftest$ac_exeext; then +- eval "$as_ac_var=yes" +-else +- echo "$as_me: failed program was:" >&5 +-sed 's/^/| /' conftest.$ac_ext >&5 +- +- eval "$as_ac_var=no" +-fi +- +-rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ +- conftest$ac_exeext conftest.$ac_ext +-fi +-ac_res=`eval echo '${'$as_ac_var'}'` +- { echo "$as_me:$LINENO: result: $ac_res" >&5 +-echo "${ECHO_T}$ac_res" >&6; } +-if test `eval echo '${'$as_ac_var'}'` = yes; then +- cat >>confdefs.h <<_ACEOF +-#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1 +-_ACEOF +- +-fi +-done +- +- +- +- +- +- +- +- +- +- +- +-for ac_header in sys/time.h pwd.h stdarg.h vmsdir.h memory.h alloca.h ncurses.h sgtty.h termios.h termio.h +-do +-as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` +-if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then +- { echo "$as_me:$LINENO: checking for $ac_header" >&5 +-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; } +-if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then +- echo $ECHO_N "(cached) $ECHO_C" >&6 +-fi +-ac_res=`eval echo '${'$as_ac_Header'}'` +- { echo "$as_me:$LINENO: result: $ac_res" >&5 +-echo "${ECHO_T}$ac_res" >&6; } +-else +- # Is the header compilable? +-{ echo "$as_me:$LINENO: checking $ac_header usability" >&5 +-echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; } +-cat >conftest.$ac_ext <<_ACEOF +-/* confdefs.h. */ +-_ACEOF +-cat confdefs.h >>conftest.$ac_ext +-cat >>conftest.$ac_ext <<_ACEOF +-/* end confdefs.h. */ +-$ac_includes_default +-#include <$ac_header> +-_ACEOF +-rm -f conftest.$ac_objext +-if { (ac_try="$ac_compile" +-case "(($ac_try" in +- *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; +- *) ac_try_echo=$ac_try;; +-esac +-eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_compile") 2>conftest.er1 +- ac_status=$? +- grep -v '^ *+' conftest.er1 >conftest.err +- rm -f conftest.er1 +- cat conftest.err >&5 +- echo "$as_me:$LINENO: \$? = $ac_status" >&5 +- (exit $ac_status); } && { +- test -z "$ac_c_werror_flag" || +- test ! -s conftest.err +- } && test -s conftest.$ac_objext; then +- ac_header_compiler=yes +-else +- echo "$as_me: failed program was:" >&5 +-sed 's/^/| /' conftest.$ac_ext >&5 +- +- ac_header_compiler=no +-fi +- +-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +-{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 +-echo "${ECHO_T}$ac_header_compiler" >&6; } +- +-# Is the header present? +-{ echo "$as_me:$LINENO: checking $ac_header presence" >&5 +-echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; } +-cat >conftest.$ac_ext <<_ACEOF +-/* confdefs.h. */ +-_ACEOF +-cat confdefs.h >>conftest.$ac_ext +-cat >>conftest.$ac_ext <<_ACEOF +-/* end confdefs.h. */ +-#include <$ac_header> +-_ACEOF +-if { (ac_try="$ac_cpp conftest.$ac_ext" +-case "(($ac_try" in +- *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; +- *) ac_try_echo=$ac_try;; +-esac +-eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1 +- ac_status=$? +- grep -v '^ *+' conftest.er1 >conftest.err +- rm -f conftest.er1 +- cat conftest.err >&5 +- echo "$as_me:$LINENO: \$? = $ac_status" >&5 +- (exit $ac_status); } >/dev/null && { +- test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || +- test ! -s conftest.err +- }; then +- ac_header_preproc=yes +-else +- echo "$as_me: failed program was:" >&5 +-sed 's/^/| /' conftest.$ac_ext >&5 +- +- ac_header_preproc=no +-fi +- +-rm -f conftest.err conftest.$ac_ext +-{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 +-echo "${ECHO_T}$ac_header_preproc" >&6; } +- +-# So? What about this header? +-case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in +- yes:no: ) +- { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5 +-echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;} +- { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5 +-echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;} +- ac_header_preproc=yes +- ;; +- no:yes:* ) +- { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5 +-echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;} +- { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5 +-echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;} +- { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5 +-echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;} +- { echo "$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&5 +-echo "$as_me: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&2;} +- { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5 +-echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;} +- { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5 +-echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;} +- ( cat <<\_ASBOX +-## --------------------------------- ## +-## Report this to cadaver@webdav.org ## +-## --------------------------------- ## +-_ASBOX +- ) | sed "s/^/$as_me: WARNING: /" >&2 +- ;; +-esac +-{ echo "$as_me:$LINENO: checking for $ac_header" >&5 +-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; } +-if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then +- echo $ECHO_N "(cached) $ECHO_C" >&6 +-else +- eval "$as_ac_Header=\$ac_header_preproc" +-fi +-ac_res=`eval echo '${'$as_ac_Header'}'` +- { echo "$as_me:$LINENO: result: $ac_res" >&5 +-echo "${ECHO_T}$ac_res" >&6; } +- +-fi +-if test `eval echo '${'$as_ac_Header'}'` = yes; then +- cat >>confdefs.h <<_ACEOF +-#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1 +-_ACEOF +- +-fi +- +-done +- +- +- +- +- +-for ac_func in localtime_r +-do +-as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh` +-{ echo "$as_me:$LINENO: checking for $ac_func" >&5 +-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; } +-if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then +- echo $ECHO_N "(cached) $ECHO_C" >&6 +-else +- cat >conftest.$ac_ext <<_ACEOF +-/* confdefs.h. */ +-_ACEOF +-cat confdefs.h >>conftest.$ac_ext +-cat >>conftest.$ac_ext <<_ACEOF +-/* end confdefs.h. */ +-/* Define $ac_func to an innocuous variant, in case declares $ac_func. +- For example, HP-UX 11i declares gettimeofday. */ +-#define $ac_func innocuous_$ac_func +- +-/* System header to define __stub macros and hopefully few prototypes, +- which can conflict with char $ac_func (); below. +- Prefer to if __STDC__ is defined, since +- exists even on freestanding compilers. */ +- +-#ifdef __STDC__ +-# include +-#else +-# include +-#endif +- +-#undef $ac_func +- +-/* Override any GCC internal prototype to avoid an error. +- Use char because int might match the return type of a GCC +- builtin and then its argument prototype would still apply. */ +-#ifdef __cplusplus +-extern "C" +-#endif +-char $ac_func (); +-/* The GNU C library defines this for functions which it implements +- to always fail with ENOSYS. Some functions are actually named +- something starting with __ and the normal name is an alias. */ +-#if defined __stub_$ac_func || defined __stub___$ac_func +-choke me +-#endif +- +-int +-main () +-{ +-return $ac_func (); +- ; +- return 0; +-} +-_ACEOF +-rm -f conftest.$ac_objext conftest$ac_exeext +-if { (ac_try="$ac_link" +-case "(($ac_try" in +- *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; +- *) ac_try_echo=$ac_try;; +-esac +-eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_link") 2>conftest.er1 +- ac_status=$? +- grep -v '^ *+' conftest.er1 >conftest.err +- rm -f conftest.er1 +- cat conftest.err >&5 +- echo "$as_me:$LINENO: \$? = $ac_status" >&5 +- (exit $ac_status); } && { +- test -z "$ac_c_werror_flag" || +- test ! -s conftest.err +- } && test -s conftest$ac_exeext && +- $as_test_x conftest$ac_exeext; then +- eval "$as_ac_var=yes" +-else +- echo "$as_me: failed program was:" >&5 +-sed 's/^/| /' conftest.$ac_ext >&5 +- +- eval "$as_ac_var=no" +-fi +- +-rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ +- conftest$ac_exeext conftest.$ac_ext +-fi +-ac_res=`eval echo '${'$as_ac_var'}'` +- { echo "$as_me:$LINENO: result: $ac_res" >&5 +-echo "${ECHO_T}$ac_res" >&6; } +-if test `eval echo '${'$as_ac_var'}'` = yes; then +- cat >>confdefs.h <<_ACEOF +-#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1 +-_ACEOF +- +-fi +-done +- +- +- +-for ac_func in strftime +-do +-as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh` +-{ echo "$as_me:$LINENO: checking for $ac_func" >&5 +-echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; } +-if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then +- echo $ECHO_N "(cached) $ECHO_C" >&6 +-else +- cat >conftest.$ac_ext <<_ACEOF +-/* confdefs.h. */ +-_ACEOF +-cat confdefs.h >>conftest.$ac_ext +-cat >>conftest.$ac_ext <<_ACEOF +-/* end confdefs.h. */ +-/* Define $ac_func to an innocuous variant, in case declares $ac_func. +- For example, HP-UX 11i declares gettimeofday. */ +-#define $ac_func innocuous_$ac_func +- +-/* System header to define __stub macros and hopefully few prototypes, +- which can conflict with char $ac_func (); below. +- Prefer to if __STDC__ is defined, since +- exists even on freestanding compilers. */ +- +-#ifdef __STDC__ +-# include +-#else +-# include +-#endif +- +-#undef $ac_func +- +-/* Override any GCC internal prototype to avoid an error. +- Use char because int might match the return type of a GCC +- builtin and then its argument prototype would still apply. */ +-#ifdef __cplusplus +-extern "C" +-#endif +-char $ac_func (); +-/* The GNU C library defines this for functions which it implements +- to always fail with ENOSYS. Some functions are actually named +- something starting with __ and the normal name is an alias. */ +-#if defined __stub_$ac_func || defined __stub___$ac_func +-choke me +-#endif +- +-int +-main () +-{ +-return $ac_func (); +- ; +- return 0; +-} ++#include <$ac_header> + _ACEOF +-rm -f conftest.$ac_objext conftest$ac_exeext +-if { (ac_try="$ac_link" ++if { (ac_try="$ac_cpp conftest.$ac_ext" + case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; + esac + eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_link") 2>conftest.er1 ++ (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 +- (exit $ac_status); } && { +- test -z "$ac_c_werror_flag" || ++ (exit $ac_status); } >/dev/null && { ++ test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || + test ! -s conftest.err +- } && test -s conftest$ac_exeext && +- $as_test_x conftest$ac_exeext; then +- eval "$as_ac_var=yes" ++ }; then ++ ac_header_preproc=yes + else + echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + +- eval "$as_ac_var=no" ++ ac_header_preproc=no + fi + +-rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ +- conftest$ac_exeext conftest.$ac_ext ++rm -f conftest.err conftest.$ac_ext ++{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 ++echo "${ECHO_T}$ac_header_preproc" >&6; } ++ ++# So? What about this header? ++case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in ++ yes:no: ) ++ { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5 ++echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;} ++ { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5 ++echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;} ++ ac_header_preproc=yes ++ ;; ++ no:yes:* ) ++ { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5 ++echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;} ++ { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5 ++echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;} ++ { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5 ++echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;} ++ { echo "$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&5 ++echo "$as_me: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&2;} ++ { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5 ++echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;} ++ { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5 ++echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;} ++ ( cat <<\_ASBOX ++## --------------------------------- ## ++## Report this to cadaver@webdav.org ## ++## --------------------------------- ## ++_ASBOX ++ ) | sed "s/^/$as_me: WARNING: /" >&2 ++ ;; ++esac ++{ echo "$as_me:$LINENO: checking for $ac_header" >&5 ++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; } ++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then ++ echo $ECHO_N "(cached) $ECHO_C" >&6 ++else ++ eval "$as_ac_Header=\$ac_header_preproc" + fi +-ac_res=`eval echo '${'$as_ac_var'}'` ++ac_res=`eval echo '${'$as_ac_Header'}'` + { echo "$as_me:$LINENO: result: $ac_res" >&5 + echo "${ECHO_T}$ac_res" >&6; } +-if test `eval echo '${'$as_ac_var'}'` = yes; then ++ ++fi ++if test `eval echo '${'$as_ac_Header'}'` = yes; then + cat >>confdefs.h <<_ACEOF +-#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1 ++#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1 + _ACEOF + +-else +- case " $LIBOBJS " in +- *" $ac_func.$ac_objext "* ) ;; +- *) LIBOBJS="$LIBOBJS $ac_func.$ac_objext" +- ;; +-esac +- + fi +-done + ++done + + ++jm_FUNC_STRFTIME() + + { echo "$as_me:$LINENO: checking for a thread-safe mkdir -p" >&5 + echo $ECHO_N "checking for a thread-safe mkdir -p... $ECHO_C" >&6; } +@@ -22721,267 +21527,98 @@ + exit (sig != SIGFPE); + } + +-int x = 1; +-int y = 0; +-int z; +-int nan; +- +-int main () +-{ +- signal (SIGFPE, sigfpe_handler); +-/* IRIX and AIX (when "xlc -qcheck" is used) yield signal SIGTRAP. */ +-#if (defined (__sgi) || defined (_AIX)) && defined (SIGTRAP) +- signal (SIGTRAP, sigfpe_handler); +-#endif +-/* Linux/SPARC yields signal SIGILL. */ +-#if defined (__sparc__) && defined (__linux__) +- signal (SIGILL, sigfpe_handler); +-#endif +- +- z = x / y; +- nan = y / y; +- exit (1); +-} +- +-_ACEOF +-rm -f conftest$ac_exeext +-if { (ac_try="$ac_link" +-case "(($ac_try" in +- *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; +- *) ac_try_echo=$ac_try;; +-esac +-eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_link") 2>&5 +- ac_status=$? +- echo "$as_me:$LINENO: \$? = $ac_status" >&5 +- (exit $ac_status); } && { ac_try='./conftest$ac_exeext' +- { (case "(($ac_try" in +- *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; +- *) ac_try_echo=$ac_try;; +-esac +-eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_try") 2>&5 +- ac_status=$? +- echo "$as_me:$LINENO: \$? = $ac_status" >&5 +- (exit $ac_status); }; }; then +- gt_cv_int_divbyzero_sigfpe=yes +-else +- echo "$as_me: program exited with status $ac_status" >&5 +-echo "$as_me: failed program was:" >&5 +-sed 's/^/| /' conftest.$ac_ext >&5 +- +-( exit $ac_status ) +-gt_cv_int_divbyzero_sigfpe=no +-fi +-rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext +-fi +- +- +- fi +- +-fi +-{ echo "$as_me:$LINENO: result: $gt_cv_int_divbyzero_sigfpe" >&5 +-echo "${ECHO_T}$gt_cv_int_divbyzero_sigfpe" >&6; } +- case "$gt_cv_int_divbyzero_sigfpe" in +- *yes) value=1;; +- *) value=0;; +- esac +- +-cat >>confdefs.h <<_ACEOF +-#define INTDIV0_RAISES_SIGFPE $value +-_ACEOF +- +- +- +- { echo "$as_me:$LINENO: checking for inttypes.h" >&5 +-echo $ECHO_N "checking for inttypes.h... $ECHO_C" >&6; } +-if test "${gl_cv_header_inttypes_h+set}" = set; then +- echo $ECHO_N "(cached) $ECHO_C" >&6 +-else +- cat >conftest.$ac_ext <<_ACEOF +-/* confdefs.h. */ +-_ACEOF +-cat confdefs.h >>conftest.$ac_ext +-cat >>conftest.$ac_ext <<_ACEOF +-/* end confdefs.h. */ +-#include +-#include +-int +-main () +-{ +-uintmax_t i = (uintmax_t) -1; return !i; +- ; +- return 0; +-} +-_ACEOF +-rm -f conftest.$ac_objext +-if { (ac_try="$ac_compile" +-case "(($ac_try" in +- *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; +- *) ac_try_echo=$ac_try;; +-esac +-eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_compile") 2>conftest.er1 +- ac_status=$? +- grep -v '^ *+' conftest.er1 >conftest.err +- rm -f conftest.er1 +- cat conftest.err >&5 +- echo "$as_me:$LINENO: \$? = $ac_status" >&5 +- (exit $ac_status); } && { +- test -z "$ac_c_werror_flag" || +- test ! -s conftest.err +- } && test -s conftest.$ac_objext; then +- gl_cv_header_inttypes_h=yes +-else +- echo "$as_me: failed program was:" >&5 +-sed 's/^/| /' conftest.$ac_ext >&5 +- +- gl_cv_header_inttypes_h=no +-fi +- +-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +-fi +-{ echo "$as_me:$LINENO: result: $gl_cv_header_inttypes_h" >&5 +-echo "${ECHO_T}$gl_cv_header_inttypes_h" >&6; } +- if test $gl_cv_header_inttypes_h = yes; then +- +-cat >>confdefs.h <<_ACEOF +-#define HAVE_INTTYPES_H_WITH_UINTMAX 1 +-_ACEOF +- +- fi +- +- +- { echo "$as_me:$LINENO: checking for unsigned long long int" >&5 +-echo $ECHO_N "checking for unsigned long long int... $ECHO_C" >&6; } +-if test "${ac_cv_type_unsigned_long_long_int+set}" = set; then +- echo $ECHO_N "(cached) $ECHO_C" >&6 +-else +- cat >conftest.$ac_ext <<_ACEOF ++int x = 1; ++int y = 0; ++int z; ++int nan; + +- /* confdefs.h. */ +-_ACEOF +-cat confdefs.h >>conftest.$ac_ext +-cat >>conftest.$ac_ext <<_ACEOF +-/* end confdefs.h. */ +-/* Test preprocessor. */ +- #if ! (-9223372036854775807LL < 0 && 0 < 9223372036854775807ll) +- error in preprocessor; +- #endif +- #if ! (18446744073709551615ULL <= -1ull) +- error in preprocessor; +- #endif +- /* Test literals. */ +- long long int ll = 9223372036854775807ll; +- long long int nll = -9223372036854775807LL; +- unsigned long long int ull = 18446744073709551615ULL; +- /* Test constant expressions. */ +- typedef int a[((-9223372036854775807LL < 0 && 0 < 9223372036854775807ll) +- ? 1 : -1)]; +- typedef int b[(18446744073709551615ULL <= (unsigned long long int) -1 +- ? 1 : -1)]; +- int i = 63; +-int +-main () ++int main () + { +-/* Test availability of runtime routines for shift and division. */ +- long long int llmax = 9223372036854775807ll; +- unsigned long long int ullmax = 18446744073709551615ull; +- return ((ll << 63) | (ll >> 63) | (ll < i) | (ll > i) +- | (llmax / ll) | (llmax % ll) +- | (ull << 63) | (ull >> 63) | (ull << i) | (ull >> i) +- | (ullmax / ull) | (ullmax % ull)); +- ; +- return 0; ++ signal (SIGFPE, sigfpe_handler); ++/* IRIX and AIX (when "xlc -qcheck" is used) yield signal SIGTRAP. */ ++#if (defined (__sgi) || defined (_AIX)) && defined (SIGTRAP) ++ signal (SIGTRAP, sigfpe_handler); ++#endif ++/* Linux/SPARC yields signal SIGILL. */ ++#if defined (__sparc__) && defined (__linux__) ++ signal (SIGILL, sigfpe_handler); ++#endif ++ ++ z = x / y; ++ nan = y / y; ++ exit (1); + } + + _ACEOF +-rm -f conftest.$ac_objext conftest$ac_exeext ++rm -f conftest$ac_exeext + if { (ac_try="$ac_link" + case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; + esac + eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_link") 2>conftest.er1 ++ (eval "$ac_link") 2>&5 + ac_status=$? +- grep -v '^ *+' conftest.er1 >conftest.err +- rm -f conftest.er1 +- cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 +- (exit $ac_status); } && { +- test -z "$ac_c_werror_flag" || +- test ! -s conftest.err +- } && test -s conftest$ac_exeext && +- $as_test_x conftest$ac_exeext; then +- ac_cv_type_unsigned_long_long_int=yes ++ (exit $ac_status); } && { ac_try='./conftest$ac_exeext' ++ { (case "(($ac_try" in ++ *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; ++ *) ac_try_echo=$ac_try;; ++esac ++eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 ++ (eval "$ac_try") 2>&5 ++ ac_status=$? ++ echo "$as_me:$LINENO: \$? = $ac_status" >&5 ++ (exit $ac_status); }; }; then ++ gt_cv_int_divbyzero_sigfpe=yes + else +- echo "$as_me: failed program was:" >&5 ++ echo "$as_me: program exited with status $ac_status" >&5 ++echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + +- ac_cv_type_unsigned_long_long_int=no ++( exit $ac_status ) ++gt_cv_int_divbyzero_sigfpe=no + fi +- +-rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ +- conftest$ac_exeext conftest.$ac_ext ++rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext + fi +-{ echo "$as_me:$LINENO: result: $ac_cv_type_unsigned_long_long_int" >&5 +-echo "${ECHO_T}$ac_cv_type_unsigned_long_long_int" >&6; } +- if test $ac_cv_type_unsigned_long_long_int = yes; then +- +-cat >>confdefs.h <<\_ACEOF +-#define HAVE_UNSIGNED_LONG_LONG_INT 1 +-_ACEOF +- +- fi + + ++ fi + +- +- if test $gl_cv_header_inttypes_h = no && test $gl_cv_header_stdint_h = no; then +- +- test $ac_cv_type_unsigned_long_long_int = yes \ +- && ac_type='unsigned long long' \ +- || ac_type='unsigned long' ++fi ++{ echo "$as_me:$LINENO: result: $gt_cv_int_divbyzero_sigfpe" >&5 ++echo "${ECHO_T}$gt_cv_int_divbyzero_sigfpe" >&6; } ++ case "$gt_cv_int_divbyzero_sigfpe" in ++ *yes) value=1;; ++ *) value=0;; ++ esac + + cat >>confdefs.h <<_ACEOF +-#define uintmax_t $ac_type +-_ACEOF +- +- else +- +-cat >>confdefs.h <<\_ACEOF +-#define HAVE_UINTMAX_T 1 ++#define INTDIV0_RAISES_SIGFPE $value + _ACEOF + +- fi +- + + +-for ac_header in inttypes.h +-do +-as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` +-if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then +- { echo "$as_me:$LINENO: checking for $ac_header" >&5 +-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; } +-if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then ++ { echo "$as_me:$LINENO: checking for inttypes.h" >&5 ++echo $ECHO_N "checking for inttypes.h... $ECHO_C" >&6; } ++if test "${gl_cv_header_inttypes_h+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +-fi +-ac_res=`eval echo '${'$as_ac_Header'}'` +- { echo "$as_me:$LINENO: result: $ac_res" >&5 +-echo "${ECHO_T}$ac_res" >&6; } + else +- # Is the header compilable? +-{ echo "$as_me:$LINENO: checking $ac_header usability" >&5 +-echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; } +-cat >conftest.$ac_ext <<_ACEOF ++ cat >conftest.$ac_ext <<_ACEOF + /* confdefs.h. */ + _ACEOF + cat confdefs.h >>conftest.$ac_ext + cat >>conftest.$ac_ext <<_ACEOF + /* end confdefs.h. */ +-$ac_includes_default +-#include <$ac_header> ++#include ++#include ++int ++main () ++{ ++uintmax_t i = (uintmax_t) -1; return !i; ++ ; ++ return 0; ++} + _ACEOF + rm -f conftest.$ac_objext + if { (ac_try="$ac_compile" +@@ -23000,142 +21637,79 @@ + test -z "$ac_c_werror_flag" || + test ! -s conftest.err + } && test -s conftest.$ac_objext; then +- ac_header_compiler=yes ++ gl_cv_header_inttypes_h=yes + else + echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + +- ac_header_compiler=no ++ gl_cv_header_inttypes_h=no + fi + + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +-{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 +-echo "${ECHO_T}$ac_header_compiler" >&6; } +- +-# Is the header present? +-{ echo "$as_me:$LINENO: checking $ac_header presence" >&5 +-echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; } +-cat >conftest.$ac_ext <<_ACEOF +-/* confdefs.h. */ +-_ACEOF +-cat confdefs.h >>conftest.$ac_ext +-cat >>conftest.$ac_ext <<_ACEOF +-/* end confdefs.h. */ +-#include <$ac_header> +-_ACEOF +-if { (ac_try="$ac_cpp conftest.$ac_ext" +-case "(($ac_try" in +- *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; +- *) ac_try_echo=$ac_try;; +-esac +-eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1 +- ac_status=$? +- grep -v '^ *+' conftest.er1 >conftest.err +- rm -f conftest.er1 +- cat conftest.err >&5 +- echo "$as_me:$LINENO: \$? = $ac_status" >&5 +- (exit $ac_status); } >/dev/null && { +- test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || +- test ! -s conftest.err +- }; then +- ac_header_preproc=yes +-else +- echo "$as_me: failed program was:" >&5 +-sed 's/^/| /' conftest.$ac_ext >&5 +- +- ac_header_preproc=no +-fi +- +-rm -f conftest.err conftest.$ac_ext +-{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 +-echo "${ECHO_T}$ac_header_preproc" >&6; } +- +-# So? What about this header? +-case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in +- yes:no: ) +- { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5 +-echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;} +- { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5 +-echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;} +- ac_header_preproc=yes +- ;; +- no:yes:* ) +- { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5 +-echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;} +- { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5 +-echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;} +- { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5 +-echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;} +- { echo "$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&5 +-echo "$as_me: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&2;} +- { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5 +-echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;} +- { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5 +-echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;} +- ( cat <<\_ASBOX +-## --------------------------------- ## +-## Report this to cadaver@webdav.org ## +-## --------------------------------- ## +-_ASBOX +- ) | sed "s/^/$as_me: WARNING: /" >&2 +- ;; +-esac +-{ echo "$as_me:$LINENO: checking for $ac_header" >&5 +-echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; } +-if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then +- echo $ECHO_N "(cached) $ECHO_C" >&6 +-else +- eval "$as_ac_Header=\$ac_header_preproc" + fi +-ac_res=`eval echo '${'$as_ac_Header'}'` +- { echo "$as_me:$LINENO: result: $ac_res" >&5 +-echo "${ECHO_T}$ac_res" >&6; } ++{ echo "$as_me:$LINENO: result: $gl_cv_header_inttypes_h" >&5 ++echo "${ECHO_T}$gl_cv_header_inttypes_h" >&6; } ++ if test $gl_cv_header_inttypes_h = yes; then + +-fi +-if test `eval echo '${'$as_ac_Header'}'` = yes; then +- cat >>confdefs.h <<_ACEOF +-#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1 ++cat >>confdefs.h <<_ACEOF ++#define HAVE_INTTYPES_H_WITH_UINTMAX 1 + _ACEOF + +-fi +- +-done +- +- if test $ac_cv_header_inttypes_h = yes; then +- { echo "$as_me:$LINENO: checking whether the inttypes.h PRIxNN macros are broken" >&5 +-echo $ECHO_N "checking whether the inttypes.h PRIxNN macros are broken... $ECHO_C" >&6; } +-if test "${gt_cv_inttypes_pri_broken+set}" = set; then ++ fi ++ ++ ++ { echo "$as_me:$LINENO: checking for unsigned long long int" >&5 ++echo $ECHO_N "checking for unsigned long long int... $ECHO_C" >&6; } ++if test "${ac_cv_type_unsigned_long_long_int+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 + else ++ cat >conftest.$ac_ext <<_ACEOF + +- cat >conftest.$ac_ext <<_ACEOF +-/* confdefs.h. */ ++ /* confdefs.h. */ + _ACEOF + cat confdefs.h >>conftest.$ac_ext + cat >>conftest.$ac_ext <<_ACEOF + /* end confdefs.h. */ +-#include +-#ifdef PRId32 +-char *p = PRId32; +-#endif +- ++/* Test preprocessor. */ ++ #if ! (-9223372036854775807LL < 0 && 0 < 9223372036854775807ll) ++ error in preprocessor; ++ #endif ++ #if ! (18446744073709551615ULL <= -1ull) ++ error in preprocessor; ++ #endif ++ /* Test literals. */ ++ long long int ll = 9223372036854775807ll; ++ long long int nll = -9223372036854775807LL; ++ unsigned long long int ull = 18446744073709551615ULL; ++ /* Test constant expressions. */ ++ typedef int a[((-9223372036854775807LL < 0 && 0 < 9223372036854775807ll) ++ ? 1 : -1)]; ++ typedef int b[(18446744073709551615ULL <= (unsigned long long int) -1 ++ ? 1 : -1)]; ++ int i = 63; + int + main () + { +- ++/* Test availability of runtime routines for shift and division. */ ++ long long int llmax = 9223372036854775807ll; ++ unsigned long long int ullmax = 18446744073709551615ull; ++ return ((ll << 63) | (ll >> 63) | (ll < i) | (ll > i) ++ | (llmax / ll) | (llmax % ll) ++ | (ull << 63) | (ull >> 63) | (ull << i) | (ull >> i) ++ | (ullmax / ull) | (ullmax % ull)); + ; + return 0; + } ++ + _ACEOF +-rm -f conftest.$ac_objext +-if { (ac_try="$ac_compile" ++rm -f conftest.$ac_objext conftest$ac_exeext ++if { (ac_try="$ac_link" + case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; + esac + eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 +- (eval "$ac_compile") 2>conftest.er1 ++ (eval "$ac_link") 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 +@@ -23144,80 +21718,68 @@ + (exit $ac_status); } && { + test -z "$ac_c_werror_flag" || + test ! -s conftest.err +- } && test -s conftest.$ac_objext; then +- gt_cv_inttypes_pri_broken=no ++ } && test -s conftest$ac_exeext && ++ $as_test_x conftest$ac_exeext; then ++ ac_cv_type_unsigned_long_long_int=yes + else + echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + +- gt_cv_inttypes_pri_broken=yes ++ ac_cv_type_unsigned_long_long_int=no + fi + +-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +- ++rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ ++ conftest$ac_exeext conftest.$ac_ext + fi +-{ echo "$as_me:$LINENO: result: $gt_cv_inttypes_pri_broken" >&5 +-echo "${ECHO_T}$gt_cv_inttypes_pri_broken" >&6; } +- fi +- if test "$gt_cv_inttypes_pri_broken" = yes; then ++{ echo "$as_me:$LINENO: result: $ac_cv_type_unsigned_long_long_int" >&5 ++echo "${ECHO_T}$ac_cv_type_unsigned_long_long_int" >&6; } ++ if test $ac_cv_type_unsigned_long_long_int = yes; then + +-cat >>confdefs.h <<_ACEOF +-#define PRI_MACROS_BROKEN 1 ++cat >>confdefs.h <<\_ACEOF ++#define HAVE_UNSIGNED_LONG_LONG_INT 1 + _ACEOF + +- PRI_MACROS_BROKEN=1 +- else +- PRI_MACROS_BROKEN=0 + fi + + + +-cat >>confdefs.h <<\_ACEOF +-#define _GNU_SOURCE 1 +-_ACEOF + ++ if test $gl_cv_header_inttypes_h = no && test $gl_cv_header_stdint_h = no; then + ++ test $ac_cv_type_unsigned_long_long_int = yes \ ++ && ac_type='unsigned long long' \ ++ || ac_type='unsigned long' + +-{ echo "$as_me:$LINENO: checking for AIX" >&5 +-echo $ECHO_N "checking for AIX... $ECHO_C" >&6; } +-cat >conftest.$ac_ext <<_ACEOF +-/* confdefs.h. */ ++cat >>confdefs.h <<_ACEOF ++#define uintmax_t $ac_type + _ACEOF +-cat confdefs.h >>conftest.$ac_ext +-cat >>conftest.$ac_ext <<_ACEOF +-/* end confdefs.h. */ +-#ifdef _AIX +- yes +-#endif + +-_ACEOF +-if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | +- $EGREP "yes" >/dev/null 2>&1; then +- { echo "$as_me:$LINENO: result: yes" >&5 +-echo "${ECHO_T}yes" >&6; } ++ else ++ + cat >>confdefs.h <<\_ACEOF +-#define _ALL_SOURCE 1 ++#define HAVE_UINTMAX_T 1 + _ACEOF + +-else +- { echo "$as_me:$LINENO: result: no" >&5 +-echo "${ECHO_T}no" >&6; } +-fi +-rm -f conftest* ++ fi + + +-if test "${ac_cv_header_minix_config_h+set}" = set; then +- { echo "$as_me:$LINENO: checking for minix/config.h" >&5 +-echo $ECHO_N "checking for minix/config.h... $ECHO_C" >&6; } +-if test "${ac_cv_header_minix_config_h+set}" = set; then ++ ++for ac_header in inttypes.h ++do ++as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` ++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then ++ { echo "$as_me:$LINENO: checking for $ac_header" >&5 ++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; } ++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then + echo $ECHO_N "(cached) $ECHO_C" >&6 + fi +-{ echo "$as_me:$LINENO: result: $ac_cv_header_minix_config_h" >&5 +-echo "${ECHO_T}$ac_cv_header_minix_config_h" >&6; } ++ac_res=`eval echo '${'$as_ac_Header'}'` ++ { echo "$as_me:$LINENO: result: $ac_res" >&5 ++echo "${ECHO_T}$ac_res" >&6; } + else + # Is the header compilable? +-{ echo "$as_me:$LINENO: checking minix/config.h usability" >&5 +-echo $ECHO_N "checking minix/config.h usability... $ECHO_C" >&6; } ++{ echo "$as_me:$LINENO: checking $ac_header usability" >&5 ++echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; } + cat >conftest.$ac_ext <<_ACEOF + /* confdefs.h. */ + _ACEOF +@@ -23225,7 +21787,7 @@ + cat >>conftest.$ac_ext <<_ACEOF + /* end confdefs.h. */ + $ac_includes_default +-#include ++#include <$ac_header> + _ACEOF + rm -f conftest.$ac_objext + if { (ac_try="$ac_compile" +@@ -23257,15 +21819,15 @@ + echo "${ECHO_T}$ac_header_compiler" >&6; } + + # Is the header present? +-{ echo "$as_me:$LINENO: checking minix/config.h presence" >&5 +-echo $ECHO_N "checking minix/config.h presence... $ECHO_C" >&6; } ++{ echo "$as_me:$LINENO: checking $ac_header presence" >&5 ++echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; } + cat >conftest.$ac_ext <<_ACEOF + /* confdefs.h. */ + _ACEOF + cat confdefs.h >>conftest.$ac_ext + cat >>conftest.$ac_ext <<_ACEOF + /* end confdefs.h. */ +-#include ++#include <$ac_header> + _ACEOF + if { (ac_try="$ac_cpp conftest.$ac_ext" + case "(($ac_try" in +@@ -23298,25 +21860,25 @@ + # So? What about this header? + case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in + yes:no: ) +- { echo "$as_me:$LINENO: WARNING: minix/config.h: accepted by the compiler, rejected by the preprocessor!" >&5 +-echo "$as_me: WARNING: minix/config.h: accepted by the compiler, rejected by the preprocessor!" >&2;} +- { echo "$as_me:$LINENO: WARNING: minix/config.h: proceeding with the compiler's result" >&5 +-echo "$as_me: WARNING: minix/config.h: proceeding with the compiler's result" >&2;} ++ { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5 ++echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;} ++ { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5 ++echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;} + ac_header_preproc=yes + ;; + no:yes:* ) +- { echo "$as_me:$LINENO: WARNING: minix/config.h: present but cannot be compiled" >&5 +-echo "$as_me: WARNING: minix/config.h: present but cannot be compiled" >&2;} +- { echo "$as_me:$LINENO: WARNING: minix/config.h: check for missing prerequisite headers?" >&5 +-echo "$as_me: WARNING: minix/config.h: check for missing prerequisite headers?" >&2;} +- { echo "$as_me:$LINENO: WARNING: minix/config.h: see the Autoconf documentation" >&5 +-echo "$as_me: WARNING: minix/config.h: see the Autoconf documentation" >&2;} +- { echo "$as_me:$LINENO: WARNING: minix/config.h: section \"Present But Cannot Be Compiled\"" >&5 +-echo "$as_me: WARNING: minix/config.h: section \"Present But Cannot Be Compiled\"" >&2;} +- { echo "$as_me:$LINENO: WARNING: minix/config.h: proceeding with the preprocessor's result" >&5 +-echo "$as_me: WARNING: minix/config.h: proceeding with the preprocessor's result" >&2;} +- { echo "$as_me:$LINENO: WARNING: minix/config.h: in the future, the compiler will take precedence" >&5 +-echo "$as_me: WARNING: minix/config.h: in the future, the compiler will take precedence" >&2;} ++ { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5 ++echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;} ++ { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5 ++echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;} ++ { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5 ++echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;} ++ { echo "$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&5 ++echo "$as_me: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&2;} ++ { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5 ++echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;} ++ { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5 ++echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;} + ( cat <<\_ASBOX + ## --------------------------------- ## + ## Report this to cadaver@webdav.org ## +@@ -23325,66 +21887,45 @@ + ) | sed "s/^/$as_me: WARNING: /" >&2 + ;; + esac +-{ echo "$as_me:$LINENO: checking for minix/config.h" >&5 +-echo $ECHO_N "checking for minix/config.h... $ECHO_C" >&6; } +-if test "${ac_cv_header_minix_config_h+set}" = set; then ++{ echo "$as_me:$LINENO: checking for $ac_header" >&5 ++echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; } ++if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then + echo $ECHO_N "(cached) $ECHO_C" >&6 + else +- ac_cv_header_minix_config_h=$ac_header_preproc ++ eval "$as_ac_Header=\$ac_header_preproc" + fi +-{ echo "$as_me:$LINENO: result: $ac_cv_header_minix_config_h" >&5 +-echo "${ECHO_T}$ac_cv_header_minix_config_h" >&6; } ++ac_res=`eval echo '${'$as_ac_Header'}'` ++ { echo "$as_me:$LINENO: result: $ac_res" >&5 ++echo "${ECHO_T}$ac_res" >&6; } + + fi +-if test $ac_cv_header_minix_config_h = yes; then +- MINIX=yes +-else +- MINIX= +-fi +- +- +-if test "$MINIX" = yes; then +- +-cat >>confdefs.h <<\_ACEOF +-#define _POSIX_SOURCE 1 +-_ACEOF +- +- +-cat >>confdefs.h <<\_ACEOF +-#define _POSIX_1_SOURCE 2 +-_ACEOF +- +- +-cat >>confdefs.h <<\_ACEOF +-#define _MINIX 1 ++if test `eval echo '${'$as_ac_Header'}'` = yes; then ++ cat >>confdefs.h <<_ACEOF ++#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1 + _ACEOF + + fi + ++done + +- +- +- +- +- +- +- +- +- +- { echo "$as_me:$LINENO: checking whether it is safe to define __EXTENSIONS__" >&5 +-echo $ECHO_N "checking whether it is safe to define __EXTENSIONS__... $ECHO_C" >&6; } +-if test "${ac_cv_safe_to_define___extensions__+set}" = set; then ++ if test $ac_cv_header_inttypes_h = yes; then ++ { echo "$as_me:$LINENO: checking whether the inttypes.h PRIxNN macros are broken" >&5 ++echo $ECHO_N "checking whether the inttypes.h PRIxNN macros are broken... $ECHO_C" >&6; } ++if test "${gt_cv_inttypes_pri_broken+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 + else +- cat >conftest.$ac_ext <<_ACEOF ++ ++ cat >conftest.$ac_ext <<_ACEOF + /* confdefs.h. */ + _ACEOF + cat confdefs.h >>conftest.$ac_ext + cat >>conftest.$ac_ext <<_ACEOF + /* end confdefs.h. */ ++#include ++#ifdef PRId32 ++char *p = PRId32; ++#endif + +-# define __EXTENSIONS__ 1 +- $ac_includes_default + int + main () + { +@@ -23410,30 +21951,30 @@ + test -z "$ac_c_werror_flag" || + test ! -s conftest.err + } && test -s conftest.$ac_objext; then +- ac_cv_safe_to_define___extensions__=yes ++ gt_cv_inttypes_pri_broken=no + else + echo "$as_me: failed program was:" >&5 + sed 's/^/| /' conftest.$ac_ext >&5 + +- ac_cv_safe_to_define___extensions__=no ++ gt_cv_inttypes_pri_broken=yes + fi + + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ++ + fi +-{ echo "$as_me:$LINENO: result: $ac_cv_safe_to_define___extensions__" >&5 +-echo "${ECHO_T}$ac_cv_safe_to_define___extensions__" >&6; } +- test $ac_cv_safe_to_define___extensions__ = yes && +- cat >>confdefs.h <<\_ACEOF +-#define __EXTENSIONS__ 1 +-_ACEOF ++{ echo "$as_me:$LINENO: result: $gt_cv_inttypes_pri_broken" >&5 ++echo "${ECHO_T}$gt_cv_inttypes_pri_broken" >&6; } ++ fi ++ if test "$gt_cv_inttypes_pri_broken" = yes; then + +- cat >>confdefs.h <<\_ACEOF +-#define _POSIX_PTHREAD_SEMANTICS 1 ++cat >>confdefs.h <<_ACEOF ++#define PRI_MACROS_BROKEN 1 + _ACEOF + +- cat >>confdefs.h <<\_ACEOF +-#define _TANDEM_SOURCE 1 +-_ACEOF ++ PRI_MACROS_BROKEN=1 ++ else ++ PRI_MACROS_BROKEN=0 ++ fi + + + +@@ -30441,13 +28982,13 @@ + NE_FLAG_ZLIB!$NE_FLAG_ZLIB$ac_delim + NE_FLAG_IPV6!$NE_FLAG_IPV6$ac_delim + NE_FLAG_LFS!$NE_FLAG_LFS$ac_delim +-NE_FLAG_SOCKS!$NE_FLAG_SOCKS$ac_delim + NE_FLAG_TS_SSL!$NE_FLAG_TS_SSL$ac_delim + LIBOBJS!$LIBOBJS$ac_delim + PKG_CONFIG!$PKG_CONFIG$ac_delim + GNUTLS_CONFIG!$GNUTLS_CONFIG$ac_delim + NEON_SUPPORTS_SSL!$NEON_SUPPORTS_SSL$ac_delim + KRB5_CONFIG!$KRB5_CONFIG$ac_delim ++NE_FLAG_LIBPXY!$NE_FLAG_LIBPXY$ac_delim + NEON_CFLAGS!$NEON_CFLAGS$ac_delim + NEON_LIBS!$NEON_LIBS$ac_delim + NEON_LTLIBS!$NEON_LTLIBS$ac_delim +diff a/m4/neon/neon.m4 b/m4/neon/neon.m4 +--- a/m4/neon/neon.m4 ++++ b/m4/neon/neon.m4 +@@ -937,27 +937,47 @@ + NEON_EXTRAOBJS="$NEON_EXTRAOBJS ne_openssl" + ;; + gnutls) +- AC_PATH_PROG(GNUTLS_CONFIG, libgnutls-config, no) ++ ne_gnutls_use_pkgconfig="yes" ++ if test "$PKG_CONFIG" = "no"; then ++ ne_gnutls_use_pkgconfig="no" ++ else if ! $PKG_CONFIG --exists gnutls; then ++ ne_gnutls_use_pkgconfig="no" ++ fi; fi ++ ++ if test "$ne_gnutls_use_pkgconfig" = "yes"; then ++ ne_gnutls_ver=`$PKG_CONFIG --modversion gnutls` ++ else ++ AC_PATH_PROG(GNUTLS_CONFIG, libgnutls-config, no) ++ ++ if test "$GNUTLS_CONFIG" = "no"; then ++ AC_MSG_ERROR([could not find libgnutls-config in \$PATH]) ++ fi + +- if test "$GNUTLS_CONFIG" = "no"; then +- AC_MSG_ERROR([could not find libgnutls-config in \$PATH]) ++ ne_gnutls_ver=`$GNUTLS_CONFIG --version` + fi + +- ne_gnutls_ver=`$GNUTLS_CONFIG --version` + case $ne_gnutls_ver in + 1.0.?|1.0.1?|1.0.20|1.0.21) + AC_MSG_ERROR([GNU TLS version $ne_gnutls_ver is too old -- 1.0.22 or later required]) + ;; + esac + +- CPPFLAGS="$CPPFLAGS `$GNUTLS_CONFIG --cflags`" ++ if test "$ne_gnutls_use_pkgconfig" = "yes"; then ++ CPPFLAGS="$CPPFLAGS `$PKG_CONFIG --cflags gnutls`" ++ else ++ CPPFLAGS="$CPPFLAGS `$GNUTLS_CONFIG --cflags`" ++ fi + + AC_CHECK_HEADER([gnutls/gnutls.h],, + [AC_MSG_ERROR([could not find gnutls/gnutls.h in include path])]) + + NE_ENABLE_SUPPORT(SSL, [SSL support enabled, using GnuTLS $ne_gnutls_ver]) + NEON_EXTRAOBJS="$NEON_EXTRAOBJS ne_gnutls" +- NEON_LIBS="$NEON_LIBS `$GNUTLS_CONFIG --libs`" ++ if test "$ne_gnutls_use_pkgconfig" = "yes"; then ++ NEON_LIBS="$NEON_LIBS `$PKG_CONFIG --libs gnutls`" ++ else ++ NEON_LIBS="$NEON_LIBS `$GNUTLS_CONFIG --libs`" ++ fi + AC_DEFINE([HAVE_GNUTLS], 1, [Define if GnuTLS support is enabled]) + + # Check for functions in later releases -- 2.30.2