# Copyright (C) 1998-2018  Internet Systems Consortium, Inc. ("ISC")
#
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.

dnl
AC_DIVERT_PUSH(1)dnl
esyscmd([sed -e 's/^/# /' -e '/Portions of this code/,$d' COPYRIGHT])dnl
AC_DIVERT_POP()dnl

AC_INIT(BIND, [9.12], [info@isc.org], [], [https://www.isc.org/downloads/BIND/])
AC_PREREQ(2.59)

AC_CONFIG_HEADER(config.h)
AC_CONFIG_MACRO_DIR([libtool.m4])

AC_CANONICAL_HOST

AC_PROG_MAKE_SET

#
# GNU libtool support
#
case $build_os in
sunos*)
    # Just set the maximum command line length for sunos as it otherwise
    # takes a exceptionally long time to work it out. Required for libtool.
     
    lt_cv_sys_max_cmd_len=4096;
    ;;
esac

AC_PROG_LIBTOOL
AC_PROG_INSTALL
AC_PROG_LN_S

AC_SUBST(STD_CINCLUDES)
AC_SUBST(STD_CDEFINES)
AC_SUBST(STD_CWARNINGS)
AC_SUBST(CCOPT)
AC_SUBST(CCNOOPT)
AC_SUBST(BACKTRACECFLAGS)

# Warn if the user specified libbind, which is now deprecated
AC_ARG_ENABLE(libbind, AS_HELP_STRING([--enable-libbind], [deprecated]))

case "$enable_libbind" in
	yes)
		AC_MSG_ERROR(['libbind' is no longer part of the BIND 9 distribution.
It is available from http://www.isc.org as a separate download.])
		;;
	no|'')
		;;
esac

AC_ARG_ENABLE(buffer_useinline,
	      AS_HELP_STRING([--enable-buffer-useinline],
		             [define ISC_BUFFER_USEINLINE when compiling
				[default=yes]]),
	      if test yes = "${enable}"
	      then
		      AC_DEFINE([ISC_BUFFER_USEINLINE], [1],
			        [Define if you want to use inline buffers])
	      fi,
	      AC_DEFINE([ISC_BUFFER_USEINLINE], [1]))

AC_ARG_ENABLE(warn_shadow,
	      AS_HELP_STRING([--enable-warn-shadow],
			     [turn on -Wshadow when compiling]))

AC_ARG_ENABLE(warn_error,
	      AS_HELP_STRING([--enable-warn-error],
			    [turn on -Werror when compiling]))

AC_ARG_ENABLE(developer,
	      AS_HELP_STRING([--enable-developer],
			     [enable developer build settings]))
XTARGETS=
case "$enable_developer" in
yes)
	STD_CDEFINES="$STD_CDEFINES -DISC_MEM_DEFAULTFILL=1 -DISC_LIST_CHECKINIT=1 -DNS_HOOKS_ENABLE=1"
	test "${enable_fixed_rrset+set}" = set || enable_fixed_rrset=yes
	test "${enable_querytrace+set}" = set || enable_querytrace=yes
	test "${with_atf+set}" = set || with_atf=yes
	test "${with_dlz_filesystem+set}" = set || with_dlz_filesystem=yes
	test "${enable_symtable+set}" = set || enable_symtable=all
	test "${enable_warn_error+set}" = set || enable_warn_error=yes
	test "${enable_warn_shadow+set}" = set || enable_warn_shadow=yes
	test "${with_zlib+set}" = set || with_zlib=yes
	XTARGETS='${XTARGETS}'
	;;
esac
AC_SUBST(XTARGETS)

# American Fuzzy Lop
AC_ARG_ENABLE(afl,
	      AS_HELP_STRING([--enable-afl],
			     [enable American Fuzzy Lop test harness
				[default=no]]),
	      [AC_DEFINE([ENABLE_AFL], [1],
			 [Define to enable American Fuzzy Lop test harness])])
case "$enable_afl" in
yes)
	LIBS="$LIBS -lpthread"
	;;
esac


#libseccomp sandboxing
AC_CHECK_FUNCS(getrandom)
AC_ARG_ENABLE(seccomp,
	      AS_HELP_STRING([--enable-seccomp],
			     [enable support for libseccomp system call
				 filtering [default=no]]))
case "$enable_seccomp" in
	yes)
	case $host_os in
	linux*)
		;;
	*)
		AC_MSG_WARN([seccomp is not supported on non-linux platforms; disabling it])
		enable_seccomp=no
		;;
	esac
	AC_SEARCH_LIBS(seccomp_init, [seccomp])
	if test "X$ac_cv_search_seccomp_init" = "X-lseccomp" ; then
		AC_TRY_RUN([
		#include <stdio.h>
		#include <stdlib.h>
		#include <errno.h>
		#include <sys/prctl.h>
		#include <linux/seccomp.h>

		int main(void)
		{
			int ret;

			ret = prctl(PR_GET_SECCOMP, 0, 0, 0, 0);
			if (ret < 0) {
				switch (errno) {
				case ENOSYS:
					return 1;
				case EINVAL:
					return 1;
				default:
					return 1;
				}
			}
			ret = 
			prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, NULL, 0, 0);
			if (ret < 0) {
				switch (errno) {
				case EINVAL:
					return 1;
				case EFAULT:
					return 0;
				default:
					return 1;
			}
		}
	return 1;
	}
	]
	, AC_DEFINE([HAVE_LIBSECCOMP], 1, 
	[Define to use libseccomp system call filtering.])   
	, []
	)
	fi
		;;
	*)
		;;
esac

#
# Make very sure that these are the first files processed by
# config.status, since we use the processed output as the input for
# AC_SUBST_FILE() substitutions in other files.
#
AC_CONFIG_FILES([make/rules make/includes])

AC_PATH_PROG(AR, ar)
ARFLAGS="cruv"
AC_SUBST(AR)
AC_SUBST(ARFLAGS)

# The POSIX ln(1) program.  Non-POSIX systems may substitute
# "copy" or something.
LN=ln
AC_SUBST(LN)

case "$AR" in
	"")
		AC_MSG_ERROR([
ar program not found.  Please fix your PATH to include the directory in
which ar resides, or set AR in the environment with the full path to ar.
])

		;;
esac

#
# Etags.
#
AC_PATH_PROGS(ETAGS, etags emacs-etags)

#
# Some systems, e.g. RH7, have the Exuberant Ctags etags instead of
# GNU emacs etags, and it requires the -L flag.
#
if test "X$ETAGS" != "X"; then
	AC_MSG_CHECKING(for Exuberant Ctags etags)
	if $ETAGS --version 2>&1 | grep 'Exuberant Ctags' >/dev/null 2>&1; then
		AC_MSG_RESULT(yes)
		ETAGS="$ETAGS -L"
	else
		AC_MSG_RESULT(no)
	fi
fi
AC_SUBST(ETAGS)

#
# Perl is optional; it is used only by some of the system test scripts.
# Note: the backtrace feature (see below) uses perl to build the symbol table,
# but it still compiles without perl, in which case an empty table will be used.
#
AC_PATH_PROGS(PERL, perl5 perl)
AC_SUBST(PERL)

#
# Python is also optional; it is used by the tools in bin/python.
# If python is unavailable, we simply don't build those.
#
AC_ARG_WITH(python,
	    AS_HELP_STRING([--with-python=PATH],
			   [specify path to python interpreter]),
    use_python="$withval", use_python="unspec")
AC_ARG_WITH(python-install-dir,
	    AS_HELP_STRING([--with-python-install-dir=PATH],
			   [installation directory for Python modules]),
	    use_python_install_dir="$withval", use_python_install_dir="unspec")

python="python python3 python3.5 python3.4 python3.3 python3.2 python2 python2.7"

testargparse='try: import argparse
except: exit(1)'

testply='try: from ply import *
except: exit(1)'

testminvers='import sys
if (sys.version_info < (2,7)) or (sys.version_info < (3,2) and sys.version_info >= (3,0)):
   exit(1)'

case "$use_python" in
	no)
		AC_MSG_CHECKING([for python support])
		AC_MSG_RESULT(disabled)
		;;
	unspec|yes|*)
		case "$use_python" in
		unspec|yes|'')
			for p in $python
			do
				AC_PATH_PROGS(PYTHON, $p)
				if test "X$PYTHON" = "X"; then
					continue;
				fi
				AC_MSG_CHECKING([python2 version >= 2.7 or python3 version >= 3.2])
				if ${PYTHON:-false} -c "$testminvers"; then
					AC_MSG_RESULT([found])
				else
					AC_MSG_RESULT([not found])
					unset ac_cv_path_PYTHON
					unset PYTHON
					continue
				fi
				AC_MSG_CHECKING([python module 'argparse'])
				if ${PYTHON:-false} -c "$testargparse"; then
					AC_MSG_RESULT([found])
				else
					AC_MSG_RESULT([not found])
					unset ac_cv_path_PYTHON
					unset PYTHON
					continue
				fi

				AC_MSG_CHECKING([python module 'ply'])
				if ${PYTHON:-false} -c "$testply"; then
					AC_MSG_RESULT([found])
					break
				else
					AC_MSG_RESULT([not found])
					unset ac_cv_path_PYTHON
					unset PYTHON
				fi
			done
			if test "X$PYTHON" != "X"
			then
				case "$use_python_install_dir" in
				unspec)
					PYTHON_INSTALL_DIR=""
					PYTHON_INSTALL_LIB=""
					;;
				*)
					PYTHON_INSTALL_DIR="$use_python_install_dir"
					PYTHON_INSTALL_LIB="--install-lib=$use_python_install_dir"
					;;
				esac
			else
				AC_MSG_CHECKING([for python support])
				case "$use_python" in
				unspec)
					AC_MSG_RESULT(disabled)
					;;
				yes)
					AC_MSG_ERROR([missing python])
					;;
				esac
			fi
			;;
		*)
			case "$use_python" in
			/*)
				PYTHON="$use_python"
				;;
			*)
				AC_PATH_PROGS(PYTHON, $use_python)
				;;
			esac
			AC_MSG_CHECKING([python2 version >= 2.7 or python3 version >= 3.2])
			if ${PYTHON:-false} -c "$testminvers"; then
				AC_MSG_RESULT([found])
			else
				AC_MSG_ERROR([not found])
			fi
			AC_MSG_CHECKING([python module 'argparse'])
			if ${PYTHON:-false} -c "$testargparse"; then
				AC_MSG_RESULT([found, using $PYTHON])
			else
				AC_MSG_ERROR([not found])
			fi
			AC_MSG_CHECKING([python module 'ply'])
			if ${PYTHON:-false} -c "$testply"; then
				AC_MSG_RESULT([found, using $PYTHON])
			else
				AC_MSG_ERROR([not found])
			fi
			;;
		esac
		;;
esac

PYTHON_TOOLS=''
CHECKDS=''
COVERAGE=''
KEYMGR=''
if test "X$PYTHON" != "X"; then
	PYTHON_TOOLS=python
	CHECKDS=checkds
	COVERAGE=coverage
	KEYMGR=keymgr
fi
AC_SUBST(CHECKDS)
AC_SUBST(COVERAGE)
AC_SUBST(KEYMGR)
AC_SUBST(PYTHON_TOOLS)
AC_SUBST(PYTHON_INSTALL_DIR)
AC_SUBST(PYTHON_INSTALL_LIB)

#
# Special processing of paths depending on whether --prefix,
# --sysconfdir or --localstatedir arguments were given.  What's
# desired is some compatibility with the way previous versions
# of BIND built; they defaulted to /usr/local for most parts of
# the installation, but named.boot/named.conf was in /etc
# and named.pid was in /var/run.
#
# So ... if none of --prefix, --sysconfdir or --localstatedir are
# specified, set things up that way.  If --prefix is given, use
# it for sysconfdir and localstatedir the way configure normally
# would.  To change the prefix for everything but leave named.conf
# in /etc or named.pid in /var/run, then do this the usual configure way:
# ./configure --prefix=/somewhere --sysconfdir=/etc
# ./configure --prefix=/somewhere --localstatedir=/var
#
# To put named.conf and named.pid in /usr/local with everything else,
# set the prefix explicitly to /usr/local even though that's the default:
# ./configure --prefix=/usr/local
#
case "$prefix" in
	NONE)
		case "$sysconfdir" in
			'${prefix}/etc')
				sysconfdir=/etc
				;;
		esac
		case "$localstatedir" in
			'${prefix}/var')
				localstatedir=/var
				;;
		esac
		;;
esac
expanded_sysconfdir=`eval echo $sysconfdir`
AC_SUBST(expanded_sysconfdir)

#
# Make sure INSTALL uses an absolute path, else it will be wrong in all
# Makefiles, since they use make/rules.in and INSTALL will be adjusted by
# configure based on the location of the file where it is substituted.
# Since in BIND9 INSTALL is only substituted into make/rules.in, an immediate
# subdirectory of install-sh, This relative path will be wrong for all
# directories more than one level down from install-sh.
#
case "$INSTALL" in
	/*)
		;;
	*)
		#
		# Not all systems have dirname.
		#
		changequote({, })
		ac_dir="`echo $INSTALL | sed 's%/[^/]*$%%'`"
		changequote([, ])

		ac_prog="`echo $INSTALL | sed 's%.*/%%'`"
		test "X$ac_dir" = "X$ac_prog" && ac_dir=.
		test -d "$ac_dir" && ac_dir="`(cd \"$ac_dir\" && pwd)`"
		INSTALL="$ac_dir/$ac_prog"
		;;
esac

#
# On these hosts, we really want to use cc, not gcc, even if it is
# found.  The gcc that these systems have will not correctly handle
# pthreads.
#
# However, if the user sets $CC to be something, let that override
# our change.
#
if test "X$CC" = "X" ; then
	case "$host" in
		*-dec-osf*)
			CC="cc"
			;;
		*-solaris*)
			# Use Sun's cc if it is available, but watch
			# out for /usr/ucb/cc; it will never be the right
			# compiler to use.
			#
			# If setting CC here fails, the AC_PROG_CC done
			# below might still find gcc.
			IFS="${IFS=	}"; ac_save_ifs="$IFS"; IFS=":"
			for ac_dir in $PATH; do
				test -z "$ac_dir" && ac_dir=.
				case "$ac_dir" in
				/usr/ucb)
					# exclude
					;;
				*)
					if test -f "$ac_dir/cc"; then
						CC="$ac_dir/cc"
						break
					fi
					;;
				esac
			done
			IFS="$ac_save_ifs"
			;;
		*-hp-hpux*)
			CC="cc"
			;;
		mips-sgi-irix*)
			CC="cc"
			;;
	esac
fi

AC_PROG_CC

#
# gcc's optimiser is broken at -02 for ultrasparc
#
if test "$ac_env_CFLAGS_set" != set -a "X$GCC" = "Xyes"; then
	case "$host" in
	sparc-*)
		CCFLAGS="-g -O1"
		;;
	esac
fi

#
# OS dependent CC flags
#
case "$host" in
	# OSF 5.0: recv/send are only available with -D_POSIX_PII_SOCKET or
	# -D_XOPEN_SOURCE_EXTENDED.
	*-dec-osf*)
		STD_CDEFINES="$STD_CDEFINES -D_POSIX_PII_SOCKET"
		CPPFLAGS="$CPPFLAGS -D_POSIX_PII_SOCKET"
		;;
	#HP-UX: need -D_XOPEN_SOURCE_EXTENDED and -lxnet for CMSG macros
	*-hp-hpux*)
		STD_CDEFINES="$STD_CDEFINES -D_XOPEN_SOURCE_EXTENDED"
		CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE_EXTENDED"
		LIBS="-lxnet $LIBS"
		;;
	# Solaris: need -D_XPG4_2 and -D__EXTENSIONS__ for CMSG macros
	*-solaris*)
		STD_CDEFINES="$STD_CDEFINES -D_XPG4_2 -D__EXTENSIONS__"
		CPPFLAGS="$CPPFLAGS -D_XPG4_2 -D__EXTENSIONS__"
		;;
	# POSIX doesn't include the IPv6 Advanced Socket API and glibc hides
	# parts of the IPv6 Advanced Socket API as a result.  This is stupid
	# as it breaks how the two halves (Basic and Advanced) of the IPv6
	# Socket API were designed to be used but we have to live with it.
	# Define _GNU_SOURCE to pull in the IPv6 Advanced Socket API.
	*-linux* | *-kfreebsd*-gnu*)
		STD_CDEFINES="$STD_CDEFINES -D_GNU_SOURCE"
		CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
		;;
	#
	# Starting with OSX 10.7 (Lion) we must choose which IPv6 API to use.
	# Setting this is sufficient to select the correct behavior for BIND 9.
	#
	*-darwin*)
	  STD_CDEFINES="$STD_CDEFINES -D__APPLE_USE_RFC_3542"
	  CPPFLAGS="$CPPFLAGS -D__APPLE_USE_RFC_3542"
	  ;;
esac

#
# CCNOOPT defaults to -O0 on gcc and disables optimization when is last
#
if test "X$CCNOOPT" = "X" -a "X$GCC" = "Xyes"; then
	CCNOOPT="-O0"
fi

AC_HEADER_STDC

AC_CHECK_HEADERS(fcntl.h regex.h sys/time.h unistd.h sys/mman.h sys/sockio.h sys/select.h sys/param.h sys/sysctl.h net/if6.h sys/socket.h net/route.h linux/netlink.h linux/rtnetlink.h,,,
[$ac_includes_default
#ifdef HAVE_SYS_PARAM_H
# include <sys/param.h>
#endif
#ifdef HAVE_SYS_SOCKET_H
# include <sys/socket.h>
#endif
])

AC_C_CONST
AC_C_INLINE
AC_C_VOLATILE
AC_CHECK_FUNC(sysctlbyname, AC_DEFINE(HAVE_SYSCTLBYNAME))
AC_C_FLEXIBLE_ARRAY_MEMBER

#
# Check for the existence of mmap to enable the fast format zones
#
AC_CHECK_FUNCS(mmap)

#
# Older versions of HP/UX don't define seteuid() and setegid()
#
AC_CHECK_FUNCS(seteuid setresuid)
AC_CHECK_FUNCS(setegid setresgid)

# BSDI doesn't have ftello fseeko
AC_CHECK_FUNCS(ftello fseeko)

#
# UnixWare 7.1.1 with the feature supplement to the UDK compiler
# is reported to not support "static inline" (RT #1212).
#
AC_MSG_CHECKING(for static inline breakage)
AC_TRY_COMPILE([
	static inline int foo1() {
		return 0;
	}

	static inline int foo2() {
		return foo1();
	}
	], [foo1();],
	[AC_MSG_RESULT(no)],
	[AC_MSG_RESULT(yes)
	 AC_DEFINE(inline, ,[Define to empty if your compiler does not support "static inline".])])

AC_TYPE_SIZE_T
AC_CHECK_TYPE(ssize_t, int)
AC_CHECK_TYPE(uintptr_t,unsigned long)
AC_CHECK_TYPE(socklen_t,
[AC_DEFINE(ISC_SOCKADDR_LEN_T, socklen_t)],
[
AC_TRY_COMPILE(
[
#include <sys/types.h>
#include <sys/socket.h>
int getsockname(int, struct sockaddr *, size_t *);
],[],
[AC_DEFINE(ISC_SOCKADDR_LEN_T, size_t)],
[AC_DEFINE(ISC_SOCKADDR_LEN_T, int)])
],
[
#include <sys/types.h>
#include <sys/socket.h>
])
AC_SUBST(ISC_SOCKADDR_LEN_T)
AC_HEADER_TIME
AC_MSG_CHECKING(for long long)
AC_TRY_COMPILE([],[long long i = 0; return (0);],
	[AC_MSG_RESULT(yes)
		ISC_PLATFORM_HAVELONGLONG="#define ISC_PLATFORM_HAVELONGLONG 1"],
	[AC_MSG_RESULT(no)
		ISC_PLATFORM_HAVELONGLONG="#undef ISC_PLATFORM_HAVELONGLONG"])
AC_SUBST(ISC_PLATFORM_HAVELONGLONG)

#
# check for uname library routine
#
AC_MSG_CHECKING(for uname)
AC_TRY_COMPILE([
#include <sys/utsname.h>
#include <stdio.h>
],
[
struct utsname uts;
uname(&uts);
printf("running on %s %s %s for %s\n",
       uts.sysname, uts.release, uts.version, uts.machine);
],
	[AC_MSG_RESULT(yes)
	 AC_DEFINE(HAVE_UNAME)],
	[AC_MSG_RESULT(no)
	 AC_MSG_WARN([uname is not correctly supported])])

#
# check for GCC noreturn attribute
#
AC_MSG_CHECKING(for GCC noreturn attribute)
AC_TRY_COMPILE([],[void foo() __attribute__((noreturn));],
	[AC_MSG_RESULT(yes)
		ISC_PLATFORM_NORETURN_PRE="#define ISC_PLATFORM_NORETURN_PRE"
		ISC_PLATFORM_NORETURN_POST="#define ISC_PLATFORM_NORETURN_POST __attribute__((noreturn))"],
	[AC_MSG_RESULT(no)
		ISC_PLATFORM_NORETURN_PRE="#define ISC_PLATFORM_NORETURN_PRE"
		ISC_PLATFORM_NORETURN_POST="#define ISC_PLATFORM_NORETURN_POST"])
AC_SUBST(ISC_PLATFORM_NORETURN_PRE)
AC_SUBST(ISC_PLATFORM_NORETURN_POST)

#
# check if we have lifconf
#
AC_MSG_CHECKING(for struct lifconf)
AC_TRY_COMPILE([
#include <sys/types.h>
#include <sys/socket.h>
#include <net/if.h>
],
[
struct lifconf lifconf;
lifconf.lifc_len = 0;
]
,
	[AC_MSG_RESULT(yes)
		ISC_PLATFORM_HAVELIFCONF="#define ISC_PLATFORM_HAVELIFCONF 1"],
	[AC_MSG_RESULT(no)
		ISC_PLATFORM_HAVELIFCONF="#undef ISC_PLATFORM_HAVELIFCONF"])
AC_SUBST(ISC_PLATFORM_HAVELIFCONF)

#
# check if we have kqueue
#
AC_ARG_ENABLE(kqueue,
	      AS_HELP_STRING([--enable-kqueue],
			     [use BSD kqueue when available [default=yes]]),
	      want_kqueue="$enableval",  want_kqueue="yes")
case $want_kqueue in
yes)
	AC_CHECK_FUNC(kqueue, ac_cv_have_kqueue=yes, ac_cv_have_kqueue=no)
	case $ac_cv_have_kqueue in
	yes)
		ISC_PLATFORM_HAVEKQUEUE="#define ISC_PLATFORM_HAVEKQUEUE 1"
		;;
	*)
		ISC_PLATFORM_HAVEKQUEUE="#undef ISC_PLATFORM_HAVEKQUEUE"
		;;
	esac
	;;
*)
	ISC_PLATFORM_HAVEKQUEUE="#undef ISC_PLATFORM_HAVEKQUEUE"
	;;
esac
AC_SUBST(ISC_PLATFORM_HAVEKQUEUE)

#
# check if we have epoll.  Linux kernel 2.4 has epoll_create() which fails,
# so we need to try running the code, not just test its existence.
#
AC_ARG_ENABLE(epoll,
	      AS_HELP_STRING([--enable-epoll],
			     [use Linux epoll when available [default=auto]]),
	      want_epoll="$enableval",  want_epoll="auto")
case $want_epoll in
auto)
	AC_MSG_CHECKING(epoll support)
	AC_TRY_RUN([
#include <sys/epoll.h>
int main() {
	if (epoll_create(1) < 0)
		return (1);
	return (0);
}
],
	[AC_MSG_RESULT(yes)
	ISC_PLATFORM_HAVEEPOLL="#define ISC_PLATFORM_HAVEEPOLL 1"],
	[AC_MSG_RESULT(no)
	ISC_PLATFORM_HAVEEPOLL="#undef ISC_PLATFORM_HAVEEPOLL"],
	[AC_MSG_RESULT(no)
	ISC_PLATFORM_HAVEEPOLL="#undef ISC_PLATFORM_HAVEEPOLL"])
	;;
yes)
	ISC_PLATFORM_HAVEEPOLL="#define ISC_PLATFORM_HAVEEPOLL 1"
	;;
*)
	ISC_PLATFORM_HAVEEPOLL="#undef ISC_PLATFORM_HAVEEPOLL"
	;;
esac
AC_SUBST(ISC_PLATFORM_HAVEEPOLL)

#
# check if we support /dev/poll
#
AC_ARG_ENABLE(devpoll,
	      AS_HELP_STRING([--enable-devpoll],
			     [use /dev/poll when available [default=yes]]),
	      want_devpoll="$enableval",  want_devpoll="yes")
case $want_devpoll in
yes)
	AC_CHECK_HEADERS(sys/devpoll.h devpoll.h,
	ISC_PLATFORM_HAVEDEVPOLL="#define ISC_PLATFORM_HAVEDEVPOLL 1"
	,
	ISC_PLATFORM_HAVEDEVPOLL="#undef ISC_PLATFORM_HAVEDEVPOLL"
	)
	;;
*)
	ISC_PLATFORM_HAVEDEVPOLL="#undef ISC_PLATFORM_HAVEDEVPOLL"
	;;
esac
AC_SUBST(ISC_PLATFORM_HAVEDEVPOLL)

#
# check if we need to #include sys/select.h explicitly
#
case $ac_cv_header_unistd_h in
yes)
AC_MSG_CHECKING(if unistd.h or sys/types.h defines fd_set)
AC_TRY_COMPILE([
#include <sys/types.h> /* Ultrix */
#include <unistd.h>],
[fd_set read_set; return (0);],
	[AC_MSG_RESULT(yes)
	 ISC_PLATFORM_NEEDSYSSELECTH="#undef ISC_PLATFORM_NEEDSYSSELECTH"],
	[AC_MSG_RESULT(no)
	case $ac_cv_header_sys_select_h in
	yes)
	 ISC_PLATFORM_NEEDSYSSELECTH="#define ISC_PLATFORM_NEEDSYSSELECTH 1"
		;;
	no)
		AC_MSG_ERROR([need either working unistd.h or sys/select.h])
		;;
	esac
	])
	;;
no)
	case $ac_cv_header_sys_select_h in
	yes)
	     ISC_PLATFORM_NEEDSYSSELECTH="#define ISC_PLATFORM_NEEDSYSSELECTH 1"
		;;
	no)
		AC_MSG_ERROR([need either unistd.h or sys/select.h])
		;;
	esac
	;;
esac
AC_SUBST(ISC_PLATFORM_NEEDSYSSELECTH)

#
# Find the machine's endian flavor.
#
AC_C_BIGENDIAN

#
# GeoIP support?
#
GEOIPLINKSRCS=
GEOIPLINKOBJS=
AC_ARG_WITH(geoip,
	    AS_HELP_STRING([--with-geoip=PATH],
			   [Build with GeoIP support (yes|no|path)]),
    use_geoip="$withval", use_geoip="no")

