8bc194b266a17f89e6c54469d4dfbb408070f39eMark Andrews# Copyright (C) 1998-2018 Internet Systems Consortium, Inc. ("ISC")

8bc194b266a17f89e6c54469d4dfbb408070f39eMark Andrews#

0c27b3fe77ac1d5094ba3521e8142d9e7973133fMark Andrews# This Source Code Form is subject to the terms of the Mozilla Public

bf8267aa453e5d2a735ed732a043b77a0b355b20Mark Andrews# License, v. 2.0. If a copy of the MPL was not distributed with this

0c27b3fe77ac1d5094ba3521e8142d9e7973133fMark Andrews# file, You can obtain one at http://mozilla.org/MPL/2.0/.

0c27b3fe77ac1d5094ba3521e8142d9e7973133fMark Andrews

0c27b3fe77ac1d5094ba3521e8142d9e7973133fMark Andrewsdnl

8bc194b266a17f89e6c54469d4dfbb408070f39eMark AndrewsAC_DIVERT_PUSH(1)dnl

8bc194b266a17f89e6c54469d4dfbb408070f39eMark Andrewsesyscmd([sed -e 's/^/# /' -e '/Portions of this code/,$d' COPYRIGHT])dnl

8bc194b266a17f89e6c54469d4dfbb408070f39eMark AndrewsAC_DIVERT_POP()dnl

8bc194b266a17f89e6c54469d4dfbb408070f39eMark Andrews

8bc194b266a17f89e6c54469d4dfbb408070f39eMark AndrewsAC_INIT(BIND, [9.11], [info@isc.org], [], [https://www.isc.org/downloads/BIND/])

8bc194b266a17f89e6c54469d4dfbb408070f39eMark AndrewsAC_PREREQ(2.59)

47d837a49967a6a1b290024f5efb0669276013b1Mukund Sivaraman

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

#

# On these hosts, we really want to use cc, not gcc, even if it is

# found. The gcc that these systems have will not correctly handle

# pthreads.

#

# However, if the user sets $CC to be something, let that override

# our change.

#

if test "X$CC" = "X" ; then

case "$host" in

*-dec-osf*)

CC="cc"

;;

*-solaris*)

# Use Sun's cc if it is available, but watch

# out for /usr/ucb/cc; it will never be the right

# compiler to use.

#

# If setting CC here fails, the AC_PROG_CC done

# below might still find gcc.

IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS=":"

for ac_dir in $PATH; do

test -z "$ac_dir" && ac_dir=.

case "$ac_dir" in

/usr/ucb)

# exclude

;;

*)

if test -f "$ac_dir/cc"; then

CC="$ac_dir/cc"

break

fi

;;

esac

done

IFS="$ac_save_ifs"

;;

*-hp-hpux*)

CC="cc"

;;

mips-sgi-irix*)

CC="cc"

;;

esac

fi

AC_PROG_CC

#

# gcc's optimiser is broken at -02 for ultrasparc

#

if test "$ac_env_CFLAGS_set" != set -a "X$GCC" = "Xyes"; then

case "$host" in

sparc-*)

CCFLAGS="-g -O1"

;;

esac

fi

#

# OS dependent CC flags

#

case "$host" in

# OSF 5.0: recv/send are only available with -D_POSIX_PII_SOCKET or

# -D_XOPEN_SOURCE_EXTENDED.

*-dec-osf*)

STD_CDEFINES="$STD_CDEFINES -D_POSIX_PII_SOCKET"

CPPFLAGS="$CPPFLAGS -D_POSIX_PII_SOCKET"

;;

#HP-UX: need -D_XOPEN_SOURCE_EXTENDED and -lxnet for CMSG macros

*-hp-hpux*)

STD_CDEFINES="$STD_CDEFINES -D_XOPEN_SOURCE_EXTENDED"

CPPFLAGS="$CPPFLAGS -D_XOPEN_SOURCE_EXTENDED"

LIBS="-lxnet $LIBS"

;;

# Solaris: need -D_XPG4_2 and -D__EXTENSIONS__ for CMSG macros

