diff options
Diffstat (limited to '')
| -rw-r--r-- | configure.in | 5655 |
1 files changed, 5655 insertions, 0 deletions
diff --git a/configure.in b/configure.in new file mode 100644 index 0000000..9aa7e2d --- /dev/null +++ b/configure.in @@ -0,0 +1,5655 @@ +# Copyright (C) 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/. +# +# See the COPYRIGHT file distributed with this work for additional +# information regarding copyright ownership. + +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.11], [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_LIST_CHECKINIT=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 "${enable_filter_aaaa+set}" = set || enable_filter_aaaa=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 + +AC_PROG_CC +AC_PROG_CC_C99 + +# +# 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_TYPE_SSIZE_T +AC_TYPE_UINTPTR_T + +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" + LWRES_PLATFORM_NEEDSYSSELECTH="#undef LWRES_PLATFORM_NEEDSYSSELECTH"], + [AC_MSG_RESULT(no) + case $ac_cv_header_sys_select_h in + yes) + ISC_PLATFORM_NEEDSYSSELECTH="#define ISC_PLATFORM_NEEDSYSSELECTH 1" + LWRES_PLATFORM_NEEDSYSSELECTH="#define LWRES_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" + LWRES_PLATFORM_NEEDSYSSELECTH="#define LWRES_PLATFORM_NEEDSYSSELECTH 1" + ;; + no) + AC_MSG_ERROR([need either unistd.h or sys/select.h]) + ;; + esac + ;; +esac +AC_SUBST(ISC_PLATFORM_NEEDSYSSELECTH) +AC_SUBST(LWRES_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 -lcrypto -lcrypt -lasn1 -lroken -lcom_err" \ + "-lgssapi -lkrb5 -lgssapi_krb5 -lcrypto -lcrypt -lasn1 -lroken -lcom_err" \ + "-lgssapi -lkrb5 -lhx509 -lcrypto -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" + else + LIBS="-L$use_gssapi/lib $TRY_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 $DNS_CRYPTO_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") + +# +# was --enable-openssl-hash specified? +# +AC_ARG_ENABLE(openssl-hash, + AS_HELP_STRING([--enable-openssl-hash], + [use OpenSSL for hash functions [default=no]]), + want_openssl_hash="$enableval", want_openssl_hash="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" + OPENSSLECDSALINKOBJS="" + OPENSSLECDSALINKSRCS="" + OPENSSLEDDSALINKOBJS="" + OPENSSLEDDSALINKSRCS="" + OPENSSLGOSTLINKOBJS="" + OPENSSLGOSTLINKSRCS="" + OPENSSLLINKOBJS="" + OPENSSLLINKSRCS="" + ;; + no) + AC_MSG_RESULT(no) + DST_OPENSSL_INC="" + CRYPTO="" + OPENSSLECDSALINKOBJS="" + OPENSSLECDSALINKSRCS="" + OPENSSLEDDSALINKOBJS="" + OPENSSLEDDSALINKSRCS="" + OPENSSLGOSTLINKOBJS="" + OPENSSLGOSTLINKSRCS="" + OPENSSLLINKOBJS="" + OPENSSLLINKSRCS="" + ;; + auto) + DST_OPENSSL_INC="" + CRYPTO="" + 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 don't 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' + 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_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_CHECK_FUNCS([DH_get0_key ECDSA_SIG_get0 RSA_set0_key DSA_get0_pqg]) + + 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) + +DNS_CRYPTO_LIBS="$DNS_CRYPTO_LIBS $DST_OPENSSL_LIBS" + +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) + if test "X$CRYPTO" = "X-DOPENSSL" + then + if test "checkcc" = "$want_openssl_hash" + then + want_openssl_hash="yes" + fi + fi + AC_DEFINE(HMAC_SHA1_CC, 1, + [Use HMAC-SHA1 for Client Cookie generation]) + ;; + sha256) + AC_MSG_RESULT(sha256) + if test "X$CRYPTO" = "X-DOPENSSL" + then + if test "checkcc" = "$want_openssl_hash" + then + want_openssl_hash="yes" + fi + fi + AC_DEFINE(HMAC_SHA256_CC, 1, + [Use HMAC-SHA256 for Client Cookie generation]) + ;; + aes) + AC_MSG_RESULT(aes) + if test "yes" != "$with_aes" + then + AC_MSG_ERROR("Client Cookie wants to use unavailable AES"); + fi + AC_DEFINE(AES_CC, 1, + [Use AES for Client Cookie generation]) + ;; +esac +if test "checkcc" = "$want_openssl_hash" +then + want_openssl_hash="no" +fi + +# +# Use OpenSSL for hash functions +# + +AC_MSG_CHECKING(for using OpenSSL for hash functions) +ISC_PLATFORM_OPENSSLHASH="#undef ISC_PLATFORM_OPENSSLHASH" +case $want_openssl_hash in + yes) + if test "$CRYPTO" != "-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) + +# +# 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 + +# +# 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" + LWRES_PLATFORM_NEEDNETINET6IN6H="#define LWRES_PLATFORM_NEEDNETINET6IN6H 1" + isc_netinet6in6_hack="#include <netinet6/in6.h>" + ;; +*) + ISC_PLATFORM_NEEDNETINET6IN6H="#undef ISC_PLATFORM_NEEDNETINET6IN6H" + LWRES_PLATFORM_NEEDNETINET6IN6H="#undef LWRES_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" + LWRES_PLATFORM_NEEDNETINETIN6H="#define LWRES_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" + LWRES_PLATFORM_NEEDNETINETIN6H="#undef LWRES_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" + LWRES_PLATFORM_HAVEIPV6="#define LWRES_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" + LWRES_PLATFORM_HAVEINADDR6="#undef LWRES_PLATFORM_HAVEINADDR6" + isc_in_addr6_hack=""], + [AC_MSG_RESULT(no) + ISC_PLATFORM_HAVEINADDR6="#define ISC_PLATFORM_HAVEINADDR6 1" + LWRES_PLATFORM_HAVEINADDR6="#define LWRES_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" + LWRES_PLATFORM_NEEDIN6ADDRANY="#undef LWRES_PLATFORM_NEEDIN6ADDRANY"], + [AC_MSG_RESULT(no) + ISC_PLATFORM_NEEDIN6ADDRANY="#define ISC_PLATFORM_NEEDIN6ADDRANY 1" + LWRES_PLATFORM_NEEDIN6ADDRANY="#define LWRES_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" + LWRES_PLATFORM_NEEDIN6ADDRLOOPBACK="#undef LWRES_PLATFORM_NEEDIN6ADDRLOOPBACK"], + [AC_MSG_RESULT(no) + ISC_PLATFORM_NEEDIN6ADDRLOOPBACK="#define ISC_PLATFORM_NEEDIN6ADDRLOOPBACK 1" + LWRES_PLATFORM_NEEDIN6ADDRLOOPBACK="#define LWRES_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" + result="#define LWRES_HAVE_SIN6_SCOPE_ID 1"], + [AC_MSG_RESULT(no) + ISC_PLATFORM_HAVESCOPEID="#undef ISC_PLATFORM_HAVESCOPEID" + result="#undef LWRES_HAVE_SIN6_SCOPE_ID"]) + LWRES_HAVE_SIN6_SCOPE_ID="$result" + + 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" + LWRES_PLATFORM_HAVEIPV6="#undef LWRES_PLATFORM_HAVEIPV6" + ISC_PLATFORM_NEEDIN6ADDRANY="#undef ISC_PLATFORM_NEEDIN6ADDRANY" + LWRES_PLATFORM_NEEDIN6ADDRANY="#undef LWRES_PLATFORM_NEEDIN6ADDRANY" + ISC_PLATFORM_HAVEIN6PKTINFO="#undef ISC_PLATFORM_HAVEIN6PKTINFO" + LWRES_HAVE_SIN6_SCOPE_ID="#define LWRES_HAVE_SIN6_SCOPE_ID 1" + 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(LWRES_PLATFORM_HAVEIPV6) +AC_SUBST(ISC_PLATFORM_NEEDNETINETIN6H) +AC_SUBST(LWRES_PLATFORM_NEEDNETINETIN6H) +AC_SUBST(ISC_PLATFORM_NEEDNETINET6IN6H) +AC_SUBST(LWRES_PLATFORM_NEEDNETINET6IN6H) +AC_SUBST(ISC_PLATFORM_HAVEINADDR6) +AC_SUBST(LWRES_PLATFORM_HAVEINADDR6) +AC_SUBST(ISC_PLATFORM_NEEDIN6ADDRANY) +AC_SUBST(LWRES_PLATFORM_NEEDIN6ADDRANY) +AC_SUBST(ISC_PLATFORM_NEEDIN6ADDRLOOPBACK) +AC_SUBST(LWRES_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(LWRES_HAVE_SIN6_SCOPE_ID) +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" + LWRES_PLATFORM_HAVESALEN="#define LWRES_PLATFORM_HAVESALEN 1"], + [AC_MSG_RESULT(no) + ISC_PLATFORM_HAVESALEN="#undef ISC_PLATFORM_HAVESALEN" + LWRES_PLATFORM_HAVESALEN="#undef LWRES_PLATFORM_HAVESALEN"]) +AC_SUBST(ISC_PLATFORM_HAVESALEN) +AC_SUBST(LWRES_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_LWRES_NEEDADDRINFO="#undef ISC_LWRES_NEEDADDRINFO" + ISC_IRS_NEEDADDRINFO="#undef ISC_IRS_NEEDADDRINFO" + AC_DEFINE(HAVE_ADDRINFO)], + [AC_MSG_RESULT(no) + ISC_LWRES_NEEDADDRINFO="#define ISC_LWRES_NEEDADDRINFO 1" + ISC_IRS_NEEDADDRINFO="#define ISC_IRS_NEEDADDRINFO 1"]) +AC_SUBST(ISC_LWRES_NEEDADDRINFO) +AC_SUBST(ISC_IRS_NEEDADDRINFO) + +# +# Check for rrsetinfo +# +AC_MSG_CHECKING(for struct rrsetinfo) +AC_TRY_COMPILE([ +#include <netdb.h>], +[struct rrsetinfo r; return (0);], + [AC_MSG_RESULT(yes) + ISC_LWRES_NEEDRRSETINFO="#undef ISC_LWRES_NEEDRRSETINFO"], + [AC_MSG_RESULT(no) + ISC_LWRES_NEEDRRSETINFO="#define ISC_LWRES_NEEDRRSETINFO 1"]) +AC_SUBST(ISC_LWRES_NEEDRRSETINFO) + +AC_MSG_CHECKING(for int sethostent) +AC_TRY_COMPILE([ +#include <netdb.h>], +[int i = sethostent(0); return(0);], + [AC_MSG_RESULT(yes) + ISC_LWRES_SETHOSTENTINT="#define ISC_LWRES_SETHOSTENTINT 1"], + [AC_MSG_RESULT(no) + ISC_LWRES_SETHOSTENTINT="#undef ISC_LWRES_SETHOSTENTINT"]) +AC_SUBST(ISC_LWRES_SETHOSTENTINT) + +AC_MSG_CHECKING(for int endhostent) +AC_TRY_COMPILE([ +#include <netdb.h>], +[int i = endhostent(); return(0);], + [AC_MSG_RESULT(yes) + ISC_LWRES_ENDHOSTENTINT="#define ISC_LWRES_ENDHOSTENTINT 1"], + [AC_MSG_RESULT(no) + ISC_LWRES_ENDHOSTENTINT="#undef ISC_LWRES_ENDHOSTENTINT"]) +AC_SUBST(ISC_LWRES_ENDHOSTENTINT) + +AC_MSG_CHECKING(for getnetbyaddr(in_addr_t, ...)) +AC_TRY_COMPILE([ +#include <netdb.h> +struct netent *getnetbyaddr(in_addr_t, int);], +[], + [AC_MSG_RESULT(yes) + ISC_LWRES_GETNETBYADDRINADDR="#define ISC_LWRES_GETNETBYADDRINADDR 1"], + [AC_MSG_RESULT(no) + ISC_LWRES_GETNETBYADDRINADDR="#undef ISC_LWRES_GETNETBYADDRINADDR"]) +AC_SUBST(ISC_LWRES_GETNETBYADDRINADDR) + +AC_MSG_CHECKING(for int setnetent) +AC_TRY_COMPILE([ +#include <netdb.h>], +[int i = setnetent(0); return(0);], + [AC_MSG_RESULT(yes) + ISC_LWRES_SETNETENTINT="#define ISC_LWRES_SETNETENTINT 1"], + [AC_MSG_RESULT(no) + ISC_LWRES_SETNETENTINT="#undef ISC_LWRES_SETNETENTINT"]) +AC_SUBST(ISC_LWRES_SETNETENTINT) + +AC_MSG_CHECKING(for int endnetent) +AC_TRY_COMPILE([ +#include <netdb.h>], +[int i = endnetent(); return(0);], + [AC_MSG_RESULT(yes) + ISC_LWRES_ENDNETENTINT="#define ISC_LWRES_ENDNETENTINT 1"], + [AC_MSG_RESULT(no) + ISC_LWRES_ENDNETENTINT="#undef ISC_LWRES_ENDNETENTINT"]) +AC_SUBST(ISC_LWRES_ENDNETENTINT) + +AC_MSG_CHECKING(for gethostbyaddr(const void *, size_t, ...)) +AC_TRY_COMPILE([ +#include <netdb.h> +struct hostent *gethostbyaddr(const void *, size_t, int);], +[return(0);], + [AC_MSG_RESULT(yes) + ISC_LWRES_GETHOSTBYADDRVOID="#define ISC_LWRES_GETHOSTBYADDRVOID 1"], + [AC_MSG_RESULT(no) + ISC_LWRES_GETHOSTBYADDRVOID="#undef ISC_LWRES_GETHOSTBYADDRVOID"]) +AC_SUBST(ISC_LWRES_GETHOSTBYADDRVOID) + +AC_MSG_CHECKING(for h_errno in netdb.h) +AC_TRY_COMPILE([ +#include <netdb.h>], +[h_errno = 1; return(0);], + [AC_MSG_RESULT(yes) + ISC_LWRES_NEEDHERRNO="#undef ISC_LWRES_NEEDHERRNO"], + [AC_MSG_RESULT(no) + ISC_LWRES_NEEDHERRNO="#define ISC_LWRES_NEEDHERRNO 1"]) +AC_SUBST(ISC_LWRES_NEEDHERRNO) + +# +# 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(getipnodebyname, + [ISC_LWRES_GETIPNODEPROTO="#undef ISC_LWRES_GETIPNODEPROTO"], + [ISC_LWRES_GETIPNODEPROTO="#define ISC_LWRES_GETIPNODEPROTO 1"]) +AC_CHECK_FUNC(getnameinfo, + [ISC_LWRES_GETNAMEINFOPROTO="#undef ISC_LWRES_GETNAMEINFOPROTO"], + [ISC_LWRES_GETNAMEINFOPROTO="#define ISC_LWRES_GETNAMEINFOPROTO 1"]) +AC_CHECK_FUNC(getaddrinfo, + [ISC_LWRES_GETADDRINFOPROTO="#undef ISC_LWRES_GETADDRINFOPROTO" + AC_DEFINE(HAVE_GETADDRINFO)], + [ISC_LWRES_GETADDRINFOPROTO="#define ISC_LWRES_GETADDRINFOPROTO 1"]) +AC_CHECK_FUNC(gai_strerror, AC_DEFINE(HAVE_GAISTRERROR)) +AC_SUBST(ISC_LWRES_GETIPNODEPROTO) +AC_SUBST(ISC_LWRES_GETADDRINFOPROTO) +AC_SUBST(ISC_LWRES_GETNAMEINFOPROTO) +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" + LWRES_PLATFORM_NEEDSTRTOUL="#undef LWRES_PLATFORM_NEEDSTRTOUL" + GENRANDOMLIB=""], + [ISC_PLATFORM_NEEDSTRTOUL="#define ISC_PLATFORM_NEEDSTRTOUL 1" + LWRES_PLATFORM_NEEDSTRTOUL="#define LWRES_PLATFORM_NEEDSTRTOUL 1" + GENRANDOMLIB='${ISCLIBS}']) +AC_SUBST(ISC_PLATFORM_NEEDSTRTOUL) +AC_SUBST(LWRES_PLATFORM_NEEDSTRTOUL) +AC_SUBST(GENRANDOMLIB) + +AC_CHECK_FUNC(strlcpy, + [ISC_PLATFORM_NEEDSTRLCPY="#undef ISC_PLATFORM_NEEDSTRLCPY" + LWRES_PLATFORM_NEEDSTRLCPY="#undef LWRES_PLATFORM_NEEDSTRLCPY"], + [ISC_PLATFORM_NEEDSTRLCPY="#define ISC_PLATFORM_NEEDSTRLCPY 1" + LWRES_PLATFORM_NEEDSTRLCPY="#define LWRES_PLATFORM_NEEDSTRLCPY 1"]) +AC_SUBST(ISC_PLATFORM_NEEDSTRLCPY) +AC_SUBST(LWRES_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' +LWRES_PLATFORM_NEEDVSNPRINTF='#undef LWRES_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" +LWRES_PLATFORM_NEEDSPRINTF="#define LWRES_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" + LWRES_PLATFORM_NEEDVSNPRINTF="#define LWRES_PLATFORM_NEEDVSNPRINTF 1"]) + +AC_MSG_CHECKING(printf for %z support) +AC_TRY_RUN([ +#include <stdio.h> + +int +main() { + size_t j = 0; + char buf[100]; + buf[0] = 0; + sprintf(buf, "%zu", j); + return ((buf[0] == '0' && buf[1] == '\0') ? 0 : 1); +} +], + [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" + LWRES_PLATFORM_NEEDVSNPRINTF="#define LWRES_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) +AC_SUBST(LWRES_PLATFORM_NEEDSPRINTF) +AC_SUBST(LWRES_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) + +# +# 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(LWRES_PLATFORM_USEDECLSPEC) +LWRES_PLATFORM_USEDECLSPEC="#undef LWRES_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 + 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? + AC_CHECK_SIZEOF([void *]) + if test $ac_cv_sizeof_void_p = 8; then + arch=x86_64 + have_xaddq=yes + else + arch=x86_32 + fi + ;; + x86_64-*|amd64-*) + AC_CHECK_SIZEOF([void *]) + 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 + +# +# Activate "filter-aaaa-on-v4/v6" or not? +# +AC_ARG_ENABLE(filter-aaaa, + [ --enable-filter-aaaa enable filtering of AAAA records [[default=no]]], + enable_filter="$enableval", + enable_filter="no") +case "$enable_filter" in + yes) + AC_DEFINE(ALLOW_FILTER_AAAA, 1, + [Define to enable the "filter-aaaa-on-v4" and "filter-aaaa-on-v6" options.]) + ;; + no) + ;; + *) + ;; +esac + +# +# 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 /opt/local/share/xsl/docbook-xsl-nons /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 using idnkit +# +AC_ARG_WITH(idnkit, + AS_HELP_STRING([--with-idnkit[=PATH]], + [enable IDN support using idnkit [yes|no|path]]), + use_idnkit="$withval", use_idnkit="no") +case "$use_idnkit" in +yes) + if test X$prefix = XNONE ; then + idnkit_path=/usr/local + else + idnkit_path=$prefix + fi + ;; +no) + ;; +*) + idnkit_path="$use_idnkit" + ;; +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 + +IDNKIT_LIBS= +if test "no" != "$use_idnkit"; then + AC_DEFINE(WITH_IDNKIT, 1, [define if idnkit support is to be included.]) + STD_CINCLUDES="$STD_CINCLUDES -I$idnkit_path/include" + if test "no" != "$idnlib"; then + IDNKIT_LIBS="$idnlib $iconvlib" + else + IDNKIT_LIBS="-L$idnkit_path/lib -lidnkit $iconvlib" + fi +fi +AC_SUBST(IDNKIT_LIBS) + +# +# IDN support using libidn2 +# + +LIBIDN2_CFLAGS= +LIBIDN2_LDFLAGS= +LIBIDN2_LIBS= +AC_ARG_WITH(libidn2, + AS_HELP_STRING([--with-libidn2[=PATH]], [enable IDN support using GNU libidn2 [yes|no|path]]), + use_libidn2="$withval", use_libidn2="no") +AS_CASE([$use_libidn2], + [no],[:], + [yes],[:], + [*],[ + LIBIDN2_CFLAGS="-I$use_libidn2/include" + LIBIDN2_LDFLAGS="-L$use_libidn2/lib" + ]) + +AS_IF([test "$use_libidn2" != "no"], + [save_CFLAGS="$CFLAGS" + save_LIBS="$LIBS" + save_LDFLAGS="$LDFLAGS" + CFLAGS="$LIBIDN2_CFLAGS $CFLAGS" + LDFLAGS="$LIBIDN2_LDFLAGS $LDFLAGS" + AC_SEARCH_LIBS([idn2_to_ascii_8z], [idn2], + [AC_DEFINE(WITH_IDN_SUPPORT, 1, [define if IDN input support is to be included.]) + AC_DEFINE(WITH_LIBIDN2, 1, [define if libidn2 support is to be included.]) + LIBIDN2_LIBS="$LIBIDN2_LDFLAGS -lidn2"], + [AC_MSG_ERROR([libidn2 requested, but not found])]) + AC_TRY_LINK([#include <idn2.h>], + [idn2_to_unicode_8zlz(".", NULL, IDN2_NONTRANSITIONAL|IDN2_NFC_INPUT);], + [AC_MSG_RESULT(yes) + AC_DEFINE(WITH_IDN_OUT_SUPPORT, 1, [define if IDN output support is to be included.])], + [AC_MSG_RESULT([no])]) + CFLAGS="$save_CFLAGS" + LIBS="$save_LIBS" + LDFLAGS="$save_LDFLAGS" + ]) +AC_SUBST([LIBIDN2_CFLAGS]) +AC_SUBST([LIBIDN2_LIBS]) + +# +# IDN support in general +# + +# check if idnkit and libidn2 are not used at the same time +if test "$use_idnkit" != no && test "$use_libidn2" != no; then + AC_MSG_ERROR([idnkit and libidn2 cannot be used at the same time.]) +fi +# the IDN support is on +if test "$use_idnkit" != no || test "$use_libidn2" != no; then + AC_DEFINE(WITH_IDN_SUPPORT, 1, [define if IDN input support is to be included.]) + if test "$use_libidn2" = no || test "$use_libidn2_out" != no; then + AC_DEFINE(WITH_IDN_OUT_SUPPORT, 1, [define if IDN output support is to be included.]) + fi +fi + +# +# 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" + 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_LWRES_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_LWRES_BUILDINCLUDE="-I${BIND9_TOP_BUILDDIR}/lib/lwres/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_LWRES_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(LIBLWRES_API) +LIBLWRES_API="$srcdir/lib/lwres/api" + +AC_SUBST_FILE(LIBIRS_API) +LIBIRS_API="$srcdir/lib/irs/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/headerdep_test.sh + bin/tests/optional/Makefile + bin/tests/pkcs11/Makefile + bin/tests/pkcs11/benchmarks/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/dlzs.conf + bin/tests/system/dyndb/Makefile + bin/tests/system/dyndb/driver/Makefile + bin/tests/system/inline/checkdsa.sh + bin/tests/system/lwresd/Makefile + bin/tests/system/pipelined/Makefile + bin/tests/system/rndc/Makefile + bin/tests/system/rsabigexponent/Makefile + bin/tests/system/tkey/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/lwres/Makefile + lib/lwres/include/Makefile + lib/lwres/include/lwres/Makefile + lib/lwres/include/lwres/netdb.h + lib/lwres/include/lwres/platform.h + lib/lwres/man/Makefile + lib/lwres/tests/Makefile + lib/lwres/unix/Makefile + lib/lwres/unix/include/Makefile + lib/lwres/unix/include/lwres/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 "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)" + test "no" = "$use_libidn2" || echo " IDN support (--with-libidn2)" + 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_fixed" && \ + echo " Allow 'fixed' rrset-order (--enable-fixed-rrset)" + test "yes" = "$enable_filter" && \ + echo " AAAA filtering (--enable-filter-aaaa)" + 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 " 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 "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" = "$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)" + test "no" = "$use_libidn2" && echo " IDN support (--with-libidn2)" + + echo "-------------------------------------------------------------------------------" + echo "Configured paths:" + echo " prefix: $prefix" + echo " sysconfdir: $sysconfdir" + echo " localstatedir: $localstatedir" + echo "-------------------------------------------------------------------------------" + echo "Compiler: $CC" + $CC --version 2>&1 | sed 's/^/ /' + + if test "X$ac_unrecognized_opts" != "X"; then + 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 + +# Tell Emacs to edit this file in shell mode. +# Local Variables: +# mode: sh +# End: |