if test "yes" = "$use_geoip"
then
	for d in /usr /usr/local /opt/local
	do
		if test -f $d/include/GeoIP.h
		then
			use_geoip=$d
			break
		fi
	done
fi

case "$use_geoip" in
	no|'')
		AC_MSG_CHECKING([for GeoIP support])
		AC_MSG_RESULT([disabled])
		;;
	*)
		if test -d "$use_geoip" -o -L "$use_geoip"
		then
			CFLAGS="$CFLAGS -I$use_geoip/include"
			CPPFLAGS="$CPPFLAGS -I$use_geoip/include"
			LIBS="$LIBS -L$use_geoip/lib"
			case "$host_os" in
				netbsd*|openbsd*|solaris*)
					LIBS="$LIBS -Wl,-rpath=$use_geoip/lib"
					;;
			esac
		elif test "yes" = "$use_geoip"
		then
			AC_MSG_ERROR([GeoIP path not found])
		else
			AC_MSG_ERROR([GeoIP path $use_geoip does not exist])
		fi
		AC_CHECK_HEADER(GeoIP.h, [],
			[AC_MSG_ERROR([GeoIP header file not found])]
		)
		AC_SEARCH_LIBS(GeoIP_id_by_addr_gl, GeoIP, [],
			[AC_MSG_ERROR([suitable GeoIP library not found])]
		)
		AC_SEARCH_LIBS(fabsf, m, [],
			[AC_MSG_ERROR([Math library not found])]
		)
		AC_DEFINE(HAVE_GEOIP, 1, Build with GeoIP support)
		GEOIPLINKSRCS='${GEOIPLINKSRCS}'
		GEOIPLINKOBJS='${GEOIPLINKOBJS}'
		AC_MSG_CHECKING([for GeoIP support])
		AC_MSG_RESULT([yes])

		AC_MSG_CHECKING([for GeoIP Country IPv6 support])
		AC_COMPILE_IFELSE(
			[AC_LANG_PROGRAM([
				#include <GeoIP.h>
				#include <netinet/in.h>
			], [
				struct in6_addr in6;
				GeoIP_country_name_by_ipnum_v6(NULL, in6);
			])],
			[
				AC_MSG_RESULT([yes])
				AC_DEFINE(HAVE_GEOIP_V6, 1, Build with GeoIP Country IPv6 support)
			],
			[AC_MSG_RESULT([no])]
		)

		AC_MSG_CHECKING([for GeoIP City IPv6 support])
		AC_COMPILE_IFELSE(
			[AC_LANG_PROGRAM([
				#include <GeoIP.h>
				#include <GeoIPCity.h>
				#include <netinet/in.h>
			], [
				struct in6_addr in6;
				int i = GEOIP_CITY_EDITION_REV0_V6;
				GeoIP_record_by_ipnum_v6(NULL, in6);
			])],
			[
				AC_MSG_RESULT([yes])
				AC_DEFINE(HAVE_GEOIP_CITY_V6, 1, Build with GeoIP City IPv6 support)
			],
			[AC_MSG_RESULT([no])]
		)
		;;
esac
AC_SUBST(GEOIPLINKSRCS)
AC_SUBST(GEOIPLINKOBJS)

AC_MSG_CHECKING(for GSSAPI library)
AC_ARG_WITH(gssapi,
	    AS_HELP_STRING([--with-gssapi=[PATH|[/path/]krb5-config]],
			   [Specify path for system-supplied GSSAPI
				[default=yes]]),
	    use_gssapi="$withval", use_gssapi="yes")

# first try using krb5-config, if that does not work then fall back to "yes" method.

case "$use_gssapi" in
*/krb5-config|krb5-config)
    AC_MSG_RESULT(trying $use_gssapi)
    if test krb5-config = "$use_gssapi"
    then
	AC_PATH_PROG(KRB5_CONFIG, $use_gssapi)
    else
	KRB5_CONFIG="$use_gssapi"
    fi
    gssapi_cflags=`$KRB5_CONFIG --cflags gssapi`
    gssapi_libs=`$KRB5_CONFIG --libs gssapi`
    saved_cppflags="$CPPFLAGS"
    CPPFLAGS="$gssapi_cflags $CPPFLAGS"
    AC_CHECK_HEADERS(gssapi.h gssapi/gssapi.h,
	[ISC_PLATFORM_GSSAPIHEADER="#define ISC_PLATFORM_GSSAPIHEADER <$ac_header>"])
    if test "" = "$ISC_PLATFORM_GSSAPIHEADER"; then
	AC_MSG_RESULT([krb5-config: gssapi.h not found])
	CPPFLAGS="$saved_cppflags"
	use_gssapi="yes"
    else
	AC_CHECK_HEADERS(krb5/krb5.h krb5.h,
	    [ISC_PLATFORM_KRB5HEADER="#define ISC_PLATFORM_KRB5HEADER <$ac_header>"])
	if test "" = "$ISC_PLATFORM_KRB5HEADER"; then
	    AC_MSG_RESULT([krb5-config: krb5.h not found])
	    CPPFLAGS="$saved_cppflags"
	    use_gssapi="yes"
	else
	    CPPFLAGS="$saved_cppflags"
	    saved_libs="$LIBS"
	    LIBS=$gssapi_libs
	    AC_MSG_CHECKING([krb5-config linking as $LIBS])
	    AC_TRY_LINK( , [gss_acquire_cred();krb5_init_context()],
		gssapi_linked=yes, gssapi_linked=no)
	    case $gssapi_linked in
		yes) AC_MSG_RESULT([krb5-config: linked]);;
		no)  AC_MSG_RESULT([krb5-config: could not determine proper GSSAPI linkage])
		    use_gssapi="yes"
		    ;;
	    esac
	    LIBS=$saved_libs
	fi
    fi
    if test "yes" = "$use_gssapi"; then
	AC_MSG_CHECKING([for GSSAPI library, non krb5-config method])
    fi
    ;;
esac

case "$host" in
*darwin*)
	if test "yes" = "$use_gssapi"
	then
		use_gssapi=framework
	fi
	;;
esac

# gssapi is just the framework, we really require kerberos v5, so
# look for those headers (the gssapi headers must be there, too)
# The problem with this implementation is that it doesn't allow
# for the specification of gssapi and krb5 headers in different locations,
# which probably ought to be fixed although fixing might raise the issue of
# trying to build with incompatible versions of gssapi and krb5.
if test "yes" = "$use_gssapi"
then
	# first, deal with the obvious
	if test \( -f /usr/include/kerberosv5/krb5.h -o \
		   -f /usr/include/krb5/krb5.h -o \
		   -f /usr/include/krb5.h \)   -a \
		\( -f /usr/include/gssapi.h -o \
		   -f /usr/include/gssapi/gssapi.h \)
	then
		use_gssapi=/usr
	else
	    krb5dirs="/usr/local /usr/local/krb5 /usr/local/kerberosv5 /usr/local/kerberos /usr/pkg /usr/krb5 /usr/kerberosv5 /usr/kerberos /usr"
	    for d in $krb5dirs
	    do
		if test -f $d/include/gssapi/gssapi_krb5.h -o \
			-f $d/include/krb5.h
		then
			if test -f $d/include/gssapi/gssapi.h -o \
				-f $d/include/gssapi.h
			then
				use_gssapi=$d
				break
			fi
		fi
		use_gssapi="no"
	    done
	fi
fi

case "$use_gssapi" in
	no)
		AC_MSG_RESULT(disabled)
		USE_GSSAPI=''
		;;
	yes)
		AC_MSG_ERROR([--with-gssapi must specify a path])
		;;
	*/krb5-config|krb5-config)
		USE_GSSAPI='-DGSSAPI'
		DST_GSSAPI_INC="$gssapi_cflags"
		DNS_GSSAPI_LIBS="$gssapi_libs"
		;;
	framework)
		USE_GSSAPI='-DGSSAPI'
		ISC_PLATFORM_GSSAPIHEADER="#define ISC_PLATFORM_GSSAPIHEADER <Kerberos/Kerberos.h>"
		ISC_PLATFORM_KRB5HEADER="#define ISC_PLATFORM_KRB5HEADER <Kerberos/Kerberos.h>"
		DNS_GSSAPI_LIBS="-framework Kerberos"
		AC_MSG_RESULT(framework)
		;;
		
	*)
		AC_MSG_RESULT(looking in $use_gssapi/lib)
		USE_GSSAPI='-DGSSAPI'
		saved_cppflags="$CPPFLAGS"
		CPPFLAGS="-I$use_gssapi/include $CPPFLAGS"
		AC_CHECK_HEADERS(gssapi.h gssapi/gssapi.h,
		    [ISC_PLATFORM_GSSAPIHEADER="#define ISC_PLATFORM_GSSAPIHEADER <$ac_header>"
		     gssapi_hack="#include <$ac_header>"])

		if test "" = "$ISC_PLATFORM_GSSAPIHEADER"; then
		    AC_MSG_ERROR([gssapi.h not found])
		fi

		AC_CHECK_HEADERS(gssapi_krb5.h gssapi/gssapi_krb5.h,
		    [ISC_PLATFORM_GSSAPI_KRB5_HEADER="#define ISC_PLATFORM_GSSAPI_KRB5_HEADER <$ac_header>"
		     gssapi_krb5_hack="#include <$ac_header>"])

		AC_CHECK_HEADERS(krb5.h krb5/krb5.h kerberosv5/krb5.h,
		    [ISC_PLATFORM_KRB5HEADER="#define ISC_PLATFORM_KRB5HEADER <$ac_header>"
		    krb5_hack="#include <$ac_header>"])

		if test "" = "$ISC_PLATFORM_KRB5HEADER"; then
		    AC_MSG_ERROR([krb5.h not found])
		fi

		#
		# XXXDCL This probably doesn't work right on all systems.
		# It will need to be worked on as problems become evident.
		#
		# Essentially the problems here relate to two different
		# areas.  The first area is building with either KTH
		# or MIT Kerberos, particularly when both are present on
		# the machine.  The other is static versus dynamic linking.
		#
		# On the KTH vs MIT issue, Both have libkrb5 that can mess
		# up the works if one implementation ends up trying to
		# use the other's krb.  This is unfortunately a situation
		# that very easily arises.
		#
		# Dynamic linking when the dependency information is built
		# into MIT's libgssapi_krb5 or KTH's libgssapi magically makes
		# all such problems go away, but when that setup is not
		# present, because either the dynamic libraries lack
		# dependencies or static linking is being done, then the
		# problems start to show up.
		saved_libs="$LIBS"
		for TRY_LIBS in \
		    "-lgssapi_krb5" \
		    "-lgssapi_krb5 -lkrb5 -lk5crypto -lcom_err" \
		    "-lgssapi_krb5 -lkrb5 -lk5crypto -lcom_err -lresolv" \
		    "-lgssapi" \
		    "-lgssapi -lkrb5 -ldes -lcrypt -lasn1 -lroken -lcom_err" \
		    "-lgssapi -lkrb5 -lcrypt -lasn1 -lroken -lcom_err" \
		    "-lgssapi -lkrb5 -lgssapi_krb5 -lcrypt -lasn1 -lroken -lcom_err" \
		    "-lgssapi -lkrb5 -lhx509 -lcrypt -lasn1 -lroken -lcom_err" \
		    "-lgss -lkrb5"
		do
		    # Note that this does not include $saved_libs, because
		    # on FreeBSD machines this configure script has added
		    # -L/usr/local/lib to LIBS, which can make the
		    # -lgssapi_krb5 test succeed with shared libraries even
		    # when you are trying to build with KTH in /usr/lib.
		    if test "/usr" = "$use_gssapi"
		    then
			    LIBS="$TRY_LIBS $ISC_OPENSSL_LIBS"
		    else
			    LIBS="-L$use_gssapi/lib $TRY_LIBS $ISC_OPENSSL_LIBS"
		    fi
		    AC_MSG_CHECKING(linking as $TRY_LIBS)
		    AC_TRY_LINK([
#include <sys/types.h>
$gssapi_hack
$gssapi_krb5_hack
$krb5_hack
				] , [gss_acquire_cred(NULL, NULL, 0, NULL, 0, NULL, NULL, NULL);krb5_init_context(NULL);
#if defined(HAVE_GSSAPI_KRB5_H) || defined(HAVE_GSSAPI_GSSAPI_KRB5_H)
gsskrb5_register_acceptor_identity(NULL);
#endif],
				gssapi_linked=yes, gssapi_linked=no)
		    case $gssapi_linked in
		    yes) AC_MSG_RESULT(yes); break ;;
		    no)  AC_MSG_RESULT(no) ;;
		    esac
		done

		CPPFLAGS="$saved_cppflags"

		case $gssapi_linked in
		no) AC_MSG_ERROR(could not determine proper GSSAPI linkage) ;;
		esac

		#
		# XXXDCL Major kludge.  Tries to cope with KTH in /usr/lib
		# but MIT in /usr/local/lib and trying to build with KTH.
		# /usr/local/lib can end up earlier on the link lines.
		# Like most kludges, this one is not only inelegant it
		# is also likely to be the wrong thing to do at least as
		# many times as it is the right thing.  Something better
		# needs to be done.
		#
		if test "/usr" = "$use_gssapi" -a \
			-f /usr/local/lib/libkrb5.a; then
		    FIX_KTH_VS_MIT=yes
		fi

		case "$FIX_KTH_VS_MIT" in
		yes)
		    case "$enable_static_linking" in
		    yes) gssapi_lib_suffix=".a"  ;;
		    *)   gssapi_lib_suffix=".so" ;;
		    esac

		    for lib in $LIBS; do
			case $lib in
			-L*)
			    ;;
			-l*)
			    new_lib=`echo $lib |
				     sed -e s%^-l%$use_gssapi/lib/lib% \
					 -e s%$%$gssapi_lib_suffix%`
			    NEW_LIBS="$NEW_LIBS $new_lib"
			    ;;
			*)
			   AC_MSG_ERROR([KTH vs MIT Kerberos confusion!])
			    ;;
			esac
		    done
		    LIBS="$NEW_LIBS"
		    ;;
		esac

		DST_GSSAPI_INC="-I$use_gssapi/include"
		DNS_GSSAPI_LIBS="$LIBS"

		AC_MSG_RESULT(using GSSAPI from $use_gssapi/lib and $use_gssapi/include)
		LIBS="$saved_libs"
		;;
esac

AC_SUBST(ISC_PLATFORM_HAVEGSSAPI)
AC_SUBST(ISC_PLATFORM_GSSAPIHEADER)
AC_SUBST(ISC_PLATFORM_GSSAPI_KRB5_HEADER)
AC_SUBST(ISC_PLATFORM_KRB5HEADER)

AC_SUBST(USE_GSSAPI)
AC_SUBST(DST_GSSAPI_INC)
AC_SUBST(DNS_GSSAPI_LIBS)
DNS_CRYPTO_LIBS="$DNS_GSSAPI_LIBS"

#
# Applications linking with libdns also need to link with these libraries.
#

AC_SUBST(DNS_CRYPTO_LIBS)

#
# was --with-randomdev specified?
#
AC_MSG_CHECKING(for random device)
AC_ARG_WITH(randomdev,
	    AS_HELP_STRING([--with-randomdev=PATH],
			   [Specify path for random device]),
	    use_randomdev="$withval", use_randomdev="unspec")

case "$use_randomdev" in
	unspec)
		case "$cross_compiling" in
		yes)
			AC_MSG_RESULT(unspecified)
			AC_MSG_ERROR([ need --with-randomdev=PATH or --with-randomdev=no])
		esac
		case "$host" in
			*-openbsd*)
				devrandom=/dev/arandom
				;;
			*)
				devrandom=/dev/random
				;;
		esac
		AC_MSG_RESULT($devrandom)
		AC_CHECK_FILE($devrandom,
			      AC_DEFINE_UNQUOTED(PATH_RANDOMDEV,
						 "$devrandom"),)
			      
		;;
	yes)
		AC_MSG_ERROR([--with-randomdev must specify a path])
		;;
	no)
		AC_MSG_RESULT(disabled)
		;;
	*)
		AC_DEFINE_UNQUOTED(PATH_RANDOMDEV, "$use_randomdev")
		AC_MSG_RESULT(using "$use_randomdev")
		;;
esac

#
# Only check dsa signature generation on these platforms when performing
# system tests.
#
CHECK_DSA=0
if grep "#define PATH_RANDOMDEV " confdefs.h > /dev/null
then
	case "$host" in
	*darwin*|*freebsd*)
		CHECK_DSA=1
		;;
	esac
fi
AC_SUBST(CHECK_DSA)

#
# Do we have arc4random(), etc ?
# Will use stir and if not exist addrandom
#
AC_CHECK_FUNCS(arc4random)
AC_CHECK_FUNCS(arc4random_stir)
AC_CHECK_FUNCS(arc4random_addrandom)

sinclude(config.threads.in)dnl

if $use_threads
then
	if test "X$GCC" = "Xyes"; then
		case "$host" in
		*-freebsd*)
			CC="$CC -pthread"
			CCOPT="$CCOPT -pthread"
			CCNOOPT="$CCNOOPT -pthread"
			STD_CDEFINES="$STD_CDEFINES -D_THREAD_SAFE"
			;;
		*-openbsd*)
			CC="$CC -pthread"
			CCOPT="$CCOPT -pthread"
			CCNOOPT="$CCNOOPT -pthread"
			;;
		*-solaris*)
			LIBS="$LIBS -lthread"
			;;
		*-ibm-aix*)
			STD_CDEFINES="$STD_CDEFINES -D_THREAD_SAFE"
			;;
		esac
	else
		case $host in
		*-dec-osf*)
			CC="$CC -pthread"
			CCOPT="$CCOPT -pthread"
			CCNOOPT="$CCNOOPT -pthread"
			;;
		*-solaris*)
			CC="$CC -mt"
			CCOPT="$CCOPT -mt"
			CCNOOPT="$CCNOOPT -mt"
			;;
		*-ibm-aix*)
			STD_CDEFINES="$STD_CDEFINES -D_THREAD_SAFE"
			;;
		*-sco-sysv*uw*|*-*-sysv*UnixWare*)
			CC="$CC -Kthread"
			CCOPT="$CCOPT -Kthread"
			CCNOOPT="$CCNOOPT -Kthread"
			;;
		*-*-sysv*OpenUNIX*)
			CC="$CC -Kpthread"
			CCOPT="$CCOPT -Kpthread"
			CCNOOPT="$CCNOOPT -Kpthread"
			;;
		esac
	fi
	ALWAYS_DEFINES="-D_REENTRANT"
	ISC_PLATFORM_USETHREADS="#define ISC_PLATFORM_USETHREADS 1"
	THREADOPTOBJS='${THREADOPTOBJS}'
	THREADOPTSRCS='${THREADOPTSRCS}'
	thread_dir=pthreads
	#
	# We'd like to use sigwait() too
	#
	AC_CHECK_FUNC(sigwait,
		      AC_DEFINE(HAVE_SIGWAIT),
		      AC_CHECK_LIB(c, sigwait,
		      AC_DEFINE(HAVE_SIGWAIT),
		      AC_CHECK_LIB(pthread, sigwait,
				   AC_DEFINE(HAVE_SIGWAIT),
				   AC_CHECK_LIB(pthread, _Psigwait,
						AC_DEFINE(HAVE_SIGWAIT),))))

	AC_CHECK_FUNC(pthread_attr_getstacksize,
		      AC_DEFINE(HAVE_PTHREAD_ATTR_GETSTACKSIZE),)

	AC_CHECK_FUNC(pthread_attr_setstacksize,
		      AC_DEFINE(HAVE_PTHREAD_ATTR_SETSTACKSIZE),)

	AC_ARG_WITH(locktype,
		    AS_HELP_STRING([--with-locktype=ARG],
				   [Specify mutex lock type
					(adaptive or standard)]),
		    locktype="$withval", locktype="adaptive")

	case "$locktype" in
		adaptive)
			AC_MSG_CHECKING([for PTHREAD_MUTEX_ADAPTIVE_NP])

			AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
			  #ifndef _GNU_SOURCE
			  #define _GNU_SOURCE
			  #endif
			  #include <pthread.h>
			]], [[
			  return (PTHREAD_MUTEX_ADAPTIVE_NP);
			]])],
			[ AC_MSG_RESULT(using adaptive lock type)
			  AC_DEFINE([HAVE_PTHREAD_MUTEX_ADAPTIVE_NP], 1,
				    [Support for PTHREAD_MUTEX_ADAPTIVE_NP]) ],
			[ AC_MSG_RESULT(using standard lock type) ])
			;;
		standard)
			AC_MSG_RESULT(using standard lock type)
			;;
		*)
			AC_MSG_ERROR([You must specify "adaptive" or "standard" for --with-locktype.])
			;;
	esac

	AC_CHECK_HEADERS(sched.h)

	case "$host" in
	*solaris-*)
		AC_CHECK_LIB(rt, sched_yield)
		;;
	esac

	AC_CHECK_FUNCS(sched_yield pthread_yield pthread_yield_np)

	#
	# Additional OS-specific issues related to pthreads and sigwait.
	#
	case "$host" in
		#
		# One more place to look for sigwait.
		#
		*-freebsd*)
			AC_CHECK_LIB(c_r, sigwait, AC_DEFINE(HAVE_SIGWAIT),)
			case $host in
			*-freebsd5.[[012]]|*-freebsd5.[[012]].*);;
			*-freebsd5.[[3456789]]|*-freebsd5.[[3456789]].*)
				AC_DEFINE(NEED_PTHREAD_SCOPE_SYSTEM)
				;;
			*-freebsd6.*)
				AC_DEFINE(NEED_PTHREAD_SCOPE_SYSTEM)
				;;
			esac
			;;
		#
		# BSDI 3.0 through 4.0.1 needs pthread_init() to be
		# called before certain pthreads calls.	 This is deprecated
		# in BSD/OS 4.1.
		#
		*-bsdi3.*|*-bsdi4.0*)
			AC_DEFINE(NEED_PTHREAD_INIT)
			;;
		#
		# LinuxThreads requires some changes to the way we
		# deal with signals.
		#
		*-linux*)
			AC_DEFINE(HAVE_LINUXTHREADS)
			;;
		#
		# Ensure the right sigwait() semantics on Solaris and make
		# sure we call pthread_setconcurrency.
		#
		*-solaris*)
			AC_DEFINE(_POSIX_PTHREAD_SEMANTICS)
			AC_CHECK_FUNC(pthread_setconcurrency,
				      AC_DEFINE(CALL_PTHREAD_SETCONCURRENCY))
			;;
		#
		# UnixWare does things its own way.
		#
		*-sco-sysv*uw*|*-*-sysv*UnixWare*|*-*-sysv*OpenUNIX*)
			AC_DEFINE(HAVE_UNIXWARE_SIGWAIT)
			;;
	esac

	# Look for functions relating to thread naming
	AC_CHECK_FUNCS(pthread_setname_np pthread_set_name_np)
	AC_CHECK_HEADERS([pthread_np.h], [], [], [#include <pthread.h>])

	#
	# Look for sysconf to allow detection of the number of processors.
	#
	AC_CHECK_FUNC(sysconf, AC_DEFINE(HAVE_SYSCONF),)

else
	ISC_PLATFORM_USETHREADS="#undef ISC_PLATFORM_USETHREADS"
	thread_dir=nothreads
	THREADOPTOBJS=""
	THREADOPTSRCS=""
	ALWAYS_DEFINES=""
fi

AC_SUBST(ALWAYS_DEFINES)
AC_SUBST(ISC_PLATFORM_USETHREADS)
AC_SUBST(THREADOPTOBJS)
AC_SUBST(THREADOPTSRCS)
ISC_THREAD_DIR=$thread_dir
AC_SUBST(ISC_THREAD_DIR)

AC_MSG_CHECKING(for libtool)
AC_ARG_WITH(libtool, AS_HELP_STRING([--with-libtool], [use GNU libtool]),
	    use_libtool="$withval", use_libtool="no")

case $use_libtool in
	yes)
		AC_MSG_RESULT(yes)
		AM_PROG_LIBTOOL
		O=lo
		A=la
		LIBTOOL_MKDEP_SED='s;\.o;\.lo;'
		LIBTOOL_MODE_COMPILE='--mode=compile --tag=CC'
		LIBTOOL_MODE_INSTALL='--mode=install --tag=CC'
		LIBTOOL_MODE_LINK='--mode=link --tag=CC'
		LIBTOOL_MODE_UNINSTALL='--mode=uninstall --tag=CC'
		INSTALL_LIBRARY='${INSTALL_PROGRAM}'
		case "$host" in
		*) LIBTOOL_ALLOW_UNDEFINED= ;;
		esac
		case "$host" in
		*-ibm-aix*) LIBTOOL_IN_MAIN="-Wl,-bI:T_testlist.imp" ;;
		*) LIBTOOL_IN_MAIN= ;;
		esac;
		;;
	*)
		AC_MSG_RESULT(no)
		O=o
		A=a
		LIBTOOL=
		AC_SUBST(LIBTOOL)
		LIBTOOL_MKDEP_SED=
		LIBTOOL_MODE_COMPILE=
		LIBTOOL_MODE_INSTALL=
		LIBTOOL_MODE_LINK=
		LIBTOOL_MODE_UNINSTALL=
		LIBTOOL_ALLOW_UNDEFINED=
		LIBTOOL_IN_MAIN=
		INSTALL_LIBRARY='${INSTALL_DATA}'
		;;
esac
AC_SUBST(INSTALL_LIBRARY)

#
# was --enable-native-pkcs11 specified?
#  (note it implies both --without-openssl and --with-pkcs11)
#
AC_ARG_ENABLE(native-pkcs11,
	      AS_HELP_STRING([--enable-native-pkcs11],
			     [use native PKCS11 for all crypto [default=no]]),
	      want_native_pkcs11="$enableval", want_native_pkcs11="no")

#
# was --with-openssl specified?
#
AC_ARG_WITH(openssl,
	    AS_HELP_STRING([--with-openssl[=PATH]],
			   [Build with OpenSSL [yes|no|path].
				(Crypto is required for DNSSEC)]),
	    use_openssl="$withval", use_openssl="auto")

#
# was --with-pkcs11 specified?
#
AC_ARG_WITH(pkcs11,
	    AS_HELP_STRING([--with-pkcs11[=PATH]],
			   [Build with PKCS11 support [yes|no|path]
				(PATH is for the PKCS11 provider)]),
	    use_pkcs11="$withval", use_pkcs11="auto")

#
# were --with-ecdsa, --with-gost, --with-eddsa, --with-aes specified
#
AC_ARG_WITH(ecdsa, AS_HELP_STRING([--with-ecdsa], [Crypto ECDSA]),
	    with_ecdsa="$withval", with_ecdsa="auto")
AC_ARG_WITH(gost,
	    AS_HELP_STRING([--with-gost], [Crypto GOST [yes|no|raw|asn1].]),
	    with_gost="$withval", with_gost="auto")