*-solaris*)

STD_CDEFINES="$STD_CDEFINES -D_XPG4_2 -D__EXTENSIONS__"

CPPFLAGS="$CPPFLAGS -D_XPG4_2 -D__EXTENSIONS__"

;;

# POSIX doesn't include the IPv6 Advanced Socket API and glibc hides

# parts of the IPv6 Advanced Socket API as a result. This is stupid

# as it breaks how the two halves (Basic and Advanced) of the IPv6

# Socket API were designed to be used but we have to live with it.

# Define _GNU_SOURCE to pull in the IPv6 Advanced Socket API.

*-linux* | *-kfreebsd*-gnu*)

STD_CDEFINES="$STD_CDEFINES -D_GNU_SOURCE"

CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"

;;

#

# Starting with OSX 10.7 (Lion) we must choose which IPv6 API to use.

# Setting this is sufficient to select the correct behavior for BIND 9.

#

*-darwin*)

STD_CDEFINES="$STD_CDEFINES -D__APPLE_USE_RFC_3542"

CPPFLAGS="$CPPFLAGS -D__APPLE_USE_RFC_3542"

;;

esac

#

# CCNOOPT defaults to -O0 on gcc and disables optimization when is last

#

if test "X$CCNOOPT" = "X" -a "X$GCC" = "Xyes"; then

CCNOOPT="-O0"

fi

AC_HEADER_STDC

AC_CHECK_HEADERS(fcntl.h regex.h sys/time.h unistd.h sys/mman.h sys/sockio.h sys/select.h sys/param.h sys/sysctl.h net/if6.h sys/socket.h net/route.h linux/netlink.h linux/rtnetlink.h,,,

[$ac_includes_default

#ifdef HAVE_SYS_PARAM_H

# include <sys/param.h>

#endif

#ifdef HAVE_SYS_SOCKET_H

# include <sys/socket.h>

#endif

])

AC_C_CONST

AC_C_INLINE

AC_C_VOLATILE

AC_CHECK_FUNC(sysctlbyname, AC_DEFINE(HAVE_SYSCTLBYNAME))

AC_C_FLEXIBLE_ARRAY_MEMBER

#

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

#

AC_CHECK_FUNCS(mmap)

#

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

#

AC_CHECK_FUNCS(seteuid setresuid)

AC_CHECK_FUNCS(setegid setresgid)

# BSDI doesn't have ftello fseeko

AC_CHECK_FUNCS(ftello fseeko)

#

# UnixWare 7.1.1 with the feature supplement to the UDK compiler

# is reported to not support "static inline" (RT #1212).

#

AC_MSG_CHECKING(for static inline breakage)

AC_TRY_COMPILE([

static inline int foo1() {

return 0;

}

static inline int foo2() {

return foo1();

}

], [foo1();],

[AC_MSG_RESULT(no)],

[AC_MSG_RESULT(yes)

AC_DEFINE(inline, ,[Define to empty if your compiler does not support "static inline".])])

AC_TYPE_SIZE_T

AC_CHECK_TYPE(ssize_t, int)

AC_CHECK_TYPE(uintptr_t,unsigned long)

AC_CHECK_TYPE(socklen_t,

[AC_DEFINE(ISC_SOCKADDR_LEN_T, socklen_t)],

[

AC_TRY_COMPILE(

[

#include <sys/types.h>

#include <sys/socket.h>

int getsockname(int, struct sockaddr *, size_t *);

],[],

[AC_DEFINE(ISC_SOCKADDR_LEN_T, size_t)],

[AC_DEFINE(ISC_SOCKADDR_LEN_T, int)])

],

[

#include <sys/types.h>

#include <sys/socket.h>

])

AC_SUBST(ISC_SOCKADDR_LEN_T)

AC_HEADER_TIME

AC_MSG_CHECKING(for long long)

AC_TRY_COMPILE([],[long long i = 0; return (0);],

[AC_MSG_RESULT(yes)

ISC_PLATFORM_HAVELONGLONG="#define ISC_PLATFORM_HAVELONGLONG 1"],

[AC_MSG_RESULT(no)

ISC_PLATFORM_HAVELONGLONG="#undef ISC_PLATFORM_HAVELONGLONG"])