AC_ARG_WITH(eddsa, AS_HELP_STRING([--with-eddsa], [Crypto EDDSA [yes|all|no].]),
	    with_eddsa="$withval", with_eddsa="auto")
AC_ARG_WITH(aes, AS_HELP_STRING([--with-aes], [Crypto AES]),
	    with_aes="$withval", with_aes="checkcc")

#
# Client Cookie algorithm choice
#
AC_ARG_WITH(cc-alg,
	    AS_HELP_STRING([--with-cc-alg=ALG],
			   [choose the algorithm for Client Cookie
				[aes|sha1|sha256]]),
	with_cc_alg="$withval", with_cc_alg="auto")

case $with_cc_alg in
	*1)
		with_cc_alg="sha1"
		;;
	*2*)
		with_cc_alg="sha256"
		;;
	auto)
		if test "no" != "$with_aes"
		then
			with_aes="yes"
		fi
		;;
	*)
		with_cc_alg="aes"
		if test "no" != "$with_aes"
		then
			with_aes="yes"
		fi
		;;
esac
if test "checkcc" = "with_aes"
then
	with_aes="no"
fi

AC_MSG_CHECKING(for OpenSSL library)
OPENSSL_WARNING=
openssldirs="/usr /usr/local /usr/local/ssl /usr/pkg /usr/sfw"
if test "yes" = "$want_native_pkcs11"
then
	use_openssl="native_pkcs11"
	AC_MSG_RESULT(use of native PKCS11 instead)
fi

if test "auto" = "$use_openssl"
then
	for d in $openssldirs
	do
		if test -f $d/include/openssl/opensslv.h
		then
			use_openssl=$d
			break
		fi
	done
fi
OPENSSL_ECDSA=""
OPENSSL_GOST=""
OPENSSL_ED25519=""
gosttype="raw"
case "$with_gost" in
	raw)
		with_gost="yes"
		;;
	asn1)
		AC_DEFINE(PREFER_GOSTASN1, 1,
			  [Define if GOST private keys are encoded in ASN.1.])
		gosttype="asn1"
		with_gost="yes"
		;;
	auto|yes|no)
		;;
	*)
		AC_MSG_ERROR(unknown GOST private key encoding)
		;;
esac

case "$use_openssl" in
	native_pkcs11)
		AC_MSG_RESULT(disabled because of native PKCS11)
		DST_OPENSSL_INC=""
		CRYPTO="-DPKCS11CRYPTO"
		CRYPTOLIB="pkcs11"
		OPENSSLECDSALINKOBJS=""
		OPENSSLECDSALINKSRCS=""
		OPENSSLEDDSALINKOBJS=""
		OPENSSLEDDSALINKSRCS=""
		OPENSSLGOSTLINKOBJS=""
		OPENSSLGOSTLINKSRCS=""
		OPENSSLLINKOBJS=""
		OPENSSLLINKSRCS=""
		;;
	no)
		AC_MSG_RESULT(no)
		DST_OPENSSL_INC=""
		CRYPTO=""
		CRYPTOLIB=""
		OPENSSLECDSALINKOBJS=""
		OPENSSLECDSALINKSRCS=""
		OPENSSLEDDSALINKOBJS=""
		OPENSSLEDDSALINKSRCS=""
		OPENSSLGOSTLINKOBJS=""
		OPENSSLGOSTLINKSRCS=""
		OPENSSLLINKOBJS=""
		OPENSSLLINKSRCS=""
		;;
	auto)
		DST_OPENSSL_INC=""
		CRYPTO=""
		CRYPTOLIB=""
		OPENSSLECDSALINKOBJS=""
		OPENSSLECDSALINKSRCS=""
		OPENSSLEDDSALINKOBJS=""
		OPENSSLEDDSALINKSRCS=""
		OPENSSLGOSTLINKOBJS=""
		OPENSSLGOSTLINKSRCS=""
		OPENSSLLINKOBJS=""
		OPENSSLLINKSRCS=""
		AC_MSG_ERROR(
[OpenSSL was not found in any of $openssldirs; use --with-openssl=/path
If you do not want OpenSSL, use --without-openssl])
		;;
	*)
		if test "yes" = "$want_native_pkcs11"
		then
			AC_MSG_RESULT()
			AC_MSG_ERROR([OpenSSL and native PKCS11 cannot be used together.])
		fi
		if test "yes" = "$use_openssl"
		then
			# User did not specify a path - guess it
			for d in $openssldirs
			do
				if test -f $d/include/openssl/opensslv.h
				then
					use_openssl=$d
					break
				fi
			done
			if test "yes" = "$use_openssl"
			then
				AC_MSG_RESULT(not found)
				AC_MSG_ERROR(
[OpenSSL was not found in any of $openssldirs; use --with-openssl=/path])
			fi
		elif ! test -f "$use_openssl"/include/openssl/opensslv.h
		then
			AC_MSG_ERROR(["$use_openssl/include/openssl/opensslv.h" not found])
		fi
		CRYPTO='-DOPENSSL'
		CRYPTOLIB="openssl"
		if test "/usr" = "$use_openssl"
		then
			DST_OPENSSL_INC=""
			DST_OPENSSL_LIBS="-lcrypto"
		else
			DST_OPENSSL_INC="-I$use_openssl/include"
			case $host in
			*-solaris*)
				DST_OPENSSL_LIBS="-L$use_openssl/lib -R$use_openssl/lib -lcrypto"
				;;
			*-hp-hpux*)
				DST_OPENSSL_LIBS="-L$use_openssl/lib -Wl,+b: -lcrypto"
				;;
			*-apple-darwin*)
				#
				# Apple's ld seaches for serially for dynamic
				# then static libraries.  This means you can't
				# use -L to override dynamic system libraries
				# with static ones when linking.  Instead
				# we specify a absolute path.
				#
				if test -f "$use_openssl/lib/libcrypto.dylib"
				then
					DST_OPENSSL_LIBS="-L$use_openssl/lib -lcrypto"
				else
					DST_OPENSSL_LIBS="$use_openssl/lib/libcrypto.a"
				fi
				;;
			*)
				DST_OPENSSL_LIBS="-L$use_openssl/lib -lcrypto"
				;;
			esac
		fi
		AC_MSG_RESULT(using OpenSSL from $use_openssl/lib and $use_openssl/include)

		saved_cc="$CC"
		saved_cflags="$CFLAGS"
		saved_libs="$LIBS"
		CFLAGS="$DST_OPENSSL_INC $CFLAGS"
		LIBS="$DST_OPENSSL_LIBS $LIBS"
		AC_MSG_CHECKING(whether linking with OpenSSL works)
		AC_TRY_RUN([
#include <openssl/err.h>
int main() {
	ERR_clear_error();
	return (0);
}
],
		[AC_MSG_RESULT(yes)],
		[AC_MSG_RESULT(no)
		 AC_MSG_ERROR(Could not run test program using OpenSSL from
$use_openssl/lib and $use_openssl/include.
Please check the argument to --with-openssl and your
shared library configuration (e.g., LD_LIBRARY_PATH).)],
		[AC_MSG_RESULT(assuming it does work on target platform)])

		AC_MSG_CHECKING(whether linking with OpenSSL requires -ldl)
		AC_TRY_LINK([
#include <openssl/opensslv.h>
#if !defined(LIBRESSL_VERSION_NUMBER) && (OPENSSL_VERSION_NUMBER >= 0x10100004L)
#include <openssl/crypto.h>
#else
#include <openssl/err.h>
#include <openssl/dso.h>
#endif
],
[
#if !defined(LIBRESSL_VERSION_NUMBER) && (OPENSSL_VERSION_NUMBER >= 0x10100004L)
OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_ALL_BUILTIN, NULL);
#else
DSO_METHOD_dlfcn();
#endif
],
		[AC_MSG_RESULT(no)],
		[LIBS="$LIBS -ldl"
		AC_TRY_LINK([
#if !defined(LIBRESSL_VERSION_NUMBER) && (OPENSSL_VERSION_NUMBER >= 0x10100004L)
#include <openssl/crypto.h>
#else
#include <openssl/err.h>
#include <openssl/dso.h>
#endif
],
[
#if !defined(LIBRESSL_VERSION_NUMBER) && (OPENSSL_VERSION_NUMBER >= 0x10100004L)
OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_ALL_BUILTIN, NULL);
#else
DSO_METHOD_dlfcn();
#endif
],
		[AC_MSG_RESULT(yes)
		DST_OPENSSL_LIBS="$DST_OPENSSL_LIBS -ldl"
		],
		 [AC_MSG_RESULT(unknown)
		 AC_MSG_ERROR(OpenSSL has unsupported dynamic loading)],
		[AC_MSG_RESULT(assuming it does work on target platform)])
		],
		[AC_MSG_RESULT(assuming it does work on target platform)]
		)
		 
AC_ARG_ENABLE(openssl-version-check,
	      [AS_HELP_STRING([--enable-openssl-version-check],
			      [check OpenSSL version @<:@default=yes@:>@])])
case "$enable_openssl_version_check" in
yes|'')
		AC_MSG_CHECKING(OpenSSL library version)
		AC_TRY_RUN([
#include <stdio.h>
#include <openssl/opensslv.h>
int main() {
	if ((OPENSSL_VERSION_NUMBER >= 0x009070cfL &&
	     OPENSSL_VERSION_NUMBER < 0x00908000L) ||
	     (OPENSSL_VERSION_NUMBER >= 0x0090804fL &&
	     OPENSSL_VERSION_NUMBER < 0x10002000L) ||
	     OPENSSL_VERSION_NUMBER >= 0x1000205fL)
		return (0);
	printf("\n\nFound   OPENSSL_VERSION_NUMBER %#010lx\n",
		OPENSSL_VERSION_NUMBER);
	printf("Require OPENSSL_VERSION_NUMBER 0x009070cf or greater (0.9.7l)\n"
	       "Require OPENSSL_VERSION_NUMBER 0x0090804f or greater (0.9.8d)\n"
	       "Require OPENSSL_VERSION_NUMBER 0x1000000f or greater (1.0.0)\n"
	       "Require OPENSSL_VERSION_NUMBER 0x1000100f or greater (1.0.1)\n"
	       "Require OPENSSL_VERSION_NUMBER 0x1000205f or greater (1.0.2e)\n\n");
	return (1);
}
		],
		[AC_MSG_RESULT(ok)],
		[AC_MSG_RESULT(not compatible)
		 OPENSSL_WARNING=yes
		],
		[AC_MSG_RESULT(assuming target platform has compatible version)])
;;
no)
	AC_MSG_RESULT(Skipped OpenSSL version check)
;;
esac

	AC_MSG_CHECKING(for OpenSSL FIPS mode support)
	have_fips_mode=""
	AC_TRY_LINK([#include <openssl/crypto.h>],
		    [FIPS_mode();],
		    have_fips_mode=yes,
		    have_fips_mode=no)
	if test "x$have_fips_mode" = "xyes"
	then
		AC_DEFINE([HAVE_FIPS_MODE], [1],
			  [Define if OpenSSL provides FIPS_mode()])
		AC_MSG_RESULT(yes)
	else
		AC_MSG_RESULT(no)
	fi

	AC_MSG_CHECKING(for OpenSSL DSA support)
	if test -f $use_openssl/include/openssl/dsa.h
	then
		AC_DEFINE(HAVE_OPENSSL_DSA)
		AC_MSG_RESULT(yes)
	else
		AC_MSG_RESULT(no)
	fi

	AC_CHECK_FUNCS(EVP_sha256 EVP_sha384 EVP_sha512)

	AC_MSG_CHECKING(for OpenSSL ECDSA support)
	have_ecdsa=""
	AC_TRY_RUN([
#include <openssl/ecdsa.h>
#include <openssl/objects.h>
int main() {
	EC_KEY *ec256, *ec384;

#if !defined(HAVE_EVP_SHA256) || !defined(HAVE_EVP_SHA384)
	return (1);
#endif
	ec256 = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
	ec384 = EC_KEY_new_by_curve_name(NID_secp384r1);
	if (ec256 == NULL || ec384 == NULL)
		return (2);
	return (0);
}
],
	[AC_MSG_RESULT(yes)
	have_ecdsa="yes"],
	[AC_MSG_RESULT(no)
	have_ecdsa="no"],
	[AC_MSG_RESULT(using --with-ecdsa)])
	case "$with_ecdsa" in
	yes)
	    case "$have_ecdsa" in
	    no)  AC_MSG_ERROR([ecdsa not supported]) ;;
	    *)  have_ecdsa=yes ;;
	    esac
	    ;;
	no)
	    have_ecdsa=no ;;
	*)
	    case "$have_ecdsa" in
	    yes|no) ;;
	    *) AC_MSG_ERROR([need --with-ecdsa=[[yes or no]]]) ;;
	    esac
	    ;;
	esac
	case $have_ecdsa in
	yes)
		OPENSSL_ECDSA="yes"
		OPENSSLECDSALINKOBJS='${OPENSSLECDSALINKOBJS}'
		OPENSSLECDSALINKSRCS='${OPENSSLECDSALINKSRCS}'
		AC_DEFINE(HAVE_OPENSSL_ECDSA, 1,
			  [Define if your OpenSSL version supports ECDSA.])
		;;
	*)
		;;
	esac

	AC_MSG_CHECKING(for OpenSSL GOST support)
	have_gost=""
	case "$use_pkcs11" in
		auto|no)
			;;
		*)
			if $use_threads; then
				CC="$CC -pthread"
			fi
			;;
	esac
	AC_TRY_RUN([
#include <openssl/conf.h>
#include <openssl/engine.h>
int main() {
#if !defined(LIBRESSL_VERSION_NUMBER) && (OPENSSL_VERSION_NUMBER >= 0x10000000L)
	ENGINE *e;
	EC_KEY *ek;

	ek = NULL;
	OPENSSL_config(NULL);

	e = ENGINE_by_id("gost");
	if (e == NULL)
		return (1);
	if (ENGINE_init(e) <= 0)
		return (1);
	return (0);
#else
	return (1);
#endif
}
],
	[AC_MSG_RESULT(yes)
	have_gost="yes"],
	[AC_MSG_RESULT(no)
	have_gost="no"],
	[AC_MSG_RESULT(using --with-gost)])
	case "$with_gost" in
	yes)
	    case "$have_gost" in
	    no)  AC_MSG_ERROR([gost not supported]) ;;
	    *)  have_gost=yes ;;
	    esac
	    ;;
	no)
	    have_gost=no ;;
	*)
	    case "$have_gost" in
	    yes|no) ;;
	    *) AC_MSG_ERROR([need --with-gost=[[yes, no, raw or asn1]]]) ;;
	    esac
	    ;;
	esac
	case $have_gost in
	yes)
		OPENSSL_GOST="yes"
		OPENSSLGOSTLINKOBJS='${OPENSSLGOSTLINKOBJS}'
		OPENSSLGOSTLINKSRCS='${OPENSSLGOSTLINKSRCS}'
		AC_DEFINE(HAVE_OPENSSL_GOST, 1,
			  [Define if your OpenSSL version supports GOST.])
		;;
	*)
		;;
	esac

	AC_MSG_CHECKING(for OpenSSL Ed25519 support)
	have_ed25519=""
	have_ed448=""
	AC_TRY_RUN([
#include <openssl/evp.h>
#include <openssl/objects.h>
int main() {
	EVP_PKEY_CTX *ctx;

	ctx = EVP_PKEY_CTX_new_id(NID_ED25519, NULL);
	if (ctx == NULL)
		return (2);
	return (0);
}
],
	[AC_MSG_RESULT(yes)
	have_ed25519="yes"],
	[AC_MSG_RESULT(no)
	have_ed25519="no"],
	[AC_MSG_RESULT(using --with-eddsa)])
	case "$with_eddsa" in
	yes|all)
	    case "$have_ed25519" in
	    no)  AC_MSG_ERROR([eddsa not supported]) ;;
	    *)  have_ed25519=yes ;;
	    esac
	    ;;
	no)
	    have_ed25519=no ;;
	*)
	    case "$have_ed25519" in
	    yes|no) ;;
	    *) AC_MSG_ERROR([need --with-eddsa=[[yes, all or no]]]) ;;
	    esac
	    ;;
	esac
	case $have_ed25519 in
	yes)
		OPENSSL_ED25519="yes"
		OPENSSLEDDSALINKOBJS='${OPENSSLEDDSALINKOBJS}'
		OPENSSLEDDSALINKSRCS='${OPENSSLEDDSALINKSRCS}'
		AC_DEFINE(HAVE_OPENSSL_ED25519, 1,
			  [Define if your OpenSSL version supports Ed25519.])
		AC_MSG_CHECKING(for OpenSSL Ed448 support)
		AC_TRY_RUN([
#include <openssl/evp.h>
#include <openssl/objects.h>
int main() {
	EVP_PKEY_CTX *ctx;

	ctx = EVP_PKEY_CTX_new_id(NID_ED448, NULL);
	if (ctx == NULL)
		return (2);
	return (0);
}
],
		[AC_MSG_RESULT(yes)
		have_ed448="yes"],
		[AC_MSG_RESULT(no)
		have_ed448="no"],
		[AC_MSG_RESULT(using --with-eddsa)])
		case $with_eddsa in
		all)
			have_ed448=yes ;;
		*)
			;;
		esac
		case $have_ed448 in
		yes)
			AC_DEFINE(HAVE_OPENSSL_ED448, 1,
				  [Define if your OpenSSL version supports Ed448.])],
			;;	   
		*)
			;;
		esac
		;;
	*)
		;;
	esac

	have_aes="no"
	AC_MSG_CHECKING(for OpenSSL AES support)
	AC_TRY_RUN([
#include <openssl/evp.h>
int main() {
	const EVP_CIPHER *aes128, *aes192, *aes256;

	aes128 = EVP_aes_128_ecb();
	aes192 = EVP_aes_192_ecb();
	aes256 = EVP_aes_256_ecb();
	if (aes128 == NULL || aes192 == NULL || aes256 == NULL)
		return (1);
	return (0);
}
],
	[AC_MSG_RESULT(yes)
	 have_aes="evp"],
	[AC_CHECK_FUNC(AES_encrypt,
	[AC_MSG_RESULT(yes)
	 have_aes="yes"],
	[AC_MSG_RESULT(no)])],
	[AC_MSG_RESULT(using --with-aes)
	 # Expect cross-compiling with a modern OpenSSL
	 have_aes="evp"])

	ISC_OPENSSL_INC=""
	ISC_OPENSSL_LIBS=""
	if test "yes" = "$with_aes"
	then
		case "$have_aes" in
		evp)
			AC_DEFINE(HAVE_OPENSSL_EVP_AES, 1,
				  [Define if your OpenSSL version supports EVP AES])
			ISC_OPENSSL_INC="$DST_OPENSSL_INC"
			ISC_OPENSSL_LIBS="$DST_OPENSSL_LIBS"
			;;
		yes)	
			AC_DEFINE(HAVE_OPENSSL_AES, 1,
				  [Define if your OpenSSL version supports AES])
			ISC_OPENSSL_INC="$DST_OPENSSL_INC"
			ISC_OPENSSL_LIBS="$DST_OPENSSL_LIBS"
			;;
		*)
			;;
		esac
	fi

	CC="$saved_cc"
	CFLAGS="$saved_cflags"
	LIBS="$saved_libs"
	OPENSSLLINKOBJS='${OPENSSLLINKOBJS}'
	OPENSSLLINKSRCS='${OPENSSLLINKSRCS}'

	;;
esac

#
# This would include the system openssl path (and linker options to use
# it as needed) if it is found.
#

AC_SUBST(DST_OPENSSL_INC)
AC_SUBST(OPENSSLECDSALINKOBJS)
AC_SUBST(OPENSSLECDSALINKSRCS)
AC_SUBST(OPENSSLEDDSALINKOBJS)
AC_SUBST(OPENSSLEDDSALINKSRCS)
AC_SUBST(OPENSSLGOSTLINKOBJS)
AC_SUBST(OPENSSLGOSTLINKSRCS)
AC_SUBST(OPENSSLLINKOBJS)
AC_SUBST(OPENSSLLINKSRCS)
AC_SUBST(OPENSSL_ECDSA)
AC_SUBST(OPENSSL_ED25519)
AC_SUBST(OPENSSL_GOST)

ISC_PLATFORM_WANTAES="#undef ISC_PLATFORM_WANTAES"
if test "yes" = "$with_aes"
then
	if test "X$CRYPTO" = "X"
	then
		with_aes="no"
	fi
fi
if test "yes" = "$with_aes"
then
	ISC_PLATFORM_WANTAES="#define ISC_PLATFORM_WANTAES 1"
fi
AC_SUBST(ISC_PLATFORM_WANTAES)

#
# Choose Client Cookie algorithm
#

AC_MSG_CHECKING(for the algorithm for Client Cookie)
if test "auto" = "$with_cc_alg"
then
	if test "yes" = "$with_aes"
	then
		with_cc_alg="aes"
	else
		with_cc_alg="sha256"
	fi
fi
case $with_cc_alg in
	sha1)
		AC_MSG_RESULT(sha1)
		AC_DEFINE(HMAC_SHA1_CC, 1,
			  [Use HMAC-SHA1 for Client Cookie generation])
		;;
	sha256)
		AC_MSG_RESULT(sha256)
		AC_DEFINE(HMAC_SHA256_CC, 1,
			  [Use HMAC-SHA256 for Client Cookie generation])
		;;
	aes)
		AC_MSG_RESULT(aes)
		AC_DEFINE(AES_CC, 1,
			  [Use AES for Client Cookie generation])
		;;
esac

#
# Use OpenSSL for hash functions
#

#
# was --enable-openssl-hash specified?
#
AC_ARG_ENABLE(openssl-hash,
	      AS_HELP_STRING([--enable-openssl-hash],
			     [use OpenSSL for hash functions [default=yes]]),
	want_openssl_hash="$enableval", want_openssl_hash="whenossl")

AC_MSG_CHECKING(for using OpenSSL for hash functions)
ISC_PLATFORM_OPENSSLHASH="#undef ISC_PLATFORM_OPENSSLHASH"
if test "whenossl" = "$want_openssl_hash"
then
	if test "X$CRYPTO" = "X-DOPENSSL"
	then
		want_openssl_hash="yes"
	else
		want_openssl_hash="no"
	fi
fi
case $want_openssl_hash in
	yes)
		if test "X$CRYPTO" != "X-DOPENSSL"
		then
			AC_MSG_ERROR([No OpenSSL for hash functions])
		fi
		AC_MSG_RESULT(yes)
		ISC_PLATFORM_OPENSSLHASH="#define ISC_PLATFORM_OPENSSLHASH 1"
		ISC_OPENSSL_INC="$DST_OPENSSL_INC"
		ISC_OPENSSL_LIBS="$DST_OPENSSL_LIBS"
		;;
	no)
		AC_MSG_RESULT(no)
		;;
esac
AC_SUBST(ISC_PLATFORM_OPENSSLHASH)
AC_SUBST(ISC_OPENSSL_INC)
AC_SUBST(ISC_OPENSSL_LIBS)

if test "X${ISC_OPENSSL_LIBS}" != "X${DST_OPENSSL_LIBS}"
then
	DNS_CRYPTO_LIBS="$DNS_CRYPTO_LIBS $DST_OPENSSL_LIBS"
fi

#
# PKCS11 (aka crypto hardware) support (--with moved just after openssl)
#
AC_MSG_CHECKING(for PKCS11 support)

if test "auto" = "$use_pkcs11"
then
	if test "yes" = "$want_native_pkcs11"
	then
		use_pkcs11="yes"
	else
		use_pkcs11="no"
	fi
fi

case "$use_pkcs11" in
	no)
		AC_MSG_RESULT(no)
		USE_PKCS11=""
		PKCS11_TEST=""
		PKCS11_TOOLS=""
		ISC_PK11_C=""
		ISC_PK11_O=""
		ISC_PK11_API_C=""
		ISC_PK11_API_O=""
		ISC_PK11_RESULT_C=""
		ISC_PK11_RESULT_O=""
		ISC_ISCPK11_API_C=""
		ISC_ISCPK11_API_O=""
		;;
	yes|*)
		AC_MSG_RESULT(yes)
		if ! $use_threads; then
			AC_MSG_ERROR([PKCS11 requires thread support])
		fi
		if test "X$CRYPTO" = "X-DOPENSSL"
		then
			AC_MSG_CHECKING(for OpenSSL with PKCS11 support)
			saved_cc="$CC"
			saved_cflags="$CFLAGS"
			saved_libs="$LIBS"
			CC="$CC -pthread"
			CFLAGS="$CFLAGS $DST_OPENSSL_INC"
			LIBS="$LIBS $DST_OPENSSL_LIBS"
			AC_TRY_RUN([
#include <openssl/conf.h>
#include <openssl/engine.h>
int main() {
	ENGINE *e;

	OPENSSL_config(NULL);
	e = ENGINE_by_id("pkcs11");
	if (e == NULL)
		return (1);
	if (ENGINE_init(e) <= 0)
		return (1);
	return (0);
}
],
			[AC_MSG_RESULT(yes)
			PKCS11_TEST=pkcs11ssl
			PKCS11_ENGINE='-DPKCS11_ENGINE="\"pkcs11\""'],
			[AC_MSG_RESULT(no)
			PKCS11_TEST=''
			PKCS11_ENGINE='-DPKCS11_ENGINE=NULL'],
			[AC_MSG_RESULT(cross compile, defaulting to no)
			PKCS11_TEST=''
			PKCS11_ENGINE='-DPKCS11_ENGINE=NULL'])
			CC="$saved_cc"
			CFLAGS="$saved_cflags"
			LIBS="$saved_libs"
		else
			PKCS11_TEST=''
			PKCS11_ENGINE='-DPKCS11_ENGINE=NULL'

		fi
		USE_PKCS11='-DUSE_PKCS11'
		PKCS11_TOOLS=pkcs11
		AC_CHECK_FUNC(getpassphrase, AC_DEFINE(HAVE_GETPASSPHRASE),)
		ISC_PK11_C="pk11.c"
		ISC_PK11_O="pk11.$O"
		ISC_PK11_API_C="pk11_api.c"
		ISC_PK11_API_O="pk11_api.$O"
		ISC_PK11_RESULT_C="pk11_result.c"
		ISC_PK11_RESULT_O="pk11_result.$O"
		ISC_ISCPK11_API_C="unix/pk11_api.c"
		ISC_ISCPK11_API_O="unix/pk11_api.$O"
		;;
esac
AC_SUBST(USE_PKCS11)
AC_SUBST(PKCS11_TOOLS)
AC_SUBST(PKCS11_ENGINE)
AC_SUBST(ISC_PK11_C)
AC_SUBST(ISC_PK11_O)
AC_SUBST(ISC_PK11_API_C)
AC_SUBST(ISC_PK11_API_O)
AC_SUBST(ISC_PK11_RESULT_C)
AC_SUBST(ISC_PK11_RESULT_O)
AC_SUBST(ISC_ISCPK11_API_C)
AC_SUBST(ISC_ISCPK11_API_O)

AC_MSG_CHECKING(for PKCS11 tools)
case "$use_pkcs11" in
	no)
		PKCS11_PROVIDER="undefined"
		AC_MSG_RESULT(disabled)
		;;
	yes|'')
		PKCS11_PROVIDER="undefined"
		AC_MSG_RESULT(enabled)
		;;
	*)
		PKCS11_PROVIDER="$use_pkcs11"
		AC_MSG_RESULT([enabled, PKCS11 provider is $PKCS11_PROVIDER])
		;;
esac

AC_SUBST(PKCS11_PROVIDER)

PKCS11_ECDSA=""
PKCS11_GOST=""
PKCS11_ED25519=""
set_pk11_flavor="no"
AC_MSG_CHECKING(for native PKCS11)

case "$want_native_pkcs11" in
	yes)
		AC_MSG_RESULT(using native PKCS11 crypto)
		PKCS11LINKOBJS='${PKCS11LINKOBJS}'
		PKCS11LINKSRCS='${PKCS11LINKSRCS}'
		PKCS11_TEST=pkcs11
		AC_MSG_CHECKING(for PKCS11 ECDSA)
		case "$with_ecdsa" in
		no)
			AC_MSG_RESULT(disabled)
			;;
		*)
			AC_MSG_RESULT(enabled)
			PKCS11_ECDSA="yes"
			AC_DEFINE(HAVE_PKCS11_ECDSA, 1,
				  [Define if your PKCS11 provider supports ECDSA.])
			;;
		esac
		AC_MSG_CHECKING(for PKCS11 GOST)
		case "$with_gost" in
		yes)
			AC_MSG_RESULT(enabled)
			PKCS11_GOST="yes"
			AC_DEFINE(HAVE_PKCS11_GOST, 1,
				  [Define if your PKCS11 provider supports GOST.])
			;;
		*)
			AC_MSG_RESULT(disabled)
			;;
		esac
		AC_MSG_CHECKING(for PKCS11 Ed25519)
		case "$with_eddsa" in
		yes|all)
			AC_MSG_RESULT(enabled)
			PKCS11_ED25519="yes"
			AC_DEFINE(HAVE_PKCS11_ED25519, 1,
				  [Define if your PKCS11 provider supports Ed25519.])
			AC_MSG_CHECKING(for PKCS11 Ed448)
			case "$with_eddsa" in
			all)
				AC_MSG_RESULT(enabled)
				AC_DEFINE(HAVE_PKCS11_ED448, 1,
					  [Define if your PKCS11 provider supports Ed448.])
				;;
			*)
				AC_MSG_RESULT(disabled)
				;;
			esac
			;;
		*)
			AC_MSG_RESULT(disabled)
			;;
		esac
		AC_MSG_CHECKING(for PKCS11 flavor)
		case "$PKCS11_PROVIDER" in
			*nfast*)
				AC_MSG_RESULT(Thales nCipher)
				# default
				pk11_flavor="PK11_THALES_FLAVOR"
				set_pk11_flavor="yes"
				;;
			*libsofthsm2*)
				AC_MSG_RESULT(SoftHSMv2)
				pk11_flavor="PK11_SOFTHSMV2_FLAVOR"
				set_pk11_flavor="yes"
				;;
			*libsofthsm*)
				AC_MSG_RESULT(SoftHSM)
				pk11_flavor="PK11_SOFTHSMV1_FLAVOR"
				set_pk11_flavor="yes"
				;;
			*cryptech*)
				AC_MSG_RESULT(Cryptech)
				pk11_flavor="PK11_CRYPTECH_FLAVOR"
				set_pk11_flavor="yes"
				;;
			*Keyper*)
				AC_MSG_RESULT(AEP Keyper)
				pk11_flavor="PK11_AEP_FLAVOR"
				set_pk11_flavor="yes"
				;;
			undefined)
				AC_MSG_RESULT(undefined provider?)
				;;
			*)
				AC_MSG_RESULT(unknown provider: tweaks are in lib/isc/include/pk11/site.h)
				;;
		esac
		if test "yes" = "$set_pk11_flavor" ; then
			CFLAGS="$CFLAGS -DPK11_FLAVOR=$pk11_flavor"
		fi
		;;
	no|'')
		AC_MSG_RESULT(disabled)
		;;
esac

AC_SUBST(PKCS11LINKOBJS)
AC_SUBST(PKCS11LINKSRCS)
AC_SUBST(CRYPTO)
AC_SUBST(PKCS11_ECDSA)
AC_SUBST(PKCS11_GOST)
AC_SUBST(PKCS11_ED25519)
AC_SUBST(PKCS11_TEST)

# for PKCS11 benchmarks

have_clock_gt=no
AC_CHECK_FUNC(clock_gettime,have_clock_gt=yes,)
if test "no" = "$have_clock_gt"; then
	AC_CHECK_LIB(rt,clock_gettime,have_clock_gt=rt,)
fi

if test "no" != "$have_clock_gt"; then
	AC_DEFINE(HAVE_CLOCK_GETTIME, 1, [Define if clock_gettime is available.])
fi

if test "rt" = "$have_clock_gt"; then
	LIBS="-lrt $LIBS"
fi

#
# Use the crypto provider (OpenSSL/PKCS#11) for random functions
#

AC_MSG_CHECKING(for using the crypto library (vs. builtin) for random functions)
AC_ARG_ENABLE(crypto-rand,
	      AS_HELP_STRING([--enable-crypto-rand],
			    [use the crypto provider for random [default=yes]]),
	want_crypto_rand="$enableval", want_crypto_rand="auto")
if test "$want_crypto_rand" = "auto"
then
	case "$CRYPTOLIB" in
	"")
		want_crypto_rand="no"
		;;
	pkcs11)
		want_crypto_rand="yes"
		;;
	openssl)
		saved_cflags="$CFLAGS"
		saved_libs="$LIBS"
		CFLAGS="$CFLAGS $DST_OPENSSL_INC"
		LIBS="$LIBS $DST_OPENSSL_LIBS"
		AC_TRY_RUN([
#include <openssl/rand.h>

unsigned char buf[128];

int main()
{
	if (RAND_bytes(buf, 128) != 1)
		return (1);
	return (0);
}
],
		[want_crypto_rand="yes"],
		[want_crypto_rand="no"],
		[want_crypto_rand="yes"])
		CFLAGS="$saved_cflags"
		LIBS="$saved_libs"
		;;
	*)
		AC_MSG_ERROR([Unknown crypto library define $CRYPTOLIB])
		;;
	esac
fi
case $want_crypto_rand in
	yes)
		if test "$CRYPTOLIB" = ""
		then
			AC_MSG_ERROR([No crypto library for random functions])
		fi
		AC_MSG_RESULT(["$CRYPTOLIB"])
		ISC_PLATFORM_CRYPTORANDOM="#define ISC_PLATFORM_CRYPTORANDOM \"$CRYPTOLIB\""
		;;
	no)
		AC_MSG_RESULT(no)
		ISC_PLATFORM_CRYPTORANDOM="#undef ISC_PLATFORM_CRYPTORANDOM"
		;;
esac
AC_SUBST(ISC_PLATFORM_CRYPTORANDOM)

#
# was --with-lmdb specified?
#
AC_MSG_CHECKING(for lmdb library)
AC_ARG_WITH(lmdb,
	    AS_HELP_STRING([--with-lmdb[=PATH]],
			   [build with LMDB library [yes|no|path]]),
    use_lmdb="$withval", use_lmdb="auto")

have_lmdb=""
case "$use_lmdb" in
	no)
		lmdb_libs=""
		;;
	auto|yes)
		for d in /usr /usr/local /opt/local
		do
			if test -f "${d}/include/lmdb.h"
			then
				if test ${d} != /usr
				then
					lmdb_cflags="-I ${d}/include"
					LIBS="$LIBS -L${d}/lib"
				fi
				have_lmdb="yes"
			fi
		done
		;;
	*)
		if test -f "${use_lmdb}/include/lmdb.h"
		then
			lmdb_cflags="-I${use_lmdb}/include"
			LIBS="$LIBS -L${use_lmdb}/lib"
			have_lmdb="yes"
		else
			AC_MSG_ERROR([$use_lmdb/include/lmdb.h not found.])
		fi
		;;
esac

if test "X${have_lmdb}" != "X"
then
	AC_MSG_RESULT(yes)
	AC_SEARCH_LIBS([mdb_env_create], [lmdb], [],
		       [AC_MSG_ERROR([found lmdb include but not library.])
			have_lmdb=""])
elif test "X$use_lmdb" = Xyes
then
	AC_MSG_ERROR([include/lmdb.h not found.])
else
	AC_MSG_RESULT(no)
fi

NZD_TOOLS=""
NZDSRCS=
NZDTARGETS=
if test "X${have_lmdb}" != "X"
then
	CFLAGS="$CFLAGS $lmdb_cflags"
	AC_DEFINE(HAVE_LMDB, 1, [Define if lmdb was found])
	NZD_TOOLS="nzd"
	NZDSRCS='${NZDSRCS}'
	NZDTARGETS='${NZDTARGETS}'
fi
AC_SUBST(NZD_TOOLS)
AC_SUBST(NZDSRCS)
AC_SUBST(NZDTARGETS)

#
# was --with-libxml2 specified?
#
AC_MSG_CHECKING(for libxml2 library)
AC_ARG_WITH(libxml2,
	    AS_HELP_STRING([--with-libxml2[=PATH]],
			   [build with libxml2 library [yes|no|path]]),
    use_libxml2="$withval", use_libxml2="auto")

case "$use_libxml2" in
	no)
		DST_LIBXML2_INC=""
		;;
	auto|yes)
		case X`(xml2-config --version) 2>/dev/null` in
		X2.[[6789]].*)
			libxml2_libs=`xml2-config --libs`
			libxml2_cflags=`xml2-config --cflags`
			;;
		*)
			if test "yes" = "$use_libxml2" ; then
				AC_MSG_RESULT(no)
				AC_MSG_ERROR(required libxml2 version not available)
			else
				libxml2_libs=
				libxml2_cflags=
			fi
			;;
		esac
		;;
	*)
		if test -f "$use_libxml2/bin/xml2-config" ; then
			libxml2_libs=`$use_libxml2/bin/xml2-config --libs`
			libxml2_cflags=`$use_libxml2/bin/xml2-config --cflags`
		fi
		;;
esac

if test "X$libxml2_libs" != "X"
then
	CFLAGS="$CFLAGS $libxml2_cflags"
	LIBS="$LIBS $libxml2_libs"
	#
	# Sanity check xml2-config output.
	#
	AC_TRY_LINK([#include <libxml/xmlwriter.h>],
		    [return(xmlTextWriterStartElement(NULL, NULL));],
		    AC_MSG_RESULT(yes),
		    AC_MSG_ERROR(xml2-config returns badness))
	AC_DEFINE(HAVE_LIBXML2, 1, [Define if libxml2 was found])
	XMLSTATS=1
else
	AC_MSG_RESULT(no)
fi
AC_SUBST(XMLSTATS)

#
# was --with-libjson specified?
#
AC_MSG_CHECKING(for json library)
AC_ARG_WITH(libjson,
	    AS_HELP_STRING([--with-libjson[=PATH]],
			   [build with libjson0 library [yes|no|path]]),
	    use_libjson="$withval", use_libjson="auto")

have_libjson=""
have_libjson_c=""
case "$use_libjson" in
	no)
		libjson_libs=""
		;;
	auto|yes)
		for d in /usr /usr/local /opt/local
		do
			if test -f "${d}/include/json/json.h"
			then
				if test ${d} != /usr
				then
					libjson_cflags="-I ${d}/include"
					LIBS="$LIBS -L${d}/lib"
				fi
				have_libjson="yes"
			elif test -f "${d}/include/json-c/json.h"
			then
				if test ${d} != /usr
				then
					libjson_cflags="-I ${d}/include"
					LIBS="$LIBS -L${d}/lib"
				fi
				have_libjson="yes"
				have_libjson_c="yes"
			fi
		done
		;;
	*)
		if test -f "${use_libjson}/include/json/json.h"
		then
			libjson_cflags="-I${use_libjson}/include"
			LIBS="$LIBS -L${use_libjson}/lib"
			have_libjson="yes"
		elif test -f "${use_libjson}/include/json-c/json.h"
		then
			libjson_cflags="-I${use_libjson}/include"
			LIBS="$LIBS -L${use_libjson}/lib"
			have_libjson="yes"
			have_libjson_c="yes"
		else
			AC_MSG_ERROR([$use_libjson/include/json{,-c}/json.h not found.])
		fi
		;;
esac

if test "X${have_libjson}" != "X"
then
	AC_MSG_RESULT(yes)
	AC_SEARCH_LIBS([json_object_new_int64], [json json-c], [],
		       [AC_MSG_ERROR([found libjson include but not library.])
			have_libjson=""])
elif test "X$use_libjson" = Xyes
then
	AC_MSG_ERROR([include/json{,-c}/json.h not found.])
else
	AC_MSG_RESULT(no)
fi

if test "X${have_libjson}" != "X"
then
	CFLAGS="$CFLAGS $libjson_cflags"
	AC_DEFINE(HAVE_JSON, 1, [Define if libjson was found])
	if test "X${have_libjson_c}" = Xyes
	then
		AC_DEFINE(HAVE_JSON_C, 1, [Define if json-c was found])
	fi
	JSONSTATS=1
fi
AC_SUBST(JSONSTATS)

#
# was --with-zlib specified?
#
AC_MSG_CHECKING(for zlib library)
AC_ARG_WITH(zlib,
	    AS_HELP_STRING([--with-zlib[=PATH]],
			   [build with zlib for HTTP compression
				[default=yes]]),
	    with_zlib="$withval", with_zlib="auto")

have_zlib=""
case "$with_zlib" in
	no)
		zlib_libs=""
		;;
	auto|yes)
		for d in /usr /usr/local /opt/local
		do
			if test -f "${d}/include/zlib.h"
			then
				if test ${d} != /usr
				then
					zlib_cflags="-I ${d}/include"
					LIBS="$LIBS -L${d}/lib"
				fi
				have_zlib="yes"
			fi
		done
		;;
	*)
		if test -f "${with_zlib}/include/zlib.h"
		then
			zlib_cflags="-I${with_zlib}/include"
			LIBS="$LIBS -L${with_zlib}/lib"
			have_zlib="yes"
		else
			AC_MSG_ERROR([$with_zlib/include/zlib.h not found.])
		fi
		;;
esac

if test "X${have_zlib}" != "X"
then
	AC_MSG_RESULT(yes)
	AC_SEARCH_LIBS([deflate], [z], [],
		       [AC_MSG_ERROR([found zlib include but not library.])
			have_zlib=""])
elif test "X$with_zlib" = Xyes
then
	AC_MSG_ERROR([include/zlib.h not found.])
else
	AC_MSG_RESULT(no)
fi

ZLIB=
if test "X${have_zlib}" != "X"
then
	CFLAGS="$CFLAGS $zlib_cflags"
	AC_DEFINE(HAVE_ZLIB, 1, [Define if zlib was found])
	ZLIB=1
fi
AC_SUBST(ZLIB)


#
# In solaris 10, SMF can manage named service
#
AC_CHECK_LIB(scf, smf_enable_instance)

#
# flockfile is usually provided by pthreads, but we may want to use it
# even if compiled with --disable-threads.  getc_unlocked might also not
# be defined.
#
AC_CHECK_FUNC(flockfile, AC_DEFINE(HAVE_FLOCKFILE),)
AC_CHECK_FUNC(getc_unlocked, AC_DEFINE(HAVE_GETCUNLOCKED),)

# 
# Indicate what the final decision was regarding threads.
#
AC_MSG_CHECKING(whether to build with threads)
if $use_threads; then
	AC_MSG_RESULT(yes)
else
	AC_MSG_RESULT(no)
fi

# 
# End of pthreads stuff.
#

#
# Large File
#
AC_ARG_ENABLE(largefile,
	      AS_HELP_STRING([--enable-largefile], [64-bit file support]),
	      want_largefile="yes", want_largefile="no")
case $want_largefile in
	yes)
		ALWAYS_DEFINES="$ALWAYS_DEFINES -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64"
		;;
	*)
		;;
esac

#
# Additional compiler settings.
#
MKDEPCC="$CC"
MKDEPCFLAGS="-M"
IRIX_DNSSEC_WARNINGS_HACK=""

if test "X$GCC" = "Xyes"; then
	STD_CWARNINGS="$STD_CWARNINGS -W -Wall -Wmissing-prototypes -Wcast-qual -Wwrite-strings -Wformat -Wpointer-arith"
	AC_MSG_CHECKING(if "$CC" supports -fno-strict-aliasing)
	SAVE_CFLAGS="$CFLAGS"
	CFLAGS="$CFLAGS -Werror -fno-strict-aliasing"
	AC_TRY_COMPILE(,, [FNOSTRICTALIASING=yes],[FNOSTRICTALIASING=no])
	CFLAGS="$SAVE_CFLAGS"
	if test "yes" = "$FNOSTRICTALIASING"; then
		AC_MSG_RESULT(yes)
		STD_CWARNINGS="$STD_CWARNINGS -fno-strict-aliasing"
	else
		AC_MSG_RESULT(no)
	fi
	#
	# turn off delete null pointer checks
	#
	AC_MSG_CHECKING(if "$CC" supports -fno-delete-null-pointer-checks)
	SAVE_CFLAGS="$CFLAGS"
	CFLAGS="$CFLAGS -Werror -fno-delete-null-pointer-checks"
	AC_TRY_COMPILE(,, [FNODELETENULLPOINTERCHECKS=yes],
			  [FNODELETENULLPOINTERCHECKS=no])
	CFLAGS="$SAVE_CFLAGS"
	if test "yes" = "$FNODELETENULLPOINTERCHECKS"; then
		AC_MSG_RESULT(yes)
		STD_CWARNINGS="$STD_CWARNINGS -fno-delete-null-pointer-checks"
	else
		AC_MSG_RESULT(no)
	fi
	case "$host" in
	*-hp-hpux*)
		CFLAGS="$CFLAGS -Wl,+vnocompatwarnings"
		BACKTRACECFLAGS="$BACKTRACECFLAGS -Wl,+vnocompatwarnings"
		;;
	esac
	if test "X$enable_warn_shadow" = Xyes; then
		STD_CWARNINGS="$STD_CWARNINGS -Wshadow"
	fi
	if test "X$enable_warn_error" = Xyes; then
		STD_CWARNINGS="$STD_CWARNINGS -Werror"
	fi
else
	case $host in
	*-dec-osf*)
		CC="$CC -std"
		CCOPT="$CCOPT -std"
		CCNOOPT="$CCNOOPT -std"
		MKDEPCC="$CC"
		;;
	*-hp-hpux*)
		CC="$CC -Ae -z"
		# The version of the C compiler that constantly warns about
		# 'const' as well as alignment issues is unfortunately not
		# able to be discerned via the version of the operating
		# system, nor does cc have a version flag.
		case "`$CC +W 123 2>&1`" in
		*Unknown?option*)
			STD_CWARNINGS="+w1"
			;;
		*)
			# Turn off the pointlessly noisy warnings.
			STD_CWARNINGS="+w1 +W 474,530,2193,2236"
			;;
		esac
		CCOPT="$CCOPT -Ae -z"
		CCNOOPT="$CCNOOPT -Ae -z"
		CFLAGS="$CFLAGS -Wl,+vnocompatwarnings"
		BACKTRACECFLAGS="$BACKTRACECFLAGS -Wl,+vnocompatwarnings"
		MKDEPPROG='cc -Ae -E -Wp,-M >/dev/null 2>>$TMP'
		;;
	*-sgi-irix*)
		STD_CWARNINGS="-fullwarn -woff 1209"
		#
		# Silence more than 250 instances of
		#   "prototyped function redeclared without prototype"
		# and 11 instances of
		#   "variable ... was set but never used"
		# from lib/dns/sec/openssl.
		#
		IRIX_DNSSEC_WARNINGS_HACK="-woff 1692,1552"
		;;
	*-solaris*)
		MKDEPCFLAGS="-xM"
		;;
	*-sco-sysv*uw*|*-*-sysv*UnixWare*|*-*-sysv*OpenUNIX*)
		# UnixWare
		CC="$CC -w"
		;;
	esac
fi

AC_SUBST(MKDEPCC)
AC_SUBST(MKDEPCFLAGS)
AC_SUBST(MKDEPPROG)
AC_SUBST(IRIX_DNSSEC_WARNINGS_HACK)

#
# NLS
#
AC_CHECK_FUNC(catgets, AC_DEFINE(HAVE_CATGETS),)

#
# -lxnet buys us one big porting headache...  standards, gotta love 'em.
#
# AC_CHECK_LIB(xnet, socket, ,
#    AC_CHECK_LIB(socket, socket)
# )
#
# Use this for now, instead:
#
case "$host" in
	mips-sgi-irix*)
		;;
	*-linux*)
		;;
	*)
		AC_CHECK_LIB(socket, socket)
		AC_CHECK_LIB(nsl, inet_addr)
		;;
esac

#
# Work around Solaris's select() limitations.
#
case "$host" in
	*-solaris2.[[89]]|*-solaris2.1?)
	AC_DEFINE(FD_SETSIZE, 65536,
		  [Solaris hack to get select_large_fdset.])
	;;
esac

#
# Purify support
#
AC_MSG_CHECKING(whether to use purify)
AC_ARG_WITH(purify,
	    AS_HELP_STRING([--with-purify[=PATH]],[use Rational purify]),
	    use_purify="$withval", use_purify="no")

case "$use_purify" in
	no)
		;;
	yes)
		AC_PATH_PROG(purify_path, purify, purify)
		;;
	*)
		purify_path="$use_purify"
		;;
esac

case "$use_purify" in
	no)
		AC_MSG_RESULT(no)
		PURIFY=""
		;;
	*)
		if test -f "$purify_path" || test purify = "$purify_path"; then
			AC_MSG_RESULT($purify_path)
			PURIFYFLAGS="`echo $PURIFYOPTIONS`"
			PURIFY="$purify_path $PURIFYFLAGS"
		else
			AC_MSG_ERROR([$purify_path not found.

Please choose the proper path with the following command:

    configure --with-purify=PATH
])
		fi
		;;
esac

AC_SUBST(PURIFY)

#
# Google/Great Performance Tools CPU Profiler
#
AC_MSG_CHECKING(whether to use gperftools profiler)
AC_ARG_WITH(gperftools-profiler,
	    AS_HELP_STRING([--with-gperftools-profiler],
			   [use gperftools CPU profiler]),
	    use_profiler="$withval", use_profiler="no")

case $use_profiler in
	yes)
		AC_MSG_RESULT(yes)
		AC_DEFINE([HAVE_GPERFTOOLS_PROFILER], 1,
		[Define to use gperftools CPU profiler.])
		LIBS="$LIBS -lprofiler"
		;;
	*)
		AC_MSG_RESULT(no)
		;;
esac

#
# enable/disable dumping stack backtrace.  Also check if the system supports
# glibc-compatible backtrace() function.
#
AC_ARG_ENABLE(backtrace,
	      AS_HELP_STRING([--enable-backtrace],
			     [log stack backtrace on abort [default=yes]]),
	      want_backtrace="$enableval",  want_backtrace="yes")
case $want_backtrace in
yes)
	ISC_PLATFORM_USEBACKTRACE="#define ISC_PLATFORM_USEBACKTRACE 1"
	AC_TRY_LINK([#include <execinfo.h>],
	[return (backtrace((void **)0, 0));],
	[AC_DEFINE([HAVE_LIBCTRACE], [], [if system have backtrace function])],)
	;;
*)
	ISC_PLATFORM_USEBACKTRACE="#undef ISC_PLATFORM_USEBACKTRACE"
	;;
esac
AC_SUBST(ISC_PLATFORM_USEBACKTRACE)

AC_ARG_ENABLE(symtable,
	      AS_HELP_STRING([--enable-symtable],
			     [use internal symbol table for backtrace
			      [all|minimal(default)|none]]),
		want_symtable="$enableval",  want_symtable="minimal")
case $want_symtable in
yes|all|minimal)     # "yes" is a hidden value equivalent to "minimal"
	if test "" = "$PERL"
	then
		AC_MSG_ERROR([Internal symbol table requires perl but no perl is found.
Install perl or explicitly disable the feature by --disable-symtable.])
	fi
	if test "yes" = "$use_libtool"; then
		AC_MSG_WARN([Internal symbol table does not work with libtool.  Disabling symbol table.])
	else
		# we generate the internal symbol table only for those systems
		# known to work to avoid unexpected build failure.  Also, warn
		# about unsupported systems when the feature is enabled
		#  manually.
		case $host_os in
		freebsd*|netbsd*|openbsd*|linux*|solaris*|darwin*)
			MKSYMTBL_PROGRAM="$PERL"
			if test "all" = "$want_symtable"; then
				ALWAYS_MAKE_SYMTABLE="yes"
			fi
			;;
		*)
			if test "yes" = "$want_symtable" -o "all" = "$want_symtable"
			then
				AC_MSG_WARN([this system is not known to generate internal symbol table safely; disabling it])
			fi
		esac
	fi
	;;
*)
	;;
esac
AC_SUBST(MKSYMTBL_PROGRAM)
AC_SUBST(ALWAYS_MAKE_SYMTABLE)

#
# File name extension for static archive files, for those few places
# where they are treated differently from dynamic ones.
#
SA=a

AC_SUBST(O)
AC_SUBST(A)
AC_SUBST(SA)
AC_SUBST(LIBTOOL_MKDEP_SED)
AC_SUBST(LIBTOOL_MODE_COMPILE)
AC_SUBST(LIBTOOL_MODE_INSTALL)
AC_SUBST(LIBTOOL_MODE_LINK)
AC_SUBST(LIBTOOL_MODE_UNINSTALL)
AC_SUBST(LIBTOOL_ALLOW_UNDEFINED)
AC_SUBST(LIBTOOL_IN_MAIN)

BIND9_CO_RULE=".c.$O:"
AC_SUBST(BIND9_CO_RULE)

#
# Here begins a very long section to determine the system's networking
# capabilities.  The order of the tests is significant.
#

#
# IPv6
#
AC_ARG_ENABLE(ipv6,
	      AS_HELP_STRING([--enable-ipv6], [use IPv6 [default=autodetect]]))

case "$enable_ipv6" in
	yes|''|autodetect)
		AC_DEFINE(WANT_IPV6)
		;;
	no)
		;;
esac

#
# We do the IPv6 compilation checking after libtool so that we can put
# the right suffix on the files.
#
AC_MSG_CHECKING(for IPv6 structures)
AC_TRY_COMPILE([
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>],
[struct sockaddr_in6 sin6; return (0);],
	[AC_MSG_RESULT(yes)
	 found_ipv6=yes],
	[AC_MSG_RESULT(no)
	 found_ipv6=no])