AC_SUBST(ISC_PLATFORM_HAVELONGLONG)

#

# check for uname library routine

#

AC_MSG_CHECKING(for uname)

AC_TRY_COMPILE([

#include <sys/utsname.h>

#include <stdio.h>

],

[

struct utsname uts;

uname(&uts);

printf("running on %s %s %s for %s\n",

uts.sysname, uts.release, uts.version, uts.machine);

],

[AC_MSG_RESULT(yes)

AC_DEFINE(HAVE_UNAME)],

[AC_MSG_RESULT(no)

AC_MSG_WARN([uname is not correctly supported])])

#

# check for GCC noreturn attribute

#

AC_MSG_CHECKING(for GCC noreturn attribute)

AC_TRY_COMPILE([],[void foo() __attribute__((noreturn));],

[AC_MSG_RESULT(yes)

ISC_PLATFORM_NORETURN_PRE="#define ISC_PLATFORM_NORETURN_PRE"

ISC_PLATFORM_NORETURN_POST="#define ISC_PLATFORM_NORETURN_POST __attribute__((noreturn))"],

[AC_MSG_RESULT(no)

ISC_PLATFORM_NORETURN_PRE="#define ISC_PLATFORM_NORETURN_PRE"

ISC_PLATFORM_NORETURN_POST="#define ISC_PLATFORM_NORETURN_POST"])

AC_SUBST(ISC_PLATFORM_NORETURN_PRE)

AC_SUBST(ISC_PLATFORM_NORETURN_POST)

#

# check if we have lifconf

#

AC_MSG_CHECKING(for struct lifconf)

AC_TRY_COMPILE([

#include <sys/types.h>

#include <sys/socket.h>

#include <net/if.h>

],

[

struct lifconf lifconf;

lifconf.lifc_len = 0;

]

,

[AC_MSG_RESULT(yes)

ISC_PLATFORM_HAVELIFCONF="#define ISC_PLATFORM_HAVELIFCONF 1"],

[AC_MSG_RESULT(no)

ISC_PLATFORM_HAVELIFCONF="#undef ISC_PLATFORM_HAVELIFCONF"])

AC_SUBST(ISC_PLATFORM_HAVELIFCONF)

#

# check if we have kqueue

#

AC_ARG_ENABLE(kqueue,

AS_HELP_STRING([--enable-kqueue],

[use BSD kqueue when available [default=yes]]),

want_kqueue="$enableval", want_kqueue="yes")

case $want_kqueue in

yes)

AC_CHECK_FUNC(kqueue, ac_cv_have_kqueue=yes, ac_cv_have_kqueue=no)

case $ac_cv_have_kqueue in

yes)

ISC_PLATFORM_HAVEKQUEUE="#define ISC_PLATFORM_HAVEKQUEUE 1"

;;

*)

ISC_PLATFORM_HAVEKQUEUE="#undef ISC_PLATFORM_HAVEKQUEUE"

;;

esac

;;

*)

ISC_PLATFORM_HAVEKQUEUE="#undef ISC_PLATFORM_HAVEKQUEUE"

;;

esac

AC_SUBST(ISC_PLATFORM_HAVEKQUEUE)

#

# check if we have epoll. Linux kernel 2.4 has epoll_create() which fails,

# so we need to try running the code, not just test its existence.

#

AC_ARG_ENABLE(epoll,

AS_HELP_STRING([--enable-epoll],

[use Linux epoll when available [default=auto]]),

want_epoll="$enableval", want_epoll="auto")

case $want_epoll in

auto)

AC_MSG_CHECKING(epoll support)

AC_TRY_RUN([

#include <sys/epoll.h>

int main() {

if (epoll_create(1) < 0)

return (1);

return (0);

}

],

[AC_MSG_RESULT(yes)

ISC_PLATFORM_HAVEEPOLL="#define ISC_PLATFORM_HAVEEPOLL 1"],

[AC_MSG_RESULT(no)

ISC_PLATFORM_HAVEEPOLL="#undef ISC_PLATFORM_HAVEEPOLL"],

[AC_MSG_RESULT(no)

ISC_PLATFORM_HAVEEPOLL="#undef ISC_PLATFORM_HAVEEPOLL"])