#
# See whether IPv6 support is provided via a Kame add-on.
# This is done before other IPv6 linking tests to LIBS is properly set.
#
AC_MSG_CHECKING(for Kame IPv6 support)
AC_ARG_WITH(kame,
	    AS_HELP_STRING([--with-kame[=PATH]],
			   [use Kame IPv6 [default path /usr/local/v6]]),
	    use_kame="$withval", use_kame="no")

case "$use_kame" in
	no)
		;;
	yes)
		kame_path=/usr/local/v6
		;;
	*)
		kame_path="$use_kame"
		;;
esac

case "$use_kame" in
	no)
		AC_MSG_RESULT(no)
		;;
	*)
		if test -f $kame_path/lib/libinet6.a; then
			AC_MSG_RESULT($kame_path/lib/libinet6.a)
			LIBS="-L$kame_path/lib -linet6 $LIBS"
		else
			AC_MSG_ERROR([$kame_path/lib/libinet6.a not found.

Please choose the proper path with the following command:

    configure --with-kame=PATH
])
		fi
		;;
esac

#
# Whether netinet6/in6.h is needed has to be defined in isc/platform.h.
# Including it on Kame-using platforms is very bad, though, because
# Kame uses #error against direct inclusion.   So include it on only
# the platform that is otherwise broken without it -- BSD/OS 4.0 through 4.1.
# This is done before the in6_pktinfo check because that's what
# netinet6/in6.h is needed for.
#
changequote({, })
case "$host" in
*-bsdi4.[01]*)
	ISC_PLATFORM_NEEDNETINET6IN6H="#define ISC_PLATFORM_NEEDNETINET6IN6H 1"
	isc_netinet6in6_hack="#include <netinet6/in6.h>"
	;;
*)
	ISC_PLATFORM_NEEDNETINET6IN6H="#undef ISC_PLATFORM_NEEDNETINET6IN6H"
	isc_netinet6in6_hack=""
	;;
esac
changequote([, ])

#
# This is similar to the netinet6/in6.h issue.
#
case "$host" in
*-sco-sysv*uw*|*-*-sysv*UnixWare*|*-*-sysv*OpenUNIX*)
	# UnixWare
	ISC_PLATFORM_NEEDNETINETIN6H="#define ISC_PLATFORM_NEEDNETINETIN6H 1"
	ISC_PLATFORM_FIXIN6ISADDR="#define ISC_PLATFORM_FIXIN6ISADDR 1"
	isc_netinetin6_hack="#include <netinet/in6.h>"
	;;
*)
	ISC_PLATFORM_NEEDNETINETIN6H="#undef ISC_PLATFORM_NEEDNETINETIN6H"
	ISC_PLATFORM_FIXIN6ISADDR="#undef ISC_PLATFORM_FIXIN6ISADDR"
	isc_netinetin6_hack=""
	;;
esac

#
# Now delve deeper into the suitability of the IPv6 support.
#
case "$found_ipv6" in
	yes)
		ISC_PLATFORM_HAVEIPV6="#define ISC_PLATFORM_HAVEIPV6 1"

		AC_MSG_CHECKING(for in6_addr)
		AC_TRY_COMPILE([
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
$isc_netinetin6_hack
$isc_netinet6in6_hack
],
[struct in6_addr in6; return (0);],
		[AC_MSG_RESULT(yes)
		 ISC_PLATFORM_HAVEINADDR6="#undef ISC_PLATFORM_HAVEINADDR6"
		 isc_in_addr6_hack=""],
		[AC_MSG_RESULT(no)
		 ISC_PLATFORM_HAVEINADDR6="#define ISC_PLATFORM_HAVEINADDR6 1"
		 isc_in_addr6_hack="#define in6_addr in_addr6"])

		AC_MSG_CHECKING(for in6addr_any)
		AC_TRY_LINK([
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
$isc_netinetin6_hack
$isc_netinet6in6_hack
$isc_in_addr6_hack
],
		[struct in6_addr in6; in6 = in6addr_any; return (in6.s6_addr[0]);],
			[AC_MSG_RESULT(yes)
			 ISC_PLATFORM_NEEDIN6ADDRANY="#undef ISC_PLATFORM_NEEDIN6ADDRANY"],
			[AC_MSG_RESULT(no)
			 ISC_PLATFORM_NEEDIN6ADDRANY="#define ISC_PLATFORM_NEEDIN6ADDRANY 1"])

		AC_MSG_CHECKING(for in6addr_loopback)
		AC_TRY_LINK([
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
$isc_netinetin6_hack
$isc_netinet6in6_hack
$isc_in_addr6_hack
],
		[struct in6_addr in6; in6 = in6addr_loopback; return (in6.s6_addr[0]);],
			[AC_MSG_RESULT(yes)
			 ISC_PLATFORM_NEEDIN6ADDRLOOPBACK="#undef ISC_PLATFORM_NEEDIN6ADDRLOOPBACK"],
			[AC_MSG_RESULT(no)
			 ISC_PLATFORM_NEEDIN6ADDRLOOPBACK="#define ISC_PLATFORM_NEEDIN6ADDRLOOPBACK 1"])

		AC_MSG_CHECKING(for sin6_scope_id in struct sockaddr_in6)
		AC_TRY_COMPILE([
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
$isc_netinetin6_hack
$isc_netinet6in6_hack
],
		[struct sockaddr_in6 xyzzy; xyzzy.sin6_scope_id = 0; return (0);],
			[AC_MSG_RESULT(yes)
			 ISC_PLATFORM_HAVESCOPEID="#define ISC_PLATFORM_HAVESCOPEID 1"],
			[AC_MSG_RESULT(no)
			 ISC_PLATFORM_HAVESCOPEID="#undef ISC_PLATFORM_HAVESCOPEID"])

		AC_MSG_CHECKING(for in6_pktinfo)
		AC_TRY_COMPILE([
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
$isc_netinetin6_hack
$isc_netinet6in6_hack
],
		[struct in6_pktinfo xyzzy; return (0);],
			[AC_MSG_RESULT(yes)
			 ISC_PLATFORM_HAVEIN6PKTINFO="#define ISC_PLATFORM_HAVEIN6PKTINFO 1"],
			[AC_MSG_RESULT(no -- disabling runtime ipv6 support)
			 ISC_PLATFORM_HAVEIN6PKTINFO="#undef ISC_PLATFORM_HAVEIN6PKTINFO"])
		;;
	no)
		ISC_PLATFORM_HAVEIPV6="#undef ISC_PLATFORM_HAVEIPV6"
		ISC_PLATFORM_NEEDIN6ADDRANY="#undef ISC_PLATFORM_NEEDIN6ADDRANY"
		ISC_PLATFORM_HAVEIN6PKTINFO="#undef ISC_PLATFORM_HAVEIN6PKTINFO"
		ISC_PLATFORM_HAVESCOPEID="#define ISC_PLATFORM_HAVESCOPEID 1"
		ISC_IPV6_H="ipv6.h"
		ISC_IPV6_O="ipv6.$O"
		ISC_ISCIPV6_O="unix/ipv6.$O"
		ISC_IPV6_C="ipv6.c"
		;;
esac

AC_MSG_CHECKING(for struct sockaddr_storage)
AC_TRY_COMPILE([
#include <sys/types.h>
#include <sys/socket.h>
$isc_netinetin6_hack
$isc_netinet6in6_hack
],
[struct sockaddr_storage storage; return (0);],
[AC_MSG_RESULT(yes)
ISC_PLATFORM_HAVESOCKADDRSTORAGE="#define ISC_PLATFORM_HAVESOCKADDRSTORAGE 1"],
[AC_MSG_RESULT(no)
ISC_PLATFORM_HAVESOCKADDRSTORAGE="#undef ISC_PLATFORM_HAVESOCKADDRSTORAGE"])

AC_SUBST(ISC_PLATFORM_HAVEIPV6)
AC_SUBST(ISC_PLATFORM_NEEDNETINETIN6H)
AC_SUBST(ISC_PLATFORM_NEEDNETINET6IN6H)
AC_SUBST(ISC_PLATFORM_HAVEINADDR6)
AC_SUBST(ISC_PLATFORM_NEEDIN6ADDRANY)
AC_SUBST(ISC_PLATFORM_NEEDIN6ADDRLOOPBACK)
AC_SUBST(ISC_PLATFORM_HAVEIN6PKTINFO)
AC_SUBST(ISC_PLATFORM_FIXIN6ISADDR)
AC_SUBST(ISC_PLATFORM_HAVESOCKADDRSTORAGE)
AC_SUBST(ISC_IPV6_H)
AC_SUBST(ISC_IPV6_O)
AC_SUBST(ISC_ISCIPV6_O)
AC_SUBST(ISC_IPV6_C)
AC_SUBST(ISC_PLATFORM_HAVESCOPEID)

AC_MSG_CHECKING([for struct if_laddrreq])
AC_TRY_LINK([
#include <sys/types.h>
#include <net/if6.h>
],[ struct if_laddrreq a; ],
	[AC_MSG_RESULT(yes)
	ISC_PLATFORM_HAVEIF_LADDRREQ="#define ISC_PLATFORM_HAVEIF_LADDRREQ 1"],
	[AC_MSG_RESULT(no)
	ISC_PLATFORM_HAVEIF_LADDRREQ="#undef ISC_PLATFORM_HAVEIF_LADDRREQ"])
AC_SUBST(ISC_PLATFORM_HAVEIF_LADDRREQ)

AC_MSG_CHECKING([for struct if_laddrconf])
AC_TRY_LINK([
#include <sys/types.h>
#include <net/if6.h>
],[ struct if_laddrconf a; ],
	[AC_MSG_RESULT(yes)
	ISC_PLATFORM_HAVEIF_LADDRCONF="#define ISC_PLATFORM_HAVEIF_LADDRCONF 1"],
	[AC_MSG_RESULT(no)
	ISC_PLATFORM_HAVEIF_LADDRCONF="#undef ISC_PLATFORM_HAVEIF_LADDRCONF"])
AC_SUBST(ISC_PLATFORM_HAVEIF_LADDRCONF)

#
# Check for network functions that are often missing.  We do this
# after the libtool checking, so we can put the right suffix on
# the files.  It also needs to come after checking for a Kame add-on,
# which provides some (all?) of the desired functions.
#

AC_MSG_CHECKING([for inet_ntop with IPv6 support])
AC_TRY_RUN([
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
main() {
char a[16],b[64]; return(inet_ntop(AF_INET6, a, b, sizeof(b)) == (char*)0);}],
	[AC_MSG_RESULT(yes)
	ISC_PLATFORM_NEEDNTOP="#undef ISC_PLATFORM_NEEDNTOP"],

	[AC_MSG_RESULT(no)
	ISC_EXTRA_OBJS="$ISC_EXTRA_OBJS inet_ntop.$O"
	ISC_EXTRA_SRCS="$ISC_EXTRA_SRCS inet_ntop.c"
	ISC_PLATFORM_NEEDNTOP="#define ISC_PLATFORM_NEEDNTOP 1"],
	[AC_MSG_RESULT(assuming inet_ntop not needed)
	ISC_PLATFORM_NEEDNTOP="#undef ISC_PLATFORM_NEEDNTOP"])


# On NetBSD 1.4.2 and maybe others, inet_pton() incorrectly accepts
# addresses with less than four octets, like "1.2.3".  Also leading
# zeros should also be rejected.

AC_MSG_CHECKING([for working inet_pton with IPv6 support])
AC_TRY_RUN([
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
main() { char a[16]; return (inet_pton(AF_INET, "1.2.3", a) == 1 ? 1 :
			     inet_pton(AF_INET, "1.2.3.04", a) == 1 ? 1 : 
			     (inet_pton(AF_INET6, "::1.2.3.4", a) != 1)); }],
	[AC_MSG_RESULT(yes)
	ISC_PLATFORM_NEEDPTON="#undef ISC_PLATFORM_NEEDPTON"],
	[AC_MSG_RESULT(no)
	ISC_EXTRA_OBJS="$ISC_EXTRA_OBJS inet_pton.$O"
	ISC_EXTRA_SRCS="$ISC_EXTRA_SRCS inet_pton.c"
	ISC_PLATFORM_NEEDPTON="#define ISC_PLATFORM_NEEDPTON 1"],
	[AC_MSG_RESULT(assuming inet_pton needed)
	ISC_EXTRA_OBJS="$ISC_EXTRA_OBJS inet_pton.$O"
	ISC_EXTRA_SRCS="$ISC_EXTRA_SRCS inet_pton.c"
	ISC_PLATFORM_NEEDPTON="#define ISC_PLATFORM_NEEDPTON 1"])

AC_SUBST(ISC_PLATFORM_NEEDNTOP)
AC_SUBST(ISC_PLATFORM_NEEDPTON)

#
# Look for a 4.4BSD-style sa_len member in struct sockaddr.
#
case "$host" in
	*-dec-osf*)
		# Turn on 4.4BSD style sa_len support.
		AC_DEFINE(_SOCKADDR_LEN)
		;;
esac

AC_MSG_CHECKING(for sa_len in struct sockaddr)
AC_TRY_COMPILE([
#include <sys/types.h>
#include <sys/socket.h>],
[struct sockaddr sa; sa.sa_len = 0; return (0);],
	[AC_MSG_RESULT(yes)
	ISC_PLATFORM_HAVESALEN="#define ISC_PLATFORM_HAVESALEN 1"],
	[AC_MSG_RESULT(no)
	ISC_PLATFORM_HAVESALEN="#undef ISC_PLATFORM_HAVESALEN"])
AC_SUBST(ISC_PLATFORM_HAVESALEN)

#
# Look for a 4.4BSD or 4.3BSD struct msghdr
#
AC_MSG_CHECKING(for struct msghdr flavor)
AC_TRY_COMPILE([
#include <sys/types.h>
#include <sys/socket.h>],
[struct msghdr msg; msg.msg_flags = 0; return (0);],
	[AC_MSG_RESULT(4.4BSD)
	ISC_PLATFORM_MSGHDRFLAVOR="#define ISC_NET_BSD44MSGHDR 1"],
	[AC_MSG_RESULT(4.3BSD)
	ISC_PLATFORM_MSGHDRFLAVOR="#define ISC_NET_BSD43MSGHDR 1"])
AC_SUBST(ISC_PLATFORM_MSGHDRFLAVOR)

#
# Look for in_port_t.
#
AC_MSG_CHECKING(for type in_port_t)
AC_TRY_COMPILE([
#include <sys/types.h>
#include <netinet/in.h>],
[in_port_t port = 25; return (0);],
	[AC_MSG_RESULT(yes)
	ISC_PLATFORM_NEEDPORTT="#undef ISC_PLATFORM_NEEDPORTT"],
	[AC_MSG_RESULT(no)
	ISC_PLATFORM_NEEDPORTT="#define ISC_PLATFORM_NEEDPORTT 1"])
AC_SUBST(ISC_PLATFORM_NEEDPORTT)

#
# Allow forcibly disabling TCP Fast Open support as autodetection might yield
# confusing results on some systems (e.g. FreeBSD; see set_tcp_fastopen()
# comment in lib/isc/unix/socket.c).
#

AC_ARG_ENABLE(tcp_fastopen,
	      AS_HELP_STRING([--disable-tcp-fastopen],
		     [disable TCP Fast Open support [default=autodetect]]))

AC_MSG_CHECKING(for TCP_FASTOPEN socket option)
case "$enable_tcp_fastopen" in
yes|''|autodetect)
	AC_EGREP_CPP(has_tfo, [
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/tcp.h>
#ifdef TCP_FASTOPEN
int has_tfo() { return (0); }
#endif
],
		[AC_MSG_RESULT(yes)
		ISC_PLATFORM_HAVETFO="#define ISC_PLATFORM_HAVETFO 1"],
		[AC_MSG_RESULT(no)
		ISC_PLATFORM_HAVETFO="#undef ISC_PLATFORM_HAVETFO"])

		;;
	no)
		AC_MSG_RESULT(disabled)
		ISC_PLATFORM_HAVETFO="#undef ISC_PLATFORM_HAVETFO"
		;;
esac
AC_SUBST(ISC_PLATFORM_HAVETFO)

#
# Check for addrinfo
#
AC_MSG_CHECKING(for struct addrinfo)
AC_TRY_COMPILE([
#include <netdb.h>],
[struct addrinfo a; return (0);],
	[AC_MSG_RESULT(yes)
	ISC_IRS_NEEDADDRINFO="#undef ISC_IRS_NEEDADDRINFO"
	AC_DEFINE(HAVE_ADDRINFO)],
	[AC_MSG_RESULT(no)
	ISC_IRS_NEEDADDRINFO="#define ISC_IRS_NEEDADDRINFO 1"])
AC_SUBST(ISC_IRS_NEEDADDRINFO)

#
# Sadly, the definitions of system-supplied getnameinfo(3) vary.  Try to catch
# known variations here:
#
AC_MSG_CHECKING(for getnameinfo prototype definitions)
AC_TRY_COMPILE([
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
int getnameinfo(const struct sockaddr *, socklen_t, char *,
		socklen_t, char *, socklen_t, unsigned int);],
[ return (0);],
	[AC_MSG_RESULT(socklen_t for buflen; u_int for flags)
	 AC_DEFINE(IRS_GETNAMEINFO_SOCKLEN_T, socklen_t,
		   [Define to the sockaddr length type used by getnameinfo(3).])
	 AC_DEFINE(IRS_GETNAMEINFO_BUFLEN_T, socklen_t,
		   [Define to the buffer length type used by getnameinfo(3).])
	 AC_DEFINE(IRS_GETNAMEINFO_FLAGS_T, unsigned int,
		   [Define to the flags type used by getnameinfo(3).])],
[AC_TRY_COMPILE([
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
int getnameinfo(const struct sockaddr *, socklen_t, char *,
		size_t, char *, size_t, int);],
[ return (0);],
	[AC_MSG_RESULT(size_t for buflen; int for flags)
	 AC_DEFINE(IRS_GETNAMEINFO_SOCKLEN_T, socklen_t)
	 AC_DEFINE(IRS_GETNAMEINFO_BUFLEN_T, size_t)
	 AC_DEFINE(IRS_GETNAMEINFO_FLAGS_T, int)],
[AC_TRY_COMPILE([
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
int getnameinfo(const struct sockaddr *, size_t, char *,
		size_t, char *, size_t, int);],
[ return (0);],
	[AC_MSG_RESULT(size_t for buflen; int for flags)
	 AC_DEFINE(IRS_GETNAMEINFO_SOCKLEN_T, size_t)
	 AC_DEFINE(IRS_GETNAMEINFO_BUFLEN_T, size_t)
	 AC_DEFINE(IRS_GETNAMEINFO_FLAGS_T, int)],
[AC_MSG_RESULT(not match any subspecies; assume standard definition)
AC_DEFINE(IRS_GETNAMEINFO_SOCKLEN_T, socklen_t)
AC_DEFINE(IRS_GETNAMEINFO_BUFLEN_T, socklen_t)
AC_DEFINE(IRS_GETNAMEINFO_FLAGS_T, int)])])])

#
# ...and same for gai_strerror().
#
AC_MSG_CHECKING(for gai_strerror prototype definitions)
AC_TRY_COMPILE([
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
char *gai_strerror(int ecode);],
[ return (0); ],
	[AC_MSG_RESULT(returning char *)
	 AC_DEFINE([IRS_GAISTRERROR_RETURN_T], [char *],
	 [return type of gai_strerror])],
[AC_MSG_RESULT(not match any subspecies; assume standard definition)
AC_DEFINE([IRS_GAISTRERROR_RETURN_T], [const char *])])

AC_CHECK_FUNC(getaddrinfo, AC_DEFINE(HAVE_GETADDRINFO))
AC_CHECK_FUNC(gai_strerror, AC_DEFINE(HAVE_GAISTRERROR))
AC_SUBST(ISC_IRS_GETNAMEINFOSOCKLEN)

AC_ARG_ENABLE(getifaddrs,
	      AS_HELP_STRING([--enable-getifaddrs],
			     [enable the use of getifaddrs() [yes|no].]),
    want_getifaddrs="$enableval",  want_getifaddrs="yes")

#
# This interface iteration code for getifaddrs() will fall back to using
# /proc/net/if_inet6 if getifaddrs() in glibc doesn't return any IPv6
# addresses.
# 
case $want_getifaddrs in
glibc)
AC_MSG_WARN("--enable-getifaddrs=glibc is no longer required")
AC_CHECK_FUNC(getifaddrs, AC_DEFINE(HAVE_GETIFADDRS))
;;
yes)
AC_CHECK_FUNC(getifaddrs, AC_DEFINE(HAVE_GETIFADDRS))
;;
no)
;;
esac

#
# Look for a sysctl call to get the list of network interfaces.
#
case $ac_cv_header_sys_sysctl_h in
yes)
AC_MSG_CHECKING(for interface list sysctl)
AC_EGREP_CPP(found_rt_iflist, [
#include <sys/param.h>
#include <sys/sysctl.h>
#include <sys/socket.h>
#ifdef NET_RT_IFLIST
found_rt_iflist
#endif
],
	[AC_MSG_RESULT(yes)
	 AC_DEFINE(HAVE_IFLIST_SYSCTL)],
	[AC_MSG_RESULT(no)])
;;
esac

#
# Check for some other useful functions that are not ever-present.
#

# We test for strsep() using AC_TRY_LINK instead of AC_CHECK_FUNC
# because AIX 4.3.3 with patches for bos.adt.include to version 4.3.3.77
# reportedly defines strsep() without declaring it in <string.h> when
# -D_LINUX_SOURCE_COMPAT is not defined [RT #2190], and
# AC_CHECK_FUNC() incorrectly succeeds because it declares
# the function itself.
AC_MSG_CHECKING(for correctly declared strsep())
AC_TRY_LINK([#include <string.h>], [char *sp; char *foo = strsep(&sp, ".");],
	[AC_MSG_RESULT(yes); ISC_PLATFORM_NEEDSTRSEP="#undef ISC_PLATFORM_NEEDSTRSEP"],
	[AC_MSG_RESULT(no); ISC_PLATFORM_NEEDSTRSEP="#define ISC_PLATFORM_NEEDSTRSEP 1"])
AC_SUBST(ISC_PLATFORM_NEEDSTRSEP)

AC_CHECK_FUNC(memmove,
	[ISC_PLATFORM_NEEDMEMMOVE="#undef ISC_PLATFORM_NEEDMEMMOVE"],
	[ISC_PLATFORM_NEEDMEMMOVE="#define ISC_PLATFORM_NEEDMEMMOVE 1"])
AC_SUBST(ISC_PLATFORM_NEEDMEMMOVE)

AC_CHECK_FUNC(strtoul,
	[ISC_PLATFORM_NEEDSTRTOUL="#undef ISC_PLATFORM_NEEDSTRTOUL"
	 GENRANDOMLIB=""],
	[ISC_PLATFORM_NEEDSTRTOUL="#define ISC_PLATFORM_NEEDSTRTOUL 1"
	 GENRANDOMLIB='${ISCLIBS}'])
AC_SUBST(ISC_PLATFORM_NEEDSTRTOUL)
AC_SUBST(GENRANDOMLIB)

AC_CHECK_FUNC(strlcpy,
	[ISC_PLATFORM_NEEDSTRLCPY="#undef ISC_PLATFORM_NEEDSTRLCPY"],
	[ISC_PLATFORM_NEEDSTRLCPY="#define ISC_PLATFORM_NEEDSTRLCPY 1"])
AC_SUBST(ISC_PLATFORM_NEEDSTRLCPY)

AC_CHECK_FUNC(strlcat,
	[ISC_PLATFORM_NEEDSTRLCAT="#undef ISC_PLATFORM_NEEDSTRLCAT"],
	[ISC_PLATFORM_NEEDSTRLCAT="#define ISC_PLATFORM_NEEDSTRLCAT 1"])
AC_SUBST(ISC_PLATFORM_NEEDSTRLCAT)

AC_CHECK_FUNC(strcasestr,
	[ISC_PLATFORM_NEEDSTRCASESTR="#undef ISC_PLATFORM_NEEDSTRCASESTR"],
	[ISC_PLATFORM_NEEDSTRCASESTR="#define ISC_PLATFORM_NEEDSTRCASESTR 1"])
AC_SUBST(ISC_PLATFORM_NEEDSTRCASESTR)

AC_SUBST(READLINE_LIB)
AC_ARG_WITH(readline,
	    AS_HELP_STRING([--with-readline[=LIBSPEC]],
			   [specify readline library [default auto]]),
	    use_readline="$withval", use_readline="auto")
case "$use_readline" in
no)	;;
*)
	saved_LIBS="$LIBS"
	case "$use_readline" in
	yes|auto) try_readline="-ledit"; or_readline="-lreadline" ;;
	*) try_readline="$use_readline"
	esac
	for readline in "$try_readline" $or_readline
	do
		LIBS="$readline"
		AC_MSG_NOTICE(checking for readline with $readline)
		AC_CHECK_FUNCS(readline)
		if test "yes" = "$ac_cv_func_readline"
		then
			READLINE_LIB="$readline"
			break
		fi
		for lib in -lterminfo -ltermcap -lncurses -lcurses
		do
			AC_MSG_NOTICE(checking for readline with $readline $lib)
			unset ac_cv_func_readline
			LIBS="$readline $lib"
			AC_CHECK_FUNCS(readline)
			if test "yes" = "$ac_cv_func_readline"
			then
				READLINE_LIB="$readline $lib"
				break
			fi
		done
		if test "yes" = "$ac_cv_func_readline"
		then
			break
		fi
	done
	if test "auto" != "$use_readline" &&
	   test "X$READLINE_LIB" = "X"
	then
		AC_MSG_ERROR([The readline library was not found.])
	fi
	LIBS="$saved_LIBS"
	;;
esac
if test "yes" = "$ac_cv_func_readline"
then
	case "$READLINE_LIB" in
	*edit*)
		AC_CHECK_HEADERS(editline/readline.h)
		AC_CHECK_HEADERS(edit/readline/readline.h)
		AC_CHECK_HEADERS(edit/readline/history.h)
		;;
	esac
	AC_CHECK_HEADERS(readline/readline.h)
	AC_CHECK_HEADERS(readline/history.h)
fi

ISC_PRINT_OBJS=
ISC_PRINT_SRCS=
ISC_PLATFORM_NEEDPRINTF='#undef ISC_PLATFORM_NEEDPRINTF'
ISC_PLATFORM_NEEDFPRINTF='#undef ISC_PLATFORM_NEEDFPRINTF'
ISC_PLATFORM_NEEDSPRINTF='#undef ISC_PLATFORM_NEEDSPRINTF'
ISC_PLATFORM_NEEDVSNPRINTF='#undef ISC_PLATFORM_NEEDVSNPRINTF'

AC_MSG_CHECKING(sprintf return type)
AC_TRY_COMPILE([
#include <stdio.h>
],
[ char buf[2]; return(*sprintf(buf,"x"));],
[AC_MSG_RESULT(char *)
ISC_PRINT_OBJS="print.$O"
ISC_PRINT_SRCS="print.c"
ISC_PLATFORM_NEEDSPRINTF="#define ISC_PLATFORM_NEEDSPRINTF"
],[AC_MSG_RESULT(int)])

AC_CHECK_FUNC(vsnprintf, [],
	[ISC_PRINT_OBJS="print.$O"
	 ISC_PRINT_SRCS="print.c"
	 ISC_PLATFORM_NEEDVSNPRINTF="#define ISC_PLATFORM_NEEDVSNPRINTF 1"])

AC_MSG_CHECKING(printf for %z support)
AC_TRY_RUN([
#include <stdio.h>
main() {
	size_t j = 0;
	char buf[100];
	buf[0] = 0;
	sprintf(buf, "%zu", j);
	exit(strcmp(buf, "0") != 0);
}
],
	[AC_MSG_RESULT(yes)],
	[AC_MSG_RESULT(no)
	ISC_PRINT_OBJS="print.$O"
	ISC_PRINT_SRCS="print.c"
	ISC_PLATFORM_NEEDPRINTF='#define ISC_PLATFORM_NEEDPRINTF 1'
	ISC_PLATFORM_NEEDFPRINTF='#define ISC_PLATFORM_NEEDFPRINTF 1'
	ISC_PLATFORM_NEEDFSRINTF='#define ISC_PLATFORM_NEEDSPRINTF 1'
	ISC_PLATFORM_NEEDVSNPRINTF="#define ISC_PLATFORM_NEEDVSNPRINTF 1"],
	[AC_MSG_RESULT(assuming target platform supports %z)])

AC_SUBST(ISC_PLATFORM_NEEDPRINTF)
AC_SUBST(ISC_PLATFORM_NEEDFPRINTF)
AC_SUBST(ISC_PLATFORM_NEEDSPRINTF)
AC_SUBST(ISC_PLATFORM_NEEDVSNPRINTF)

ISC_EXTRA_OBJS="$ISC_EXTRA_OBJS $ISC_PRINT_OBJS"
ISC_EXTRA_SRCS="$ISC_EXTRA_SRCS $ISC_PRINT_SRCS"
AC_SUBST(ISC_EXTRA_OBJS)
AC_SUBST(ISC_EXTRA_SRCS)

AC_CHECK_FUNC(strerror, AC_DEFINE(HAVE_STRERROR))
#
# Use our own SPNEGO implementation?
#
AC_ARG_ENABLE(isc-spnego,
	      AS_HELP_STRING([--disable-isc-spnego],
			     [use SPNEGO from GSSAPI library]))

if test -n "$USE_GSSAPI"
then
	case "$enable_isc_spnego" in
		yes|'')
			USE_ISC_SPNEGO='-DUSE_ISC_SPNEGO'
			DST_EXTRA_OBJS="$DST_EXTRA_OBJS spnego.$O"
			DST_EXTRA_SRCS="$DST_EXTRA_SRCS spnego.c"
			AC_MSG_RESULT(using SPNEGO from lib/dns)
			;;
		no)
			AC_MSG_RESULT(using SPNEGO from GSSAPI library)
			;;
	esac
fi

AC_SUBST(USE_ISC_SPNEGO)

AC_SUBST(DST_EXTRA_OBJS)
AC_SUBST(DST_EXTRA_SRCS)

# Determine the printf format characters to use when printing
# values of type isc_int64_t. This will normally be "ll", but where
# the compiler treats "long long" as a alias for "long" and printf
# doesn't know about "long long" use "l".  Hopefully the sprintf
# will produce a inconsistent result in the later case.  If the compiler
# fails due to seeing "%lld" we fall back to "l".
#
# Digital Unix 4.0 (gcc?) (long long) is 64 bits as is its long. It uses
# %ld even for (long long)/
#
# Win32 uses "%I64d", but that's defined elsewhere since we don't use
# configure on Win32.
#
AC_MSG_CHECKING(printf format modifier for 64-bit integers)
AC_TRY_RUN([
#include <stdio.h>
main() {
	long long int j = 0;
	char buf[100];
	buf[0] = 0;
	sprintf(buf, "%lld", j);
	exit((sizeof(long long int) != sizeof(long int))? 0 :
	     (strcmp(buf, "0") != 0));
} 
],
	[AC_MSG_RESULT(ll)
	ISC_PLATFORM_QUADFORMAT='#define ISC_PLATFORM_QUADFORMAT "ll"'],
	[AC_MSG_RESULT(l)
	ISC_PLATFORM_QUADFORMAT='#define ISC_PLATFORM_QUADFORMAT "l"'],
	[AC_MSG_RESULT(assuming target platform uses ll)
	ISC_PLATFORM_QUADFORMAT='#define ISC_PLATFORM_QUADFORMAT "ll"'])
AC_SUBST(ISC_PLATFORM_QUADFORMAT)


#
# Security Stuff
#
# Note it is very recommended to *not* disable chroot(),
# this is only because chroot() was made obsolete by Posix.
AC_ARG_ENABLE(chroot, AS_HELP_STRING([--disable-chroot], [disable chroot]))
case "$enable_chroot" in
	yes|'')
		AC_CHECK_FUNCS(chroot)
		;;
	no)
		;;
esac
AC_ARG_ENABLE(linux-caps,
	      AS_HELP_STRING([--disable-linux-caps],
			     [disable linux capabilities]))
case "$enable_linux_caps" in
	yes|'')
		AC_CHECK_HEADERS(linux/types.h)
		AC_CHECK_HEADERS([sys/capability.h])
		AC_CHECK_HEADERS([linux/capability.h], [], [],
				 [#ifdef HAVE_LINUX_TYPES_H
				  #include <linux/types.h>
				  #endif
				 ])
		AC_CHECK_LIB(cap, cap_set_proc)
		;;
	no)
		;;
esac
AC_CHECK_HEADERS(sys/prctl.h)

AC_CHECK_HEADERS(sys/un.h,
ISC_PLATFORM_HAVESYSUNH="#define ISC_PLATFORM_HAVESYSUNH 1"
,
ISC_PLATFORM_HAVESYSUNH="#undef ISC_PLATFORM_HAVESYSUNH"
)
AC_SUBST(ISC_PLATFORM_HAVESYSUNH)

case "$host" in
*-solaris*)
	AC_DEFINE(NEED_SECURE_DIRECTORY, 1,
		  [Define if connect does not honour the permission on the UNIX domain socket.])
	;;
*-sunos*)
	AC_DEFINE(NEED_SECURE_DIRECTORY, 1,
		  [Define if connect does not honour the permission on the UNIX domain socket.])
	;;
esac

#
# Time Zone Stuff
#
AC_CHECK_FUNC(tzset, AC_DEFINE(HAVE_TZSET))

AC_MSG_CHECKING(for optarg declaration)
AC_TRY_COMPILE([
#include <unistd.h>
],
[optarg = 0;],
[AC_MSG_RESULT(yes)],
[AC_MSG_RESULT(no)
GEN_NEED_OPTARG="-DNEED_OPTARG=1"
AC_DEFINE(NEED_OPTARG, 1, [Defined if extern char *optarg is not declared.])])

#
# Check for nanoseconds in file stats
#
AC_MSG_CHECKING(st_mtim.tv_nsec)
AC_TRY_COMPILE([#include <sys/fcntl.h>],[struct stat s; return(s.st_mtim.tv_nsec);],
	[AC_MSG_RESULT(yes)
	ISC_PLATFORM_HAVESTATNSEC="#define ISC_PLATFORM_HAVESTATNSEC 1"],
	[AC_MSG_RESULT(no)
	ISC_PLATFORM_HAVESTATNSEC="#undef ISC_PLATFORM_HAVESTATNSEC"])
AC_SUBST(ISC_PLATFORM_HAVESTATNSEC)

#
# BSD/OS, and perhaps some others, don't define rlim_t.
#
AC_MSG_CHECKING(for type rlim_t)
AC_TRY_COMPILE([
#include <sys/types.h>
#include <sys/time.h>
#include <sys/resource.h>],
[rlim_t rl = 19671212; return (0);],
[AC_MSG_RESULT(yes)
 ISC_PLATFORM_RLIMITTYPE="#define ISC_PLATFORM_RLIMITTYPE rlim_t"],
[AC_MSG_RESULT(no)

AC_MSG_CHECKING(type of rlim_cur)
AC_TRY_RUN([
#include <sys/types.h>
#include <sys/time.h>
#include <sys/resource.h>
main() { struct rlimit r; exit(!(sizeof(r.rlim_cur) == sizeof(int)));}],
[AC_MSG_RESULT(int)
ISC_PLATFORM_RLIMITTYPE="#define ISC_PLATFORM_RLIMITTYPE int"],
[
AC_TRY_RUN([
#include <sys/types.h>
#include <sys/time.h>
#include <sys/resource.h>
main() { struct rlimit r; exit(!(sizeof(r.rlim_cur) == sizeof(long int)));}],
[AC_MSG_RESULT(long int)
ISC_PLATFORM_RLIMITTYPE="#define ISC_PLATFORM_RLIMITTYPE long int"],
[
AC_TRY_RUN([
#include <sys/types.h>
#include <sys/time.h>
#include <sys/resource.h>
main() { struct rlimit r; exit((!sizeof(r.rlim_cur) == sizeof(long long int)));}],
[AC_MSG_RESULT(long long int)
ISC_PLATFORM_RLIMITTYPE="#define ISC_PLATFORM_RLIMITTYPE long long int"],
[AC_MSG_ERROR([unable to determine sizeof rlim_cur])
],[AC_MSG_ERROR(this cannot happen)])
],[AC_MSG_ERROR(this cannot happen)])
],[
AC_ARG_WITH(rlimtype, , rlimtype="$withval", rlimtype="long long int")
ISC_PLATFORM_RLIMITTYPE="#define ISC_PLATFORM_RLIMITTYPE $rlimtype"
AC_MSG_RESULT(cannot determine type of rlim_cur when cross compiling - assuming $rlimtype)])
])
AC_SUBST(ISC_PLATFORM_RLIMITTYPE)

#
# Older HP-UX doesn't have gettune
#
case "$host" in
	*-hp-hpux*)
		AC_CHECK_HEADERS(sys/dyntune.h)
		;;
	*)
		;;
esac


#
# Compaq TruCluster requires more code for handling cluster IP aliases
#
case "$host" in
	*-dec-osf*)
		AC_CHECK_LIB(clua, clua_getaliasaddress, LIBS="-lclua $LIBS")
		AC_CHECK_FUNC(clua_getaliasaddress,
				AC_DEFINE(HAVE_TRUCLUSTER, 1,
					[Define if running under Compaq TruCluster]))
		;;
	*)
		;;
esac

#
# Some hosts need msg_namelen to match the size of the socket structure.
# Some hosts don't set msg_namelen appropriately on return from recvmsg().
#
case $host in
*os2*|*hp-mpeix*)
	AC_DEFINE(BROKEN_RECVMSG, 1,
		  [Define if recvmsg() does not meet all of the BSD socket API specifications.])
	;;
esac

#
# Microsoft has their own way of handling shared libraries that requires
# additional qualifiers on extern variables.  Unix systems don't need it.
#
AC_SUBST(ISC_PLATFORM_USEDECLSPEC)
ISC_PLATFORM_USEDECLSPEC="#undef ISC_PLATFORM_USEDECLSPEC"
AC_SUBST(IRS_PLATFORM_USEDECLSPEC)
IRS_PLATFORM_USEDECLSPEC="#undef IRS_PLATFORM_USEDECLSPEC"

#
# Random remaining OS-specific issues involving compiler warnings.
# XXXDCL print messages to indicate some compensation is being done?
#
AC_SUBST(ISC_PLATFORM_BRACEPTHREADONCEINIT)
ISC_PLATFORM_BRACEPTHREADONCEINIT="#undef ISC_PLATFORM_BRACEPTHREADONCEINIT"

case "$host" in
	*-aix5.[[123]].*)
		hack_shutup_pthreadonceinit=yes
		;;
	*-bsdi3.1*)
		hack_shutup_sputaux=yes
		;;
	*-bsdi4.0*)
		hack_shutup_sigwait=yes
		hack_shutup_sputaux=yes
		;;
	[*-bsdi4.[12]*])
		hack_shutup_stdargcast=yes
		;;
	[*-solaris2.[89]])
		hack_shutup_pthreadonceinit=yes
		;;
	*-solaris2.1[[0-9]])
		AC_TRY_COMPILE([ #include <pthread.h> ], [ static pthread_once_t once_test = { PTHREAD_ONCE_INIT }; ], [hack_shutup_pthreadonceinit=yes], )
		;;
esac

case "$hack_shutup_pthreadonceinit" in
	yes)
		#
		# Shut up PTHREAD_ONCE_INIT unbraced initializer warnings.
		#
		ISC_PLATFORM_BRACEPTHREADONCEINIT="#define ISC_PLATFORM_BRACEPTHREADONCEINIT 1"
		;;
esac

case "$hack_shutup_sigwait" in
	yes)
		#
		# Shut up a -Wmissing-prototypes warning for sigwait().
		#
		AC_DEFINE(SHUTUP_SIGWAIT)
		;;
esac

case "$hack_shutup_sputaux" in
	yes)
		#
		# Shut up a -Wmissing-prototypes warning from <stdio.h>.
		#
		AC_DEFINE(SHUTUP_SPUTAUX)
		;;
esac

case "$hack_shutup_stdargcast" in
	yes)
		#
		# Shut up a -Wcast-qual warning from va_start().
		#
		AC_DEFINE(SHUTUP_STDARG_CAST)
		;;
esac

AC_CHECK_HEADERS(strings.h,
  ISC_PLATFORM_HAVESTRINGSH="#define ISC_PLATFORM_HAVESTRINGSH 1"
,
  ISC_PLATFORM_HAVESTRINGSH="#undef ISC_PLATFORM_HAVESTRINGSH"
)
AC_SUBST(ISC_PLATFORM_HAVESTRINGSH)

#
# Check for if_nametoindex() for IPv6 scoped addresses support
#
AC_CHECK_FUNC(if_nametoindex, ac_cv_have_if_nametoindex=yes,
		ac_cv_have_if_nametoindex=no)
case $ac_cv_have_if_nametoindex in
no)
	case "$host" in
	*-hp-hpux*)
		AC_CHECK_LIB(ipv6, if_nametoindex,
				ac_cv_have_if_nametoindex=yes
				LIBS="-lipv6 $LIBS",)
	;;
	esac
esac
case $ac_cv_have_if_nametoindex in
yes)
	ISC_PLATFORM_HAVEIFNAMETOINDEX="#define ISC_PLATFORM_HAVEIFNAMETOINDEX 1"
	AC_DEFINE(HAVE_IF_NAMETOINDEX, 1,
	[Define to 1 if you have the if_nametoindex function.])
	;;
*)
	ISC_PLATFORM_HAVEIFNAMETOINDEX="#undef ISC_PLATFORM_HAVEIFNAMETOINDEX"
	;;
esac
AC_SUBST(ISC_PLATFORM_HAVEIFNAMETOINDEX)

AC_CHECK_FUNCS(nanosleep usleep explicit_bzero)

#
# Machine architecture dependent features
#
have_stdatomic=no
AC_MSG_CHECKING(for usable stdatomic.h)
AC_TRY_COMPILE([
#include <stdio.h>
#include <stdatomic.h>
],
[
atomic_int_fast32_t val = 0; atomic_fetch_add_explicit(&val, 1, memory_order_relaxed);
],
        [AC_MSG_RESULT(yes)
	 have_stdatomic=yes
	 ISC_PLATFORM_HAVESTDATOMIC="#define ISC_PLATFORM_HAVESTDATOMIC 1"],
	[AC_MSG_RESULT(no)
	 have_stdatomic=no
	 ISC_PLATFORM_HAVESTDATOMIC="#undef ISC_PLATFORM_HAVESTDATOMIC"])

AC_ARG_ENABLE(atomic,
	      AS_HELP_STRING([--enable-atomic],
			     [enable machine specific atomic operations [default=autodetect]]),
			enable_atomic="$enableval",
			enable_atomic="autodetect")
case "$enable_atomic" in
	yes|''|autodetect)
		case "$host" in
		powerpc-ibm-aix*)
			if test "X$GCC" = "Xyes"; then
				AC_MSG_CHECKING([if asm("ics"); works])
				AC_TRY_COMPILE(,[
				main() { asm("ics"); exit(0); }
				],
				[AC_MSG_RESULT(yes)
				 use_atomic=yes],
				[
				saved_cflags="$CFLAGS"
				CFLAGS="$CFLAGS -Wa,-many"
				AC_TRY_RUN([
				main() { asm("ics"); exit(0); }
				],
				[AC_MSG_RESULT([yes, required -Wa,-many])
				 use_atomic=yes],
				[AC_MSG_RESULT([no, use_atomic disabled])
				 CFLAGS="$saved_cflags"
				 use_atomic=no],
				[AC_MSG_RESULT([cross compile, assume yes])
				 CFLAGS="$saved_cflags"
				 use_atomic=yes])
				]
				)
			else
				use_atomic=yes
			fi
			;;
		*)
			use_atomic=yes
			;;
		esac
		;;
	no)
		have_stdatomic=no
		ISC_PLATFORM_HAVESTDATOMIC="#undef ISC_PLATFORM_HAVESTDATOMIC"
		use_atomic=no
		arch=noatomic
		;;
esac

if test "X$have_stdatomic" = "Xyes"; then
    AC_MSG_CHECKING(if -latomic is needed to use 64-bit stdatomic.h primitives)
    AC_LINK_IFELSE(
	[AC_LANG_PROGRAM([#include <stdatomic.h>],
			 [atomic_int_fast64_t val = 0; atomic_fetch_add_explicit(&val, 1, memory_order_relaxed);])],
	[AC_MSG_RESULT(no)
	 ISC_ATOMIC_LIBS=""],
	[AC_MSG_RESULT(yes)
	 ISC_ATOMIC_LIBS="-latomic"]
    )
    LIBS="$LIBS $ISC_ATOMIC_LIBS"
fi

AC_SUBST(ISC_PLATFORM_HAVESTDATOMIC)

ISC_PLATFORM_USEOSFASM="#undef ISC_PLATFORM_USEOSFASM"
ISC_PLATFORM_USEGCCASM="#undef ISC_PLATFORM_USEGCCASM"
ISC_PLATFORM_USESTDASM="#undef ISC_PLATFORM_USESTDASM"
ISC_PLATFORM_USEMACASM="#undef ISC_PLATFORM_USEMACASM"
if test "yes" = "$use_atomic"; then
	AC_CHECK_SIZEOF([void *])
	have_atomic=yes		# set default
	case "$host" in
	[i[3456]86-*])
		# XXX: some old x86 architectures actually do not support
		#      (some of) these operations.  Do we need stricter checks?
		if test $ac_cv_sizeof_void_p = 8; then
			arch=x86_64
			have_xaddq=yes
		else
			arch=x86_32
		fi
	;;
	x86_64-*|amd64-*)
		if test $ac_cv_sizeof_void_p = 8; then
			arch=x86_64
			have_xaddq=yes
		else
			arch=x86_32
		fi
	;;
	alpha*-*)
		arch=alpha
	;;
	powerpc-*|powerpc64-*)
		arch=powerpc
	;;
	mips-*|mipsel-*|mips64-*|mips64el-*)
		arch=mips
	;;
	ia64-*)
		arch=ia64
	;;
	*)
		have_atomic=no
		arch=noatomic
	;;
	esac
	AC_MSG_CHECKING([architecture type for atomic operations])
	AC_MSG_RESULT($arch)
fi

if test "yes" = "$have_atomic"; then
	AC_MSG_CHECKING([compiler support for inline assembly code])

	compiler=generic
	# Check whether the compiler supports the assembly syntax we provide.
	if test "X$GCC" = "Xyes"; then
		# GCC's ASM extension always works
		compiler=gcc
		if test $arch = "x86_64"; then
			# We can share the same code for gcc with x86_32
			arch=x86_32
		fi
		if test $arch = "powerpc"; then
			#
			# The MacOS (and maybe others) uses "r0" for register
			# zero. Under linux/ibm it is "0" for register 0.
			# Probe to see if we have a MacOS style assembler.
			#
			AC_MSG_CHECKING([Checking for MacOS style assembler syntax])
			AC_TRY_COMPILE(, [
			__asm__ volatile ("li r0, 0x0\n"::);
			], [
			AC_MSG_RESULT(yes)
			compiler="mac"
			ISC_PLATFORM_USEMACASM="#define ISC_PLATFORM_USEMACASM 1"
			], [AC_MSG_RESULT(no)])
		fi
	else
		case "$host" in
		alpha*-dec-osf*)
			# Tru64 compiler has its own syntax for inline 
			# assembly.
			AC_TRY_COMPILE(, [
#ifndef __DECC
#error "unexpected compiler"
#endif
				return (0);],
				[compiler=osf],)
		;;
		powerpc-ibm-aix*)
			compiler=aix
		;;
		esac
	fi
	case "$compiler" in
	gcc)
		ISC_PLATFORM_USEGCCASM="#define ISC_PLATFORM_USEGCCASM 1"
		;;
	osf)
		ISC_PLATFORM_USEOSFASM="#define ISC_PLATFORM_USEOSFASM 1"
		;;
	aix)
		;;
	mac)
		;;
	*)
		# See if the generic __asm function works.  If not,
		# we need to disable the atomic operations.
		AC_TRY_LINK(, [
					__asm("nop")
				],
		[compiler="standard"
		ISC_PLATFORM_USESTDASM="#define ISC_PLATFORM_USESTDASM 1"],
		[compiler="not supported (atomic operations disabled)"
		have_atomic=no
		arch=noatomic ]);
		;;
	esac

	AC_MSG_RESULT($compiler)
fi

if test "yes" = "$have_atomic"; then
	ISC_PLATFORM_HAVEXADD="#define ISC_PLATFORM_HAVEXADD 1"
	ISC_PLATFORM_HAVECMPXCHG="#define ISC_PLATFORM_HAVECMPXCHG 1"
	ISC_PLATFORM_HAVEATOMICSTORE="#define ISC_PLATFORM_HAVEATOMICSTORE 1"
	if test "yes" = "$have_xaddq"; then
		ISC_PLATFORM_HAVEXADDQ="#define ISC_PLATFORM_HAVEXADDQ 1"
		ISC_PLATFORM_HAVEATOMICSTOREQ="#define ISC_PLATFORM_HAVEATOMICSTOREQ 1"
	else
		ISC_PLATFORM_HAVEXADDQ="#undef ISC_PLATFORM_HAVEXADDQ"
		ISC_PLATFORM_HAVEATOMICSTOREQ="#undef ISC_PLATFORM_HAVEATOMICSTOREQ"
	fi
else
	ISC_PLATFORM_HAVEXADD="#undef ISC_PLATFORM_HAVEXADD"
	ISC_PLATFORM_HAVECMPXCHG="#undef ISC_PLATFORM_HAVECMPXCHG"
	ISC_PLATFORM_HAVEATOMICSTORE="#undef ISC_PLATFORM_HAVEATOMICSTORE"
	ISC_PLATFORM_HAVEXADDQ="#undef ISC_PLATFORM_HAVEXADDQ"
	ISC_PLATFORM_HAVEATOMICSTOREQ="#undef ISC_PLATFORM_HAVEATOMICSTOREQ"
fi

AC_SUBST(ISC_PLATFORM_HAVEXADD)
AC_SUBST(ISC_PLATFORM_HAVEXADDQ)
AC_SUBST(ISC_PLATFORM_HAVECMPXCHG)
AC_SUBST(ISC_PLATFORM_HAVEATOMICSTORE)
AC_SUBST(ISC_PLATFORM_HAVEATOMICSTOREQ)

AC_SUBST(ISC_PLATFORM_USEGCCASM)
AC_SUBST(ISC_PLATFORM_USEOSFASM)
AC_SUBST(ISC_PLATFORM_USESTDASM)
AC_SUBST(ISC_PLATFORM_USEMACASM)

ISC_ARCH_DIR=$arch
AC_SUBST(ISC_ARCH_DIR)

#
# Check for __builtin_expect
#
AC_MSG_CHECKING([compiler support for __builtin_expect])
AC_TRY_LINK(, [
	return (__builtin_expect(1, 1) ? 1 : 0);
], [
	have_builtin_expect=yes
	AC_MSG_RESULT(yes)
], [
	have_builtin_expect=no
	AC_MSG_RESULT(no)
])
if test "yes" = "$have_builtin_expect"; then
	AC_DEFINE(HAVE_BUILTIN_EXPECT, 1, [Define to 1 if the compiler supports __builtin_expect.])
fi

#
# Check for __builtin_clz
#
AC_MSG_CHECKING([compiler support for __builtin_clz])
AC_TRY_LINK(, [
	return (__builtin_clz(0xff) == 24 ? 1 : 0);
], [
	have_builtin_clz=yes
	AC_MSG_RESULT(yes)
], [
	have_builtin_clz=no
	AC_MSG_RESULT(no)
])
if test "yes" = "$have_builtin_clz"; then
	AC_DEFINE(HAVE_BUILTIN_CLZ, 1, [Define to 1 if the compiler supports __builtin_clz.])
fi

#
# CPU relax (for spin locks)
#
if $use_threads
then
	case "$host" in
	[i[3456]86-*])
		# x86_32
		AC_MSG_CHECKING([if asm("rep; nop"); works])
		AC_TRY_COMPILE(,[asm("rep; nop");],
		[AC_MSG_RESULT(yes)
		 ISC_PLATFORM_BUSYWAITNOP="#define ISC_PLATFORM_BUSYWAITNOP asm(\"rep; nop\")"],
		[AC_MSG_RESULT(no)],
		[AC_MSG_RESULT([cross compile, assume yes])
		 ISC_PLATFORM_BUSYWAITNOP="#define ISC_PLATFORM_BUSYWAITNOP asm(\"rep; nop\")"])
		;;
	x86_64-*|amd64-*)
		# x86_64
		AC_MSG_CHECKING([if asm("rep; nop"); works])
		AC_TRY_COMPILE(,[asm("rep; nop");],
		[AC_MSG_RESULT(yes)
		 ISC_PLATFORM_BUSYWAITNOP="#define ISC_PLATFORM_BUSYWAITNOP asm(\"rep; nop\")"],
		[AC_MSG_RESULT(no)],
		[AC_MSG_RESULT([cross compile, assume yes])
		 ISC_PLATFORM_BUSYWAITNOP="#define ISC_PLATFORM_BUSYWAITNOP asm(\"rep; nop\")"])
		;;
	ia64-*)
		# ia64
		AC_MSG_CHECKING([if asm("hint @pause"); works])
		AC_TRY_COMPILE(,[asm("hint @pause");],
		[AC_MSG_RESULT(yes)
		 ISC_PLATFORM_BUSYWAITNOP="#define ISC_PLATFORM_BUSYWAITNOP asm(\"hint @pause\")"],
		[AC_MSG_RESULT(no)],
		[AC_MSG_RESULT([cross compile, assume yes])
		 ISC_PLATFORM_BUSYWAITNOP="#define ISC_PLATFORM_BUSYWAITNOP asm(\"hint @pause\")"])
		;;
	sparc-*)
		# sparc
		AC_MSG_CHECKING([if cpu_relax(); or __cpu_relax(); works])
		AC_CHECK_FUNC(cpu_relax,
		[AC_MSG_RESULT(yes)
		 ISC_PLATFORM_BUSYWAITNOP="#define ISC_PLATFORM_BUSYWAITNOP cpu_relax()"],
		 [AC_CHECK_FUNC(__cpu_relax,
		  [AC_MSG_RESULT(yes)
		   ISC_PLATFORM_BUSYWAITNOP="#define ISC_PLATFORM_BUSYWAITNOP __cpu_relax()"],
		   [AC_MSG_RESULT(no)])])
		;;
	esac