;;

yes)

ISC_PLATFORM_HAVEEPOLL="#define ISC_PLATFORM_HAVEEPOLL 1"

;;

*)

ISC_PLATFORM_HAVEEPOLL="#undef ISC_PLATFORM_HAVEEPOLL"

;;

esac

AC_SUBST(ISC_PLATFORM_HAVEEPOLL)

#

# check if we support /dev/poll

#

AC_ARG_ENABLE(devpoll,

AS_HELP_STRING([--enable-devpoll],

[use /dev/poll when available [default=yes]]),

want_devpoll="$enableval", want_devpoll="yes")

case $want_devpoll in

yes)

AC_CHECK_HEADERS(sys/devpoll.h devpoll.h,

ISC_PLATFORM_HAVEDEVPOLL="#define ISC_PLATFORM_HAVEDEVPOLL 1"

,

ISC_PLATFORM_HAVEDEVPOLL="#undef ISC_PLATFORM_HAVEDEVPOLL"

)

;;

*)

ISC_PLATFORM_HAVEDEVPOLL="#undef ISC_PLATFORM_HAVEDEVPOLL"

;;

esac

AC_SUBST(ISC_PLATFORM_HAVEDEVPOLL)

#

# check if we need to #include sys/select.h explicitly

#

case $ac_cv_header_unistd_h in

yes)

AC_MSG_CHECKING(if unistd.h or sys/types.h defines fd_set)

AC_TRY_COMPILE([

#include <sys/types.h> /* Ultrix */

#include <unistd.h>],

[fd_set read_set; return (0);],

[AC_MSG_RESULT(yes)

ISC_PLATFORM_NEEDSYSSELECTH="#undef ISC_PLATFORM_NEEDSYSSELECTH"

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_ARG_ENABLE(openssl-version-check,

[AS_HELP_STRING([--enable-openssl-version-check],

[check OpenSSL version @<:@default=yes@:>@])])

case "$enable_openssl_version_check" in

yes|'')

AC_MSG_CHECKING(OpenSSL library version)

AC_TRY_RUN([

#include <stdio.h>

#include <openssl/opensslv.h>

int main() {

if ((OPENSSL_VERSION_NUMBER >= 0x009070cfL &&

OPENSSL_VERSION_NUMBER < 0x00908000L) ||

(OPENSSL_VERSION_NUMBER >= 0x0090804fL &&

OPENSSL_VERSION_NUMBER < 0x10002000L) ||

OPENSSL_VERSION_NUMBER >= 0x1000205fL)

return (0);

printf("\n\nFound OPENSSL_VERSION_NUMBER %#010lx\n",

OPENSSL_VERSION_NUMBER);

printf("Require OPENSSL_VERSION_NUMBER 0x009070cf or greater (0.9.7l)\n"

"Require OPENSSL_VERSION_NUMBER 0x0090804f or greater (0.9.8d)\n"

"Require OPENSSL_VERSION_NUMBER 0x1000000f or greater (1.0.0)\n"

"Require OPENSSL_VERSION_NUMBER 0x1000100f or greater (1.0.1)\n"

"Require OPENSSL_VERSION_NUMBER 0x1000205f or greater (1.0.2e)\n\n");

return (1);

}

],

[AC_MSG_RESULT(ok)],

[AC_MSG_RESULT(not compatible)

OPENSSL_WARNING=yes

],

[AC_MSG_RESULT(assuming target platform has compatible version)])

;;

no)

AC_MSG_RESULT(Skipped OpenSSL version check)

;;

esac

AC_MSG_CHECKING(for OpenSSL FIPS mode support)

have_fips_mode=""

AC_TRY_LINK([#include <openssl/crypto.h>],

[FIPS_mode();],

have_fips_mode=yes,

have_fips_mode=no)

if test "x$have_fips_mode" = "xyes"

then

AC_DEFINE([HAVE_FIPS_MODE], [1],

[Define if OpenSSL provides FIPS_mode()])

AC_MSG_RESULT(yes)

else

AC_MSG_RESULT(no)

fi

AC_MSG_CHECKING(for OpenSSL DSA support)

if test -f $use_openssl/include/openssl/dsa.h

then

AC_DEFINE(HAVE_OPENSSL_DSA)

AC_MSG_RESULT(yes)

else

AC_MSG_RESULT(no)

fi

AC_CHECK_FUNCS(EVP_sha256 EVP_sha384 EVP_sha512)

AC_MSG_CHECKING(for OpenSSL ECDSA support)

have_ecdsa=""

AC_TRY_RUN([

#include <openssl/ecdsa.h>

#include <openssl/objects.h>

int main() {

EC_KEY *ec256, *ec384;

#if !defined(HAVE_EVP_SHA256) || !defined(HAVE_EVP_SHA384)

return (1);

#endif

ec256 = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);

ec384 = EC_KEY_new_by_curve_name(NID_secp384r1);

if (ec256 == NULL || ec384 == NULL)

return (2);

return (0);

}

],

[AC_MSG_RESULT(yes)

have_ecdsa="yes"],

[AC_MSG_RESULT(no)

have_ecdsa="no"],

[AC_MSG_RESULT(using --with-ecdsa)])

case "$with_ecdsa" in

yes)

case "$have_ecdsa" in

no) AC_MSG_ERROR([ecdsa not supported]) ;;

*) have_ecdsa=yes ;;

esac

;;

no)

have_ecdsa=no ;;

*)

case "$have_ecdsa" in

yes|no) ;;

*) AC_MSG_ERROR([need --with-ecdsa=[[yes or no]]]) ;;

esac

;;

esac

case $have_ecdsa in

yes)

OPENSSL_ECDSA="yes"

OPENSSLECDSALINKOBJS='${OPENSSLECDSALINKOBJS}'

OPENSSLECDSALINKSRCS='${OPENSSLECDSALINKSRCS}'

AC_DEFINE(HAVE_OPENSSL_ECDSA, 1,

[Define if your OpenSSL version supports ECDSA.])

;;

*)

;;

esac

AC_MSG_CHECKING(for OpenSSL GOST support)

have_gost=""

case "$use_pkcs11" in

auto|no)

;;

*)

if $use_threads; then

CC="$CC -pthread"

fi

;;

esac

AC_TRY_RUN([

#include <openssl/conf.h>

#include <openssl/engine.h>

int main() {

#if !defined(LIBRESSL_VERSION_NUMBER) && (OPENSSL_VERSION_NUMBER >= 0x10000000L)

ENGINE *e;

EC_KEY *ek;

ek = NULL;

OPENSSL_config(NULL);

e = ENGINE_by_id("gost");

if (e == NULL)

return (1);

if (ENGINE_init(e) <= 0)

return (1);

return (0);

#else

return (1);

#endif

}

],

[AC_MSG_RESULT(yes)

have_gost="yes"],

[AC_MSG_RESULT(no)

have_gost="no"],

[AC_MSG_RESULT(using --with-gost)])

case "$with_gost" in

yes)

case "$have_gost" in

no) AC_MSG_ERROR([gost not supported]) ;;

*) have_gost=yes ;;

esac

;;

no)

have_gost=no ;;

*)

case "$have_gost" in

yes|no) ;;

*) AC_MSG_ERROR([need --with-gost=[[yes, no, raw or asn1]]]) ;;

esac

;;

esac

case $have_gost in

yes)

OPENSSL_GOST="yes"

OPENSSLGOSTLINKOBJS='${OPENSSLGOSTLINKOBJS}'

OPENSSLGOSTLINKSRCS='${OPENSSLGOSTLINKSRCS}'

AC_DEFINE(HAVE_OPENSSL_GOST, 1,

[Define if your OpenSSL version supports GOST.])

;;

*)

;;

esac