fi

AC_SUBST(ISC_PLATFORM_BUSYWAITNOP)

#
# Activate "rrset-order fixed" or not?
#
AC_ARG_ENABLE(fixed-rrset,
	      AS_HELP_STRING([--enable-fixed-rrset],
			     [enable fixed rrset ordering [default=no]]),
	      enable_fixed="$enableval", enable_fixed="no")
case "$enable_fixed" in
	yes)
		AC_DEFINE(DNS_RDATASET_FIXED, 1,
			  [Define to enable "rrset-order fixed" syntax.])
		;;
	no)
		;;
	*)
		;;
esac

#
# Enable response policy rewriting using NS IP addresses
#
AC_ARG_ENABLE(rpz-nsip,
	      AS_HELP_STRING([--disable-rpz-nsip],
			     [disable rpz nsip rules [default=enabled]]),
	      enable_nsip="$enableval", enable_nsip="yes")
case "$enable_nsip" in
	yes)
		AC_DEFINE(ENABLE_RPZ_NSIP, 1,
			  [Define to enable rpz nsip rules.])
		;;
	no)
		;;
	*)
		;;
esac

#
# Enable response policy rewriting using NS name
#
AC_ARG_ENABLE(rpz-nsdname,
	      AS_HELP_STRING([--disable-rpz-nsdname],
			     [disable rpz nsdname rules [default=enabled]]),
	      enable_nsdname="$enableval", enable_nsdname="yes")
case "$enable_nsdname" in
	yes)
		AC_DEFINE(ENABLE_RPZ_NSDNAME, 1,
			  [Define to enable rpz nsdname rules.])
		;;
	no)
		;;
	*)
		;;
esac

#
# Response policy rewriting using DNS Response Policy Service (DNSRPS)
# interface.
#
# DNSRPS can be compiled into BIND everywhere with a reasonably
# modern C compiler.  It is enabled on systems with dlopen() and librpz.so.
#
dnsrps_avail=yes
AC_MSG_CHECKING([for librpz __attribute__s])
    AC_TRY_COMPILE(,[
	extern void f(char *p __attribute__((unused)), ...)
	__attribute__((format(printf,1,2))) __attribute__((__noreturn__));],
    librpz_have_attr=yes
    AC_DEFINE([LIBRPZ_HAVE_ATTR], 1, [have __attribute__s used in librpz.h])
    AC_MSG_RESULT([yes]),
    librpz_have_attr=no
    AC_MSG_RESULT([no]))

AC_SEARCH_LIBS(dlopen, dl)
librpz_dl=yes
AC_CHECK_FUNCS(dlopen dlclose dlsym,,librpz_dl=no)
AC_ARG_ENABLE([dnsrps-dl],
	      AS_HELP_STRING([--enable-dnsrps-dl],
			     [DNS Response Policy Service delayed link
				[default=$librpz_dl]]),
	      [enable_librpz_dl="$enableval"], [enable_librpz_dl="$librpz_dl"])
AC_ARG_WITH([dnsrps-libname],
	    AS_HELP_STRING([--with-dnsrps-libname],
			   [DNSRPS provider library name (librpz.so)]),
	    [librpz_name="$withval"], [librpz_name="librpz.so"])
AC_ARG_WITH([dnsrps-dir],
	    AS_HELP_STRING([--with-dnsrps-dir],
			   [path to DNSRPS provider library]),
	    [librpz_path="$withval/$librpz_name"], [librpz_path="$librpz_name"])
AC_DEFINE_UNQUOTED([DNSRPS_LIBRPZ_PATH], ["$librpz_path"],
	[dnsrps $librpz_name])
if test "x$enable_librpz_dl" = "xyes"; then
	dnsrps_lib_open=2
else
	dnsrps_lib_open=1
	# Add librpz.so to linked libraries if we are not using dlopen()
	AC_SEARCH_LIBS([librpz_client_create], [rpz], [],
		[dnsrps_lib_open=0
		 dnsrps_avail=no])
fi
AC_DEFINE_UNQUOTED([DNSRPS_LIB_OPEN], [$dnsrps_lib_open],
	[0=no DNSRPS  1=static link  2=dlopen()])

AC_ARG_ENABLE([dnsrps],
	      AS_HELP_STRING([--enable-dnsrps],
			     [enable DNS Response Policy Service API]),
	      [enable_dnsrps=$enableval], [enable_dnsrps=no])
if test "x$enable_dnsrps" != "xno"; then
	if test "x$dnsrps_avail" != "xyes"; then
		AC_MSG_ERROR([[dlopen and librpz.so needed for DNSRPS]])
	fi
	if test "x$dnsrps_lib_open" = "x0"; then
		AC_MSG_ERROR([[dlopen and librpz.so needed for DNSRPS]])
	fi
	AC_DEFINE([USE_DNSRPS], [1], [Enable DNS Response Policy Service API])
fi

#
# Activate dnstap?
#
AC_ARG_ENABLE(dnstap,
	      AS_HELP_STRING([--enable-dnstap],
			     [enable dnstap support
				(requires fstrm, protobuf-c)]),
	      use_dnstap=$enableval, use_dnstap=no)

DNSTAP=
DNSTAPSRCS=
DNSTAPOBJS=
DNSTAPTARGETS=
DNSTAP_PB_C_H=
if test "x$use_dnstap" != "xno"; then
	if ! $use_threads; then
		AC_MSG_ERROR([Dnstap requires threads.])
	fi
	AC_ARG_WITH([protobuf-c],
		    AS_HELP_STRING([--with-protobuf-c=path],
				   [Path where protobuf-c is installed, for dnstap]), [
	    # workaround for protobuf-c includes at old dir
	    # before protobuf-c-1.0.0
	    if test -f $withval/include/google/protobuf-c/protobuf-c.h
	    then
		CFLAGS="$CFLAGS -I$withval/include/google"
	    else
		CFLAGS="$CFLAGS -I$withval/include"
	    fi
	    LDFLAGS="$LDFLAGS -L$withval/lib"
	    AC_PATH_PROG([PROTOC_C], [protoc-c], [],
			 [$PATH$PATH_SEPARATOR$withval/bin])
	], [
	    # workaround for protobuf-c includes at old dir
	    # before protobuf-c-1.0.0
	    if test -f /usr/include/google/protobuf-c/protobuf-c.h
	    then
		CFLAGS="$CFLAGS -I/usr/include/google"
	    else
		if test -f /usr/local/include/google/protobuf-c/protobuf-c.h
		then
		    CFLAGS="$CFLAGS -I/usr/local/include/google"
		    LDFLAGS="$LDFLAGS -L/usr/local/lib"
		fi
	    fi
	    AC_PATH_PROG([PROTOC_C],[protoc-c])
	])
	if test -z "$PROTOC_C"; then
		AC_MSG_ERROR([The protoc-c program was not found.])
	fi
	AC_ARG_WITH([libfstrm], AS_HELP_STRING([--with-libfstrm=path],
		    [Path where libfstrm is installed, for dnstap]), [
	    CFLAGS="$CFLAGS -I$withval/include"
	    LDFLAGS="$LDFLAGS -L$withval/lib"
	    AC_PATH_PROG([FSTRM_CAPTURE], [fstrm_capture], [], [$PATH$PATH_SEPARATOR$withval/bin])
	],[
	    AC_PATH_PROG([FSTRM_CAPTURE], [fstrm_capture])
	])

	AC_SEARCH_LIBS([fstrm_iothr_init], [fstrm], [],
		       AC_MSG_ERROR([The fstrm library was not found. Please install fstrm!]))
	AC_SEARCH_LIBS([protobuf_c_message_pack], [protobuf-c], [],
		       AC_MSG_ERROR([The protobuf-c library was not found. Please install protobuf-c!]))

	AC_DEFINE(HAVE_DNSTAP, 1, [Define to 1 to enable dnstap support])
	DNSTAP=dnstap
	DNSTAPSRCS='${DNSTAPSRCS}'
	DNSTAPOBJS='${DNSTAPOBJS}'
	DNSTAPTARGETS='${DNSTAPTARGETS}'
	DNSTAP_PB_C_H="dnstap.pb-c.h"
fi
AC_SUBST(DNSTAP)
AC_SUBST(DNSTAPSRCS)
AC_SUBST(DNSTAPOBJS)
AC_SUBST(DNSTAPTARGETS)
AC_SUBST(DNSTAP_PB_C_H)

#
#  The following sets up how non-blocking i/o is established.
#  Sunos, cygwin and solaris 2.x (x<5) require special handling.
#
case "$host" in
*-sunos*) AC_DEFINE(PORT_NONBLOCK, O_NDELAY);;
*-cygwin*) AC_DEFINE(PORT_NONBLOCK, O_NDELAY);;
*-solaris2.[[01234]])
	AC_DEFINE(PORT_NONBLOCK, O_NONBLOCK)
	AC_DEFINE(USE_FIONBIO_IOCTL, 1,
		  [Defined if you need to use ioctl(FIONBIO) instead a fcntl call to make non-blocking.])
	;;
*) AC_DEFINE(PORT_NONBLOCK, O_NONBLOCK,
	     [Sets which flag to pass to open/fcntl to make non-blocking (O_NDELAY/O_NONBLOCK).])
	;;
esac
#
# Solaris 2.5.1 and earlier cannot bind() then connect() a TCP socket.
# This prevents the source address being set.
#
case "$host" in
*-solaris2.[[012345]]|*-solaris2.5.1)
	AC_DEFINE(BROKEN_TCP_BIND_BEFORE_CONNECT, 1,
		  [Define if you cannot bind() before connect() for TCP sockets.])
	;;
esac
#
# The following sections deal with tools used for formatting
# the documentation.  They are all optional, unless you are
# a developer editing the documentation source.
#

#
# Look for TeX.
#

AC_PATH_PROGS(LATEX, latex, latex)
AC_SUBST(LATEX)

AC_PATH_PROGS(PDFLATEX, pdflatex, pdflatex)
AC_SUBST(PDFLATEX)

AC_PATH_PROGS(DBLATEX, dblatex, dblatex)
AC_SUBST(DBLATEX)

#
# Look for w3m
#

AC_PATH_PROGS(W3M, w3m, w3m)
AC_SUBST(W3M)

#
# Look for pandoc
#
AC_PATH_PROG(PANDOC, pandoc, pandoc)
AC_SUBST(PANDOC)


#
# Look for xsltproc (libxslt)
#

AC_PATH_PROG(XSLTPROC, xsltproc, xsltproc)
AC_SUBST(XSLTPROC)

#
# Look for xmllint (libxml2)
#

AC_PATH_PROG(XMLLINT, xmllint, xmllint)
AC_SUBST(XMLLINT)

#
# Look for Doxygen
#

AC_PATH_PROG(DOXYGEN, doxygen, doxygen)
AC_SUBST(DOXYGEN)

#
# Look for curl
#

AC_PATH_PROG(CURL, curl, curl)
AC_SUBST(CURL)

#
# Subroutine for searching for an ordinary file (e.g., a stylesheet)
# in a number of directories:
#
#   NOM_PATH_FILE(VARIABLE, FILENAME, DIRECTORIES)
#
# If the file FILENAME is found in one of the DIRECTORIES, the shell
# variable VARIABLE is defined to its absolute pathname.  Otherwise, 
# it is set to FILENAME, with no directory prefix (that's not terribly
# useful, but looks less confusing in substitutions than leaving it
# empty).  The variable VARIABLE will be substituted into output files.
# 

AC_DEFUN(NOM_PATH_FILE, [
$1=""
AC_MSG_CHECKING(for $2)
for d in $3
do
	f=$d/$2
	if test -f $f
	then
		$1=$f
		AC_MSG_RESULT($f)
		break
	fi
done
if test "X[$]$1" = "X"
then
	AC_MSG_RESULT("not found");
	$1=$2
fi
AC_SUBST($1)
])

#
# Look for Docbook-XSL stylesheets.  Location probably varies by system.
# If it's not explicitly specified, guess where it might be found, based on
# where SGML stuff lives on some systems (FreeBSD is the only one we're sure
# of at the moment).
#
AC_MSG_CHECKING(for Docbook-XSL path)
AC_ARG_WITH(docbook-xsl,
	    AS_HELP_STRING([--with-docbook-xsl[=PATH]],
			   [specify path for Docbook-XSL stylesheets]),
   docbook_path="$withval", docbook_path="auto")
case "$docbook_path" in
auto)
	AC_MSG_RESULT(auto)
	docbook_xsl_trees="/usr/pkg/share/xsl/docbook /usr/local/share/xsl/docbook-ns /usr/local/share/xsl/docbook /usr/share/xsl/docbook /opt/local/share/xsl/docbook-xsl /usr/share/xml/docbook/stylesheet/docbook-xsl"
	;;
*)
	docbook_xsl_trees="$withval"
	AC_MSG_RESULT($docbook_xsl_trees)
	;;
esac

#
# Look for stylesheets we need.
#

NOM_PATH_FILE(XSLT_DOCBOOK_STYLE_HTML, html/docbook.xsl, $docbook_xsl_trees)
NOM_PATH_FILE(XSLT_DOCBOOK_STYLE_XHTML, xhtml/docbook.xsl, $docbook_xsl_trees)
NOM_PATH_FILE(XSLT_DOCBOOK_STYLE_MAN, manpages/docbook.xsl, $docbook_xsl_trees)
NOM_PATH_FILE(XSLT_DOCBOOK_CHUNK_HTML, html/chunk.xsl, $docbook_xsl_trees)
NOM_PATH_FILE(XSLT_DOCBOOK_CHUNK_XHTML, xhtml/chunk.xsl, $docbook_xsl_trees)
NOM_PATH_FILE(XSLT_DOCBOOK_CHUNKTOC_HTML, html/chunktoc.xsl, $docbook_xsl_trees)
NOM_PATH_FILE(XSLT_DOCBOOK_CHUNKTOC_XHTML, xhtml/chunktoc.xsl, $docbook_xsl_trees)
NOM_PATH_FILE(XSLT_DOCBOOK_MAKETOC_HTML, html/maketoc.xsl, $docbook_xsl_trees)
NOM_PATH_FILE(XSLT_DOCBOOK_MAKETOC_XHTML, xhtml/maketoc.xsl, $docbook_xsl_trees)

#
# Same dance for dblatex
#
dblatex_xsl_trees="/usr/local/share/xml/docbook/stylesheet/dblatex /usr/pkg/share/xml/docbook/stylesheet/dblatex /usr/share/xml/docbook/stylesheet/dblatex"
NOM_PATH_FILE(XSLT_DBLATEX_STYLE, xsl/docbook.xsl, $dblatex_xsl_trees)
NOM_PATH_FILE(XSLT_DBLATEX_FASTBOOK, xsl/latex_book_fast.xsl, $dblatex_xsl_trees)

#
# IDN support
#
AC_ARG_WITH(idn,
	    AS_HELP_STRING([--with-idn[=MPREFIX]],
			   [enable IDN support using idnkit [default PREFIX]]),
	use_idn="$withval", use_idn="no")
case "$use_idn" in
yes)
	if test X$prefix = XNONE ; then
		idn_path=/usr/local
	else
		idn_path=$prefix
	fi
	;;
no)
	;;
*)
	idn_path="$use_idn"
	;;
esac

iconvinc=
iconvlib=
AC_ARG_WITH(libiconv,
	    AS_HELP_STRING([--with-libiconv[=IPREFIX]],
			   [GNU libiconv are in IPREFIX [default PREFIX]]),
	use_libiconv="$withval", use_libiconv="no")
case "$use_libiconv" in
yes)
	if test X$prefix = XNONE ; then
		iconvlib="-L/usr/local/lib -R/usr/local/lib -liconv"
	else
		iconvlib="-L$prefix/lib -R$prefix/lib -liconv"
	fi
	;;
no)
	iconvlib=
	;;
*)
	iconvlib="-L$use_libiconv/lib -R$use_libiconv/lib -liconv"
	;;
esac

AC_ARG_WITH(iconv,
	    AS_HELP_STRING([--with-iconv[=LIBSPEC]],
			   [specify iconv library [default -liconv]]),
	iconvlib="$withval")
case "$iconvlib" in
no)
	iconvlib=
	;;
yes)
	iconvlib=-liconv
	;;
esac

AC_ARG_WITH(idnlib,
	    AS_HELP_STRING([--with-idnlib=ARG], [specify libidnkit]),
	    idnlib="$withval", idnlib="no")
if test "yes" = "$idnlib"; then
	AC_MSG_ERROR([You must specify ARG for --with-idnlib.])
fi

IDNLIBS=
if test "no" != "$use_idn"; then
	AC_DEFINE(WITH_IDN, 1, [define if idnkit support is to be included.])
	STD_CINCLUDES="$STD_CINCLUDES -I$idn_path/include"
	if test "no" != "$idnlib"; then
		IDNLIBS="$idnlib $iconvlib"
	else
		IDNLIBS="-L$idn_path/lib -lidnkit $iconvlib"
	fi
fi
AC_SUBST(IDNLIBS)

#
# Check whether to build Automated Test Framework unit tests
#
AC_ARG_WITH(atf,
	    AS_HELP_STRING([--with-atf],[support Automated Test Framework]),
	atf="$withval", atf="no")
if test "yes" = "$atf"; then
	atf=`pwd`/unit/atf
	ATFBUILD=atf-src
	AC_SUBST(ATFBUILD)
	AC_CONFIG_COMMANDS([atf-config],
		[(
		 mkdir -p unit/atf-src;
		 cd unit/atf-src;
		 case "$srcdir" in
		 /*) ;;
		 *) srcdir="../../$srcdir";;
		 esac
		 ${SHELL} "${srcdir}${srcdir:+/unit/atf-src/}./configure" --enable-tools --disable-shared MISSING=: --prefix $atfdir;
		) || AC_MSG_ERROR([Failed to configure ATF.]) ],
		[atfdir=`pwd`/unit/atf])
	AC_MSG_RESULT(building ATF from bind9/unit/atf-src)
fi

ATFLIBS=
if test "no" != "$atf"; then
	AC_DEFINE(ATF_TEST, 1, [define if ATF unit tests are to be built.])
	STD_CINCLUDES="$STD_CINCLUDES -I$atf/include"
	STD_CDEFINES="$STD_CDEFINES -DNS_HOOKS_ENABLE=1"
	ATFBIN="$atf/bin"
	ATFLIBS="-L$atf/lib -latf-c"
	AC_CHECK_LIB(m, exp, libm=yes, libm=no)
	if test "yes" = "$libm"; then
		ATFLIBS="$ATFLIBS -lm"
	fi
	UNITTESTS=tests
fi
AC_SUBST(ATFBIN)
AC_SUBST(ATFLIBS)
AC_SUBST(UNITTESTS)

AC_CHECK_HEADERS(locale.h)
AC_CHECK_FUNCS(setlocale)

#
# was --with-tuning specified?
#
AC_ARG_WITH(tuning,
	    AS_HELP_STRING([--with-tuning=ARG],
			   [Specify server tuning (large or default)]),
	    use_tuning="$withval", use_tuning="no")

case "$use_tuning" in
	large)
		if ! $use_threads; then
			AC_MSG_ERROR([Large-system tuning requires threads.])
		fi
		AC_DEFINE(TUNE_LARGE, 1, [Define to use large-system tuning.])
		AC_MSG_RESULT(using large-system tuning)
		;;
	no|default)
		AC_MSG_RESULT(using default tuning)
		;;
	yes|*)
		AC_MSG_ERROR([You must specify "large" or "default" for --with-tuning.])
		;;
esac

#
# was --enable-querytrace specified?
#
AC_ARG_ENABLE(querytrace,
	      AS_HELP_STRING([--enable-querytrace],
			     [enable very verbose query trace logging
				[default=no]]),
	      want_querytrace="$enableval", want_querytrace="no")

AC_MSG_CHECKING([whether to enable query trace logging])
case "$want_querytrace" in
yes)
	AC_MSG_RESULT(yes)
	AC_DEFINE(WANT_QUERYTRACE, 1, [Define to enable very verbose query trace logging.])
	;;
no)
	AC_MSG_RESULT(no)
	;;
*)
	AC_MSG_ERROR("--enable-querytrace requires yes or no")
	;;
esac

#
# Substitutions
#
AC_SUBST(BIND9_TOP_BUILDDIR)
BIND9_TOP_BUILDDIR=`pwd`

AC_SUBST(BIND9_ISC_BUILDINCLUDE)
AC_SUBST(BIND9_ISCCC_BUILDINCLUDE)
AC_SUBST(BIND9_ISCCFG_BUILDINCLUDE)
AC_SUBST(BIND9_DNS_BUILDINCLUDE)
AC_SUBST(BIND9_NS_BUILDINCLUDE)
AC_SUBST(BIND9_BIND9_BUILDINCLUDE)
AC_SUBST(BIND9_IRS_BUILDINCLUDE)
if test "X$srcdir" != "X"; then
	BIND9_ISC_BUILDINCLUDE="-I${BIND9_TOP_BUILDDIR}/lib/isc/include"
	BIND9_ISCCC_BUILDINCLUDE="-I${BIND9_TOP_BUILDDIR}/lib/isccc/include"
	BIND9_ISCCFG_BUILDINCLUDE="-I${BIND9_TOP_BUILDDIR}/lib/isccfg/include"
	BIND9_DNS_BUILDINCLUDE="-I${BIND9_TOP_BUILDDIR}/lib/dns/include"
	BIND9_NS_BUILDINCLUDE="-I${BIND9_TOP_BUILDDIR}/lib/ns/include"
	BIND9_BIND9_BUILDINCLUDE="-I${BIND9_TOP_BUILDDIR}/lib/bind9/include"
	BIND9_IRS_BUILDINCLUDE="-I${BIND9_TOP_BUILDDIR}/lib/irs/include"
else
	BIND9_ISC_BUILDINCLUDE=""
	BIND9_ISCCC_BUILDINCLUDE=""
	BIND9_ISCCFG_BUILDINCLUDE=""
	BIND9_DNS_BUILDINCLUDE=""
	BIND9_NS_BUILDINCLUDE=""
	BIND9_BIND9_BUILDINCLUDE=""
	BIND9_IRS_BUILDINCLUDE=""
fi

AC_SUBST_FILE(BIND9_MAKE_INCLUDES)
BIND9_MAKE_INCLUDES=$BIND9_TOP_BUILDDIR/make/includes

AC_SUBST_FILE(BIND9_MAKE_RULES)
BIND9_MAKE_RULES=$BIND9_TOP_BUILDDIR/make/rules

. "$srcdir/version"
BIND9_PRODUCT="PRODUCT=\"${PRODUCT}\""
AC_SUBST(BIND9_PRODUCT)
BIND9_DESCRIPTION="DESCRIPTION=\"${DESCRIPTION}\""
AC_SUBST(BIND9_DESCRIPTION)
BIND9_VERSION="${MAJORVER}.${MINORVER}${PATCHVER:+.}${PATCHVER}${RELEASETYPE}${RELEASEVER}${EXTENSIONS}"
AC_SUBST(BIND9_VERSION)
BIND9_MAJOR="MAJOR=${MAJORVER}.${MINORVER}"
AC_SUBST(BIND9_MAJOR)
BIND9_VERSIONSTRING="${PRODUCT} ${MAJORVER}.${MINORVER}${PATCHVER:+.}${PATCHVER}${RELEASETYPE}${RELEASEVER}${EXTENSIONS}${DESCRIPTION:+ }${DESCRIPTION}"
AC_SUBST(BIND9_VERSIONSTRING)
BIND9_VERSIONSHORT="${PRODUCT} ${MAJORVER}.${MINORVER}${PATCHVER:+.}${PATCHVER}${RELEASETYPE}${RELEASEVER}${EXTENSIONS}"
AC_SUBST(BIND9_VERSIONSHORT)

BIND9_SRCID="SRCID=unset_id"
if test -f "${srcdir}/srcid"; then
	. "${srcdir}/srcid"
	BIND9_SRCID="SRCID=$SRCID"
elif test -d "${srcdir}/.git"; then
	BIND9_SRCID="SRCID="`(cd "${srcdir}";git rev-parse --short HEAD)`
fi

AC_SUBST(BIND9_SRCID)

if test -z "$ac_configure_args"; then
	BIND9_CONFIGARGS="defaults"
else
	for a in $ac_configure_args
	do
		BIND9_CONFIGARGS="$BIND9_CONFIGARGS $a"
	done
fi
BIND9_CONFIGARGS="`echo $BIND9_CONFIGARGS | sed 's/^ //'`"
BIND9_CONFIGARGS="CONFIGARGS=${BIND9_CONFIGARGS}"
AC_SUBST(BIND9_CONFIGARGS)

AC_SUBST_FILE(LIBISC_API)
LIBISC_API="$srcdir/lib/isc/api"

AC_SUBST_FILE(LIBISCCC_API)
LIBISCCC_API="$srcdir/lib/isccc/api"

AC_SUBST_FILE(LIBISCCFG_API)
LIBISCCFG_API="$srcdir/lib/isccfg/api"

AC_SUBST_FILE(LIBDNS_API)
LIBDNS_API="$srcdir/lib/dns/api"

AC_SUBST_FILE(LIBDNS_MAPAPI)
LIBDNS_MAPAPI="$srcdir/lib/dns/mapapi"

AC_SUBST_FILE(LIBBIND9_API)
LIBBIND9_API="$srcdir/lib/bind9/api"

AC_SUBST_FILE(LIBIRS_API)
LIBIRS_API="$srcdir/lib/irs/api"

AC_SUBST_FILE(LIBNS_API)
LIBNS_API="$srcdir/lib/ns/api"

#
# Configure any DLZ drivers.
#
# If config.dlz.in selects one or more DLZ drivers, it will set
# CONTRIB_DLZ to a non-empty value, which will be our clue to
# build DLZ drivers in contrib.
#
# This section has to come after the libtool stuff because it needs to
# know how to name the driver object files.
#

CONTRIB_DLZ=""
DLZ_DRIVER_INCLUDES=""
DLZ_DRIVER_LIBS=""
DLZ_DRIVER_SRCS=""
DLZ_DRIVER_OBJS=""
DLZ_SYSTEM_TEST=""
DLZ_DRIVER_MYSQL_INCLUDES=""
DLZ_DRIVER_MYSQL_LIBS=""

# 
# Configure support for building a shared library object
#
# Even when libtool is available it can't always be relied upon
# to build an object that can be dlopen()'ed, but this is necessary
# for building the dlzexternal system test, so we'll try it the
# old-fashioned way.
#
SO="so"
SO_CFLAGS=""
SO_LDFLAGS=""
SO_LD=""
SO_TARGETS=""
SO_STRIP="cat"

AC_ARG_WITH(dlopen,
	    AS_HELP_STRING([--with-dlopen=ARG],
			   [support dynamically loadable DLZ drivers]),
	    dlopen="$withval", dlopen="yes")

case $host in
	*-sunos*) dlopen="no"
		;;
esac

if test "yes" = "$dlopen"; then
	AC_CHECK_LIB(dl, dlopen, have_dl=yes, have_dl=no)
	if test "yes" = "$have_dl"; then
		LIBS="-ldl $LIBS"
	fi
	AC_CHECK_FUNCS(dlopen dlclose dlsym,,dlopen=no)
fi

if test "yes" = "$dlopen"; then
	case $host in
		*-linux*|*-gnu*)
			SO_CFLAGS="-fPIC"
			SO_LDFLAGS=""
			if test "yes" = "$have_dl"
			then
				if test "yes" = "$use_libtool"; then
					SO_LDFLAGS="-Xcompiler -shared"
					SO_LD="${CC}"
				else
					SO_LDFLAGS="-shared"
					SO_LD="${CC}"
				fi
			else
				SO_LDFLAGS="-shared"
				SO_LD="ld"
			fi
			;;
		*-freebsd*|*-openbsd*)
			LDFLAGS="${LDFLAGS} -Wl,-E"
			SO_CFLAGS="-fpic"
			if test "yes" = "$use_libtool"; then
				SO_LDFLAGS="-Xcompiler -shared"
				SO_LD="${CC}"
			else
				SO_LDFLAGS="-shared"
				SO_LD="${CC}"
			fi
			;;
		*-netbsd*)
			SO_CFLAGS="-fpic"
			SO_LDFLAGS="-Bshareable -x"
			SO_LD="ld"
			SO_STRIP="sed -e s/-Wl,//g"
			;;
		*-solaris*)
			SO_CFLAGS="-KPIC"
			SO_LDFLAGS="-G -z text"
			SO_LD="ld"
			;;
		*-hp-hpux*)
			SO=sl
			SO_CFLAGS="+z"
			SO_LDFLAGS="-b +vnocompatwarnings"
			SO_LD="ld"
			;;
		*)
			SO_CFLAGS="-fPIC"
			;;
	esac

	if test "X$GCC" = "Xyes"; then
		SO_CFLAGS="-fPIC"
		if test -z "$SO_LD"
		then
			if test "yes" = "$use_libtool"; then
				SO_LDFLAGS="-Xcompiler -shared"
				SO_LD="${CC}"
			else
				SO_LDFLAGS="-shared"
				SO_LD="${CC}"
			fi
		fi
	fi

	# If we still don't know how to make shared objects, don't make any.
	if test -n "$SO_LD"; then
		SO_TARGETS="\${SO_TARGETS}"
		AC_DEFINE(ISC_DLZ_DLOPEN, 1,
			  [Define to allow building of objects for dlopen().])
	fi
fi
CFLAGS="$CFLAGS $SO_CFLAGS"

AC_SUBST(SO)
AC_SUBST(SO_CFLAGS)
AC_SUBST(SO_LDFLAGS)
AC_SUBST(SO_LD)
AC_SUBST(SO_STRIP)
AC_SUBST(SO_TARGETS)

sinclude(contrib/dlz/config.dlz.in)
AC_MSG_CHECKING(contributed DLZ drivers)

if test -n "$CONTRIB_DLZ"
then
	AC_MSG_RESULT(yes)
	DLZ_DRIVER_RULES=contrib/dlz/drivers/rules
	AC_CONFIG_FILES([$DLZ_DRIVER_RULES
		contrib/dlz/modules/mysql/Makefile
		contrib/dlz/modules/mysqldyn/Makefile])
else
	AC_MSG_RESULT(no)
	DLZ_DRIVER_RULES=/dev/null
fi

AC_SUBST(CONTRIB_DLZ)
AC_SUBST(DLZ_DRIVER_INCLUDES)
AC_SUBST(DLZ_DRIVER_LIBS)
AC_SUBST(DLZ_DRIVER_SRCS)
AC_SUBST(DLZ_DRIVER_OBJS)
AC_SUBST(DLZ_SYSTEM_TEST)
AC_SUBST(DLZ_DRIVER_MYSQL_INCLUDES)
AC_SUBST(DLZ_DRIVER_MYSQL_LIBS)
AC_SUBST_FILE(DLZ_DRIVER_RULES)

if test "yes" = "$cross_compiling"; then
	if test -z "$BUILD_CC"; then
		AC_MSG_ERROR([BUILD_CC not set])
	fi
	BUILD_CFLAGS="$BUILD_CFLAGS"
	BUILD_CPPFLAGS="$BUILD_CPPFLAGS"
	BUILD_LDFLAGS="$BUILD_LDFLAGS"
	BUILD_LIBS="$BUILD_LIBS"
else
	BUILD_CC="$CC" 
	BUILD_CFLAGS="$CFLAGS" 
	BUILD_CPPFLAGS="$CPPFLAGS $GEN_NEED_OPTARG"
	BUILD_LDFLAGS="$LDFLAGS"
	BUILD_LIBS="$LIBS"
fi

NEWFLAGS=""
for e in $BUILD_LDFLAGS ; do
    case $e in
	-L*)
	    case $host_os in
		netbsd*)
		    ee=`echo $e | sed -e 's%^-L%-Wl,-rpath,%'`
		    NEWFLAGS="$NEWFLAGS $e $ee"
		    ;;
		freebsd*)
		    ee=`echo $e | sed -e 's%^-L%-Wl,-rpath,%'`
		    NEWFLAGS="$NEWFLAGS $e $ee"
		    ;;
		solaris*)
		    ee=`echo $e | sed -e 's%^-L%-R%'`
		    NEWFLAGS="$NEWFLAGS $e $ee"
		    ;;
		*)
		    NEWFLAGS="$NEWFLAGS $e"
		    ;;
		esac
	    ;;
	*)
	    NEWFLAGS="$NEWFLAGS $e"
	    ;;
    esac
done
BUILD_LDFLAGS="$NEWFLAGS"

NEWFLAGS=""
for e in $DNS_GSSAPI_LIBS ; do
    case $e in
	-L*)
	    case $host_os in
		netbsd*)
		    ee=`echo $e | sed -e 's%^-L%-Wl,-rpath,%'`
		    NEWFLAGS="$NEWFLAGS $e $ee"
		    ;;
		freebsd*)
		    ee=`echo $e | sed -e 's%^-L%-Wl,-rpath,%'`
		    NEWFLAGS="$NEWFLAGS $e $ee"
		    ;;
		solaris*)
		    ee=`echo $e | sed -e 's%^-L%-R%'`
		    NEWFLAGS="$NEWFLAGS $e $ee"
		    ;;
		*)
		    NEWFLAGS="$NEWFLAGS $e"
		    ;;
		esac
	    ;;
	*)
	    NEWFLAGS="$NEWFLAGS $e"
	    ;;
    esac
done
DNS_GSSAPI_LIBS="$NEWFLAGS"

NEWFLAGS=""
for e in $ISC_OPENSSL_LIBS ; do
    case $e in
	-L*)
	    case $host_os in
		netbsd*)
		    ee=`echo $e | sed -e 's%^-L%-Wl,-rpath,%'`
		    NEWFLAGS="$NEWFLAGS $e $ee"
		    ;;
		freebsd*)
		    ee=`echo $e | sed -e 's%^-L%-Wl,-rpath,%'`
		    NEWFLAGS="$NEWFLAGS $e $ee"
		    ;;
		solaris*)
		    ee=`echo $e | sed -e 's%^-L%-R%'`
		    NEWFLAGS="$NEWFLAGS $e $ee"
		    ;;
		*)
		    NEWFLAGS="$NEWFLAGS $e"
		    ;;
		esac
	    ;;
	*)
	    NEWFLAGS="$NEWFLAGS $e"
	    ;;
    esac
done
ISC_OPENSSL_LIBS="$NEWFLAGS"

NEWFLAGS=""
for e in $DNS_CRYPTO_LIBS ; do
    case $e in
	-L*)
	    case $host_os in
		netbsd*)
		    ee=`echo $e | sed -e 's%^-L%-Wl,-rpath,%'`
		    NEWFLAGS="$NEWFLAGS $e $ee"
		    ;;
		freebsd*)
		    ee=`echo $e | sed -e 's%^-L%-Wl,-rpath,%'`
		    NEWFLAGS="$NEWFLAGS $e $ee"
		    ;;
		solaris*)
		    ee=`echo $e | sed -e 's%^-L%-R%'`
		    NEWFLAGS="$NEWFLAGS $e $ee"
		    ;;
		*)
		    NEWFLAGS="$NEWFLAGS $e"
		    ;;
		esac
	    ;;
	*)
	    NEWFLAGS="$NEWFLAGS $e"
	    ;;
    esac
done
DNS_CRYPTO_LIBS="$NEWFLAGS"

AC_SUBST(BUILD_CC)
AC_SUBST(BUILD_CFLAGS)
AC_SUBST(BUILD_CPPFLAGS)
AC_SUBST(BUILD_LDFLAGS)
AC_SUBST(BUILD_LIBS)

#
# Commands to run at the end of config.status.
# Don't just put these into configure, it won't work right if somebody
# runs config.status directly (which autoconf allows).
#

AC_CONFIG_COMMANDS(
	[chmod],
	[chmod a+x isc-config.sh doc/doxygen/doxygen-input-filter])

#
# Files to configure.  These are listed here because we used to
# specify them as arguments to AC_OUTPUT.  It's (now) ok to move these
# elsewhere if there's a good reason for doing so.
#

AC_CONFIG_FILES([
  make/Makefile
  make/mkdep
	Makefile
	bin/Makefile
	bin/check/Makefile
	bin/confgen/Makefile
	bin/confgen/unix/Makefile
	bin/delv/Makefile
	bin/dig/Makefile
	bin/dnssec/Makefile
	bin/named/Makefile
	bin/named/unix/Makefile
	bin/nsupdate/Makefile
	bin/pkcs11/Makefile
	bin/python/Makefile
	bin/python/isc/Makefile
	bin/python/isc/utils.py
	bin/python/isc/tests/Makefile
	bin/python/dnssec-checkds.py
	bin/python/dnssec-coverage.py
	bin/python/dnssec-keymgr.py
	bin/python/isc/__init__.py
	bin/python/isc/checkds.py
	bin/python/isc/coverage.py
	bin/python/isc/dnskey.py
	bin/python/isc/eventlist.py
	bin/python/isc/keydict.py
	bin/python/isc/keyevent.py
	bin/python/isc/keymgr.py
	bin/python/isc/keyseries.py
	bin/python/isc/keyzone.py
	bin/python/isc/policy.py
	bin/python/isc/rndc.py
	bin/python/isc/tests/dnskey_test.py
	bin/python/isc/tests/policy_test.py
	bin/rndc/Makefile
	bin/tests/Makefile
	bin/tests/atomic/Makefile
	bin/tests/db/Makefile
	bin/tests/dst/Makefile
	bin/tests/dst/Kdh.+002+18602.key
	bin/tests/dst/Kdh.+002+18602.private
	bin/tests/dst/Kdh.+002+48957.key
	bin/tests/dst/Kdh.+002+48957.private
	bin/tests/dst/Ktest.+001+00002.key
	bin/tests/dst/Ktest.+001+54622.key
	bin/tests/dst/Ktest.+001+54622.private
	bin/tests/dst/Ktest.+003+23616.key
	bin/tests/dst/Ktest.+003+23616.private
	bin/tests/dst/Ktest.+003+49667.key
	bin/tests/dst/dst_2_data
	bin/tests/dst/t2_data_1
	bin/tests/dst/t2_data_2
	bin/tests/dst/t2_dsasig
	bin/tests/dst/t2_rsasig
	bin/tests/hashes/Makefile
	bin/tests/headerdep_test.sh
	bin/tests/master/Makefile
	bin/tests/mem/Makefile
	bin/tests/names/Makefile
	bin/tests/net/Makefile
	bin/tests/pkcs11/Makefile
	bin/tests/pkcs11/benchmarks/Makefile
	bin/tests/rbt/Makefile
	bin/tests/resolver/Makefile
	bin/tests/sockaddr/Makefile
	bin/tests/system/Makefile
	bin/tests/system/conf.sh
	bin/tests/system/dlz/prereq.sh
	bin/tests/system/dlzexternal/Makefile
	bin/tests/system/dlzexternal/ns1/named.conf
	bin/tests/system/dyndb/Makefile
	bin/tests/system/dyndb/driver/Makefile
	bin/tests/system/inline/checkdsa.sh
	bin/tests/system/pipelined/Makefile
	bin/tests/system/rndc/Makefile
	bin/tests/system/rpz/Makefile
	bin/tests/system/rsabigexponent/Makefile
	bin/tests/system/tkey/Makefile
	bin/tests/tasks/Makefile
	bin/tests/timers/Makefile
	bin/tests/virtual-time/Makefile
	bin/tests/virtual-time/conf.sh
	bin/tools/Makefile
	contrib/scripts/check-secure-delegation.pl
	contrib/scripts/zone-edit.sh
	doc/Makefile
	doc/arm/Makefile
	doc/arm/noteversion.xml
	doc/arm/pkgversion.xml
	doc/arm/releaseinfo.xml
	doc/doxygen/Doxyfile
	doc/doxygen/Makefile
	doc/doxygen/doxygen-input-filter
	doc/misc/Makefile
	doc/tex/Makefile
	doc/tex/armstyle.sty
	doc/xsl/Makefile
	doc/xsl/isc-docbook-chunk.xsl
	doc/xsl/isc-docbook-html.xsl
	doc/xsl/isc-manpage.xsl
	doc/xsl/isc-notes-html.xsl
	isc-config.sh
	lib/Makefile
	lib/bind9/Makefile
	lib/bind9/include/Makefile
	lib/bind9/include/bind9/Makefile
	lib/dns/Makefile
	lib/dns/include/Makefile
	lib/dns/include/dns/Makefile
	lib/dns/include/dst/Makefile
	lib/dns/tests/Makefile
	lib/irs/Makefile
	lib/irs/include/Makefile
	lib/irs/include/irs/Makefile
	lib/irs/include/irs/netdb.h
	lib/irs/include/irs/platform.h
	lib/irs/tests/Makefile
	lib/isc/$arch/Makefile
	lib/isc/$arch/include/Makefile
	lib/isc/$arch/include/isc/Makefile
	lib/isc/$thread_dir/Makefile
	lib/isc/$thread_dir/include/Makefile
	lib/isc/$thread_dir/include/isc/Makefile
	lib/isc/Makefile
	lib/isc/include/Makefile
	lib/isc/include/isc/Makefile
	lib/isc/include/isc/platform.h
	lib/isc/include/pk11/Makefile
	lib/isc/include/pkcs11/Makefile
	lib/isc/tests/Makefile
	lib/isc/nls/Makefile
	lib/isc/unix/Makefile
	lib/isc/unix/include/Makefile
	lib/isc/unix/include/isc/Makefile
	lib/isc/unix/include/pkcs11/Makefile
	lib/isccc/Makefile
	lib/isccc/include/Makefile
	lib/isccc/include/isccc/Makefile
	lib/isccfg/Makefile
	lib/isccfg/include/Makefile
	lib/isccfg/include/isccfg/Makefile
	lib/isccfg/tests/Makefile
	lib/ns/Makefile
	lib/ns/include/Makefile
	lib/ns/include/ns/Makefile
	lib/ns/tests/Makefile
	lib/tests/Makefile
	lib/tests/include/Makefile
	lib/tests/include/tests/Makefile
	lib/samples/Makefile
	lib/samples/Makefile-postinstall
	unit/Makefile
	unit/unittest.sh
])

#
# Do it
#

AC_OUTPUT

#
# Now that the Makefiles exist we can ensure that everything is rebuilt.
#
AC_ARG_WITH(make-clean,
	    AS_HELP_STRING([--with-make-clean],
			   [run "make clean" at end of configure [yes|no]]),
    make_clean="$withval", make_clean="yes")
case "$make_clean" in
yes)
	if test "yes" != "$no_create"
	then
		if test "yes" = "$silent"
		then
			make clean > /dev/null
		else
			make clean
		fi
	fi
	;;
esac

AC_ARG_ENABLE(full-report,
	      AS_HELP_STRING([--enable-full-report],
			     [report values of all configure options]))

report() {
    echo "==============================================================================="
    echo "Configuration summary:"
    echo "-------------------------------------------------------------------------------"
    echo "Optional features enabled:"
    if $use_threads; then
	echo "    Multiprocessing support (--enable-threads)"
	if test "yes" = "$enable_full_report" -o "standard" = "$locktype"; then
	    echo "        Mutex lock type: $locktype"
	fi
    fi
    test "large" = "$use_tuning" && echo "    Large-system tuning (--with-tuning)"
    test "no" = "$use_dnstap" || \
	    echo "    Allow 'dnstap' packet logging (--enable-dnstap)"
    test "no" = "$use_geoip" || echo "    GeoIP access control (--with-geoip)"
    test "no" = "$use_gssapi" || echo "    GSS-API (--with-gssapi)"
    if test "yes" = "$enable_full_report" -o "aes" != "$with_cc_alg"; then
	echo "        Algorithm: $with_cc_alg"
    fi

    # these lines are only printed if run with --enable-full-report 
    if test "yes" = "$enable_full_report"; then
	test "no" = "$enable_ipv6" -o "no" = "$found_ipv6" || \
	    echo "    IPv6 support (--enable-ipv6)"
	test "X$CRYPTO" = "X" -o "yes" = "$want_native_pkcs11" || \
		echo "    OpenSSL cryptography/DNSSEC (--with-openssl)"
	test "no" = "$want_crypto_rand" || \
		echo "    Crypto provider entropy source (--enable-crypto-rand)"
	test "X$PYTHON" = "X" || echo "    Python tools (--with-python)"
	test "X$XMLSTATS" = "X" || echo "    XML statistics (--with-libxml2)"
	test "X$JSONSTATS" = "X" || echo "    JSON statistics (--with-libjson)"
	test "X$ZLIB" = "X" || echo "    HTTP zlib compression (--with-zlib)"
	test "X$NZD_TOOLS" = "X" || echo "    LMDB database to store configuration for 'addzone' zones (--with-lmdb)"
    fi

    if test "no" != "$use_pkcs11"; then
	if test "yes" = "$want_native_pkcs11"; then
	    echo "    Native PKCS#11/Cryptoki support (--enable-native-pkcs11)"
	else
	    echo "    PKCS#11/Cryptoki support using OpenSSL (--with-pkcs11)"
	fi
	echo "        Provider library: $PKCS11_PROVIDER"
    fi
    if test "yes" = "$OPENSSL_GOST" -o "yes" = "$PKCS11_GOST"; then
	echo "    GOST algorithm support (encoding: $gosttype) (--with-gost)"
    fi
    test "yes" = "$OPENSSL_ECDSA" -o "$PKCS11_ECDSA" && \
	echo "    ECDSA algorithm support (--with-ecdsa)"
    test "yes" = "$OPENSSL_ED25519" -o "$PKCS11_ED25519" && \
	echo "    EDDSA algorithm support (--with-eddsa)"
    test "yes" = "$enable_dnsrps" && \
	echo "    DNS Response Policy Service interface (--enable-dnsrps)"
    test "yes" = "$enable_fixed" && \
	echo "    Allow 'fixed' rrset-order (--enable-fixed-rrset)"
    test "yes" = "$enable_seccomp" && \
	echo "    Use libseccomp system call filtering (--enable-seccomp)"
    test "yes" = "$want_backtrace" && \
	echo "    Print backtrace on crash (--enable-backtrace)"
    test "minimal" = "$want_symtable" && \
	echo "    Use symbol table for backtrace, named only (--enable-symtable)"
    test "yes" = "$want_symtable" -o "all" = "$want_symtable" && \
	echo "    Use symbol table for backtrace, all binaries (--enable-symtable=all)"
    test "no" = "$use_libtool" || echo "    Use GNU libtool (--with-libtool)"
    test "yes" = "$want_querytrace" && \
	echo "    Very verbose query trace logging (--enable-querytrace)"
    test "no" = "$atf" || echo "    Automated Testing Framework (--with-atf)"

    echo "    Cryptographic library for DNSSEC: $CRYPTOLIB"

    echo "    Dynamically loadable zone (DLZ) drivers:"
    test "no" = "$use_dlz_bdb" || \
	echo "        Berkeley DB (--with-dlz-bdb)"
    test "no" = "$use_dlz_ldap" || \
	echo "        LDAP (--with-dlz-ldap)"
    test "no" = "$use_dlz_mysql" || \
	echo "        MySQL (--with-dlz-mysql)"
    test "no" = "$use_dlz_odbc" || \
	echo "        ODBC (--with-dlz-odbc)"
    test "no" = "$use_dlz_postgres" || \
	echo "        Postgres (--with-dlz-postgres)"
    test "no" = "$use_dlz_filesystem" || \
	echo "        Filesystem (--with-dlz-filesystem)"
    test "no" = "$use_dlz_stub" || \
	echo "        Stub (--with-dlz-stub)"
    test "$use_dlz_bdb $use_dlz_ldap $use_dlz_mysql $use_dlz_odbc $use_dlz_postgres $use_dlz_filesystem $use_dlz_stub" = "no no no no no no no" && echo "        None"

    echo "-------------------------------------------------------------------------------"

    echo "Features disabled or unavailable on this platform:"
    $use_threads || echo "    Multiprocessing support (--enable-threads)"
    test "no" = "$enable_ipv6" -o "no" = "$found_ipv6" && \
	    echo "    IPv6 support (--enable-ipv6)"
    test "large" = "$use_tuning" || echo "    Large-system tuning (--with-tuning)"

    test "no" = "$use_dnstap" && \
	    echo "    Allow 'dnstap' packet logging (--enable-dnstap)"
    test "no" = "$use_geoip" && echo "    GeoIP access control (--with-geoip)"
    test "no" = "$use_gssapi" && echo "    GSS-API (--with-gssapi)"

    test "no" = "$enable_dnsrps" && \
	echo "    DNS Response Policy Service interface (--enable-dnsrps)"

    test "yes" = "$enable_fixed" || \
	echo "    Allow 'fixed' rrset-order (--enable-fixed-rrset)"

    if test "X$CRYPTO" = "X" -o "yes" = "$want_native_pkcs11"
    then
	echo "    OpenSSL cryptography/DNSSEC (--with-openssl)"
    elif test "no" = "$use_pkcs11"; then
	echo "    PKCS#11/Cryptoki support (--with-pkcs11)"
    fi
    test "yes" = "$want_native_pkcs11" ||
	echo "    Native PKCS#11/Cryptoki support (--enable-native-pkcs11)"
    test "X$CRYPTO" = "X" -o "yes" = "$OPENSSL_GOST" -o "yes" = "$PKCS11_GOST" || \
	echo "    GOST algorithm support (--with-gost)"
    test "X$CRYPTO" = "X" -o "yes" = "$OPENSSL_ECDSA" -o "yes" = "$PKCS11_ECDSA" || \
	echo "    ECDSA algorithm support (--with-ecdsa)"
    test "X$CRYPTO" = "X" -o "yes" = "$OPENSSL_ED25519" -o "yes" = "$PKCS11_ED25519" || \
	echo "    EDDSA algorithm support (--with-eddsa)"
    test "yes" = "$want_crypto_rand" || \
	echo "    Crypto provider entropy source (--enable-crypto-rand)"

    test "yes" = "$enable_seccomp" || \
	echo "    Use libseccomp system call filtering (--enable-seccomp)"
    test "yes" = "$want_backtrace" || \
	echo "    Print backtrace on crash (--enable-backtrace)"
    test "yes" = "$want_querytrace" || \
	echo "    Very verbose query trace logging (--enable-querytrace)"

    test "yes" = "$use_libtool" || echo "    Use GNU libtool (--with-libtool)"
    test "no" = "$atf" && echo "    Automated Testing Framework (--with-atf)"

    test "X$PYTHON" = "X" && echo "    Python tools (--with-python)"
    test "X$XMLSTATS" = "X" && echo "    XML statistics (--with-libxml2)"
    test "X$JSONSTATS" = "X" && echo "    JSON statistics (--with-libjson)"
    test "X$ZLIB" = "X" && echo "    HTTP zlib compression (--with-zlib)"
    test "X$NZD_TOOLS" = "X" && echo "    LMDB database to store configuration for 'addzone' zones (--with-lmdb)"

    echo "-------------------------------------------------------------------------------"
    echo "Configured paths:"
    echo "    prefix: $prefix"
    echo "    sysconfdir: $sysconfdir"
    echo "    localstatedir: $localstatedir"


    if test "X$ac_unrecognized_opts" != "X"; then
	echo
	echo "Unrecognized options:"
	echo "    $ac_unrecognized_opts"
    fi

    if test "yes" != "$enable_full_report"; then
	echo "-------------------------------------------------------------------------------"
	echo "For more detail, use --enable-full-report."
    fi
    echo "==============================================================================="
}

if test "yes" != "$silent"; then
	report
fi

if test "X$CRYPTO" = "X"; then
cat << \EOF                                                             
BIND 9 is being built without cryptography support. This means it will
not have DNSSEC support. Use --with-openssl, or --with-pkcs11 and
--enable-native-pkcs11 to enable cryptography.
EOF
fi

if test "X$OPENSSL_WARNING" != "X"; then
cat << \EOF
WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
WARNING                                                                 WARNING
WARNING         Your OpenSSL crypto library may be vulnerable to        WARNING
WARNING         one or more of the the following known security         WARNING
WARNING         flaws:                                                  WARNING
WARNING                                                                 WARNING
WARNING         CAN-2002-0659, CAN-2006-4339, CVE-2006-2937,            WARNING
WARNING         CVE-2006-2940 and CVE-2015-3193.                        WARNING
WARNING                                                                 WARNING
WARNING         It is recommended that you upgrade to OpenSSL           WARNING
WARNING         version 1.0.2e/1.0.1/1.0.0/0.9.9/0.9.8d/0.9.7l          WARNING
WARNING		(or greater).                                           WARNING
WARNING                                                                 WARNING
WARNING         You can disable this warning by specifying:             WARNING
WARNING                                                                 WARNING
WARNING               --disable-openssl-version-check          	        WARNING
WARNING                                                                 WARNING
WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
EOF
fi

# Tell Emacs to edit this file in shell mode.
# Local Variables:
# mode: sh
# End:
